vivth 1.2.3 → 1.3.1

package/src/class/SafeExit.mjs

@@ -22,9 +22,9 @@ export class SafeExit {
 	/**
 	 * @description
 	 * - only accessible after instantiation;
-	 * @type {SafeExit}
+	 * @type {SafeExit|undefined}
 	 */
-	static instance = undefined;
+	static instance;
 	/**
 	 * @description
 	 * @param {Object} options
@@ -84,7 +84,7 @@ export class SafeExit {
 	 * });
 	 */
 	constructor({ eventNames, terminator, listener = undefined }) {
-		if (SafeExit.instance) {
+		if (SafeExit.instance instanceof SafeExit) {
 			return SafeExit.instance;
 		}
 		SafeExit.instance = this;
@@ -117,8 +117,14 @@ export class SafeExit {
 	 * @type {(eventName:string)=>void}
 	 */
 	#listener = (eventName) => {
+		if (SafeExit.instance === undefined) {
+			return;
+		}
 		SafeExit.instance.exiting.env.value;
 		process.once(eventName, function () {
+			if (SafeExit.instance === undefined) {
+				return;
+			}
 			Console.log(`safe exit via "${eventName}"`);
 			SafeExit.instance.exiting.correction(true);
 		});
@@ -141,9 +147,12 @@ export class SafeExit {
 	/**
 	 * @type {()=>void}
 	 */
-	#exit;
+	#exit = () => {};
 	#autoCleanUp = new Effect(async ({ subscribe }) => {
-		if (!subscribe(this.exiting.env).value) {
+		if (
+			//
+			!subscribe(this.exiting.env).value
+		) {
 			return;
 		}
 		setOFSignals.forEach((signal) => {
@@ -156,13 +165,13 @@ export class SafeExit {
 			const [, error] = await TryAsync(async () => {
 				await cleanup();
 			});
-			if (!error) {
+			if (error === undefined) {
 				continue;
 			}
 			Console.warn(error);
 		}
 		const [, errorExitting] = TrySync(this.#exit);
-		if (!errorExitting) {
+		if (errorExitting === undefined) {
 			return;
 		}
 		Console.error(errorExitting);

package/src/class/Signal.mjs

@@ -7,7 +7,7 @@ import { Console } from './Console.mjs';
 import { Effect, setOfEffects } from './Effect.mjs';
 
 /**
- * @type {Set<Signal>}
+ * @type {Set<Signal<any>>}
  */
 export const setOFSignals = new Set();
 
@@ -64,7 +64,7 @@ export class Signal {
 		 * });
 		 */
 		notify: (callback = undefined) => {
-			if (!callback) {
+			if (callback === undefined) {
 				Signal.#notify(this.subscribers.setOf);
 				return;
 			}
@@ -86,7 +86,7 @@ export class Signal {
 		const [, error] = TrySync(() => {
 			const effects = setOfSubscribers;
 			effects.forEach((effect) => {
-				if (!setOfEffects.has(effect)) {
+				if (setOfEffects.has(effect) === false) {
 					effects.delete(effect);
 					return;
 				}
@@ -96,7 +96,7 @@ export class Signal {
 				effect.run();
 			});
 		});
-		if (!error) {
+		if (error === undefined) {
 			return;
 		}
 		Console.error(error);
@@ -135,19 +135,20 @@ export class Signal {
 		 */
 		ref: () => {
 			this.remove.allSubscribers();
+			// @ts-expect-error
 			this.#value = null;
 			setOFSignals.delete(this);
 		},
 	}));
 
 	/**
-	 * @type {VALUE}
+	 * @type {VALUE|undefined}
 	 */
-	#prev = undefined;
+	#prev;
 	/**
 	 * @description
 	 * - value before change;
-	 * @returns {VALUE}
+	 * @returns {VALUE|undefined}
 	 */
 	get prev() {
 		return this.#prev;

package/src/class/WorkerMainThread.mjs

@@ -16,7 +16,11 @@ import { Signal } from './Signal.mjs';
  * @typedef {import('./WorkerResult.mjs').WorkerResult<POST>} WorkerResult
  */
 /**
- * @typedef {import('./WorkerThread.mjs').WorkerThread} WorkerThread
+ * @template RECEIVE
+ * @template POST
+ * @typedef {import('./WorkerThread.mjs').WorkerThread<RECEIVE, POST>} WorkerThread
+ */
+/**
  * @typedef {import('../common/lazie.mjs').unwrapLazy} unwrapLazy
  */
 
@@ -24,7 +28,7 @@ import { Signal } from './Signal.mjs';
  * @description
  * - class helper to create `Worker` instance;
  * - before any `Worker` functionaily to be used, you need to setup it with `WorkerThread.setup` and `WorkerMainThread.setup` before runing anytyhing;
- * @template {WorkerThread} WT
+ * @template {WorkerThread<any, any>} WT
  */
 export class WorkerMainThread {
 	/**
@@ -69,7 +73,7 @@ export class WorkerMainThread {
 	 * });
 	 */
 	static setup = ({ workerClass, pathValidator }) => {
-		if (!Paths.root) {
+		if (Paths.root === undefined) {
 			return;
 		}
 		if (WorkerMainThread.#isRegistered) {
@@ -98,7 +102,7 @@ export class WorkerMainThread {
 		type: 'module',
 	});
 	/**
-	 * @template {WorkerThread} WT
+	 * @template {WorkerThread<any, any>} WT
 	 * @description
 	 * - create Worker_instance;
 	 * @param {string} handler
@@ -109,9 +113,9 @@ export class WorkerMainThread {
 	 *
 	 * export const myDoubleWorker = WorkerMainThread.newVivthWorker('./doubleWorkerThread.mjs');
 	 */
-	static newVivthWorker = (handler, options = {}) => {
+	static newVivthWorker(handler, options = {}) {
 		return new WorkerMainThread(handler, options);
-	};
+	}
 	/**
 	 * @private
 	 * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[0]} handler
@@ -123,7 +127,7 @@ export class WorkerMainThread {
 	 */
 	constructor(handler, options = {}) {
 		/**
-		 * @param {WT["RECEIVE"]} ev
+		 * @param {any} ev
 		 * @returns {void}
 		 */
 		const listener = (ev) => {
@@ -132,21 +136,26 @@ export class WorkerMainThread {
 		WorkerMainThread.#workerFilehandler(handler, options, this, listener);
 	}
 	/**
-	 * @type {import('./Signal.mjs').Signal<import('./WorkerResult.mjs').WorkerResult<WT["Post"]>|MessageEvent<import('./WorkerResult.mjs').WorkerResult<WT["Post"]>>>}
+	 * @type {import('./Signal.mjs').Signal<import('./WorkerResult.mjs').WorkerResult<WT["POST"]>|MessageEvent<import('./WorkerResult.mjs').WorkerResult<WT["POST"]>>>}
 	 */
+	// @ts-expect-error
 	#proxyReceiver = new Signal(undefined);
 	/**
+	 * @template {WorkerThread<any, any>} WT
 	 * @param {string} handler
 	 * @param { WorkerOptions
 	 * | import('worker_threads').WorkerOptions} options
-	 * @param {WorkerMainThread} worker
+	 * @param {WorkerMainThread<WT>} worker
 	 * @param {(any:any)=>void} listener
 	 * @returns {Promise<void>}
 	 */
-	static #workerFilehandler = async (handler, options, worker, listener) => {
+	static async #workerFilehandler(handler, options, worker, listener) {
 		let resolvedPath;
 		const pathValidator = WorkerMainThread.pathValidator;
 		const [resolvedPath_, error] = await TryAsync(async () => {
+			if (Paths.root === undefined) {
+				throw new Error('path root undefined');
+			}
 			return await pathValidator({
 				worker: handler,
 				root: Paths.root,
@@ -163,7 +172,10 @@ export class WorkerMainThread {
 		resolvedPath = resolvedPath_;
 		const runtime = GetRuntime();
 		const workerClass = WorkerMainThread.workerClass;
-		if (!workerClass) {
+		if (
+			//
+			!workerClass
+		) {
 			Console.error('invalid `Worker` inputed to `WorkerMainThread`;');
 			return;
 		}
@@ -173,11 +185,15 @@ export class WorkerMainThread {
 					throw new Error('not a browser');
 				}
 				let worker_;
-				worker_ = worker.#worker.value = new workerClass(resolvedPath, {
-					...options,
-					...WorkerMainThread.#options,
-				});
-				if (!('onmessage' in worker_)) {
+				worker_ = worker.#worker.value = new workerClass(
+					resolvedPath,
+					// @ts-expect-error
+					{
+						...options,
+						...WorkerMainThread.#options,
+					}
+				);
+				if ('onmessage' in worker_ === false) {
 					throw new Error('not a browser');
 				}
 				worker_.onmessage = listener;
@@ -188,10 +204,14 @@ export class WorkerMainThread {
 				}
 			},
 			nonBrowser: async () => {
-				const worker_ = (worker.#worker.value = new workerClass(resolvedPath, {
-					...options,
-					...WorkerMainThread.#options,
-				}));
+				const worker_ = (worker.#worker.value = new workerClass(
+					resolvedPath,
+					// @ts-expect-error
+					{
+						...options,
+						...WorkerMainThread.#options,
+					}
+				));
 				if ('addEventListener' in worker_) {
 					worker_.addEventListener('message', listener);
 					if (SafeExit.instance) {
@@ -218,16 +238,17 @@ export class WorkerMainThread {
 		if (SafeExit.instance) {
 			SafeExit.instance.addCallback(async () => {
 				if (worker.#worker.value) {
-					worker.#worker.value.postMessage(closeWorkerThreadEventObject);
+					worker.#worker.value.postMessage(closeWorkerThreadEventObject, []);
 				}
 				worker.terminate();
 			});
 		}
-	};
+	}
 	/**
 	 * lazyly generated because node version need to await
 	 * @type {Signal<Worker | import('worker_threads').Worker>}
 	 */
+	// @ts-expect-error
 	#worker = new Signal(undefined);
 	/**
 	 * @type {Signal<WT["RECEIVE"]>}
@@ -236,10 +257,10 @@ export class WorkerMainThread {
 	#handler = new Effect(async ({ subscribe }) => {
 		const postData = subscribe(this.#proxyPost).value;
 		const worker = subscribe(this.#worker).value;
-		if (!worker || postData === undefined) {
+		if (worker === undefined || postData === undefined) {
 			return;
 		}
-		worker.postMessage(postData);
+		worker.postMessage(postData, []);
 	});
 	/**
 	 * @description

package/src/class/WorkerMainThreadBundled.mjs

@@ -17,12 +17,16 @@ import { Signal } from './Signal.mjs';
  * @typedef {import('./WorkerResult.mjs').WorkerResult<POST>} WorkerResult
  */
 /**
- * @typedef {import('./WorkerThread.mjs').WorkerThread} WorkerThread
+ * @template RECEIVE
+ * @template POST
+ * @typedef {import('./WorkerThread.mjs').WorkerThread<RECEIVE, POST>} WorkerThread
+ */
+/**
  * @typedef {import('../common/lazie.mjs').unwrapLazy} unwrapLazy
  */
 
 /**
- * @template {WorkerThread} WT
+ * @template {WorkerThread<any, any>} WT
  */
 export class WorkerMainThread {
 	/**
@@ -35,7 +39,7 @@ export class WorkerMainThread {
 	 * @param {typeof WorkerMainThread["pathValidator"]} param0.pathValidator
 	 */
 	static setup = ({ workerClass, pathValidator }) => {
-		if (!Paths.root) {
+		if (Paths.root === undefined) {
 			return;
 		}
 		if (WorkerMainThread.#isRegistered) {
@@ -58,21 +62,21 @@ export class WorkerMainThread {
 		type: 'module',
 	});
 	/**
-	 * @template {WorkerThread} WT
+	 * @template {WorkerThread<any, any>} WT
 	 * @param {string} handler
 	 * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
 	 * @returns {WorkerMainThread<WT>}
 	 */
-	static newVivthWorker = (handler, options = {}) => {
+	static newVivthWorker(handler, options = {}) {
 		return new WorkerMainThread(handler, options);
-	};
+	}
 	/**
 	 * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[0]} handler
 	 * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[1]} [options]
 	 */
 	constructor(handler, options = {}) {
 		/**
-		 * @param {WT["RECEIVE"]} ev
+		 * @param {any} ev
 		 * @returns {void}
 		 */
 		const listener = (ev) => {
@@ -81,24 +85,29 @@ export class WorkerMainThread {
 		WorkerMainThread.#workerFilehandler(handler, options, this, listener);
 	}
 	/**
-	 * @type {import('./Signal.mjs').Signal<import('./WorkerResult.mjs').WorkerResult<WT["Post"]>|MessageEvent<import('./WorkerResult.mjs').WorkerResult<WT["Post"]>>>}
+	 * @type {import('./Signal.mjs').Signal<import('./WorkerResult.mjs').WorkerResult<WT["POST"]>|MessageEvent<import('./WorkerResult.mjs').WorkerResult<WT["POST"]>>>}
 	 */
+	// @ts-expect-error
 	#proxyReceiver = new Signal(undefined);
 	/**
+	 * @template {WorkerThread<any, any>} WT
 	 * @param {string} handler
 	 * @param { WorkerOptions
 	 * | import('worker_threads').WorkerOptions} options
-	 * @param {WorkerMainThread} worker
+	 * @param {WorkerMainThread<WT>} worker
 	 * @param {(any:any)=>void} listener
 	 * @returns {Promise<void>}
 	 */
-	static #workerFilehandler = async (handler, options, worker, listener) => {
+	static async #workerFilehandler(handler, options, worker, listener) {
 		let resolvedPath;
 		WorkerMainThread.#options.eval = true;
 		resolvedPath = (await FSInline.vivthFSInlineFile(handler)).toString('utf-8');
 		const runtime = GetRuntime();
 		const workerClass = WorkerMainThread.workerClass;
-		if (!workerClass) {
+		if (
+			//
+			!workerClass
+		) {
 			Console.error('invalid `Worker` inputed to `WorkerMainThread`;');
 			return;
 		}
@@ -109,11 +118,15 @@ export class WorkerMainThread {
 				}
 				let worker_;
 				const inlineURL = Base64URL(handler, 'application/javascript', btoa);
-				worker_ = worker.#worker.value = new workerClass(inlineURL, {
-					...options,
-					...WorkerMainThread.#options,
-				});
-				if (!('onmessage' in worker_)) {
+				worker_ = worker.#worker.value = new workerClass(
+					inlineURL,
+					// @ts-expect-error
+					{
+						...options,
+						...WorkerMainThread.#options,
+					}
+				);
+				if ('onmessage' in worker_ === false) {
 					throw new Error('not a browser');
 				}
 				worker_.onmessage = listener;
@@ -124,10 +137,14 @@ export class WorkerMainThread {
 				}
 			},
 			nonBrowser: async () => {
-				const worker_ = (worker.#worker.value = new workerClass(resolvedPath, {
-					...options,
-					...WorkerMainThread.#options,
-				}));
+				const worker_ = (worker.#worker.value = new workerClass(
+					resolvedPath,
+					// @ts-expect-error
+					{
+						...options,
+						...WorkerMainThread.#options,
+					}
+				));
 				if ('addEventListener' in worker_) {
 					worker_.addEventListener('message', listener);
 					if (SafeExit.instance) {
@@ -154,16 +171,17 @@ export class WorkerMainThread {
 		if (SafeExit.instance) {
 			SafeExit.instance.addCallback(async () => {
 				if (worker.#worker.value) {
-					worker.#worker.value.postMessage(closeWorkerThreadEventObject);
+					worker.#worker.value.postMessage(closeWorkerThreadEventObject, []);
 				}
 				worker.terminate();
 			});
 		}
-	};
+	}
 	/**
 	 * lazyly generated because node version need to await
 	 * @type {Signal<Worker | import('worker_threads').Worker>}
 	 */
+	// @ts-expect-error
 	#worker = new Signal(undefined);
 	/**
 	 * @type {Signal<WT["RECEIVE"]>}
@@ -172,10 +190,10 @@ export class WorkerMainThread {
 	#handler = new Effect(async ({ subscribe }) => {
 		const postData = subscribe(this.#proxyPost).value;
 		const worker = subscribe(this.#worker).value;
-		if (!worker || postData === undefined) {
+		if (worker === undefined || postData === undefined) {
 			return;
 		}
-		worker.postMessage(postData);
+		worker.postMessage(postData, []);
 	});
 	/**
 	 * @type {()=>void}

package/src/class/WorkerThread.mjs

@@ -20,9 +20,9 @@ export class WorkerThread {
 	 * @typedef {import('../types/QCBReturn.mjs').QCBReturn} QCBReturn
 	 */
 	/**
-	 * @type {Parameters<typeof WorkerThread["setup"]>[0]}
+	 * @type {Parameters<typeof WorkerThread["setup"]>[0]|undefined}
 	 */
-	static #refs = undefined;
+	static #refs;
 	/**
 	 * @description
 	 * - need to be called and exported as new `WorkerThread` class reference;
@@ -57,7 +57,7 @@ export class WorkerThread {
 	/**
 	 * @description
 	 * - instantiate via created class from `setup` static method;
-	 * @param {WorkerThread["handler"]} handler
+	 * @param {WorkerThread<RECEIVE, POST>["handler"]} handler
 	 * @example
 	 * import { MyWorkerThread } from './MyWorkerThread.mjs';
 	 *
@@ -81,30 +81,41 @@ export class WorkerThread {
 				 * @param {MessageEvent<RECEIVE>|RECEIVE} ev
 				 * @returns {Promise<void>}
 				 */
+				// @ts-expect-error
 				self.onmessage = async function (ev) {
 					const [, error] = await TryAsync(async () => {
 						ev = ev instanceof MessageEvent ? ev.data : ev;
 						if (WorkerThread.#isCloseWorkerEvent(ev)) {
 							this_.#qChannel.close();
+							// @ts-expect-error
 							self.onmessage = null;
 							return;
 						}
 						const [data, error] = await this_.#qChannel.callback(this, async ({ isLastOnQ }) => {
+							// @ts-expect-error
 							return await handler(ev, isLastOnQ);
 						});
 						if (error) {
 							throw error;
 						}
+						// @ts-expect-error
 						self.postMessage(new WorkerResult(data, undefined));
 					});
-					if (!error) {
+					if (error === undefined) {
 						return;
 					}
+					// @ts-expect-error
 					self.postMessage(new WorkerResult(undefined, error?.message ?? 'Unknown error'));
 				};
 			},
 			parentPost: async () => {
+				if (WorkerThread.#refs === undefined) {
+					return;
+				}
 				const { parentPort } = WorkerThread.#refs;
+				if (parentPort === null) {
+					return;
+				}
 				/**
 				 * @param {MessageEvent<RECEIVE>|RECEIVE} ev
 				 * @returns {Promise<void>}
@@ -117,7 +128,8 @@ export class WorkerThread {
 							parentPort.off('message', listener);
 							return;
 						}
-						const [data, error] = await this_.#qChannel.callback(this, async ({ isLastOnQ }) => {
+						const [data, error] = await this_.#qChannel.callback(this_, async ({ isLastOnQ }) => {
+							// @ts-expect-error
 							return await handler(ev, isLastOnQ);
 						});
 						if (error) {
@@ -125,7 +137,7 @@ export class WorkerThread {
 						}
 						parentPort.postMessage(new WorkerResult(data, undefined));
 					});
-					if (!error) {
+					if (error === undefined) {
 						return;
 					}
 					parentPort.postMessage(new WorkerResult(undefined, error?.message ?? 'Unknown error'));
@@ -133,7 +145,7 @@ export class WorkerThread {
 				parentPort.on('message', listener);
 			},
 		}).then(([, error]) => {
-			if (!error) {
+			if (error === undefined) {
 				return;
 			}
 			Console.error(error);
@@ -150,11 +162,13 @@ export class WorkerThread {
 	 * - helper type, hold no actual value;
 	 * @type {RECEIVE}
 	 */
+	// @ts-expect-error
 	RECEIVE;
 	/**
 	 * @description
 	 * - helper type, hold no actual value;
 	 * @type {POST}
 	 */
+	// @ts-expect-error
 	POST;
 }

package/src/common/Base64URL.mjs

@@ -14,7 +14,7 @@
  * (str, prevBufferEncoding) =>
  * 	Buffer.from(str, prevBufferEncoding).toString('base64')
  * ```
- * @returns {Base64URLString}
+ * @returns {string}
  * @example
  * import { Base64URL } from 'vivth'
  * import fileString from './fileString.mjs';
@@ -28,4 +28,4 @@ export function Base64URL(fileString, mimeType, btoaFunction) {
 		binary += String.fromCharCode(byte);
 	}
 	return `data:${mimeType.toString()};base64,${btoaFunction(binary)}`;
-}
+};

package/src/common/Base64URLFromFile.mjs

@@ -11,7 +11,7 @@ import { lookup } from 'mime-types';
  * >- can be extremely usefull to display file on desktop app webview, without exposing http server;
  * >- when using `FSInline`, use [Base64URL](#base64url) instead;
  * @param {string} filePath
- * @returns {Promise<Base64URLString>}
+ * @returns {Promise<string>}
  * @example
  * import { join } from 'node:path'
  *