vivth 0.11.2 → 1.0.0

package/types/src/class/PingUnique.d.mts

@@ -1,48 +0,0 @@
-/**
- * @description
- * - a class for Queue;
- * > - different `uniqueID`: called `first in first out` style;
- * > - same `uniqueID`: will be grouped, only the already running callback and the last callback will be called;
- * ```js
- * // @ts-check
- * import { PingUnique } from 'vivth';
- * const uniqueID = 'yourUniqueID'; // can be anything, even a reference to an object;
- * const debounceMS = 0; // in miliseconds, optionals, default is 0;
- * const handler = () =>{
- *  new PingUnique(uniqueID, async () => {
- * 		// your code
- * 	}, debounceMS);
- * }
- * ```
- * - this class provides `QUnique.makeQClass`;
- * >- this method will setup `QUnique` to use the inputed `queueMap`(as arg0) as centralized lookup for queue managed by `QUnique`;
- * >- usefull to modify this class for browser runtime, since `vivth` cannot just refer to window, you can just add `window["someobject"]`: `Map<any, [()=>Promise<any>,number]>` as lookups;
- */
-export class PingUnique {
-    /**
-     * @param {Map<any, [()=>Promise<void>,number]>} queueMap
-     * @returns {typeof PingUnique}
-     */
-    static makeQClass: (queueMap: Map<any, [() => Promise<void>, number]>) => typeof PingUnique;
-    /**
-     * @type {Map<any, [()=>Promise<void>,number]>}
-     */
-    static "__#3@#queue": Map<any, [() => Promise<void>, number]>;
-    /**
-     * @type {boolean}
-     */
-    static "__#3@#isRunning": boolean;
-    /**
-     * @param {any} id
-     * @param {()=>Promise<void>} callback
-     * @param {number} debounceMS
-     */
-    static "__#3@#push": (id: any, callback: () => Promise<void>, debounceMS: number) => void;
-    static "__#3@#run": () => Promise<void>;
-    /**
-     * @param {any} id
-     * @param {()=>Promise<void>} callback
-     * @param {number} [debounceMS]
-     */
-    constructor(id: any, callback: () => Promise<void>, debounceMS?: number);
-}

package/types/src/class/Q.d.mts

@@ -1,63 +0,0 @@
-/**
- * @description
- * - class that containts static methods to generate Promise based `awaiter` inside async function, to prevent race condition, including but not limited to:
- * > - modifying the same `Map`, `Set`(etc.) `Object`/`Instance` inside a `Promise.all`/any code that might fired simultanously;
- * ```js
- * import { Q } from 'vivth';
- *
- * const handler = async () => {
- * 	// your code;
- * 	const { resume } = await Q.fifo() // or await Q.unique(uniqueID);
- * 	// your code that modifies and/or access same `Map`;
- * 	resume();
- * 	// the rest of your code;
- * 	return;
- * }
- *
- * const runtime = async () => {
- * 	// await Promise.all(handler1, handler2, ..., handlern);
- * }
- *
- * runtime();
- * ```
- * - behaviour:
- * > - `fifo`: call all queued callback `first in first out` style;
- * > - `unique`: call all queued callback with the same `uniqueID` `first in first out` style, if the `uniqueID` is different it will be called in parallel;
- * - this class provides `Q.makeQClass`;
- * >- this method will setup `Q` to use the inputed `uniqueMap`(as arg0) as centralized lookup for queue managed by `Q`;
- * >- usefull to modify this class for browser runtime, since `vivth` cannot just refer to window, you can just add `window["someobject"]`: `Array<Map<any, Promise<any>>>` as lookups;
- */
-export class Q {
-    /**
-     * @param {Map<any, Promise<any>>} uniqueMap
-     * @returns {typeof Q}
-     */
-    static makeQClass: (uniqueMap: Map<any, Promise<any>>) => typeof Q;
-    /**
-     * @typedef {import('../types/AnyButUndefined.type.mjs').AnyButUndefined} anyButUndefined
-     */
-    /**
-     * @type {Promise<void>}
-     */
-    static "__#4@#fifo": Promise<void>;
-    /**
-     * Blocks execution for subsequent calls until the current one finishes.
-     * @returns {Promise<{resume:()=>void}>} Resolves when it's safe to proceed, returning a cleanup function
-     */
-    static fifo: () => Promise<{
-        resume: () => void;
-    }>;
-    /**
-     * @type {Map<any, Promise<any>>}
-     */
-    static "__#4@#unique": Map<any, Promise<any>>;
-    /**
-     * Ensures that each id has only one task running at a time.
-     * Calls with the same id will wait for the previous call to finish.
-     * @param {anyButUndefined} id
-     * @returns {Promise<{resume:()=>void}>} Resolves when it's safe to proceed for the given id, returning a cleanup function
-     */
-    static unique: (id: import("../types/AnyButUndefined.type.mjs").AnyButUndefined) => Promise<{
-        resume: () => void;
-    }>;
-}

