vivth 0.9.3 → 0.10.0

package/README.md

@@ -18,6 +18,8 @@ bun i vivth
 - [$](#$)
 - [Derived](#derived)
 - [Q](#q)
+- [QFIFO](#qfifo)
+- [QUnique](#qunique)
 - [Signal](#signal)
 - [New$](#new$)
 - [NewDerived](#newderived)
@@ -40,7 +42,19 @@ bun i vivth
 
 <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:
- 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="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`;
- for minimal total bundle size use `function` [NewPingUnique](#newpingunique) instead;
- this class provides `QUnique.makeQClass`;
+
+*) <sub>[go to exported list](#exported-api-and-type-list)</sub>
+
+<h2 id="qunique">QUnique</h2>
+
+- a class for Queue;
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 

package/index.mjs

@@ -25,6 +25,8 @@
 export { $ } from './src/class/$.mjs';
 export { Derived } from './src/class/Derived.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';

package/package.json

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

package/src/class/$.mjs

@@ -13,33 +13,29 @@ export class $ {
 	 * @typedef {import('../class/Signal.mjs').Signal} Signal
 	 */
 	/**
-	 * effects
 	 * @type {Map<$, Set<Signal>>}
 	 */
-	static E = new Map();
+	static effects = new Map();
 	/**
-	 * signalInstance
 	 * @type {Map<Signal, Set<$>>}
 	 */
-	static S = new Map();
+	static mappedSignals = new Map();
 	/**
-	 * activeSignalUponRegistering
 	 * @type {Set<Signal>}
 	 */
-	static A = new Set();
+	static activeSignal = new Set();
 	/**
-	 * isRegistering
 	 * @type {boolean}
 	 */
-	static R = false;
+	static isRegistering = false;
 	/**
 	 * @returns {void}
 	 */
 	remove$ = () => {
-		$.E.get(this)?.forEach((signalInstance) => {
-			$.S.get(signalInstance).delete(this);
+		$.effects.get(this)?.forEach((signalInstance) => {
+			$.mappedSignals.get(signalInstance).delete(this);
 		});
-		$.E.set(this, new Set());
+		$.effects.set(this, new Set());
 	};
 	/**
 	 * @type {()=>void}
@@ -51,22 +47,22 @@ export class $ {
 	constructor(effect) {
 		this.effect = effect;
 		NewPingFIFO(async () => {
-			$.R = true;
+			$.isRegistering = true;
 			if (isAsync(effect)) {
 				await effect();
 			} else {
 				effect();
 			}
-			$.R = false;
-			const signalInstances = $.A;
-			$.E.set(this, $.A);
+			$.isRegistering = false;
+			const signalInstances = $.activeSignal;
+			$.effects.set(this, $.activeSignal);
 			signalInstances.forEach((signal) => {
-				if (!$.S.has(signal)) {
-					$.S.set(signal, new Set());
+				if (!$.mappedSignals.has(signal)) {
+					$.mappedSignals.set(signal, new Set());
 				}
-				$.S.get(signal).add(this);
+				$.mappedSignals.get(signal).add(this);
 			});
-			$.A = new Set();
+			$.activeSignal = new Set();
 		});
 	}
 }

package/src/class/Q.mjs

@@ -25,16 +25,26 @@
  * - 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) => {
+		Q.#unique = uniqueMap;
+		return Q;
+	};
 	/**
 	 * @typedef {import('../types/anyButUndefined.type.mjs').anyButUndefined} anyButUndefined
 	 */
 	/**
-	 * @private
 	 * @type {Promise<void>}
 	 */
-	static f = Promise.resolve();
+	static #fifo = Promise.resolve();
 	/**
 	 * 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
@@ -44,8 +54,8 @@ export class Q {
 		const next = new Promise((resolve) => {
 			resolveFn = resolve;
 		});
-		const prev = Q.f;
-		Q.f = next;
+		const prev = Q.#fifo;
+		Q.#fifo = next;
 		await prev;
 		return {
 			resume: () => {
@@ -56,7 +66,7 @@ export class Q {
 	/**
 	 * @type {Map<any, Promise<any>>}
 	 */
-	static u = new Map();
+	static #unique = new Map();
 	/**
 	 * 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.
@@ -64,23 +74,23 @@ export class Q {
 	 * @returns {Promise<{resume:()=>void}>} Resolves when it's safe to proceed for the given id, returning a cleanup function
 	 */
 	static unique = async (id) => {
-		if (!Q.u.has(id)) {
-			Q.u.set(id, Promise.resolve());
+		if (!Q.#unique.has(id)) {
+			Q.#unique.set(id, Promise.resolve());
 			let resolveFn;
 			const next = new Promise((resolve) => {
 				resolveFn = resolve;
 			});
-			const prev = Q.u.get(id);
-			Q.u.set(id, next);
+			const prev = Q.#unique.get(id);
+			Q.#unique.set(id, next);
 			await prev;
 			return {
 				resume: () => {
 					resolveFn();
-					Q.u.delete(id);
+					Q.#unique.delete(id);
 				},
 			};
 		} else {
-			const prev = Q.u.get(id);
+			const prev = Q.#unique.get(id);
 			await prev;
 			return await Q.unique(id);
 		}

package/src/class/QFIFO.mjs

@@ -0,0 +1,66 @@
+// @ts-check
+
+import { timeout } from '../common.mjs';
+
+/**
+ * @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) => {
+		QFIFO.#queue = queueArray;
+		return QFIFO;
+	};
+	/**
+	 * @type {queueFIFODetails[]}
+	 */
+	static #queue = [];
+	/**
+	 * @type {boolean}
+	 */
+	static #isRunning = false;
+	/**
+	 * @type {(...queueFIFODetails:queueFIFODetails)=>void}
+	 */
+	static assign = (..._queue) => {
+		QFIFO.#push(_queue);
+		if (!QFIFO.#isRunning) {
+			QFIFO.#run();
+		}
+	};
+	/**
+	 * @param {queueFIFODetails} _queue
+	 */
+	static #push = (_queue) => {
+		QFIFO.#queue.push(_queue);
+	};
+	static #run = async () => {
+		QFIFO.#isRunning = true;
+		while (QFIFO.#queue.length !== 0) {
+			const [callback, debounceMs = 0] = QFIFO.#queue[0];
+			QFIFO.#queue.shift();
+			await callback();
+			/**
+			 * conditional debounce;
+			 * queue FIFO messing up when have debouncer while `debounceMS` are set to 0;
+			 */
+			// if (debounceMs) {
+			await timeout(debounceMs);
+			// }
+		}
+		QFIFO.#isRunning = false;
+	};
+}

package/src/class/QUnique.mjs

@@ -0,0 +1,75 @@
+// @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/class/Signal.mjs

@@ -13,25 +13,24 @@ import { $ } from './$.mjs';
  */
 export class Signal {
 	/**
-	 * subscribed
 	 * @protected
 	 */
-	get S() {
-		return $.S.get(this);
+	get subscribed() {
+		return $.mappedSignals.get(this);
 	}
 	/**
 	 * destroy all props
 	 */
 	unRef = () => {
 		this.removeAll$();
-		this.V = null;
+		this.#Value = null;
 	};
 	/**
 	 * remove all effects
 	 * @return {void}
 	 */
 	removeAll$ = () => {
-		this.S.forEach(($_) => {
+		this.subscribed?.forEach(($_) => {
 			$_.remove$();
 		});
 	};
@@ -41,7 +40,7 @@ export class Signal {
 	 * @return {void}
 	 */
 	remove$ = ($_) => {
-		if ($.E.get($_).has(this)) {
+		if ($.effects.get($_)?.has(this)) {
 			$_.remove$();
 		}
 	};
@@ -49,48 +48,52 @@ export class Signal {
 	 * @param {Value} value
 	 */
 	constructor(value) {
-		this.V = value;
+		this.#Value = value;
 	}
 	/**
-	 * @private
 	 * @type {Value}
 	 */
-	P = undefined;
+	#prev = undefined;
 	get prev() {
-		return this.P;
+		return this.#prev;
 	}
 	/**
-	 * @private
 	 * @type {Value}
 	 */
-	V;
+	#Value;
+	/**
+	 * @type {Value}
+	 */
+	get nonReactiveValue() {
+		return this.#Value;
+	}
 	/**
 	 * @type {Value}
 	 */
 	get value() {
-		if ($.R) {
-			$.A.add(this);
+		if ($.isRegistering) {
+			$.activeSignal.add(this);
 		}
-		return this.V;
+		return this.#Value;
 	}
 	/**
 	 * @type {Value}
 	 */
 	set value(newValue) {
-		if (this.V === newValue) {
+		if (this.#Value === newValue) {
 			return;
 		}
-		this.P = this.V;
-		this.V = newValue;
+		this.#prev = this.#Value;
+		this.#Value = newValue;
 		this.call$();
 	}
 	/**
 	 * @returns {void}
 	 */
 	call$ = () => {
-		if (!this.S) {
+		if (!this.subscribed) {
 			return;
 		}
-		this.S.forEach(($_) => $_.effect());
+		this.subscribed.forEach(($_) => $_.effect());
 	};
 }

package/src/function/NewPingFIFO.mjs

@@ -1,6 +1,6 @@
 // @ts-check
 
-import { timeout } from '../common.mjs';
+import { QFIFO } from '../class/QFIFO.mjs';
 
 /**
  * @description
@@ -16,76 +16,9 @@ import { timeout } from '../common.mjs';
  * }
  * ```
  */
-class qFIFO {
-	static {
-		new qFIFO();
-	}
-	/**
-	 * @typedef {[callback:()=>(any|Promise<any>),debounce?:(number)]} queueFIFODetails
-	 */
-	/**
-	 * @private
-	 */
-	constructor() {}
-	/**
-	 * queue
-	 * @private
-	 * @type {queueFIFODetails[]}
-	 */
-	static q = [];
-	/**
-	 * isRunning
-	 * @private
-	 * @type {boolean}
-	 */
-	static R = false;
-	/**
-	 * auto initiator
-	 * @private
-	 */
-	/**
-	 * assign
-	 * @type {(...queueFIFODetails:queueFIFODetails)=>void}
-	 */
-	static a = (..._queue) => {
-		qFIFO.p(_queue);
-		if (!qFIFO.R) {
-			qFIFO.r();
-		}
-	};
-	/**
-	 * push
-	 * @private
-	 * @param {queueFIFODetails} _queue
-	 */
-	static p = (_queue) => {
-		qFIFO.q.push(_queue);
-	};
-	/**
-	 * run
-	 * @private
-	 */
-	static r = async () => {
-		qFIFO.R = true;
-		while (qFIFO.q.length !== 0) {
-			const [callback, debounceMs = 0] = qFIFO.q[0];
-			qFIFO.q.shift();
-			await callback();
-			/**
-			 * conditional debounce;
-			 * queue FIFO messing up when have debouncer while `debounceMS` are set to 0;
-			 */
-			// if (debounceMs) {
-			await timeout(debounceMs);
-			// }
-		}
-		qFIFO.R = false;
-	};
-}
-
 /**
  * @param {()=>(any|Promise<any>)} callback
  * @param {number} debounce
  * @returns
  */
-export const NewPingFIFO = (callback, debounce = 0) => qFIFO.a(callback, debounce);
+export const NewPingFIFO = (callback, debounce = 0) => QFIFO.assign(callback, debounce);

package/src/function/NewPingUnique.mjs

@@ -1,6 +1,6 @@
 // @ts-check
 
-import { timeout } from '../common.mjs';
+import { QUnique } from '../../index.mjs';
 
 /**
  * @description
@@ -19,74 +19,11 @@ import { timeout } from '../common.mjs';
  * }
  * ```
  */
-class qUnique {
-	/**
-	 * @typedef {import('../types/anyButUndefined.type.mjs').anyButUndefined} anyButUndefined
-	 * @typedef {Object} queueUniqueObject
-	 * @property {any} i
-	 * @property {()=>(any|Promise<any>)} c
-	 * @property {number} [d]
-	 */
-	/**
-	 * @private
-	 * @type {Map<any, [()=>Promise<any>,number]>}
-	 */
-	static queue = new Map();
-	/**
-	 * isRunning
-	 * @private
-	 * @type {boolean}
-	 */
-	static r = false;
-	/**
-	 * assign
-	 * @type {(queueUniqueObject:queueUniqueObject)=>void}
-	 */
-	static A = (_queue) => {
-		qUnique.p(_queue);
-		if (!qUnique.r) {
-			qUnique.R();
-		}
-	};
-	/**
-	 * push
-	 * @private
-	 * @param {queueUniqueObject} _queue
-	 */
-	static p = (_queue) => {
-		const { i, c, d } = _queue;
-		qUnique.queue.set(i, [c, d ? d : 0]);
-	};
-	/**
-	 * run
-	 * @private
-	 */
-	static R = async () => {
-		qUnique.r = true;
-		const keysIterator = qUnique.queue.keys();
-		let keys = keysIterator.next();
-		while (!keys.done) {
-			const key = keys.value;
-			const [callback, debounce] = qUnique.queue.get(key);
-			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.r = false;
-	};
-}
-
 /**
- * @param {anyButUndefined} uniqueID
+ * @param {import('../../index.mjs').anyButUndefined} uniqueID
  * @param {()=>(any|Promise<any>)} callback
  * @param {number} debounce
  * @returns
  */
 export const NewPingUnique = (uniqueID, callback, debounce = 0) =>
-	qUnique.A({ i: uniqueID, c: callback, d: debounce });
+	QUnique.assign({ i: uniqueID, c: callback, d: debounce });

package/tsconfig.json

@@ -10,5 +10,5 @@
 		"esModuleInterop": true,
 		"skipLibCheck": true
 	},
-	"include": ["./index.mjs"]
+	"include": ["./index.mjs", "./src"]
 }

package/types/index.d.mts

@@ -1,6 +1,8 @@
 export { $ } from "./src/class/$.mjs";
 export { Derived } from "./src/class/Derived.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";

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

@@ -8,25 +8,21 @@ export class $ {
      * @typedef {import('../class/Signal.mjs').Signal} Signal
      */
     /**
-     * effects
      * @type {Map<$, Set<Signal>>}
      */
-    static E: Map<$, Set<import("../class/Signal.mjs").Signal<any>>>;
+    static effects: Map<$, Set<import("../class/Signal.mjs").Signal<any>>>;
     /**
-     * signalInstance
      * @type {Map<Signal, Set<$>>}
      */
-    static S: Map<import("../class/Signal.mjs").Signal<any>, Set<$>>;
+    static mappedSignals: Map<import("../class/Signal.mjs").Signal<any>, Set<$>>;
     /**
-     * activeSignalUponRegistering
      * @type {Set<Signal>}
      */
-    static A: Set<import("../class/Signal.mjs").Signal<any>>;
+    static activeSignal: Set<import("../class/Signal.mjs").Signal<any>>;
     /**
-     * isRegistering
      * @type {boolean}
      */
-    static R: boolean;
+    static isRegistering: boolean;
     /**
      * @param {$["effect"]} effect
      */

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

@@ -23,16 +23,23 @@
  * - 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
      */
     /**
-     * @private
      * @type {Promise<void>}
      */
-    private static f;
+    static "__#3@#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
@@ -43,7 +50,7 @@ export class Q {
     /**
      * @type {Map<any, Promise<any>>}
      */
-    static u: Map<any, Promise<any>>;
+    static "__#3@#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.

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

@@ -0,0 +1,47 @@
+/**
+ * @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 "__#1@#queue": queueFIFODetails[];
+    /**
+     * @type {boolean}
+     */
+    static "__#1@#isRunning": boolean;
+    /**
+     * @type {(...queueFIFODetails:queueFIFODetails)=>void}
+     */
+    static assign: (...queueFIFODetails: queueFIFODetails) => void;
+    /**
+     * @param {queueFIFODetails} _queue
+     */
+    static "__#1@#push": (_queue: queueFIFODetails) => void;
+    static "__#1@#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

@@ -0,0 +1,46 @@
+/**
+ * @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/class/Signal.d.mts

@@ -13,19 +13,13 @@ export class Signal<Value> {
      */
     constructor(value: Value);
     /**
-     * subscribed
      * @protected
      */
-    protected get S(): Set<$>;
+    protected get subscribed(): Set<$>;
     /**
      * destroy all props
      */
     unRef: () => void;
-    /**
-     * @private
-     * @type {Value}
-     */
-    private V;
     /**
      * remove all effects
      * @return {void}
@@ -37,12 +31,11 @@ export class Signal<Value> {
      * @return {void}
      */
     remove$: ($_: $) => void;
+    get prev(): Value;
     /**
-     * @private
      * @type {Value}
      */
-    private P;
-    get prev(): Value;
+    get nonReactiveValue(): Value;
     /**
      * @type {Value}
      */
@@ -55,5 +48,6 @@ export class Signal<Value> {
      * @returns {void}
      */
     call$: () => void;
+    #private;
 }
 import { $ } from './$.mjs';

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

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