vivth 0.10.0 → 0.11.0

package/README.md

@@ -14,93 +14,67 @@ bun i vivth
 - `vivth` technically can run in any `js runtime`, since it uses non platform specific api;
 - it is written specifically to be used as a primitives for javascript library or runtime, so there are no complex abstraction is, nor will be, added in `vivth` it self;
 
+### version
+- 0.11.x: drop function wrapper for all classes, for better runtime performance
 ## 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;
+- a class to `autosubscribe` to an signal changes (`Derived` and `Signal` alike);
 // runs everytime signal.value changes;
 return signal.value * 2;
 // runs everytime signal.value changes;
 console.log(signal.value);
 // console.log(derived.value);
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
 <h2 id="derived">Derived</h2>
 
-- a class for creating signal which its value are derived from other signal (`Derived` and `Signal` alike);
- can be subscribed by using [New$](#new$);
- for minimal total bundle size use `function` [NewDerived](#newderived) instead;
+- a class for creating signal which its value are derived from other signal (`Derived` and `Signal` alike);
 // runs everytime signal.value changes;
 return signal.value * 2;
 // runs everytime derived.value changes;
 console.log(derived.value);
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
-<h2 id="q">Q</h2>
+<h2 id="pingfifo">PingFIFO</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`;
+```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="qfifo">QFIFO</h2>
+<h2 id="pingunique">PingUnique</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`;
+- 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="qunique">QUnique</h2>
+<h2 id="q">Q</h2>
 
-- a class for Queue;
- for minimal total bundle size use `function` [NewPingUnique](#newpingunique) instead;
- this class provides `QUnique.makeQClass`;
- 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="signal">Signal</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;
-
-*) <sub>[go to exported list](#exported-api-and-type-list)</sub>
-
-<h2 id="new$">New$</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);
-
-*) <sub>[go to exported list](#exported-api-and-type-list)</sub>
-
-<h2 id="newderived">NewDerived</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);
-
-*) <sub>[go to exported list](#exported-api-and-type-list)</sub>
-
-<h2 id="newpingfifo">NewPingFIFO</h2>
-
-- function to auto queue callbacks that will be called `first in first out` style;
-
-*) <sub>[go to exported list](#exported-api-and-type-list)</sub>
-
-<h2 id="newpingunique">NewPingUnique</h2>
-
-- function to auto queue callbacks:
+- a class for creating signal;
 // runs everytime signal.value changes;
 return signal.value * 2;
 // runs everytime signal.value changes;
 console.log(signal.value);
 
 *) <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/dev/index.mjs

@@ -24,5 +24,7 @@ new __JSDev({
 		'- `vivth` technically can run in any `js runtime`, since it uses non platform specific api;',
 		'- it is written specifically to be used as a primitives for javascript library or runtime, so there are no complex abstraction is, nor will be, added in `vivth` it self;',
 		'',
+		'### version',
+		'- 0.11.x: drop function wrapper for all classes, for better runtime performance',
 	],
 }).run();

package/index.mjs

@@ -21,20 +21,18 @@
  * - `vivth` technically can run in any `js runtime`, since it uses non platform specific api;
  * - it is written specifically to be used as a primitives for javascript library or runtime, so there are no complex abstraction is, nor will be, added in `vivth` it self;
  * 
+ * ### version
+ * - 0.11.x: drop function wrapper for all classes, for better runtime performance
  */
 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.0",
 	"description": "extremely simple signal as library primitives",
 	"main": "index.mjs",
 	"types": "./types/index.d.mts",

package/src/class/$.mjs

@@ -1,12 +1,25 @@
 // @ts-check
 
-import { NewPingFIFO } from '../function/NewPingFIFO.mjs';
 import { isAsync } from '../common.mjs';
+import { NewQBlock } from '../function/NewQBlock.mjs';
 
 /**
  * @description
  * - a class to `autosubscribe` to an signal changes (`Derived` and `Signal` alike);
- * - for minimal total bundle size use `function` [New$](#new$) instead;
+ * ```js
+ * import { $, Derived, Signal } from 'vivth';
+ * const signal = new Signal(0);
+ * const derived = new Derived(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;
+ * ```
  */
 export class $ {
 	/**
@@ -32,26 +45,27 @@ export class $ {
 	 * @returns {void}
 	 */
 	remove$ = () => {
-		$.effects.get(this)?.forEach((signalInstance) => {
-			$.mappedSignals.get(signalInstance).delete(this);
-		});
-		$.effects.set(this, new Set());
+		NewQBlock(async () => {
+			$.effects.get(this)?.forEach((signalInstance) => {
+				$.mappedSignals.get(signalInstance).delete(this);
+			});
+			$.effects.set(this, new Set());
+		}, $);
 	};
 	/**
-	 * @type {()=>void}
+	 * @type {(arg:{remove$:$["remove$"]})=>void};
 	 */
 	effect;
 	/**
-	 * @param {$["effect"]} effect
+	 * @param {(arg:{remove$:$["remove$"]})=>void} effect
 	 */
 	constructor(effect) {
 		this.effect = effect;
-		NewPingFIFO(async () => {
+		NewQBlock(async () => {
 			$.isRegistering = true;
+			const check = this.effect({ remove$: this.remove$ });
 			if (isAsync(effect)) {
-				await effect();
-			} else {
-				effect();
+				await check;
 			}
 			$.isRegistering = false;
 			const signalInstances = $.activeSignal;
@@ -63,6 +77,6 @@ export class $ {
 				$.mappedSignals.get(signal).add(this);
 			});
 			$.activeSignal = new Set();
-		});
+		}, $);
 	}
 }

package/src/class/Derived.mjs

@@ -1,14 +1,25 @@
 // @ts-check
 
 import { Signal } from './Signal.mjs';
-import { New$ } from '../function//New$.mjs';
 import { isAsync } from '../common.mjs';
+import { $ } from './$.mjs';
 
 /**
  * @description
  * - a class for creating signal which its value are derived from other signal (`Derived` and `Signal` alike);
- * - can be subscribed by using [New$](#new$);
- * - for minimal total bundle size use `function` [NewDerived](#newderived) instead;
+ * ```js
+ * import { $, Derived, Signal } from 'vivth';
+ * const signal = new Signal(0);
+ * const derived = new Derived(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
@@ -16,19 +27,24 @@ import { isAsync } from '../common.mjs';
  */
 export class Derived extends Signal {
 	/**
-	 * @param {()=>V} derivedFunction
+	 * @param {(arg:{remove$:$["remove$"]})=>V} derivedFunction
 	 */
 	constructor(derivedFunction) {
-		// @ts-expect-error
-		super(0);
+		super(undefined);
 		const real = isAsync(derivedFunction)
-			? async () => {
-					super.value = await derivedFunction();
+			? /**
+			   * @param {{remove$:$["remove$"]}} options
+			   */
+			  async (options) => {
+					super.value = await derivedFunction(options);
 			  }
-			: () => {
-					super.value = derivedFunction();
+			: /**
+			   * @param {{remove$:$["remove$"]}} options
+			   */
+			  (options) => {
+					super.value = derivedFunction(options);
 			  };
-		New$(real);
+		new $(real);
 	}
 	/**
 	 * @type {V}

package/src/class/{QFIFO.mjs → PingFIFO.mjs}

@@ -10,19 +10,29 @@ import { timeout } from '../common.mjs';
  *  *[blank]/
  * ```
  * - a class for Queue;
- * - for minimal total bundle size use `function` [NewPingFIFO](#newpingfifo) instead;
+ * - 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 QFIFO {
+export class PingFIFO {
 	/**
 	 * @param {queueFIFODetails[]} queueArray
-	 * @returns {typeof QFIFO}
+	 * @returns {typeof PingFIFO}
 	 */
 	static makeQClass = (queueArray) => {
-		QFIFO.#queue = queueArray;
-		return QFIFO;
+		PingFIFO.#queue = queueArray;
+		return PingFIFO;
 	};
 	/**
 	 * @type {queueFIFODetails[]}
@@ -33,25 +43,27 @@ export class QFIFO {
 	 */
 	static #isRunning = false;
 	/**
-	 * @type {(...queueFIFODetails:queueFIFODetails)=>void}
+	 * @param {()=>(any|Promise<any>)} callback
+	 * @param {number} [debounce]
 	 */
-	static assign = (..._queue) => {
-		QFIFO.#push(_queue);
-		if (!QFIFO.#isRunning) {
-			QFIFO.#run();
+	constructor(callback, debounce = 0) {
+		PingFIFO.#push([callback, debounce]);
+		if (PingFIFO.#isRunning) {
+			return;
 		}
-	};
+		PingFIFO.#run();
+	}
 	/**
 	 * @param {queueFIFODetails} _queue
 	 */
 	static #push = (_queue) => {
-		QFIFO.#queue.push(_queue);
+		PingFIFO.#queue.push(_queue);
 	};
 	static #run = async () => {
-		QFIFO.#isRunning = true;
-		while (QFIFO.#queue.length !== 0) {
-			const [callback, debounceMs = 0] = QFIFO.#queue[0];
-			QFIFO.#queue.shift();
+		PingFIFO.#isRunning = true;
+		while (PingFIFO.#queue.length !== 0) {
+			const [callback, debounceMs = 0] = PingFIFO.#queue[0];
+			PingFIFO.#queue.shift();
 			await callback();
 			/**
 			 * conditional debounce;
@@ -61,6 +73,6 @@ export class QFIFO {
 			await timeout(debounceMs);
 			// }
 		}
-		QFIFO.#isRunning = false;
+		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/class/Signal.mjs

@@ -5,8 +5,19 @@ import { $ } from './$.mjs';
 /**
  * @description
  * - 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;
+ * ```js
+ * import { $, Derived, Signal } from 'vivth';
+ * const signal = new Signal(0);
+ * const derived = new Derived(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
@@ -94,6 +105,6 @@ export class Signal {
 		if (!this.subscribed) {
 			return;
 		}
-		this.subscribed.forEach(($_) => $_.effect());
+		this.subscribed.forEach(($_) => $_.effect({ remove$: $_.remove$ }));
 	};
 }

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,10 @@
 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/$.d.mts

@@ -1,7 +1,20 @@
 /**
  * @description
  * - a class to `autosubscribe` to an signal changes (`Derived` and `Signal` alike);
- * - for minimal total bundle size use `function` [New$](#new$) instead;
+ * ```js
+ * import { $, Derived, Signal } from 'vivth';
+ * const signal = new Signal(0);
+ * const derived = new Derived(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;
+ * ```
  */
 export class $ {
     /**
@@ -24,15 +37,19 @@ export class $ {
      */
     static isRegistering: boolean;
     /**
-     * @param {$["effect"]} effect
+     * @param {(arg:{remove$:$["remove$"]})=>void} effect
      */
-    constructor(effect: $["effect"]);
+    constructor(effect: (arg: {
+        remove$: $["remove$"];
+    }) => void);
     /**
      * @returns {void}
      */
     remove$: () => void;
     /**
-     * @type {()=>void}
+     * @type {(arg:{remove$:$["remove$"]})=>void};
      */
-    effect: () => void;
+    effect: (arg: {
+        remove$: $["remove$"];
+    }) => void;
 }

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

@@ -1,8 +1,19 @@
 /**
  * @description
  * - a class for creating signal which its value are derived from other signal (`Derived` and `Signal` alike);
- * - can be subscribed by using [New$](#new$);
- * - for minimal total bundle size use `function` [NewDerived](#newderived) instead;
+ * ```js
+ * import { $, Derived, Signal } from 'vivth';
+ * const signal = new Signal(0);
+ * const derived = new Derived(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
@@ -10,8 +21,11 @@
  */
 export class Derived<V> extends Signal<V> {
     /**
-     * @param {()=>V} derivedFunction
+     * @param {(arg:{remove$:$["remove$"]})=>V} derivedFunction
      */
-    constructor(derivedFunction: () => V);
+    constructor(derivedFunction: (arg: {
+        remove$: $["remove$"];
+    }) => V);
 }
 import { Signal } from './Signal.mjs';
+import { $ } from './$.mjs';

package/types/src/class/{QFIFO.d.mts → PingFIFO.d.mts}

@@ -6,42 +6,52 @@
  *  *[blank]/
  * ```
  * - a class for Queue;
- * - for minimal total bundle size use `function` [NewPingFIFO](#newpingfifo) instead;
+ * - 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 QFIFO {
+export class PingFIFO {
     /**
      * @param {queueFIFODetails[]} queueArray
-     * @returns {typeof QFIFO}
+     * @returns {typeof PingFIFO}
      */
-    static makeQClass: (queueArray: queueFIFODetails[]) => typeof QFIFO;
+    static makeQClass: (queueArray: queueFIFODetails[]) => typeof PingFIFO;
     /**
      * @type {queueFIFODetails[]}
      */
-    static "__#1@#queue": queueFIFODetails[];
+    static "__#3@#queue": queueFIFODetails[];
     /**
      * @type {boolean}
      */
-    static "__#1@#isRunning": boolean;
+    static "__#3@#isRunning": boolean;
     /**
-     * @type {(...queueFIFODetails:queueFIFODetails)=>void}
+     * @param {queueFIFODetails} _queue
      */
-    static assign: (...queueFIFODetails: queueFIFODetails) => void;
+    static "__#3@#push": (_queue: queueFIFODetails) => void;
+    static "__#3@#run": () => Promise<void>;
     /**
-     * @param {queueFIFODetails} _queue
+     * @param {()=>(any|Promise<any>)} callback
+     * @param {number} [debounce]
      */
-    static "__#1@#push": (_queue: queueFIFODetails) => void;
-    static "__#1@#run": () => Promise<void>;
+    constructor(callback: () => (any | Promise<any>), debounce?: number);
 }
 /**
  * *[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;
+ * - 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 "__#4@#queue": Map<any, [() => Promise<void>, number]>;
+    /**
+     * @type {boolean}
+     */
+    static "__#4@#isRunning": boolean;
+    /**
+     * @param {any} id
+     * @param {()=>Promise<void>} callback
+     * @param {number} debounceMS
+     */
+    static "__#4@#push": (id: any, callback: () => Promise<void>, debounceMS: number) => void;
+    static "__#4@#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 "__#1@#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 "__#1@#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/Signal.d.mts

@@ -1,8 +1,19 @@
 /**
  * @description
  * - 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;
+ * ```js
+ * import { $, Derived, Signal } from 'vivth';
+ * const signal = new Signal(0);
+ * const derived = new Derived(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

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/class/QUnique.mjs

@@ -1,75 +0,0 @@
-// @ts-check
-
-import { timeout } from '../common.mjs';
-
-/**
- * @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) => {
-		QUnique.#queue = queueMap;
-		return QUnique;
-	};
-	/**
-	 * @typedef {Object} queueUniqueObject
-	 * @property {any} i
-	 * @property {()=>(any|Promise<any>)} c
-	 * @property {number} [d]
-	 */
-	/**
-	 * @type {Map<any, [()=>Promise<any>,number]>}
-	 */
-	static #queue = new Map();
-	/**
-	 * @type {boolean}
-	 */
-	static #isRunning = false;
-	/**
-	 * @type {(queueUniqueObject:queueUniqueObject)=>void}
-	 */
-	static assign = (_queue) => {
-		QUnique.#push(_queue);
-		if (!QUnique.#isRunning) {
-			QUnique.#run();
-		}
-	};
-	/**
-	 * @param {queueUniqueObject} _queue
-	 */
-	static #push = (_queue) => {
-		const { i, c, d } = _queue;
-		QUnique.#queue.set(i, [c, d ? d : 0]);
-	};
-	static #run = async () => {
-		QUnique.#isRunning = true;
-		const keysIterator = QUnique.#queue.keys();
-		let keys = keysIterator.next();
-		while (!keys.done) {
-			const key = keys.value;
-			const q = QUnique.#queue.get(key);
-			if (!q) {
-				return;
-			}
-			const [callback, debounce] = q;
-			QUnique.#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();
-		}
-		QUnique.#isRunning = false;
-	};
-}

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/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 "__#4@#queue": Map<any, [() => Promise<any>, number]>;
-    /**
-     * @type {boolean}
-     */
-    static "__#4@#isRunning": boolean;
-    /**
-     * @type {(queueUniqueObject:queueUniqueObject)=>void}
-     */
-    static assign: (queueUniqueObject: {
-        i: any;
-        c: () => (any | Promise<any>);
-        d?: number;
-    }) => void;
-    /**
-     * @param {queueUniqueObject} _queue
-     */
-    static "__#4@#push": (_queue: {
-        i: any;
-        c: () => (any | Promise<any>);
-        d?: number;
-    }) => void;
-    static "__#4@#run": () => Promise<void>;
-}

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;