vivth 0.10.0 → 0.11.1

package/README.md

@@ -17,17 +17,15 @@ bun i vivth
 ## exported-api-and-type-list
 - [$](#$)
 - [Derived](#derived)
+- [PingFIFO](#pingfifo)
+- [PingUnique](#pingunique)
 - [Q](#q)
 - [QFIFO](#qfifo)
 - [QUnique](#qunique)
 - [Signal](#signal)
-- [New$](#new$)
-- [NewDerived](#newderived)
-- [NewPingFIFO](#newpingfifo)
-- [NewPingUnique](#newpingunique)
-- [NewSignal](#newsignal)
-- [tryAsync](#tryasync)
-- [trySync](#trysync)
+- [NewQBlock](#newqblock)
+- [TryAsync](#tryasync)
+- [TrySync](#trysync)
 <h2 id="$">$</h2>
 
 - a class to `autosubscribe` to an signal changes (`Derived` and `Signal` alike);
- for minimal total bundle size use `function` [New$](#new$) instead;
@@ -40,67 +38,55 @@ bun i vivth
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="q">Q</h2>
-
-- class that containts static methods to generate Promise based `awaiter` inside async function, to prevent race condition, including but not limited to:
- behaviour:
- this class provides `Q.makeQClass`;
-
-*) <sub>[go to exported list](#exported-api-and-type-list)</sub>
-
-<h2 id="qfifo">QFIFO</h2>
-
-```js
 * @typedef {[callback:()=>(any|Promise<any>),debounce?:(number)]} queueFIFODetails
 */
- a class for Queue;
- for minimal total bundle size use `function` [NewPingFIFO](#newpingfifo) instead;
- this class provides `QFIFO.makeQClass`;
-
-*) <sub>[go to exported list](#exported-api-and-type-list)</sub>
-
-<h2 id="qunique">QUnique</h2>
+<h2 id="pingfifo">PingFIFO</h2>
 
-- a class for Queue;
- for minimal total bundle size use `function` [NewPingUnique](#newpingunique) instead;
- this class provides `QUnique.makeQClass`;
+```js
 * @typedef {[callback:()=>(any|Promise<any>),debounce?:(number)]} queueFIFODetails
 */
- a class for Queue;
- function to auto queue callbacks that will be called `first in first out` style;
- this class provides `QFIFO.makeQClass`;
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="signal">Signal</h2>
+<h2 id="pingunique">PingUnique</h2>
 
-- a class for creating signal;
- can be subscribed by using [New$](#new$) or [NewDerived](#newderived);
- for minimal total bundle size use `function` [NewSignal](#newSignal) instead;
+- a class for Queue;
 new PingUnique(uniqueID, async () => {
- this class provides `QUnique.makeQClass`;
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="new$">New$</h2>
+<h2 id="q">Q</h2>
 
-- function to create `autosubscriber`;
 - syntatic sugar for [$](#$);
 // runs everytime signal.value changes;
 return signal.value * 2;
 // runs everytime signal.value changes;
 console.log(signal.value);
 // console.log(derived.value);
- behaviour:
- this class provides `Q.makeQClass`;
+- class that containts static methods to generate Promise based `awaiter` inside async function, to prevent race condition, including but not limited to:
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="newderived">NewDerived</h2>
+<h2 id="qfifo">QFIFO</h2>
 
-- function to create `signal` that its value are derived from another `signal`;
 - syntatic sugar for [Derived](#derived);
 // runs everytime signal.value changes;
 return signal.value * 2;
 // runs everytime derived.value changes;
 console.log(derived.value);
+```js
 * @typedef {[callback:()=>(any|Promise<any>),debounce?:(number)]} queueFIFODetails
 */
- a class for Queue;
- for minimal total bundle size use `function` [NewPingFIFO](#newpingfifo) instead;
- this class provides `QFIFO.makeQClass`;
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="newpingfifo">NewPingFIFO</h2>
+<h2 id="qunique">QUnique</h2>
 
-- function to auto queue callbacks that will be called `first in first out` style;
- for minimal total bundle size use `function` [NewPingUnique](#newpingunique) instead;
- this class provides `QUnique.makeQClass`;
+- a class for Queue;
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="newpingunique">NewPingUnique</h2>
+<h2 id="signal">Signal</h2>
 
-- function to auto queue callbacks:
- can be subscribed by using [New$](#new$) or [NewDerived](#newderived);
- for minimal total bundle size use `function` [NewSignal](#newSignal) instead;
+- a class for creating signal;
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="newsignal">NewSignal</h2>
+<h2 id="newqblock">NewQBlock</h2>
 
-- function to create `signal`;
 - syntatic sugar for [Signal](#signal);
 // runs everytime signal.value changes;
 return signal.value * 2;
 // runs everytime signal.value changes;
 console.log(signal.value);
- will wait next execution of the same `arg1`:`objectReferenceID`, without blocking other calls;
+- a function for Queue;
 const objectReferenceID = 'yourUniqueID'; // can be anything, reference to object is preferable;
 );
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="tryasync">tryAsync</h2>
+<h2 id="tryasync">TryAsync</h2>
 
 - error as value for asynchronous operation
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="trysync">trySync</h2>
+<h2 id="trysync">TrySync</h2>
 
 - error as value for synchronous operation
 

package/index.mjs

@@ -24,17 +24,15 @@
  */
 export { $ } from './src/class/$.mjs';
 export { Derived } from './src/class/Derived.mjs';
+export { PingFIFO } from './src/class/PingFIFO.mjs';
+export { PingUnique } from './src/class/PingUnique.mjs';
 export { Q } from './src/class/Q.mjs';
 export { QFIFO } from './src/class/QFIFO.mjs';
 export { QUnique } from './src/class/QUnique.mjs';
 export { Signal } from './src/class/Signal.mjs';
-export { New$ } from './src/function/New$.mjs';
-export { NewDerived } from './src/function/NewDerived.mjs';
-export { NewPingFIFO } from './src/function/NewPingFIFO.mjs';
-export { NewPingUnique } from './src/function/NewPingUnique.mjs';
-export { NewSignal } from './src/function/NewSignal.mjs';
-export { tryAsync } from './src/function/tryAsync.export.mjs';
-export { trySync } from './src/function/trySync.export.mjs';
+export { NewQBlock } from './src/function/NewQBlock.mjs';
+export { TryAsync } from './src/function/TryAsync.mjs';
+export { TrySync } from './src/function/TrySync.mjs';
 /**
- * @typedef {{}|null|number|string|boolean|symbol|bigint|function} anyButUndefined
+ * @typedef {{}|null|number|string|boolean|symbol|bigint|function} AnyButUndefined
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "vivth",
-	"version": "0.10.0",
+	"version": "0.11.1",
 	"description": "extremely simple signal as library primitives",
 	"main": "index.mjs",
 	"types": "./types/index.d.mts",

package/src/class/$.mjs

@@ -1,6 +1,6 @@
 // @ts-check
 
-import { NewPingFIFO } from '../function/NewPingFIFO.mjs';
+import { PingFIFO } from './PingFIFO.mjs';
 import { isAsync } from '../common.mjs';
 
 /**
@@ -46,7 +46,7 @@ export class $ {
 	 */
 	constructor(effect) {
 		this.effect = effect;
-		NewPingFIFO(async () => {
+		new PingFIFO(async () => {
 			$.isRegistering = true;
 			if (isAsync(effect)) {
 				await effect();

package/src/class/Derived.mjs

@@ -1,7 +1,7 @@
 // @ts-check
 
 import { Signal } from './Signal.mjs';
-import { New$ } from '../function//New$.mjs';
+import { $ } from './$.mjs';
 import { isAsync } from '../common.mjs';
 
 /**
@@ -28,7 +28,7 @@ export class Derived extends Signal {
 			: () => {
 					super.value = derivedFunction();
 			  };
-		New$(real);
+		new $(real);
 	}
 	/**
 	 * @type {V}

package/src/class/PingFIFO.mjs

@@ -0,0 +1,78 @@
+// @ts-check
+
+import { timeout } from '../common.mjs';
+
+/**
+ * @description
+ * ```js
+ * /**
+ *  * @typedef {[callback:()=>(any|Promise<any>),debounce?:(number)]} queueFIFODetails
+ *  *[blank]/
+ * ```
+ * - a class for Queue;
+ * - function to auto queue callbacks that will be called `first in first out` style;
+ * ```js
+ * // @ts-check
+ * import { PingFIFO } from 'vivth';
+ * const debounceMS = 0; // in miliseconds, optionals, default is 0;
+ * const handler = () =>{
+ * 	new PingFIFO(async () => {
+ * 		// your code
+ * 	}, debounceMS);
+ * }
+ * ```
+ * - 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 PingFIFO {
+	/**
+	 * @param {queueFIFODetails[]} queueArray
+	 * @returns {typeof PingFIFO}
+	 */
+	static makeQClass = (queueArray) => {
+		PingFIFO.#queue = queueArray;
+		return PingFIFO;
+	};
+	/**
+	 * @type {queueFIFODetails[]}
+	 */
+	static #queue = [];
+	/**
+	 * @type {boolean}
+	 */
+	static #isRunning = false;
+	/**
+	 * @param {()=>(any|Promise<any>)} callback
+	 * @param {number} [debounce]
+	 */
+	constructor(callback, debounce = 0) {
+		PingFIFO.#push([callback, debounce]);
+		if (PingFIFO.#isRunning) {
+			return;
+		}
+		PingFIFO.#run();
+	}
+	/**
+	 * @param {queueFIFODetails} _queue
+	 */
+	static #push = (_queue) => {
+		PingFIFO.#queue.push(_queue);
+	};
+	static #run = async () => {
+		PingFIFO.#isRunning = true;
+		while (PingFIFO.#queue.length !== 0) {
+			const [callback, debounceMs = 0] = PingFIFO.#queue[0];
+			PingFIFO.#queue.shift();
+			await callback();
+			/**
+			 * conditional debounce;
+			 * queue FIFO messing up when have debouncer while `debounceMS` are set to 0;
+			 */
+			// if (debounceMs) {
+			await timeout(debounceMs);
+			// }
+		}
+		PingFIFO.#isRunning = false;
+	};
+}

package/src/class/PingUnique.mjs

@@ -0,0 +1,84 @@
+// @ts-check
+
+import { timeout } from '../common.mjs';
+
+/**
+ * @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) => {
+		PingUnique.#queue = queueMap;
+		return PingUnique;
+	};
+	/**
+	 * @type {Map<any, [()=>Promise<void>,number]>}
+	 */
+	static #queue = new Map();
+	/**
+	 * @type {boolean}
+	 */
+	static #isRunning = false;
+	/**
+	 * @param {any} id
+	 * @param {()=>Promise<void>} callback
+	 * @param {number} [debounceMS]
+	 */
+	constructor(id, callback, debounceMS = 0) {
+		PingUnique.#push(id, callback, debounceMS);
+		if (!PingUnique.#isRunning) {
+			PingUnique.#run();
+		}
+	}
+	/**
+	 * @param {any} id
+	 * @param {()=>Promise<void>} callback
+	 * @param {number} debounceMS
+	 */
+	static #push = (id, callback, debounceMS) => {
+		PingUnique.#queue.set(id, [callback, debounceMS ? debounceMS : 0]);
+	};
+	static #run = async () => {
+		PingUnique.#isRunning = true;
+		const keysIterator = PingUnique.#queue.keys();
+		let keys = keysIterator.next();
+		while (!keys.done) {
+			const key = keys.value;
+			const q = PingUnique.#queue.get(key);
+			if (!q) {
+				return;
+			}
+			const [callback, debounce] = q;
+			PingUnique.#queue.delete(key);
+			/**
+			 * debounce anyway;
+			 * queue with unique id have characteristic of messing up when have no debouncer;
+			 * especially when request comes too fast;
+			 */
+			await timeout(debounce);
+			await callback();
+			keys = keysIterator.next();
+		}
+		PingUnique.#isRunning = false;
+	};
+}

package/src/class/Q.mjs

@@ -39,7 +39,7 @@ export class Q {
 		return Q;
 	};
 	/**
-	 * @typedef {import('../types/anyButUndefined.type.mjs').anyButUndefined} anyButUndefined
+	 * @typedef {import('../types/AnyButUndefined.type.mjs').AnyButUndefined} anyButUndefined
 	 */
 	/**
 	 * @type {Promise<void>}

package/src/function/NewQBlock.mjs

@@ -0,0 +1,39 @@
+// @ts-check
+
+import { Q } from '../class/Q.mjs';
+import { TryAsync } from './TryAsync.mjs';
+
+/**
+ * @description
+ * - a function for Queue;
+ * - will wait next execution of the same `arg1`:`objectReferenceID`, without blocking other calls;
+ * ```js
+ * // @ts-check
+ * import { NewQBlock } from 'vivth';
+ *  const objectReferenceID = 'yourUniqueID'; // can be anything, reference to object is preferable;
+ * const handler = () =>{
+ * 	NewQBlock(async () => {
+ * 		// your code
+ * 	 }, objectReferenceID //- default, will refer to `arg0`:`asyncCallaback`;
+ *  );
+ * }
+ * ```
+ */
+/**
+ * will wait next execution of the same `arg1`:`objectReferenceID`, without blocking other calls;
+ * @param {()=>Promise<void>} asyncCallaback
+ * @param {any} [objectReferenceID]
+ * - default, will refer to `arg0`:`asyncCallaback`;
+ */
+export const NewQBlock = (asyncCallaback, objectReferenceID = undefined) => {
+	TryAsync(async () => {
+		const { resume } = await Q.unique(objectReferenceID ?? asyncCallaback);
+		await asyncCallaback();
+		resume();
+	}).then(([_, error]) => {
+		if (!error) {
+			return;
+		}
+		console.error(error);
+	});
+};

package/src/function/{tryAsync.export.mjs → TryAsync.mjs}

@@ -10,7 +10,7 @@
  * @param {()=>Promise<ResultType>} asyncFunction_
  * @returns {Promise<[ResultType|undefined, Error|undefined]>}
  */
-export const tryAsync = async (asyncFunction_) => {
+export const TryAsync = async (asyncFunction_) => {
 	try {
 		const result = await asyncFunction_();
 		return [result, undefined];

package/src/function/{trySync.export.mjs → TrySync.mjs}

@@ -10,7 +10,7 @@
  * @param {()=>ResultType} function_
  * @returns {[ResultType|undefined, Error|undefined]}
  */
-export const trySync = (function_) => {
+export const TrySync = (function_) => {
 	try {
 		const result = function_();
 		return [result, undefined];

package/src/types/{anyButUndefined.type.mjs → AnyButUndefined.type.mjs}

@@ -1,5 +1,5 @@
 // @ts-check
 
 /**
- * @typedef {{}|null|number|string|boolean|symbol|bigint|function} anyButUndefined
+ * @typedef {{}|null|number|string|boolean|symbol|bigint|function} AnyButUndefined
  */

package/types/index.d.mts

@@ -1,14 +1,12 @@
 export { $ } from "./src/class/$.mjs";
 export { Derived } from "./src/class/Derived.mjs";
+export { PingFIFO } from "./src/class/PingFIFO.mjs";
+export { PingUnique } from "./src/class/PingUnique.mjs";
 export { Q } from "./src/class/Q.mjs";
 export { QFIFO } from "./src/class/QFIFO.mjs";
 export { QUnique } from "./src/class/QUnique.mjs";
 export { Signal } from "./src/class/Signal.mjs";
-export { New$ } from "./src/function/New$.mjs";
-export { NewDerived } from "./src/function/NewDerived.mjs";
-export { NewPingFIFO } from "./src/function/NewPingFIFO.mjs";
-export { NewPingUnique } from "./src/function/NewPingUnique.mjs";
-export { NewSignal } from "./src/function/NewSignal.mjs";
-export { tryAsync } from "./src/function/tryAsync.export.mjs";
-export { trySync } from "./src/function/trySync.export.mjs";
-export type anyButUndefined = {} | null | number | string | boolean | symbol | bigint | Function;
+export { NewQBlock } from "./src/function/NewQBlock.mjs";
+export { TryAsync } from "./src/function/TryAsync.mjs";
+export { TrySync } from "./src/function/TrySync.mjs";
+export type AnyButUndefined = {} | null | number | string | boolean | symbol | bigint | Function;

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

@@ -0,0 +1,57 @@
+/**
+ * @description
+ * ```js
+ * /**
+ *  * @typedef {[callback:()=>(any|Promise<any>),debounce?:(number)]} queueFIFODetails
+ *  *[blank]/
+ * ```
+ * - a class for Queue;
+ * - function to auto queue callbacks that will be called `first in first out` style;
+ * ```js
+ * // @ts-check
+ * import { PingFIFO } from 'vivth';
+ * const debounceMS = 0; // in miliseconds, optionals, default is 0;
+ * const handler = () =>{
+ * 	new PingFIFO(async () => {
+ * 		// your code
+ * 	}, debounceMS);
+ * }
+ * ```
+ * - 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 PingFIFO {
+    /**
+     * @param {queueFIFODetails[]} queueArray
+     * @returns {typeof PingFIFO}
+     */
+    static makeQClass: (queueArray: queueFIFODetails[]) => typeof PingFIFO;
+    /**
+     * @type {queueFIFODetails[]}
+     */
+    static "__#1@#queue": queueFIFODetails[];
+    /**
+     * @type {boolean}
+     */
+    static "__#1@#isRunning": boolean;
+    /**
+     * @param {queueFIFODetails} _queue
+     */
+    static "__#1@#push": (_queue: queueFIFODetails) => void;
+    static "__#1@#run": () => Promise<void>;
+    /**
+     * @param {()=>(any|Promise<any>)} callback
+     * @param {number} [debounce]
+     */
+    constructor(callback: () => (any | Promise<any>), debounce?: number);
+}
+/**
+ * *[blank]/
+ * ```
+ * - a class for Queue;
+ * - function to auto queue callbacks that will be called `first in first out` style;
+ * ```js
+ * //
+ */
+export type queueFIFODetails = [callback: () => (any | Promise<any>), debounce?: (number)];

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

@@ -0,0 +1,48 @@
+/**
+ * @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

@@ -34,12 +34,12 @@ export class Q {
      */
     static makeQClass: (uniqueMap: Map<any, Promise<any>>) => typeof Q;
     /**
-     * @typedef {import('../types/anyButUndefined.type.mjs').anyButUndefined} anyButUndefined
+     * @typedef {import('../types/AnyButUndefined.type.mjs').AnyButUndefined} anyButUndefined
      */
     /**
      * @type {Promise<void>}
      */
-    static "__#3@#fifo": 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
@@ -50,14 +50,14 @@ export class Q {
     /**
      * @type {Map<any, Promise<any>>}
      */
-    static "__#3@#unique": 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<{
+    static unique: (id: import("../types/AnyButUndefined.type.mjs").AnyButUndefined) => Promise<{
         resume: () => void;
     }>;
 }

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

@@ -20,11 +20,11 @@ export class QFIFO {
     /**
      * @type {queueFIFODetails[]}
      */
-    static "__#1@#queue": queueFIFODetails[];
+    static "__#5@#queue": queueFIFODetails[];
     /**
      * @type {boolean}
      */
-    static "__#1@#isRunning": boolean;
+    static "__#5@#isRunning": boolean;
     /**
      * @type {(...queueFIFODetails:queueFIFODetails)=>void}
      */
@@ -32,8 +32,8 @@ export class QFIFO {
     /**
      * @param {queueFIFODetails} _queue
      */
-    static "__#1@#push": (_queue: queueFIFODetails) => void;
-    static "__#1@#run": () => Promise<void>;
+    static "__#5@#push": (_queue: queueFIFODetails) => void;
+    static "__#5@#run": () => Promise<void>;
 }
 /**
  * *[blank]/

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

@@ -21,11 +21,11 @@ export class QUnique {
     /**
      * @type {Map<any, [()=>Promise<any>,number]>}
      */
-    static "__#4@#queue": Map<any, [() => Promise<any>, number]>;
+    static "__#6@#queue": Map<any, [() => Promise<any>, number]>;
     /**
      * @type {boolean}
      */
-    static "__#4@#isRunning": boolean;
+    static "__#6@#isRunning": boolean;
     /**
      * @type {(queueUniqueObject:queueUniqueObject)=>void}
      */
@@ -37,10 +37,10 @@ export class QUnique {
     /**
      * @param {queueUniqueObject} _queue
      */
-    static "__#4@#push": (_queue: {
+    static "__#6@#push": (_queue: {
         i: any;
         c: () => (any | Promise<any>);
         d?: number;
     }) => void;
-    static "__#4@#run": () => Promise<void>;
+    static "__#6@#run": () => Promise<void>;
 }

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

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

package/types/src/function/{tryAsync.export.d.mts → TryAsync.d.mts}

@@ -1 +1 @@
-export function tryAsync<ResultType>(asyncFunction_: () => Promise<ResultType>): Promise<[ResultType | undefined, Error | undefined]>;
+export function TryAsync<ResultType>(asyncFunction_: () => Promise<ResultType>): Promise<[ResultType | undefined, Error | undefined]>;

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

@@ -0,0 +1 @@
+export function TrySync<ResultType>(function_: () => ResultType): [ResultType | undefined, Error | undefined];

package/types/src/types/AnyButUndefined.type.d.mts

@@ -0,0 +1 @@
+export type AnyButUndefined = {} | null | number | string | boolean | symbol | bigint | Function;

package/src/function/New$.mjs

@@ -1,28 +0,0 @@
-// @ts-check
-
-import { $ } from '../class/$.mjs';
-
-/**
- * @description
- *  - function to create `autosubscriber`;
- *  - syntatic sugar for [$](#$);
- * ```js
- * import { New$, NewDerived, NewSignal } from 'vivth';
- * const signal = NewSignal(0);
- * const derived = NewDerived(async () =>{
- *  // runs everytime signal.value changes;
- *  return signal.value * 2;
- * });
- * const autosubscriber = New$(async ()=>{
- *  // runs everytime signal.value changes;
- *  console.log(signal.value);
- *  // console.log(derived.value);
- * });
- * signal.value = 1;
- * ```
- */
-/**
- * @param {()=>void} effect subscriber
- * @returns {$} instance of `$`
- */
-export const New$ = (effect) => new $(effect);

package/src/function/NewDerived.mjs

@@ -1,28 +0,0 @@
-// @ts-check
-
-import { Derived } from '../class/Derived.mjs';
-
-/**
- * @description
- *  - function to create `signal` that its value are derived from another `signal`;
- *  - syntatic sugar for [Derived](#derived);
- * ```js
- * import { New$, NewDerived, NewSignal } from 'vivth';
- * const signal = NewSignal(0);
- * const derived = NewDerived(async () =>{
- *  // runs everytime signal.value changes;
- *  return signal.value * 2;
- * });
- * const autosubscriber = New$(async ()=>{
- *  // runs everytime derived.value changes;
- *  console.log(derived.value);
- * });
- * signal.value = 1;
- * ```
- */
-/**
- * @template V
- * @param {()=>(V)} derivedFunction
- * @returns {Derived<V>}
- */
-export const NewDerived = (derivedFunction) => new Derived(derivedFunction);

package/src/function/NewPingFIFO.mjs

@@ -1,24 +0,0 @@
-// @ts-check
-
-import { QFIFO } from '../class/QFIFO.mjs';
-
-/**
- * @description
- * - function to auto queue callbacks that will be called `first in first out` style;
- * ```js
- * // @ts-check
- * import { NewPingFIFO } from 'vivth';
- * const debounceMS = 0; // in miliseconds, optionals, default is 0;
- * const handler = () =>{
- * 	NewPingFIFO(async () => {
- * 		// your code
- * 	}, debounceMS);
- * }
- * ```
- */
-/**
- * @param {()=>(any|Promise<any>)} callback
- * @param {number} debounce
- * @returns
- */
-export const NewPingFIFO = (callback, debounce = 0) => QFIFO.assign(callback, debounce);

package/src/function/NewPingUnique.mjs

@@ -1,29 +0,0 @@
-// @ts-check
-
-import { QUnique } from '../../index.mjs';
-
-/**
- * @description
- * - function to auto queue callbacks:
- * > - 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 { NewPingUnique } 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 = () =>{
- * 	NewPingUnique(uniqueID, async () => {
- * 		// your code
- * 	}, debounceMS);
- * }
- * ```
- */
-/**
- * @param {import('../../index.mjs').anyButUndefined} uniqueID
- * @param {()=>(any|Promise<any>)} callback
- * @param {number} debounce
- * @returns
- */
-export const NewPingUnique = (uniqueID, callback, debounce = 0) =>
-	QUnique.assign({ i: uniqueID, c: callback, d: debounce });

package/src/function/NewSignal.mjs

@@ -1,28 +0,0 @@
-// @ts-check
-
-import { Signal } from '../class/Signal.mjs';
-
-/**
- * @description
- *  - function to create `signal`;
- *  - syntatic sugar for [Signal](#signal);
- * ```js
- * import { New$, NewDerived, NewSignal } from 'vivth';
- * const signal = NewSignal(0);
- * const derived = NewDerived(async () =>{
- *  // runs everytime signal.value changes;
- *  return signal.value * 2;
- * });
- * const autosubscriber = New$(async ()=>{
- *  // runs everytime signal.value changes;
- *  console.log(signal.value);
- * });
- * signal.value = 1;
- * ```
- */
-/**
- * @template Value
- * @param {Value} value
- * @returns {Signal<Value>}
- */
-export const NewSignal = (value) => new Signal(value);

package/types/src/function/New$.d.mts

@@ -1,2 +0,0 @@
-export function New$(effect: () => void): $;
-import { $ } from '../class/$.mjs';

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

@@ -1,2 +0,0 @@
-export function NewDerived<V>(derivedFunction: () => (V)): Derived<V>;
-import { Derived } from '../class/Derived.mjs';

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

@@ -1 +0,0 @@
-export function NewPingFIFO(callback: () => (any | Promise<any>), debounce?: number): void;

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

@@ -1 +0,0 @@
-export function NewPingUnique(uniqueID: import("../../index.mjs").anyButUndefined, callback: () => (any | Promise<any>), debounce?: number): void;

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

@@ -1,2 +0,0 @@
-export function NewSignal<Value>(value: Value): Signal<Value>;
-import { Signal } from '../class/Signal.mjs';

package/types/src/function/trySync.export.d.mts

@@ -1 +0,0 @@
-export function trySync<ResultType>(function_: () => ResultType): [ResultType | undefined, Error | undefined];

package/types/src/types/anyButUndefined.type.d.mts

@@ -1 +0,0 @@
-export type anyButUndefined = {} | null | number | string | boolean | symbol | bigint | Function;