Compare commits
26 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| a1ea8cdf67 | |||
| fbbe3c99ef | |||
| 1c1a3f6a6e | |||
| 2dce1ad9ac | |||
| cebfd2c508 | |||
| 7c5cf3535d | |||
| 847b493772 | |||
| b1005227ab | |||
| 3a389de72e | |||
| 151465aa65 | |||
| b103b6f786 | |||
| 3b486310de | |||
| 8699fb49ff | |||
| fdb29e7984 | |||
| 274c22bb83 | |||
| b21f462d35 | |||
| 0f10aebfd2 | |||
| 1af23ac544 | |||
| 494cfaaccd | |||
| 23df6ad265 | |||
| 2fda11f3b7 | |||
| 379de273c4 | |||
| c51239d12b | |||
| e4229296c1 | |||
| b93ed45521 | |||
| 3e8f5cc00b |
12
.npmignore
Normal file
12
.npmignore
Normal file
@ -0,0 +1,12 @@
|
||||
src
|
||||
tests
|
||||
.editorconfig
|
||||
.gitignore
|
||||
.gitmodules
|
||||
.npmignore
|
||||
CODEOWNERS
|
||||
Dockerfile
|
||||
index.html
|
||||
jest.config.js
|
||||
tsconfig.json
|
||||
vite.config.js
|
||||
14
index.html
Normal file
14
index.html
Normal file
@ -0,0 +1,14 @@
|
||||
<!Doctype html>
|
||||
|
||||
<html>
|
||||
<head>
|
||||
<title>@ztimson/utils sandbox</title>
|
||||
</head>
|
||||
<body>
|
||||
<script type="module">
|
||||
import {PathEvent} from './dist/index.mjs';
|
||||
|
||||
console.log(PathEvent.filter(['storage/inventory:c', 'data:*'], `storage`));
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
5753
package-lock.json
generated
5753
package-lock.json
generated
File diff suppressed because it is too large
Load Diff
@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@ztimson/utils",
|
||||
"version": "0.17.1",
|
||||
"version": "0.21.4",
|
||||
"description": "Utility library",
|
||||
"author": "Zak Timson",
|
||||
"license": "MIT",
|
||||
@ -38,8 +38,5 @@
|
||||
},
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"dependencies": {
|
||||
"var-persist": "^1.0.1"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
33
src/aset.ts
33
src/aset.ts
@ -1,3 +1,5 @@
|
||||
import {isEqual} from './objects.ts';
|
||||
|
||||
/**
|
||||
* An array which functions as a set. It guarantees unique elements
|
||||
* and provides set functions for comparisons
|
||||
@ -19,20 +21,24 @@ export class ASet<T> extends Array {
|
||||
}
|
||||
|
||||
/**
|
||||
* Add single element to set if unique
|
||||
* @param {T} el Element to add
|
||||
* Add elements to set if unique
|
||||
* @param items
|
||||
*/
|
||||
add(el: T) {
|
||||
if(!this.has(el)) this.push(el);
|
||||
add(...items: T[]) {
|
||||
items.filter(el => !this.has(el)).forEach(el => this.push(el));
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete element from set
|
||||
* @param {T} el Element that will be deleted
|
||||
* Delete elements from set
|
||||
* @param items Elements that will be deleted
|
||||
*/
|
||||
delete(el: T) {
|
||||
delete(...items: T[]) {
|
||||
items.forEach(el => {
|
||||
const index = this.indexOf(el);
|
||||
if(index != -1) this.slice(index, 1);
|
||||
if(index != -1) this.splice(index, 1);
|
||||
})
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -53,6 +59,17 @@ export class ASet<T> extends Array {
|
||||
return this.indexOf(el) != -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find index number of element, or -1 if it doesn't exist. Matches by equality not reference
|
||||
*
|
||||
* @param {T} search Element to find
|
||||
* @param {number} fromIndex Starting index position
|
||||
* @return {number} Element index number or -1 if missing
|
||||
*/
|
||||
indexOf(search: T, fromIndex?: number): number {
|
||||
return super.findIndex((el: T) => isEqual(el, search), fromIndex);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create list of elements this set has in common with the comparison set
|
||||
* @param {ASet<T>} set Set to compare against
|
||||
|
||||
39
src/cache.ts
39
src/cache.ts
@ -1,3 +1,12 @@
|
||||
export type CacheOptions = {
|
||||
/** Delete keys automatically after x amount of seconds */
|
||||
ttl?: number;
|
||||
/** Storage to persist cache */
|
||||
storage?: Storage;
|
||||
/** Key cache will be stored under */
|
||||
storageKey?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Map of data which tracks whether it is a complete collection & offers optional expiry of cached values
|
||||
*/
|
||||
@ -13,9 +22,18 @@ export class Cache<K extends string | number | symbol, T> {
|
||||
* Create new cache
|
||||
*
|
||||
* @param {keyof T} key Default property to use as primary key
|
||||
* @param {number} ttl Default expiry in milliseconds
|
||||
* @param options
|
||||
*/
|
||||
constructor(public readonly key?: keyof T, public ttl?: number) {
|
||||
constructor(public readonly key?: keyof T, public readonly options: CacheOptions = {}) {
|
||||
if(options.storageKey && !options.storage && typeof(Storage) !== 'undefined')
|
||||
options.storage = localStorage;
|
||||
if(options.storageKey && options.storage) {
|
||||
const stored = options.storage.getItem(options.storageKey);
|
||||
if(stored) {
|
||||
try { Object.assign(this.store, JSON.parse(stored)); }
|
||||
catch { }
|
||||
}
|
||||
}
|
||||
return new Proxy(this, {
|
||||
get: (target: this, prop: string | symbol) => {
|
||||
if (prop in target) return (target as any)[prop];
|
||||
@ -69,6 +87,13 @@ export class Cache<K extends string | number | symbol, T> {
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove all keys from cache
|
||||
*/
|
||||
clear() {
|
||||
this.store = <Record<K, T>>{};
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete an item from the cache
|
||||
*
|
||||
@ -76,6 +101,8 @@ export class Cache<K extends string | number | symbol, T> {
|
||||
*/
|
||||
delete(key: K) {
|
||||
delete this.store[key];
|
||||
if(this.options.storageKey && this.options.storage)
|
||||
this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -118,15 +145,17 @@ export class Cache<K extends string | number | symbol, T> {
|
||||
*
|
||||
* @param {K} key Key item will be cached under
|
||||
* @param {T} value Item to cache
|
||||
* @param {number | undefined} ttl Override default expiry
|
||||
* @param {number | undefined} ttl Override default expiry in seconds
|
||||
* @return {this}
|
||||
*/
|
||||
set(key: K, value: T, ttl = this.ttl): this {
|
||||
set(key: K, value: T, ttl = this.options.ttl): this {
|
||||
this.store[key] = value;
|
||||
if(this.options.storageKey && this.options.storage)
|
||||
this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
|
||||
if(ttl) setTimeout(() => {
|
||||
this.complete = false;
|
||||
this.delete(key);
|
||||
}, ttl);
|
||||
}, ttl * 1000);
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
@ -1,33 +1,33 @@
|
||||
export type Listener = (...args: any[]) => any;
|
||||
export type TypedEvents = {[k in string | symbol]: Listener} & {'*': (event: string, ...args: any[]) => any};
|
||||
export type TypedListener = (...args: any[]) => any;
|
||||
export type TypedEvents = {[k in string | symbol]: TypedListener} & {'*': (event: string, ...args: any[]) => any};
|
||||
|
||||
export type NamespaceEvents<Namespace extends string, Events extends TypedEvents> = {
|
||||
[K in keyof Events as `${Namespace}:${Extract<K, string>}`]: Events[K];
|
||||
};
|
||||
|
||||
export class TypedEmitter<T extends TypedEvents = TypedEvents> {
|
||||
private static listeners: {[key: string]: Listener[]} = {};
|
||||
private static listeners: {[key: string]: TypedListener[]} = {};
|
||||
|
||||
private listeners: { [key in keyof T]?: Listener[] } = {};
|
||||
private listeners: { [key in keyof T]?: TypedListener[] } = {};
|
||||
|
||||
static emit(event: any, ...args: any[]) {
|
||||
(this.listeners['*'] || []).forEach(l => l(event, ...args));
|
||||
(this.listeners[event.toString()] || []).forEach(l => l(...args));
|
||||
};
|
||||
|
||||
static off(event: any, listener: Listener) {
|
||||
static off(event: any, listener: TypedListener) {
|
||||
const e = event.toString();
|
||||
this.listeners[e] = (this.listeners[e] || []).filter(l => l === listener);
|
||||
}
|
||||
|
||||
static on(event: any, listener: Listener) {
|
||||
static on(event: any, listener: TypedListener) {
|
||||
const e = event.toString();
|
||||
if(!this.listeners[e]) this.listeners[e] = [];
|
||||
this.listeners[e]?.push(listener);
|
||||
return () => this.off(event, listener);
|
||||
}
|
||||
|
||||
static once(event: any, listener?: Listener): Promise<any> {
|
||||
static once(event: any, listener?: TypedListener): Promise<any> {
|
||||
return new Promise(res => {
|
||||
const unsubscribe = this.on(event, <any>((...args: any) => {
|
||||
res(args.length == 1 ? args[0] : args);
|
||||
|
||||
@ -75,6 +75,7 @@ export class Http {
|
||||
|
||||
// Send request
|
||||
return new PromiseProgress((res, rej, prog) => {
|
||||
try {
|
||||
fetch(url, {
|
||||
headers,
|
||||
method: opts.method || (opts.body ? 'POST' : 'GET'),
|
||||
@ -100,6 +101,7 @@ export class Http {
|
||||
push();
|
||||
}).catch((error: any) => controller.error(error));
|
||||
}
|
||||
|
||||
push();
|
||||
}
|
||||
});
|
||||
@ -115,7 +117,10 @@ export class Http {
|
||||
|
||||
if(resp.ok) res(resp);
|
||||
else rej(resp);
|
||||
})
|
||||
}).catch(err => rej(err));
|
||||
} catch(err) {
|
||||
rej(err);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@ -11,8 +11,8 @@ export * from './logger';
|
||||
export * from './math';
|
||||
export * from './misc';
|
||||
export * from './objects';
|
||||
export * from './path-events';
|
||||
export * from './promise-progress';
|
||||
export * from './string';
|
||||
export * from './time';
|
||||
export * from './types';
|
||||
export * from 'var-persist';
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
import {TypedEmitter, TypedEvents} from './emitter';
|
||||
import {JSONSanitize} from './objects.ts';
|
||||
|
||||
export const CliEffects = {
|
||||
CLEAR: "\x1b[0m",
|
||||
@ -64,49 +65,41 @@ export class Logger extends TypedEmitter<LoggerEvents> {
|
||||
super();
|
||||
}
|
||||
|
||||
private pad(text: any, length: number, char: string, end = false) {
|
||||
const t = text.toString();
|
||||
const l = length - t.length;
|
||||
if(l <= 0) return t;
|
||||
const padding = Array(~~(l / char.length)).fill(char).join('');
|
||||
return !end ? padding + t : t + padding;
|
||||
}
|
||||
|
||||
private format(...text: string[]): string {
|
||||
protected format(...text: any[]): string {
|
||||
const now = new Date();
|
||||
const timestamp = `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()} ${this.pad(now.getHours().toString(), 2, '0')}:${this.pad(now.getMinutes().toString(), 2, '0')}:${this.pad(now.getSeconds().toString(), 2, '0')}.${this.pad(now.getMilliseconds().toString(), 3, '0', true)}`;
|
||||
return `${timestamp}${this.namespace ? ` [${this.namespace}]` : ''} ${text.join(' ')}`;
|
||||
const timestamp = `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()} ${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}.${now.getMilliseconds().toString().padEnd(3, '0')}`;
|
||||
return `${timestamp}${this.namespace ? ` [${this.namespace}]` : ''} ${text.map(t => typeof t == 'string' ? t : JSONSanitize(t, 2)).join(' ')}`;
|
||||
}
|
||||
|
||||
debug(...args: string[]) {
|
||||
debug(...args: any[]) {
|
||||
if(Logger.LOG_LEVEL < LOG_LEVEL.DEBUG) return;
|
||||
const str = this.format(...args);
|
||||
Logger.emit(LOG_LEVEL.DEBUG, str);
|
||||
console.debug(CliForeground.LIGHT_GREY + str + CliEffects.CLEAR);
|
||||
}
|
||||
|
||||
log(...args: string[]) {
|
||||
log(...args: any[]) {
|
||||
if(Logger.LOG_LEVEL < LOG_LEVEL.LOG) return;
|
||||
const str = this.format(...args);
|
||||
Logger.emit(LOG_LEVEL.LOG, str);
|
||||
console.log(CliEffects.CLEAR + str);
|
||||
}
|
||||
|
||||
info(...args: string[]) {
|
||||
info(...args: any[]) {
|
||||
if(Logger.LOG_LEVEL < LOG_LEVEL.INFO) return;
|
||||
const str = this.format(...args);
|
||||
Logger.emit(LOG_LEVEL.INFO, str);
|
||||
console.info(CliForeground.BLUE + str + CliEffects.CLEAR);
|
||||
}
|
||||
|
||||
warn(...args: string[]) {
|
||||
warn(...args: any[]) {
|
||||
if(Logger.LOG_LEVEL < LOG_LEVEL.WARN) return;
|
||||
const str = this.format(...args);
|
||||
Logger.emit(LOG_LEVEL.WARN, str);
|
||||
console.warn(CliForeground.YELLOW + str + CliEffects.CLEAR);
|
||||
}
|
||||
|
||||
error(...args: string[]) {
|
||||
error(...args: any[]) {
|
||||
if(Logger.LOG_LEVEL < LOG_LEVEL.ERROR) return;
|
||||
const str = this.format(...args);
|
||||
Logger.emit(LOG_LEVEL.ERROR, str);
|
||||
|
||||
14
src/misc.ts
14
src/misc.ts
@ -1,3 +1,4 @@
|
||||
import {PathEvent} from './path-events.ts';
|
||||
import {md5} from './string';
|
||||
|
||||
/**
|
||||
@ -11,3 +12,16 @@ export function gravatar(email: string, def='mp') {
|
||||
if(!email) return '';
|
||||
return `https://www.gravatar.com/avatar/${md5(email)}?d=${def}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Escape any regex special characters to avoid misinterpretation during search
|
||||
*
|
||||
* @param {string} value String which should be escaped
|
||||
* @return {string} New escaped sequence
|
||||
*/
|
||||
export function escapeRegex(value: string) {
|
||||
return value.replace(/[.*+?^${}()|\[\]\\]/g, '\\$&');
|
||||
}
|
||||
|
||||
export type Listener = (event: PathEvent, ...args: any[]) => any;
|
||||
export type Unsubscribe = () => void;
|
||||
|
||||
279
src/path-events.ts
Normal file
279
src/path-events.ts
Normal file
@ -0,0 +1,279 @@
|
||||
import {makeArray} from './array.ts';
|
||||
import {ASet} from './aset.ts';
|
||||
|
||||
/**
|
||||
* Available methods:
|
||||
* * - All/Wildcard
|
||||
* n - None
|
||||
* c - Create
|
||||
* r - Read
|
||||
* u - Update
|
||||
* d - Delete
|
||||
* x - Execute
|
||||
*/
|
||||
export type Method = '*' | 'n' | 'c' | 'r' | 'u' | 'd' | 'x';
|
||||
|
||||
/**
|
||||
* Shorthand for creating Event from a string
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* const event: Event = PE`users/system:*`;
|
||||
* ```
|
||||
*
|
||||
* @param {TemplateStringsArray} str String that will be parsed into Event
|
||||
* @param {string} args
|
||||
* @return {PathEvent} Event object
|
||||
*/
|
||||
export function PE(str: TemplateStringsArray, ...args: string[]) {
|
||||
const combined = [];
|
||||
for(let i = 0; i < str.length || i < args.length; i++) {
|
||||
if(str[i]) combined.push(str[i]);
|
||||
if(args[i]) combined.push(args[i]);
|
||||
}
|
||||
return new PathEvent(combined.join(''));
|
||||
}
|
||||
|
||||
/**
|
||||
* Shorthand for creating Event strings, ensures paths are correct
|
||||
*
|
||||
* @param {TemplateStringsArray} str
|
||||
* @param {string} args
|
||||
* @return {string}
|
||||
* @constructor
|
||||
*/
|
||||
export function PES(str: TemplateStringsArray, ...args: any[]) {
|
||||
let combined = [];
|
||||
for(let i = 0; i < str.length || i < args.length; i++) {
|
||||
if(str[i]) combined.push(str[i]);
|
||||
if(args[i]) combined.push(args[i]);
|
||||
}
|
||||
const [paths, methods] = combined.join('').split(':');
|
||||
return PathEvent.toString(paths, <any>methods?.split(''));
|
||||
}
|
||||
|
||||
export class PathError extends Error { }
|
||||
|
||||
/**
|
||||
* A event broken down into its core components for easy processing
|
||||
* Event Structure: `module/path/name:property:method`
|
||||
* Example: `users/system:crud` or `storage/some/path/file.txt:r`
|
||||
*/
|
||||
export class PathEvent {
|
||||
/** First directory in path */
|
||||
module!: string;
|
||||
/** Entire path, including the module & name */
|
||||
fullPath!: string;
|
||||
/** Path including the name, excluding the module */
|
||||
path!: string;
|
||||
/** Last sagment of path */
|
||||
name!: string;
|
||||
/** List of methods */
|
||||
methods!: ASet<Method>;
|
||||
|
||||
/** All/Wildcard specified */
|
||||
get all(): boolean { return this.methods.has('*') }
|
||||
set all(v: boolean) { v ? new ASet<Method>(['*']) : this.methods.delete('*'); }
|
||||
/** None specified */
|
||||
get none(): boolean { return this.methods.has('n') }
|
||||
set none(v: boolean) { v ? this.methods = new ASet<Method>(['n']) : this.methods.delete('n'); }
|
||||
/** Create method specified */
|
||||
get create(): boolean { return !this.methods.has('n') && (this.methods.has('*') || this.methods.has('c')) }
|
||||
set create(v: boolean) { v ? this.methods.delete('n').add('c') : this.methods.delete('c'); }
|
||||
/** Read method specified */
|
||||
get read(): boolean { return !this.methods.has('n') && (this.methods.has('*') || this.methods.has('r')) }
|
||||
set read(v: boolean) { v ? this.methods.delete('n').add('r') : this.methods.delete('r'); }
|
||||
/** Update method specified */
|
||||
get update(): boolean { return !this.methods.has('n') && (this.methods.has('*') || this.methods.has('u')) }
|
||||
set update(v: boolean) { v ? this.methods.delete('n').add('u') : this.methods.delete('u'); }
|
||||
/** Delete method specified */
|
||||
get delete(): boolean { return !this.methods.has('n') && (this.methods.has('*') || this.methods.has('d')) }
|
||||
set delete(v: boolean) { v ? this.methods.delete('n').add('d') : this.methods.delete('d'); }
|
||||
|
||||
constructor(Event: string | PathEvent) {
|
||||
if(typeof Event == 'object') return Object.assign(this, Event);
|
||||
let [p, scope, method] = Event.split(':');
|
||||
if(!method) method = scope || '*';
|
||||
if(p == '*' || !p && method == '*') {
|
||||
p = '';
|
||||
method = '*';
|
||||
}
|
||||
let temp = p.split('/').filter(p => !!p);
|
||||
this.module = temp.splice(0, 1)[0]?.toLowerCase() || '';
|
||||
this.fullPath = p;
|
||||
this.path = temp.join('/');
|
||||
this.name = temp.pop() || '';
|
||||
this.methods = new ASet(<any>method.split(''));
|
||||
}
|
||||
|
||||
/**
|
||||
* Combine multiple events into one parsed object. Longest path takes precedent, but all subsequent methods are
|
||||
* combined until a "none" is reached
|
||||
*
|
||||
* @param {string | PathEvent} paths Events as strings or pre-parsed
|
||||
* @return {PathEvent} Final combined permission
|
||||
*/
|
||||
static combine(...paths: (string | PathEvent)[]): PathEvent {
|
||||
let hitNone = false;
|
||||
const combined = paths.map(p => new PathEvent(p))
|
||||
.toSorted((p1, p2) => {
|
||||
const l1 = p1.fullPath.length, l2 = p2.fullPath.length;
|
||||
return l1 < l2 ? 1 : (l1 > l2 ? -1 : 0);
|
||||
}).reduce((acc, p) => {
|
||||
if(p.none) hitNone = true;
|
||||
if(!acc) return p;
|
||||
if(hitNone) return acc;
|
||||
acc.methods = [...acc.methods, ...p.methods];
|
||||
return acc;
|
||||
}, <any>null);
|
||||
combined.methods = new ASet<Method>(combined.methods);
|
||||
return combined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filter a set of paths based on the target
|
||||
*
|
||||
* @param {string | PathEvent | (string | PathEvent)[]} target Array of events that will filtered
|
||||
* @param filter {...PathEvent} Must container one of
|
||||
* @return {boolean} Whether there is any overlap
|
||||
*/
|
||||
static filter(target: string | PathEvent | (string | PathEvent)[], ...filter: (string | PathEvent)[]): PathEvent[] {
|
||||
const parsedTarget = makeArray(target).map(pe => new PathEvent(pe));
|
||||
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)
|
||||
&& (f.all || t.all || t.methods.intersection(f.methods).length));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Squash 2 sets of paths & return true if any overlap is found
|
||||
*
|
||||
* @param {string | PathEvent | (string | PathEvent)[]} target Array of Events as strings or pre-parsed
|
||||
* @param has Target must have at least one of these path
|
||||
* @return {boolean} Whether there is any overlap
|
||||
*/
|
||||
static has(target: string | PathEvent | (string | PathEvent)[], ...has: (string | PathEvent)[]): boolean {
|
||||
const parsedRequired = makeArray(has).map(pe => new PathEvent(pe));
|
||||
const parsedTarget = makeArray(target).map(pe => new PathEvent(pe));
|
||||
return !!parsedRequired.find(r => {
|
||||
if(!r.fullPath && r.all) return true;
|
||||
const filtered = parsedTarget.filter(p => r.fullPath.startsWith(p.fullPath));
|
||||
if(!filtered.length) return false;
|
||||
const combined = PathEvent.combine(...filtered);
|
||||
return !combined.none && (combined.all || new ASet(combined.methods).intersection(new ASet(r.methods)).length);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Squash 2 sets of paths & return true if the target has all paths
|
||||
*
|
||||
* @param {string | PathEvent | (string | PathEvent)[]} target Array of Events as strings or pre-parsed
|
||||
* @param has Target must have all these paths
|
||||
* @return {boolean} Whether there is any overlap
|
||||
*/
|
||||
static hasAll(target: string | PathEvent | (string | PathEvent)[], ...has: (string | PathEvent)[]): boolean {
|
||||
return has.filter(h => PathEvent.has(target, h)).length == has.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Same as `has` but raises an error if there is no overlap
|
||||
*
|
||||
* @param {string | string[]} target Array of Events as strings or pre-parsed
|
||||
* @param has Target must have at least one of these path
|
||||
*/
|
||||
static hasFatal(target: string | PathEvent | (string | PathEvent)[], ...has: (string | PathEvent)[]): void {
|
||||
if(!PathEvent.has(target, ...has)) throw new PathError(`Requires one of: ${makeArray(has).join(', ')}`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Same as `hasAll` but raises an error if the target is missing any paths
|
||||
*
|
||||
* @param {string | string[]} target Array of Events as strings or pre-parsed
|
||||
* @param has Target must have all these paths
|
||||
*/
|
||||
static hasAllFatal(target: string | PathEvent | (string | PathEvent)[], ...has: (string | PathEvent)[]): void {
|
||||
if(!PathEvent.hasAll(target, ...has)) throw new PathError(`Requires all: ${makeArray(has).join(', ')}`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create event string from its components
|
||||
*
|
||||
* @param {string | string[]} path Event path
|
||||
* @param {Method} methods Event method
|
||||
* @return {string} String representation of Event
|
||||
*/
|
||||
static toString(path: string | string[], methods: Method | Method[]): string {
|
||||
let p = makeArray(path).filter(p => p != null).join('/');
|
||||
p = p?.trim().replaceAll(/\/{2,}/g, '/').replaceAll(/(^\/|\/$)/g, '');
|
||||
if(methods?.length) p += `:${makeArray(methods).map(m => m.toLowerCase()).join('')}`;
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filter a set of paths based on this event
|
||||
*
|
||||
* @param {string | PathEvent | (string | PathEvent)[]} target Array of events that will filtered
|
||||
* @return {boolean} Whether there is any overlap
|
||||
*/
|
||||
filter(target: string | PathEvent | (string | PathEvent)[]): PathEvent[] {
|
||||
return PathEvent.filter(target, this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create event string from its components
|
||||
*
|
||||
* @return {string} String representation of Event
|
||||
*/
|
||||
toString() {
|
||||
return PathEvent.toString(this.fullPath, this.methods);
|
||||
}
|
||||
}
|
||||
|
||||
export type PathListener = (event: PathEvent, ...args: any[]) => any;
|
||||
export type PathUnsubscribe = () => void;
|
||||
|
||||
export interface IPathEventEmitter {
|
||||
emit(event: string, ...args: any[]): void;
|
||||
off(listener: PathListener): void;
|
||||
on(event: string, listener: PathListener): PathUnsubscribe;
|
||||
once(event: string, listener?: PathListener): Promise<any>;
|
||||
relayEvents(emitter: PathEventEmitter): void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Event emitter that uses paths allowing listeners to listen to different combinations of modules, paths & methods
|
||||
*/
|
||||
export class PathEventEmitter implements IPathEventEmitter{
|
||||
private listeners: [PathEvent, PathListener][] = [];
|
||||
|
||||
emit(event: string | PathEvent, ...args: any[]) {
|
||||
const parsed = new PathEvent(event);
|
||||
this.listeners.filter(l => PathEvent.has(l[0], event))
|
||||
.forEach(async l => l[1](parsed, ...args));
|
||||
};
|
||||
|
||||
off(listener: PathListener) {
|
||||
this.listeners = this.listeners.filter(l => l[1] != listener);
|
||||
}
|
||||
|
||||
on(event: string | string[], listener: PathListener): PathUnsubscribe {
|
||||
makeArray(event).forEach(e => this.listeners.push([new PathEvent(e), listener]));
|
||||
return () => this.off(listener);
|
||||
}
|
||||
|
||||
once(event: string | string[], listener?: PathListener): Promise<any> {
|
||||
return new Promise(res => {
|
||||
const unsubscribe = this.on(event, (event: PathEvent, ...args: any[]) => {
|
||||
res(args.length < 2 ? args[0] : args);
|
||||
if(listener) listener(event, ...args);
|
||||
unsubscribe();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
relayEvents(emitter: IPathEventEmitter) {
|
||||
emitter.on('*', (event, ...args) => this.emit(event, ...args));
|
||||
}
|
||||
}
|
||||
@ -36,14 +36,14 @@ export function sleep(ms: number): Promise<void> {
|
||||
* ```js
|
||||
* let loading = true;
|
||||
* setTimeout(() => wait = false, 1000);
|
||||
* await sleepUntil(() => loading); // Won't continue until loading flag is false
|
||||
* await sleepWhile(() => loading); // Won't continue until loading flag is false
|
||||
* ```
|
||||
*
|
||||
* @param {() => boolean | Promise<boolean>} fn Return true to continue
|
||||
* @param {number} checkInterval Run function ever x milliseconds
|
||||
* @return {Promise<void>} Callback when sleep is over
|
||||
*/
|
||||
export async function sleepUntil(fn : () => boolean | Promise<boolean>, checkInterval = 100): Promise<void> {
|
||||
export async function sleepWhile(fn : () => boolean | Promise<boolean>, checkInterval = 100): Promise<void> {
|
||||
while(await fn()) await sleep(checkInterval);
|
||||
}
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@ export default defineConfig({
|
||||
}
|
||||
},
|
||||
emptyOutDir: true,
|
||||
minify: true,
|
||||
minify: false,
|
||||
sourcemap: true
|
||||
},
|
||||
plugins: [dts()],
|
||||
|
||||
Reference in New Issue
Block a user