package/types/src/class/QFIFO.d.mts

@@ -1,47 +0,0 @@
-/**
- * @description
- * ```js
- * /**
- *  * @typedef {[callback:()=>(any|Promise<any>),debounce?:(number)]} queueFIFODetails
- *  *[blank]/
- * ```
- * - a class for Queue;
- * - for minimal total bundle size use `function` [NewPingFIFO](#newpingfifo) instead;
- * - this class provides `QFIFO.makeQClass`;
- * >- this method will setup `QFIFO` to use the inputed `queueArray`(as arg0) as centralized lookup for queue managed by `QFIFO`;
- * >- usefull to modify this class for browser runtime, since `vivth` cannot just refer to window, you can just add `window["someobject"]`: `Array<queueFIFODetails>` as lookups;
- */
-export class QFIFO {
-    /**
-     * @param {queueFIFODetails[]} queueArray
-     * @returns {typeof QFIFO}
-     */
-    static makeQClass: (queueArray: queueFIFODetails[]) => typeof QFIFO;
-    /**
-     * @type {queueFIFODetails[]}
-     */
-    static "__#5@#queue": queueFIFODetails[];
-    /**
-     * @type {boolean}
-     */
-    static "__#5@#isRunning": boolean;
-    /**
-     * @type {(...queueFIFODetails:queueFIFODetails)=>void}
-     */
-    static assign: (...queueFIFODetails: queueFIFODetails) => void;
-    /**
-     * @param {queueFIFODetails} _queue
-     */
-    static "__#5@#push": (_queue: queueFIFODetails) => void;
-    static "__#5@#run": () => Promise<void>;
-}
-/**
- * *[blank]/
- * ```
- * - a class for Queue;
- * - for minimal total bundle size use `function` [NewPingFIFO](#newpingfifo) instead;
- * - this class provides `QFIFO.makeQClass`;
- * >- this method will setup `QFIFO` to use the inputed `queueArray`(as arg0) as centralized lookup for queue managed by `QFIFO`;
- * >- usefull to modify this class for browser runtime, since `vivth` cannot just refer to window, you can just add `window["someobject"]`: `Array<queueFIFODetails>` as lookups;
- */
-export type queueFIFODetails = [callback: () => (any | Promise<any>), debounce?: (number)];

package/types/src/class/QUnique.d.mts

@@ -1,46 +0,0 @@
-/**
- * @description
- * - a class for Queue;
- * - for minimal total bundle size use `function` [NewPingUnique](#newpingunique) instead;
- * - this class provides `QUnique.makeQClass`;
- * >- this method will setup `QUnique` to use the inputed `queueMap`(as arg0) as centralized lookup for queue managed by `QUnique`;
- * >- usefull to modify this class for browser runtime, since `vivth` cannot just refer to window, you can just add `window["someobject"]`: `Map<any, [()=>Promise<any>,number]>` as lookups;
- */
-export class QUnique {
-    /**
-     * @param {Map<any, [()=>Promise<any>,number]>} queueMap
-     * @returns {typeof QUnique}
-     */
-    static makeQClass: (queueMap: Map<any, [() => Promise<any>, number]>) => typeof QUnique;
-    /**
-     * @typedef {Object} queueUniqueObject
-     * @property {any} i
-     * @property {()=>(any|Promise<any>)} c
-     * @property {number} [d]
-     */
-    /**
-     * @type {Map<any, [()=>Promise<any>,number]>}
-     */
-    static "__#6@#queue": Map<any, [() => Promise<any>, number]>;
-    /**
-     * @type {boolean}
-     */
-    static "__#6@#isRunning": boolean;
-    /**
-     * @type {(queueUniqueObject:queueUniqueObject)=>void}
-     */
-    static assign: (queueUniqueObject: {
-        i: any;
-        c: () => (any | Promise<any>);
-        d?: number;
-    }) => void;
-    /**
-     * @param {queueUniqueObject} _queue
-     */
-    static "__#6@#push": (_queue: {
-        i: any;
-        c: () => (any | Promise<any>);
-        d?: number;
-    }) => void;
-    static "__#6@#run": () => Promise<void>;
-}

package/types/src/common.d.mts

@@ -1,2 +0,0 @@
-export function timeout(ms: number): Promise<void>;
-export function isAsync(fn: (...any: any) => (any | Promise<any>)): boolean;

package/types/src/function/NewQBlock.d.mts

@@ -1 +0,0 @@
-export function NewQBlock(asyncCallaback: () => Promise<void>, objectReferenceID?: any): void;