Compare commits
8 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| cb117273a7 | |||
| 3bda688b1e | |||
| 446b1aa9db | |||
| 30be1c5a91 | |||
| 6b328e64ba | |||
| 435be31347 | |||
| 2522635815 | |||
| e8fdca8236 |
@ -6,11 +6,11 @@
|
||||
</head>
|
||||
<body>
|
||||
<script type="module">
|
||||
import {formatDate} from './dist/index.mjs';
|
||||
import {PES, PathEvent} from './dist/index.mjs';
|
||||
const perm = PES`storage/test/john-flag.png:r`;
|
||||
const perms = [ 'logs/Momentum:c', 'storage/test:r', 'data/Repos:r', 'email:c' ];
|
||||
|
||||
console.log(formatDate(new Date(), 'HH:mm:ss z', 5));
|
||||
console.log(formatDate(new Date(), 'HH:mm:ss z', 0));
|
||||
console.log(formatDate(new Date(), 'HH:mm:ss z', -5));
|
||||
console.log(PathEvent.filter(perms, perm));
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@ztimson/utils",
|
||||
"version": "0.23.0",
|
||||
"version": "0.23.7",
|
||||
"description": "Utility library",
|
||||
"author": "Zak Timson",
|
||||
"license": "MIT",
|
||||
|
||||
141
src/arg-parser.ts
Normal file
141
src/arg-parser.ts
Normal file
@ -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`;
|
||||
}
|
||||
}
|
||||
12
src/color.ts
Normal file
12
src/color.ts
Normal file
@ -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';
|
||||
}
|
||||
@ -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';
|
||||
|
||||
@ -224,6 +224,17 @@ export function JSONAttemptParse<T1, T2>(json: T2): T1 | T2 {
|
||||
catch { return json; }
|
||||
}
|
||||
|
||||
/**
|
||||
* Stringifies objects & skips primitives
|
||||
*
|
||||
* @param {any} obj Object to convert to serializable value
|
||||
* @return {string | T} Serialized value
|
||||
*/
|
||||
export function JSONSerialize<T1>(obj: T1): T1 | string {
|
||||
if(typeof obj == 'object' && obj != null) return JSONSanitize(obj);
|
||||
return obj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert an object to a JSON string avoiding any circular references.
|
||||
*
|
||||
|
||||
@ -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));
|
||||
});
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user