vivth 0.11.0 → 0.11.2

package/README.md

@@ -14,27 +14,27 @@ 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)
 - [NewQBlock](#newqblock)
 - [TryAsync](#tryasync)
 - [TrySync](#trysync)
 <h2 id="$">$</h2>
 
-- 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);
- for minimal total bundle size use `function` [New$](#new$) instead;
+- a class to `autosubscribe` to an signal changes (`Derived` and `Signal` alike);
 
 *) <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);
 // runs everytime signal.value changes;
 return signal.value * 2;
 // runs everytime derived.value changes;
 console.log(derived.value);
- 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);
 
 *) <sub>[go to exported list](#exported-api-and-type-list)</sub>
 
@@ -56,9 +56,21 @@ bun i vivth
 
 *) <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>
+
 <h2 id="signal">Signal</h2>
 
-- a class for creating signal;
 // runs everytime signal.value changes;
 return signal.value * 2;
 // runs everytime signal.value changes;
 console.log(signal.value);
- 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>
 

package/dev/index.mjs

@@ -24,7 +24,5 @@ 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,14 +21,14 @@
  * - `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 { NewQBlock } from './src/function/NewQBlock.mjs';
 export { TryAsync } from './src/function/TryAsync.mjs';

package/package.json

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

package/src/class/$.mjs

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

package/src/class/Derived.mjs

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

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

@@ -5,19 +5,8 @@ import { $ } from './$.mjs';
 /**
  * @description
  * - a class for creating signal;
- * ```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;
- * ```
+ * - can be subscribed by using [New$](#new$) or [NewDerived](#newderived);
+ * - for minimal total bundle size use `function` [NewSignal](#newSignal) instead;
  */
 /**
  * @template Value

package/types/index.d.mts

@@ -3,6 +3,8 @@ 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 { NewQBlock } from "./src/function/NewQBlock.mjs";
 export { TryAsync } from "./src/function/TryAsync.mjs";

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

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

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

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

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

@@ -30,16 +30,16 @@ export class PingFIFO {
     /**
      * @type {queueFIFODetails[]}
      */
-    static "__#3@#queue": queueFIFODetails[];
+    static "__#1@#queue": queueFIFODetails[];
     /**
      * @type {boolean}
      */
-    static "__#3@#isRunning": boolean;
+    static "__#1@#isRunning": boolean;
     /**
      * @param {queueFIFODetails} _queue
      */
-    static "__#3@#push": (_queue: queueFIFODetails) => void;
-    static "__#3@#run": () => Promise<void>;
+    static "__#1@#push": (_queue: queueFIFODetails) => void;
+    static "__#1@#run": () => Promise<void>;
     /**
      * @param {()=>(any|Promise<any>)} callback
      * @param {number} [debounce]

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

@@ -27,18 +27,18 @@ export class PingUnique {
     /**
      * @type {Map<any, [()=>Promise<void>,number]>}
      */
-    static "__#4@#queue": Map<any, [() => Promise<void>, number]>;
+    static "__#3@#queue": Map<any, [() => Promise<void>, number]>;
     /**
      * @type {boolean}
      */
-    static "__#4@#isRunning": boolean;
+    static "__#3@#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>;
+    static "__#3@#push": (id: any, callback: () => Promise<void>, debounceMS: number) => void;
+    static "__#3@#run": () => Promise<void>;
     /**
      * @param {any} id
      * @param {()=>Promise<void>} callback

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

@@ -39,7 +39,7 @@ export class Q {
     /**
      * @type {Promise<void>}
      */
-    static "__#1@#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,7 +50,7 @@ export class Q {
     /**
      * @type {Map<any, Promise<any>>}
      */
-    static "__#1@#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.

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

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

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

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

@@ -1,19 +1,8 @@
 /**
  * @description
  * - a class for creating signal;
- * ```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;
- * ```
+ * - can be subscribed by using [New$](#new$) or [NewDerived](#newderived);
+ * - for minimal total bundle size use `function` [NewSignal](#newSignal) instead;
  */
 /**
  * @template Value