Fixed blackorwhite invalid argument crash

index.html

@@ -8,9 +8,7 @@
 		<script type="module">
 			import {formatDate} from './dist/index.mjs';
 
-			console.log(formatDate(new Date(), 'HH:mm:ss z', 5));
+			console.log(formatDate('YYYY-01-01'));
-			console.log(formatDate(new Date(), 'HH:mm:ss z', 0));
-			console.log(formatDate(new Date(), 'HH:mm:ss z', -5));
 		</script>
 	</body>
 </html>

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ztimson/utils",
-	"version": "0.23.2",
+	"version": "0.23.9",
 	"description": "Utility library",
 	"author": "Zak Timson",
 	"license": "MIT",

src/arg-parser.ts

@@ -0,0 +1,141 @@
+export type Arg<T = any> = {
+	/** Argument/property name */
+	name: string;
+	/** Argument description for help page */
+	desc: string;
+	/** Available shorthands */
+	flags?: string[];
+	/** Argument is not required */
+	optional?: boolean;
+	/** Default value if argument is not used */
+	default?: T;
+	/** Collects any unmatched arguments */
+	extras?: boolean;
+}
+
+export class ArgParser {
+	commands: ArgParser[] = [];
+	args: Arg[] = [];
+	flags: Arg[] = [];
+	defaults!: {[key: string]: any};
+
+	/**
+	 * Create a unix-like argument parser to extract flags from the argument list. Can also create help messages.
+	 *
+	 * @param {string} name Script name
+	 * @param {string} desc Help description
+	 * @param {(ArgParser | Arg[]} argList Array of CLI arguments
+	 * @param {string[]} examples Additional examples to display
+	 */
+	constructor(public readonly name: string,
+				public readonly desc: string,
+				public readonly argList: (ArgParser | Arg)[] = [],
+				public readonly examples: string[] = []
+	) {
+		// Arguments
+		this.commands = argList.filter(arg => arg instanceof ArgParser);
+		this.args = <Arg[]>argList.filter(arg => !(arg instanceof ArgParser) && !arg.flags?.length);
+		this.flags = <Arg[]>[...argList.filter(arg => !(arg instanceof ArgParser) && arg.flags && arg.flags.length),
+			{name: 'help', desc: 'Display command\'s help message', flags: ['-h', '--help'], default: false}];
+		this.defaults = argList.reduce((acc, arg: any) => ({...acc, [arg.name]: arg['extras'] ? [] : (arg.default ?? null)}), {});
+
+		// Examples
+		this.examples = <string[]>[
+			...examples,
+			`[OPTIONS] ${this.args.map(arg => (arg.optional ? `[${arg.name.toUpperCase()}]` : arg.name.toUpperCase()) + (arg.extras ? '...' : '')).join(' ')}`,
+			this.commands.length ? `[OPTIONS] COMMAND` : null,
+			`--help ${this.commands.length ? '[COMMAND]' : ''}`
+		].filter(e => !!e);
+	}
+
+	/**
+	 * Parse an array into an arguments dictionary using the configuration.
+	 *
+	 * @param {string[]} args Array of arguments to be parsed
+	 * @returns {object} Dictionary of arguments with defaults applied
+	 */
+	parse(args: string[]) {
+		// Parse arguments
+		let extras = [], parsed: any = {...this.defaults, '_error': []}, queue = [...args];
+		while(queue.length) {
+			let arg = queue.splice(0, 1)[0];
+			if(arg[0] == '-') { // Flags
+				// Check for combined shorthand
+				if(arg[1] != '-' && arg.length > 2) {
+					queue = [...arg.substring(2).split('').map(a => `-${a}`), ...queue];
+					arg = `-${arg[1]}`;
+				}
+				// Find & add flag
+				const combined = arg.split('=');
+				const argDef = this.flags.find(flag => flag.flags?.includes(combined[0] || arg));
+				if(argDef == null) { // Not found, add to extras
+					extras.push(arg);
+					continue;
+				}
+				const value = argDef.default === false ? true :
+							  argDef.default === true ? false :
+							  queue.splice(queue.findIndex(q => q[0] != '-'), 1)[0] ||
+							  argDef.default;
+				if(value == null) parsed['_error'].push(`Option missing value: ${argDef.name || combined[0]}`);
+				parsed[argDef.name] = value;
+			} else { // Command
+				const c = this.commands.find(command => command.name == arg);
+				if(!!c) {
+					const parsedCommand = c.parse(queue.splice(0, queue.length));
+					Object.keys(parsedCommand).forEach(key => {
+						if(parsed[key] != parsedCommand[key] && parsedCommand[key] == c.defaults[key])
+							delete parsedCommand[key];
+					});
+					parsed = {
+						...parsed,
+						...parsedCommand,
+						_command: c.name
+					};
+				} else extras.push(arg); // Not found, add to extras
+			}
+		}
+		// Arguments
+		this.args.filter(arg => !arg.extras).forEach(arg => {
+			if(!arg.optional && !extras.length) parsed['_error'].push(`Argument missing: ${arg.name.toUpperCase()}`);
+			if(extras.length) parsed[arg.name] = extras.splice(0, 1)[0];
+		});
+		// Extras
+		const extraKey = this.args.find(arg => arg.extras)?.name || '_extra';
+		parsed[extraKey] = extras;
+		return parsed;
+	}
+
+	/**
+	 * Create help message from the provided description & argument list.
+	 *
+	 * @returns {string} Help message
+	 * @param opts Help options: command - display a commands help, message - override help description
+	 */
+	help(opts: {command?: string, message?: string} = {}): string {
+		const spacer = (text: string) => Array(24 - text.length || 1).fill(' ').join('');
+
+		// Help with specific command
+		if(opts.command) {
+			const argParser = this.commands.find(parser => parser.name == opts.command);
+			if(!argParser) throw new Error(`${opts.command.toUpperCase()} is not a command`)
+			return argParser.help({...opts, command: undefined});
+		}
+
+		// Description
+		let msg = `\n\n${opts.message || this.desc}`;
+		// Examples
+		msg += '\n\nUsage:\t' + this.examples.map(ex => `${this.name} ${ex}`).join('\n\t');
+		// Arguments
+		if(this.args.length) msg += '\n\n\t' + this.args.map(arg =>
+			`${arg.name.toUpperCase()}${spacer(arg.name)}${arg.desc}`).join('\n\t');
+		// Flags
+		msg += '\n\nOptions:\n\t' + this.flags.map(flag => {
+			const flags = flag.flags?.join(', ') || '';
+			return `${flags}${spacer(flags)}${flag.desc}`;
+		}).join('\n\t');
+		// Commands
+		if(this.commands.length) msg += '\n\nCommands:\n\t' + this.commands.map(command =>
+			`${command.name}${spacer(command.name)}${command.desc}`).join('\n\t');
+		return `${msg}\n\n`;
+	}
+}

