@ztimson/utils 0.20.12 → 0.21.0

package/dist/time.d.ts

@@ -24,14 +24,14 @@ export declare function sleep(ms: number): Promise<void>;
  * ```js
  * let loading = true;
  * setTimeout(() => wait = false, 1000);
- * await sleepWhile(() => loading); // Won't continue until loading flag is false
+ * await sleepUntil(() => 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 declare function sleepWhile(fn: () => boolean | Promise<boolean>, checkInterval?: number): Promise<void>;
+export declare function sleepUntil(fn: () => boolean | Promise<boolean>, checkInterval?: number): Promise<void>;
 /**
  * Calculate the number of milliseconds until date/time
  *

package/package.json

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

package/dist/path-events.d.ts

@@ -1,137 +0,0 @@
-/**
- * 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 declare function PE(str: TemplateStringsArray, ...args: string[]): PathEvent;
-/**
- * Shorthand for creating Event strings, ensures paths are correct
- *
- * @param {TemplateStringsArray} str
- * @param {string} args
- * @return {string}
- * @constructor
- */
-export declare function PES(str: TemplateStringsArray, ...args: any[]): string;
-export declare 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 declare 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: Method[];
-    /** All/Wildcard specified */
-    all: boolean;
-    /** None specified */
-    none: boolean;
-    /** Create method specified */
-    create: boolean;
-    /** Read method specified */
-    read: boolean;
-    /** Update method specified */
-    update: boolean;
-    /** Delete method specified */
-    delete: boolean;
-    constructor(Event: string | PathEvent);
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * Create  event string from its components
-     *
-     * @return {string} String representation of Event
-     */
-    toString(): string;
-}
-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 declare class PathEventEmitter implements IPathEventEmitter {
-    private listeners;
-    emit(event: string | PathEvent, ...args: any[]): void;
-    off(listener: PathListener): void;
-    on(event: string | string[], listener: PathListener): PathUnsubscribe;
-    once(event: string | string[], listener?: PathListener): Promise<any>;
-    relayEvents(emitter: IPathEventEmitter): void;
-}