vivth 1.4.4 → 1.4.6

package/README.md

@@ -2548,7 +2548,7 @@ WorkerMainThread.setup({
 
 ```js
 /**
- * @type {typeof Worker|typeof import('worker_threads').Worker}
+ * @type {typeof Worker|typeof import('node:worker_threads').Worker}
  */
 ```
 
@@ -2570,7 +2570,7 @@ WorkerMainThread.setup({
 ```js
 /**
  * @param {string} handler
- * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
+ * @param {Omit<WorkerOptions|import('node:worker_threads').WorkerOptions, 'eval'|'type'>} [options]
  * @returns {WorkerMainThread<WT>}
  */
 ```
@@ -2591,7 +2591,10 @@ export const myDoubleWorker = WorkerMainThread.newVivthWorker(
 
 ```js
 /**
- * @type {()=>void}
+ * @param {boolean} terminateAllReactivity
+ * - false: only terminate `Worker` instance;
+ * - true: also terminate `Signal`s and `Effect`s;
+ * @return {void}
  */
 ```
 
@@ -2695,7 +2698,7 @@ myDoubleWorker.postMessage(90);
 /**
  * @template RECEIVE
  * @template POST
- * @param {{parentPort:import('worker_threads')["parentPort"]}} refs
+ * @param {{parentPort:import('node:worker_threads')["parentPort"]}} refs
  * -example:
  * ```js
  * import { parentPort } from 'node:worker_threads';
@@ -2728,7 +2731,7 @@ export const MyWorkerThreadRef = WorkerThread.setup({ parentPort });
 ```js
 import { MyWorkerThread } from "./MyWorkerThread.mjs";
 
-const doubleWorker = new MyWorkerThread((ev, isLastOnQ) => {
+const handler = async (ev, isLastOnQ) => {
   // if(!isLastOnQ()) {
   // 	return null; // can be used for imperative debouncing;
   // }
@@ -2737,7 +2740,8 @@ const doubleWorker = new MyWorkerThread((ev, isLastOnQ) => {
   // 	return;
   // }
   return (ev = ev * 2);
-});
+};
+new MyWorkerThread(handler);
 ```
 
 #### reference:`WorkerThread_instance.handler`
@@ -2746,7 +2750,7 @@ const doubleWorker = new MyWorkerThread((ev, isLastOnQ) => {
 
 ```js
 /**
- * @type {(ev: RECEIVE, isLastOnQ:QCBReturn["isLastOnQ"]) => POST}
+ * @type {(ev: RECEIVE, isLastOnQ:QCBReturn["isLastOnQ"]) => Promise<POST>}
  */
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "vivth",
-	"version": "1.4.4",
+	"version": "1.4.6",
 	"description": "library primitives",
 	"main": "index.mjs",
 	"types": "./types/index.d.mts",

package/src/class/WorkerMainThread.mjs

@@ -88,7 +88,7 @@ export class WorkerMainThread {
 	 * @description
 	 * - reference for `Worker` class;
 	 * - edit via `setup`;
-	 * @type {typeof Worker|typeof import('worker_threads').Worker}
+	 * @type {typeof Worker|typeof import('node:worker_threads').Worker}
 	 */
 	static workerClass;
 	/**
@@ -98,15 +98,16 @@ export class WorkerMainThread {
 	 * @type {(paths:{worker: string, root:string})=>Promise<string>}
 	 */
 	static pathValidator;
-	static #options = /** @type {import('worker_threads').WorkerOptions & { type?: 'module' }} */ ({
-		type: 'module',
-	});
+	static #options =
+		/** @type {import('node:worker_threads').WorkerOptions & { type?: 'module' }} */ ({
+			type: 'module',
+		});
 	/**
 	 * @template {WorkerThread<any, any>} WT
 	 * @description
 	 * - create Worker_instance;
 	 * @param {string} handler
-	 * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
+	 * @param {Omit<WorkerOptions|import('node:worker_threads').WorkerOptions, 'eval'|'type'>} [options]
 	 * @returns {WorkerMainThread<WT>}
 	 * @example
 	 * import { WorkerMainThread } from 'vivth';
@@ -144,7 +145,7 @@ export class WorkerMainThread {
 	 * @template {WorkerThread<any, any>} WT
 	 * @param {string} handler
 	 * @param { WorkerOptions
-	 * | import('worker_threads').WorkerOptions} options
+	 * | import('node:worker_threads').WorkerOptions} options
 	 * @param {WorkerMainThread<WT>} worker
 	 * @param {(any:any)=>void} listener
 	 * @returns {Promise<void>}
@@ -240,13 +241,13 @@ export class WorkerMainThread {
 				if (worker.#worker.value) {
 					worker.#worker.value.postMessage(closeWorkerThreadEventObject, []);
 				}
-				worker.terminate();
+				worker.terminate(true);
 			});
 		}
 	}
 	/**
 	 * lazyly generated because node version need to await
-	 * @type {Signal<Worker | import('worker_threads').Worker>}
+	 * @type {Signal<Worker | import('node:worker_threads').Worker>}
 	 */
 	// @ts-expect-error
 	#worker = new Signal(undefined);
@@ -265,13 +266,19 @@ export class WorkerMainThread {
 	/**
 	 * @description
 	 * - terminate all signals that are used on this instance;
-	 * @type {()=>void}
+	 * @param {boolean} terminateAllReactivity
+	 * - false: only terminate `Worker` instance;
+	 * - true: also terminate `Signal`s and `Effect`s;
+	 * @return {void}
 	 */
-	terminate = () => {
+	terminate = (terminateAllReactivity) => {
 		/**
 		 * this is more for browser, as most of this are automatically cleaned with `SafeExit`;
 		 */
 		this.#worker.value?.terminate();
+		if (!terminateAllReactivity) {
+			return;
+		}
 		this.#worker.remove.ref();
 		this.#handler.options.removeEffect();
 		this.#proxyPost.remove.ref();

package/src/class/WorkerMainThreadBundled.mjs

@@ -51,20 +51,21 @@ export class WorkerMainThread {
 		WorkerMainThread.pathValidator = pathValidator;
 	};
 	/**
-	 * @type {typeof Worker|typeof import('worker_threads').Worker}
+	 * @type {typeof Worker|typeof import('node:worker_threads').Worker}
 	 */
 	static workerClass;
 	/**
 	 * @type {(paths:{worker: string, root:string})=>Promise<string>}
 	 */
 	static pathValidator;
-	static #options = /** @type {import('worker_threads').WorkerOptions & { type?: 'module' }} */ ({
-		type: 'module',
-	});
+	static #options =
+		/** @type {import('node:worker_threads').WorkerOptions & { type?: 'module' }} */ ({
+			type: 'module',
+		});
 	/**
 	 * @template {WorkerThread<any, any>} WT
 	 * @param {string} handler
-	 * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
+	 * @param {Omit<WorkerOptions|import('node:worker_threads').WorkerOptions, 'eval'|'type'>} [options]
 	 * @returns {WorkerMainThread<WT>}
 	 */
 	static newVivthWorker(handler, options = {}) {
@@ -93,7 +94,7 @@ export class WorkerMainThread {
 	 * @template {WorkerThread<any, any>} WT
 	 * @param {string} handler
 	 * @param { WorkerOptions
-	 * | import('worker_threads').WorkerOptions} options
+	 * | import('node:worker_threads').WorkerOptions} options
 	 * @param {WorkerMainThread<WT>} worker
 	 * @param {(any:any)=>void} listener
 	 * @returns {Promise<void>}
@@ -173,13 +174,13 @@ export class WorkerMainThread {
 				if (worker.#worker.value) {
 					worker.#worker.value.postMessage(closeWorkerThreadEventObject, []);
 				}
-				worker.terminate();
+				worker.terminate(true);
 			});
 		}
 	}
 	/**
 	 * lazyly generated because node version need to await
-	 * @type {Signal<Worker | import('worker_threads').Worker>}
+	 * @type {Signal<Worker | import('node:worker_threads').Worker>}
 	 */
 	// @ts-expect-error
 	#worker = new Signal(undefined);
@@ -196,13 +197,17 @@ export class WorkerMainThread {
 		worker.postMessage(postData, []);
 	});
 	/**
-	 * @type {()=>void}
+	 * @param {boolean} [terminateAllReactivity]
+	 * @return {void}
 	 */
-	terminate = () => {
+	terminate = (terminateAllReactivity = false) => {
 		/**
 		 * this is more for browser, as most of this are automatically cleaned with `SafeExit`;
 		 */
 		this.#worker.value?.terminate();
+		if (!terminateAllReactivity) {
+			return;
+		}
 		this.#worker.remove.ref();
 		this.#handler.options.removeEffect();
 		this.#proxyPost.remove.ref();

package/src/class/WorkerThread.mjs

@@ -28,7 +28,7 @@ export class WorkerThread {
 	 * - need to be called and exported as new `WorkerThread` class reference;
 	 * @template RECEIVE
 	 * @template POST
-	 * @param {{parentPort:import('worker_threads')["parentPort"]}} refs
+	 * @param {{parentPort:import('node:worker_threads')["parentPort"]}} refs
 	 * -example:
 	 * ```js
 	 * import { parentPort } from 'node:worker_threads';
@@ -61,7 +61,7 @@ export class WorkerThread {
 	 * @example
 	 * import { MyWorkerThread } from './MyWorkerThread.mjs';
 	 *
-	 * const doubleWorker = new MyWorkerThread((ev, isLastOnQ) => {
+	 * const handler = async (ev, isLastOnQ) => {
 	 * 	// if(!isLastOnQ()) {
 	 * 	// 	return null; // can be used for imperative debouncing;
 	 * 	// }
@@ -70,7 +70,8 @@ export class WorkerThread {
 	 * 	// 	return;
 	 * 	// }
 	 * 	return ev = ev \* 2;
-	 * });
+	 * }
+	 * new MyWorkerThread(handler);
 	 */
 	constructor(handler) {
 		this.handler = handler;
@@ -154,7 +155,7 @@ export class WorkerThread {
 	/**
 	 * @description
 	 * - type helper;
-	 * @type {(ev: RECEIVE, isLastOnQ:QCBReturn["isLastOnQ"]) => POST}
+	 * @type {(ev: RECEIVE, isLastOnQ:QCBReturn["isLastOnQ"]) => Promise<POST>}
 	 */
 	handler;
 	/**

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

@@ -66,9 +66,9 @@ export class WorkerMainThread<WT extends WorkerThread<any, any>> {
      * @description
      * - reference for `Worker` class;
      * - edit via `setup`;
-     * @type {typeof Worker|typeof import('worker_threads').Worker}
+     * @type {typeof Worker|typeof import('node:worker_threads').Worker}
      */
-    static workerClass: typeof Worker | typeof import("worker_threads").Worker;
+    static workerClass: typeof Worker | typeof import("node:worker_threads").Worker;
     /**
      * @description
      * - reference for validating path;
@@ -79,7 +79,7 @@ export class WorkerMainThread<WT extends WorkerThread<any, any>> {
         worker: string;
         root: string;
     }) => Promise<string>;
-    static "__#private@#options": import("worker_threads").WorkerOptions & {
+    static "__#private@#options": import("node:worker_threads").WorkerOptions & {
         type?: "module";
     };
     /**
@@ -87,24 +87,24 @@ export class WorkerMainThread<WT extends WorkerThread<any, any>> {
      * @description
      * - create Worker_instance;
      * @param {string} handler
-     * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
+     * @param {Omit<WorkerOptions|import('node:worker_threads').WorkerOptions, 'eval'|'type'>} [options]
      * @returns {WorkerMainThread<WT>}
      * @example
      * import { WorkerMainThread } from 'vivth';
      *
      * export const myDoubleWorker = WorkerMainThread.newVivthWorker('./doubleWorkerThread.mjs');
      */
-    static newVivthWorker<WT_1 extends WorkerThread<any, any>>(handler: string, options?: Omit<WorkerOptions | import("worker_threads").WorkerOptions, "eval" | "type">): WorkerMainThread<WT_1>;
+    static newVivthWorker<WT_1 extends WorkerThread<any, any>>(handler: string, options?: Omit<WorkerOptions | import("node:worker_threads").WorkerOptions, "eval" | "type">): WorkerMainThread<WT_1>;
     /**
      * @template {WorkerThread<any, any>} WT
      * @param {string} handler
      * @param { WorkerOptions
-     * | import('worker_threads').WorkerOptions} options
+     * | import('node:worker_threads').WorkerOptions} options
      * @param {WorkerMainThread<WT>} worker
      * @param {(any:any)=>void} listener
      * @returns {Promise<void>}
      */
-    static "__#private@#workerFilehandler"<WT_1 extends WorkerThread<any, any>>(handler: string, options: WorkerOptions | import("worker_threads").WorkerOptions, worker: WorkerMainThread<WT_1>, listener: (any: any) => void): Promise<void>;
+    static "__#private@#workerFilehandler"<WT_1 extends WorkerThread<any, any>>(handler: string, options: WorkerOptions | import("node:worker_threads").WorkerOptions, worker: WorkerMainThread<WT_1>, listener: (any: any) => void): Promise<void>;
     /**
      * @private
      * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[0]} handler
@@ -118,9 +118,12 @@ export class WorkerMainThread<WT extends WorkerThread<any, any>> {
     /**
      * @description
      * - terminate all signals that are used on this instance;
-     * @type {()=>void}
+     * @param {boolean} terminateAllReactivity
+     * - false: only terminate `Worker` instance;
+     * - true: also terminate `Signal`s and `Effect`s;
+     * @return {void}
      */
-    terminate: () => void;
+    terminate: (terminateAllReactivity: boolean) => void;
     /**
      * @description
      * - result signal of the processed message;

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

@@ -28,9 +28,9 @@ export class WorkerMainThread<WT extends WorkerThread<any, any>> {
         pathValidator: (typeof WorkerMainThread)["pathValidator"];
     }) => void;
     /**
-     * @type {typeof Worker|typeof import('worker_threads').Worker}
+     * @type {typeof Worker|typeof import('node:worker_threads').Worker}
      */
-    static workerClass: typeof Worker | typeof import("worker_threads").Worker;
+    static workerClass: typeof Worker | typeof import("node:worker_threads").Worker;
     /**
      * @type {(paths:{worker: string, root:string})=>Promise<string>}
      */
@@ -38,35 +38,36 @@ export class WorkerMainThread<WT extends WorkerThread<any, any>> {
         worker: string;
         root: string;
     }) => Promise<string>;
-    static "__#private@#options": import("worker_threads").WorkerOptions & {
+    static "__#private@#options": import("node:worker_threads").WorkerOptions & {
         type?: "module";
     };
     /**
      * @template {WorkerThread<any, any>} WT
      * @param {string} handler
-     * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
+     * @param {Omit<WorkerOptions|import('node:worker_threads').WorkerOptions, 'eval'|'type'>} [options]
      * @returns {WorkerMainThread<WT>}
      */
-    static newVivthWorker<WT_1 extends WorkerThread<any, any>>(handler: string, options?: Omit<WorkerOptions | import("worker_threads").WorkerOptions, "eval" | "type">): WorkerMainThread<WT_1>;
+    static newVivthWorker<WT_1 extends WorkerThread<any, any>>(handler: string, options?: Omit<WorkerOptions | import("node:worker_threads").WorkerOptions, "eval" | "type">): WorkerMainThread<WT_1>;
     /**
      * @template {WorkerThread<any, any>} WT
      * @param {string} handler
      * @param { WorkerOptions
-     * | import('worker_threads').WorkerOptions} options
+     * | import('node:worker_threads').WorkerOptions} options
      * @param {WorkerMainThread<WT>} worker
      * @param {(any:any)=>void} listener
      * @returns {Promise<void>}
      */
-    static "__#private@#workerFilehandler"<WT_1 extends WorkerThread<any, any>>(handler: string, options: WorkerOptions | import("worker_threads").WorkerOptions, worker: WorkerMainThread<WT_1>, listener: (any: any) => void): Promise<void>;
+    static "__#private@#workerFilehandler"<WT_1 extends WorkerThread<any, any>>(handler: string, options: WorkerOptions | import("node:worker_threads").WorkerOptions, worker: WorkerMainThread<WT_1>, listener: (any: any) => void): Promise<void>;
     /**
      * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[0]} handler
      * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[1]} [options]
      */
     constructor(handler: Parameters<(typeof WorkerMainThread<WT>)["newVivthWorker"]>[0], options?: Parameters<(typeof WorkerMainThread<WT>)["newVivthWorker"]>[1]);
     /**
-     * @type {()=>void}
+     * @param {boolean} [terminateAllReactivity]
+     * @return {void}
      */
-    terminate: () => void;
+    terminate: (terminateAllReactivity?: boolean) => void;
     /**
      * @type {Derived<WorkerResult<WT["POST"]>>}
      */

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

@@ -18,7 +18,7 @@ export class WorkerThread<RECEIVE, POST> {
      * - need to be called and exported as new `WorkerThread` class reference;
      * @template RECEIVE
      * @template POST
-     * @param {{parentPort:import('worker_threads')["parentPort"]}} refs
+     * @param {{parentPort:import('node:worker_threads')["parentPort"]}} refs
      * -example:
      * ```js
      * import { parentPort } from 'node:worker_threads';
@@ -31,7 +31,7 @@ export class WorkerThread<RECEIVE, POST> {
      * export const MyWorkerThreadRef = WorkerThread.setup({ parentPort });
      */
     static setup<RECEIVE_1, POST_1>(refs: {
-        parentPort: typeof import("worker_threads")["parentPort"];
+        parentPort: typeof import("node:worker_threads")["parentPort"];
     }): typeof WorkerThread<RECEIVE_1, POST_1>;
     /**
      * @param {any} ev
@@ -44,7 +44,7 @@ export class WorkerThread<RECEIVE, POST> {
      * @example
      * import { MyWorkerThread } from './MyWorkerThread.mjs';
      *
-     * const doubleWorker = new MyWorkerThread((ev, isLastOnQ) => {
+     * const handler = async (ev, isLastOnQ) => {
      * 	// if(!isLastOnQ()) {
      * 	// 	return null; // can be used for imperative debouncing;
      * 	// }
@@ -53,15 +53,16 @@ export class WorkerThread<RECEIVE, POST> {
      * 	// 	return;
      * 	// }
      * 	return ev = ev \* 2;
-     * });
+     * }
+     * new MyWorkerThread(handler);
      */
     constructor(handler: WorkerThread<RECEIVE, POST>["handler"]);
     /**
      * @description
      * - type helper;
-     * @type {(ev: RECEIVE, isLastOnQ:QCBReturn["isLastOnQ"]) => POST}
+     * @type {(ev: RECEIVE, isLastOnQ:QCBReturn["isLastOnQ"]) => Promise<POST>}
      */
-    handler: (ev: RECEIVE, isLastOnQ: () => boolean) => POST;
+    handler: (ev: RECEIVE, isLastOnQ: () => boolean) => Promise<POST>;
     /**
      * @description
      * - helper type, hold no actual value;