src/color.ts

@@ -0,0 +1,12 @@
+/**
+ * Determine if either black or white provides more contrast to the provided color
+ * @param {string} background Color to compare against
+ * @return {"white" | "black"} Color with the most contrast
+ */
+export function blackOrWhite(background: string): 'white' | 'black' {
+	const exploded = background?.match(background.length >= 6 ? /\w\w/g : /\w/g);
+	if(!exploded) return 'black';
+	const [r, g, b] = exploded.map(hex => parseInt(hex, 16));
+	const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+	return luminance > 0.5 ? 'black' : 'white';
+}

src/index.ts

@@ -1,6 +1,8 @@
+export * from './arg-parser';
 export * from './array';
 export * from './aset';
 export * from './cache';
+export * from './color';
 export * from './csv';
 export * from './files';
 export * from './emitter';

src/path-events.ts

@@ -142,7 +142,7 @@ export class PathEvent {
 		const parsedFind = makeArray(filter).map(pe => new PathEvent(pe));
 		return parsedTarget.filter(t => {
 			if(!t.fullPath && t.all) return true;
-			return !!parsedFind.find(f => t.fullPath.startsWith(f.fullPath)
+			return !!parsedFind.find(f => f.fullPath.startsWith(t.fullPath)
 				&& (f.all || t.all || t.methods.intersection(f.methods).length));
 		});
 	}

src/time.ts

@@ -23,12 +23,12 @@ export function adjustedInterval(cb: Function, ms: number) {
 /**
  * Format date
  *
- * @param {Date | number | string} date Date or timestamp to convert to string
  * @param {string} format How date string will be formatted, default: `YYYY-MM-DD H:mm A`
- * @param tz Override timezone, can be either string or number
+ * @param {Date | number | string} date Date or timestamp, defaults to now
+ * @param tz Set timezone offset
  * @return {string} Formated date
  */
-export function formatDate(date: Date | number | string, format = 'YYYY-MM-DD H:mm', tz?: string | number): string {
+export function formatDate(format = 'YYYY-MM-DD H:mm', date: Date | number | string = new Date(), tz?: string | number): string {
 	const timezones = [
 		['IDLW', -12],
 		['SST', -11],
@@ -67,16 +67,7 @@ export function formatDate(date: Date | number | string, format = 'YYYY-MM-DD H:
 	}
 
 	function day(num: number): string {
-		switch(num) {
+		return ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][num] || 'Unknown';
-			case(0): return 'Sunday';
-			case(1): return 'Monday';
-			case(2): return 'Tuesday';
-			case(3): return 'Wednesday';
-			case(4): return 'Thursday';
-			case(5): return 'Friday';
-			case(6): return 'Saturday';
-			default: return 'Unknown';
-		}
 	}
 
 	function doy(date: Date) {
@@ -85,30 +76,16 @@ export function formatDate(date: Date | number | string, format = 'YYYY-MM-DD H:
 	}
 
 	function month(num: number): string {
-		switch(num) {
+		return ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][num] || 'Unknown';
-			case(0): return 'January';
-			case(1): return 'February';
-			case(2): return 'March';
-			case(3): return 'April';
-			case(4): return 'May';
-			case(5): return 'June';
-			case(6): return 'July';
-			case(7): return 'August';
-			case(8): return 'September';
-			case(9): return 'October';
-			case(10): return 'November';
-			case(11): return 'December';
-			default: return 'Unknown';
-		}
 	}
 
 	function suffix(num: number) {
-		let n = num.toString();
+		if (num % 100 >= 11 && num % 100 <= 13) return `${num}th`;
-		switch(n.at(-1)) {
+		switch (num % 10) {
-			case('1'): return num + 'st';
+			case 1: return `${num}st`;
-			case('2'): return num + 'nd';
+			case 2: return `${num}nd`;
-			case('3'): return num + 'rd';
+			case 3: return `${num}rd`;
-			default: return num + 'th';
+			default: return `${num}th`;
 		}
 	}
 
@@ -127,46 +104,36 @@ export function formatDate(date: Date | number | string, format = 'YYYY-MM-DD H:
 	if(!t) throw new Error(`Unknown timezone: ${tz}`);
 	date = adjustTz(date, t[1]);
 
-	return format
+	// Token mapping
-		// Year
+	const tokens: Record<string, string> = {
-		.replaceAll('YYYY', date.getFullYear().toString())
+		'YYYY': date.getFullYear().toString(),
-		.replaceAll('YY', date.getFullYear().toString().slice(2))
+		'YY': date.getFullYear().toString().slice(2),
-		// Month
+		'MMMM': month(date.getMonth()),
-		.replaceAll('MMMM', month(date.getMonth()))
+		'MMM': month(date.getMonth()).slice(0, 3),
-		.replaceAll('MMM', month(date.getMonth()).slice(0, 3))
+		'MM': (date.getMonth() + 1).toString().padStart(2, '0'),
-		.replaceAll('MM', (date.getMonth() + 1).toString().padStart(2, '0'))
+		'M': (date.getMonth() + 1).toString(),
-		.replaceAll('M', (date.getMonth() + 1).toString())
+		'DDD': doy(date).toString(),
-		// Day
+		'DD': date.getDate().toString().padStart(2, '0'),
-		.replaceAll('DDD', doy(date).toString())
+		'Do': suffix(date.getDate()),
-		.replaceAll('DD', date.getDate().toString().padStart(2, '0'))
+		'D': date.getDate().toString(),
-		.replaceAll('Do', suffix(date.getDate()))
+		'dddd': day(date.getDay()),
-		.replaceAll('D', date.getDate().toString())
+		'ddd': day(date.getDay()).slice(0, 3),
-		.replaceAll('dddd', day(date.getDay()))
+		'HH': date.getHours().toString().padStart(2, '0'),
-		.replaceAll('ddd', day(date.getDay()).slice(0, 2))
+		'H': date.getHours().toString(),
-		.replaceAll('dd', date.getDate().toString().padStart(2, '0'))
+		'hh': (date.getHours() % 12 || 12).toString().padStart(2, '0'),
-		.replaceAll('d', date.getDay().toString())
+		'h': (date.getHours() % 12 || 12).toString(),
-		// Hour
+		'mm': date.getMinutes().toString().padStart(2, '0'),
-		.replaceAll('HH', date.getHours().toString().padStart(2, '0'))
+		'm': date.getMinutes().toString(),
-		.replaceAll('H', date.getHours().toString())
+		'ss': date.getSeconds().toString().padStart(2, '0'),
-		.replaceAll('hh', (date.getHours() > 12 ? date.getHours() - 12 : date.getHours()).toString().padStart(2, '0'))
+		's': date.getSeconds().toString(),
-		.replaceAll('h', (date.getHours() > 12 ? date.getHours() - 12 : date.getHours()).toString())
+		'SSS': date.getMilliseconds().toString().padStart(3, '0'),
-		// Minute
+		'A': date.getHours() >= 12 ? 'PM' : 'AM',
-		.replaceAll('mm', date.getMinutes().toString().padStart(2, '0'))
+		'a': date.getHours() >= 12 ? 'pm' : 'am',
-		.replaceAll('m', date.getMinutes().toString())
+		'ZZ': tzOffset(t[1] * 60).replace(':', ''),
-		// Second
+		'Z': tzOffset(t[1] * 60),
-		.replaceAll('ss', date.getSeconds().toString().padStart(2, '0'))
+		'z': typeof tz == 'string' ? tz : (<any>t)[0]
-		.replaceAll('s', date.getSeconds().toString())
+	};
-		// Millisecond
+	return format.replace(/YYYY|YY|MMMM|MMM|MM|M|DDD|DD|Do|D|dddd|ddd|HH|H|hh|h|mm|m|ss|s|SSS|A|a|ZZ|Z|z/g, token => tokens[token]);
-		.replaceAll('SSS', date.getMilliseconds().toString().padEnd(3, '0'))
-		.replaceAll('SS', date.getMilliseconds().toString().slice(0, 1).padEnd(2, '0'))
-		.replaceAll('S', date.getMilliseconds().toString()[0])
-		// Period/Meridian (AM/PM)
-		.replaceAll('A', date.getHours() >= 12 ? 'PM' : 'AM')
-		.replaceAll('a', date.getHours() >= 12 ? 'pm' : 'am')
-		// Timezone
-		.replaceAll('ZZ', tzOffset(t[1] * 60).replace(':', ''))
-		.replaceAll('Z', tzOffset(t[1] * 60))
-		.replaceAll('z', typeof tz == 'string' ? tz : (<any>t)[0]);
 }
 
 /**