vivth 1.1.1 → 1.2.0

package/src/class/WorkerMainThread.mjs

@@ -1,7 +1,7 @@
 // @ts-check
 
-import { Base64URL } from '../common/Base64URL.mjs';
 import { closeWorkerThreadEventObject } from '../common/eventObjects.mjs';
+import { GetRuntime } from '../function/GetRuntime.mjs';
 import { Try } from '../function/Try.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
 import { Console } from './Console.mjs';
@@ -12,40 +12,53 @@ import { SafeExit } from './SafeExit.mjs';
 import { Signal } from './Signal.mjs';
 
 /**
- * @template A
- * @typedef {import('./WorkerResult.mjs').WorkerResult<A>} WorkerResult
+ * @template POST
+ * @typedef {import('./WorkerResult.mjs').WorkerResult<POST>} WorkerResult
  */
 /**
  * @typedef {import('./WorkerThread.mjs').WorkerThread} WorkerThread
+ * @typedef {import('../common/lazie.mjs').unwrapLazy} unwrapLazy
  */
 
 /**
  * @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
  */
 export class WorkerMainThread {
+	/**
+	 * @type {boolean}
+	 */
 	static #isRegistered = false;
 	/**
 	 * @description
 	 * - need to be called first, before any `WorkerMainThread` instantiation:
 	 * @param {Object} param0
 	 * @param {typeof WorkerMainThread["workerClass"]} param0.workerClass
+	 * - example:
+	 * ```js
+	 * import { Worker } from 'node:worker_threads';
+	 * ```
 	 * @param {typeof WorkerMainThread["pathValidator"]} param0.pathValidator
+	 * - example:
 	 * ```js
-	 *	async(relativePath) => {
-	 *		// verify whether relativePath exist, then return the full path
-	 *		// use fetch | fs, chained with Paths.instance.root + WorkerMainThread.basePath;
-	 *	}
+	 * async (workerPath, root, base) => {
+	 *  const truePathCheck = `${root}/${base}/${workerPath}`;
+	 * 	const res = await fetch(truePathCheck);
+	 * 	// might also check wheter it need base or not
+	 * 	return await res.ok;
+	 * }
 	 * ```
 	 * @param {typeof WorkerMainThread["basePath"]} [param0.basePath]
 	 * - additonal realtivePath from rootPath;
 	 * - default: '';
 	 * @example
+	 * import { Worker } from 'node:worker_threads';
 	 * import { WorkerMainThread } from 'vivth';
 	 *
 	 * WorkerMainThread.setup({
-	 * 	workerClass: async () => await (import('worker_threads')).Worker,
+	 * 	workerClass: Worker,
 	 * 	basePath: 'public/assets/js/workers',
 	 * 	pathValidator: async (workerPath, root, base) => {
 	 * 		const res = await fetch(`${root}/${base}/${workerPath}`);
@@ -71,7 +84,7 @@ export class WorkerMainThread {
 	 * @description
 	 * - reference for `Worker` class;
 	 * - edit via `setup`;
-	 * @type {()=>Promise<typeof Worker|typeof import('worker_threads').Worker>}
+	 * @type {typeof Worker|typeof import('worker_threads').Worker}
 	 */
 	static workerClass;
 	/**
@@ -92,31 +105,38 @@ export class WorkerMainThread {
 		type: 'module',
 	});
 	/**
+	 * @template {WorkerThread} WT
 	 * @description
 	 * - create Worker_instance;
 	 * @param {string} handler
-	 * - if `isInline` === `false`, `handler` should be:
-	 * >- pointing to worker thread file; WHICH
-	 * >- the path must be relative to `projectRoot`;
-	 * - if `isInline` === `true`, `handler` should be
-	 * >- string literal of prebundled worker thread script; OR
-	 * >- manually made string literal of worker thread script;
 	 * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
-	 * @param {boolean} [isInline]
+	 * @returns {WorkerMainThread<WT>}
+	 * @example
+	 * import { WorkerMainThread } from 'vivth';
+	 *
+	 * export const myDoubleWorker = WorkerMainThread.newVivthWorker('./doubleWorkerThread.mjs');
+	 */
+	static newVivthWorker = (handler, options = {}) => {
+		return new WorkerMainThread(handler, options);
+	};
+	/**
+	 * @private
+	 * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[0]} handler
+	 * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[1]} [options]
 	 * @example
 	 * import { WorkerMainThread } from 'vivth';
 	 *
-	 * export const myDoubleWorker = new WorkerMainThread('./doubleWorkerThread.mjs');
+	 * export const myDoubleWorker = WorkerMainThread.newVivthWorker('./doubleWorkerThread.mjs');
 	 */
-	constructor(handler, options = {}, isInline = false) {
+	constructor(handler, options = {}) {
 		/**
-		 * @param {WT["Receive"]} ev
+		 * @param {WT["RECEIVE"]} ev
 		 * @returns {void}
 		 */
 		const listener = (ev) => {
 			this.#proxyReceiver.value = ev;
 		};
-		WorkerMainThread.#workerFilehandler(handler, options, this, listener, isInline);
+		WorkerMainThread.#workerFilehandler(handler, options, this, listener);
 	}
 	/**
 	 * @type {import('./Signal.mjs').Signal<import('./WorkerResult.mjs').WorkerResult<WT["Post"]>|MessageEvent<import('./WorkerResult.mjs').WorkerResult<WT["Post"]>>>}
@@ -128,144 +148,97 @@ export class WorkerMainThread {
 	 * | import('worker_threads').WorkerOptions} options
 	 * @param {WorkerMainThread} worker
 	 * @param {(any:any)=>void} listener
-	 * @param {boolean} isInline
 	 * @returns {Promise<void>}
 	 */
-	static #workerFilehandler = async (handler, options, worker, listener, isInline) => {
+	static #workerFilehandler = async (handler, options, worker, listener) => {
 		let resolvedPath;
-		if (!isInline) {
-			const pathValidator = WorkerMainThread.pathValidator;
-			const [resolvedPath_, error] = await TryAsync(async () => {
-				return await pathValidator({
-					worker: handler,
-					root: Paths.root,
-					base: WorkerMainThread.basePath,
-				});
+		const pathValidator = WorkerMainThread.pathValidator;
+		const [resolvedPath_, error] = await TryAsync(async () => {
+			return await pathValidator({
+				worker: handler,
+				root: Paths.root,
+				base: WorkerMainThread.basePath,
 			});
-			if (error) {
-				Console.error({
-					error,
-					pathValidator,
-					message: 'invalid pathValidator inputed to `WorkerMainThread`;',
-				});
-				return;
-			}
-			resolvedPath = resolvedPath_;
-		} else {
-			WorkerMainThread.#options.eval = true;
-			resolvedPath = handler;
+		});
+		if (error) {
+			Console.error({
+				error,
+				pathValidator,
+				message: 'invalid pathValidator inputed to `WorkerMainThread`;',
+			});
+			return;
+		}
+		resolvedPath = resolvedPath_;
+		const runtime = GetRuntime();
+		const workerClass = WorkerMainThread.workerClass;
+		if (!workerClass) {
+			Console.error('invalid `Worker` inputed to `WorkerMainThread`;');
+			return;
 		}
-		const [_1, error1] = await Try({
-			universal: async () => {
-				const WorkerClass = await WorkerMainThread.workerClass();
-				if (!WorkerClass) {
-					throw new Error('invalid `Worker` inputed to `WorkerMainThread`;');
+		const [, errorCreatingWorker] = await Try({
+			browser: async () => {
+				if (runtime !== 'browser') {
+					throw new Error('not a browser');
 				}
-				const [_2, error2] = await Try({
-					browser: async () => {
-						if (!WorkerMainThread.isBrowser) {
-							throw new Error('not a browser');
-						}
-						let worker_;
-						if (!isInline) {
-							worker_ = worker.#worker.value = new WorkerClass(resolvedPath, {
-								...options,
-								...WorkerMainThread.#options,
-							});
-						} else {
-							const inlineURL = Base64URL(handler, 'application/javascript', btoa);
-							worker_ = worker.#worker.value = new WorkerClass(inlineURL, {
-								...options,
-								...WorkerMainThread.#options,
-							});
-						}
-						if (!('onmessage' in worker_)) {
-							throw new Error();
-						}
-						worker_.onmessage = listener;
-						if (SafeExit.instance) {
-							SafeExit.instance.addCallback(async () => {
-								worker_.onmessage = null;
-							});
-						}
-					},
-					nonBrowser: async () => {
-						const worker_ = (worker.#worker.value = new WorkerClass(resolvedPath, {
-							...options,
-							...WorkerMainThread.#options,
-						}));
-						if (!('addEventListener' in worker_)) {
-							throw new Error();
-						}
-						worker_.addEventListener('message', listener);
-						if (SafeExit.instance) {
-							SafeExit.instance.addCallback(async () => {
-								worker_.removeEventListener('message', listener);
-							});
-						}
-					},
+				let worker_;
+				worker_ = worker.#worker.value = new workerClass(resolvedPath, {
+					...options,
+					...WorkerMainThread.#options,
 				});
-				if (error2) {
-					throw new Error();
+				if (!('onmessage' in worker_)) {
+					throw new Error('not a browser');
 				}
+				worker_.onmessage = listener;
 				if (SafeExit.instance) {
 					SafeExit.instance.addCallback(async () => {
-						worker.#worker.value.postMessage(closeWorkerThreadEventObject);
-						worker.terminate();
+						worker_.onmessage = null;
 					});
 				}
 			},
-			nodeOrBun: async () => {
-				if (!worker.#worker.value) {
-					const { Worker } = await import('node:worker_threads');
-					worker.#worker.value = new Worker(resolvedPath, {
-						...options,
-						...WorkerMainThread.#options,
-					});
-				}
-				const worker_ = worker.#worker.value;
-				// @ts-expect-error
-				worker_.addListener('message', listener);
-				if (SafeExit.instance) {
-					SafeExit.instance.addCallback(async () => {
-						// @ts-expect-error
-						worker_.removeListener('message', listener);
-						worker_.postMessage(closeWorkerThreadEventObject);
-						worker.terminate();
-					});
+			nonBrowser: async () => {
+				const worker_ = (worker.#worker.value = new workerClass(resolvedPath, {
+					...options,
+					...WorkerMainThread.#options,
+				}));
+				if ('addEventListener' in worker_) {
+					worker_.addEventListener('message', listener);
+					if (SafeExit.instance) {
+						SafeExit.instance.addCallback(async () => {
+							worker_.removeEventListener('message', listener);
+						});
+					}
+				} else if ('addListener' in worker_) {
+					worker_.addListener('message', listener);
+					if (SafeExit.instance) {
+						SafeExit.instance.addCallback(async () => {
+							worker_.removeListener('message', listener);
+						});
+					}
+				} else {
+					throw new Error('not a standard non browser');
 				}
 			},
 		});
-		if (error1) {
-			Console.error(error1);
+		if (errorCreatingWorker) {
+			Console.error(errorCreatingWorker);
 			return;
 		}
-	};
-	/**
-	 * @type {boolean}
-	 */
-	static #isBrowser = undefined;
-	/**
-	 * @description
-	 * - check whether js run in browser
-	 * @type {boolean}
-	 */
-	static get isBrowser() {
-		if (WorkerMainThread.#isBrowser === undefined) {
-			WorkerMainThread.#isBrowser =
-				typeof window !== 'undefined' &&
-				typeof location === 'object' &&
-				typeof location.origin === 'string';
+		if (SafeExit.instance) {
+			SafeExit.instance.addCallback(async () => {
+				if (worker.#worker.value) {
+					worker.#worker.value.postMessage(closeWorkerThreadEventObject);
+				}
+				worker.terminate();
+			});
 		}
-		return WorkerMainThread.#isBrowser;
-	}
+	};
 	/**
 	 * lazyly generated because node version need to await
 	 * @type {Signal<Worker | import('worker_threads').Worker>}
 	 */
 	#worker = new Signal(undefined);
 	/**
-	 * @type {Signal<WT["Receive"]>}
+	 * @type {Signal<WT["RECEIVE"]>}
 	 */
 	#proxyPost = new Signal(undefined);
 	#handler = new Effect(async ({ subscribe }) => {
@@ -295,7 +268,7 @@ export class WorkerMainThread {
 	/**
 	 * @description
 	 * - result signal of the processed message;
-	 * @type {Derived<WorkerResult<WT["Post"]>>}
+	 * @type {Derived<WorkerResult<WT["POST"]>>}
 	 * @example
 	 * import { Effect } from 'vivth';
 	 * import { myDoubleWorker } from './myDoubleWorker.mjs';
@@ -316,7 +289,7 @@ export class WorkerMainThread {
 	/**
 	 * @description
 	 * - callback to send message to the worker thread;
-	 * @type {(event: WT["Receive"])=>void}
+	 * @type {(event: WT["RECEIVE"])=>void}
 	 * @example
 	 * import { myDoubleWorker } from './myDoubleWorker.mjs';
 	 *

package/src/class/WorkerMainThreadBundled.mjs

@@ -0,0 +1,216 @@
+// @ts-check
+
+import { FSInline } from '../bundler/FSInline.mjs';
+import { Base64URL } from '../common/Base64URL.mjs';
+import { closeWorkerThreadEventObject } from '../common/eventObjects.mjs';
+import { GetRuntime } from '../function/GetRuntime.mjs';
+import { Try } from '../function/Try.mjs';
+import { Console } from './Console.mjs';
+import { Derived } from './Derived.mjs';
+import { Effect } from './Effect.mjs';
+import { Paths } from './Paths.mjs';
+import { SafeExit } from './SafeExit.mjs';
+import { Signal } from './Signal.mjs';
+
+/**
+ * @template POST
+ * @typedef {import('./WorkerResult.mjs').WorkerResult<POST>} WorkerResult
+ */
+/**
+ * @typedef {import('./WorkerThread.mjs').WorkerThread} WorkerThread
+ * @typedef {import('../common/lazie.mjs').unwrapLazy} unwrapLazy
+ */
+
+/**
+ * @template {WorkerThread} WT
+ */
+export class WorkerMainThread {
+	/**
+	 * @type {boolean}
+	 */
+	static #isRegistered = false;
+	/**
+	 * @param {Object} param0
+	 * @param {typeof WorkerMainThread["workerClass"]} param0.workerClass
+	 * @param {typeof WorkerMainThread["pathValidator"]} param0.pathValidator
+	 * @param {typeof WorkerMainThread["basePath"]} [param0.basePath]
+	 */
+	static setup = ({ workerClass, pathValidator, basePath = '' }) => {
+		if (!Paths.root) {
+			return;
+		}
+		if (WorkerMainThread.#isRegistered) {
+			Console.warn({ message: 'WorkerMainThread.setup, can only be called once' });
+			return;
+		}
+		WorkerMainThread.#isRegistered = true;
+		WorkerMainThread.workerClass = workerClass;
+		WorkerMainThread.pathValidator = pathValidator;
+		WorkerMainThread.basePath = basePath;
+	};
+	/**
+	 * @type {typeof Worker|typeof import('worker_threads').Worker}
+	 */
+	static workerClass;
+	/**
+	 * @type {string}
+	 */
+	static basePath;
+	/**
+	 * @type {(paths:{worker: string, root:string, base: string})=>Promise<string>}
+	 */
+	static pathValidator;
+	static #options = /** @type {import('worker_threads').WorkerOptions & { type?: 'module' }} */ ({
+		type: 'module',
+	});
+	/**
+	 * @template {WorkerThread} WT
+	 * @param {string} handler
+	 * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
+	 * @returns {WorkerMainThread<WT>}
+	 */
+	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
+		 * @returns {void}
+		 */
+		const listener = (ev) => {
+			this.#proxyReceiver.value = ev;
+		};
+		WorkerMainThread.#workerFilehandler(handler, options, this, listener);
+	}
+	/**
+	 * @type {import('./Signal.mjs').Signal<import('./WorkerResult.mjs').WorkerResult<WT["Post"]>|MessageEvent<import('./WorkerResult.mjs').WorkerResult<WT["Post"]>>>}
+	 */
+	#proxyReceiver = new Signal(undefined);
+	/**
+	 * @param {string} handler
+	 * @param { WorkerOptions
+	 * | import('worker_threads').WorkerOptions} options
+	 * @param {WorkerMainThread} worker
+	 * @param {(any:any)=>void} listener
+	 * @returns {Promise<void>}
+	 */
+	static #workerFilehandler = async (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) {
+			Console.error('invalid `Worker` inputed to `WorkerMainThread`;');
+			return;
+		}
+		const [, errorCreatingWorker] = await Try({
+			browser: async () => {
+				if (runtime !== 'browser') {
+					throw new Error('not a browser');
+				}
+				let worker_;
+				const inlineURL = Base64URL(handler, 'application/javascript', btoa);
+				worker_ = worker.#worker.value = new workerClass(inlineURL, {
+					...options,
+					...WorkerMainThread.#options,
+				});
+				if (!('onmessage' in worker_)) {
+					throw new Error('not a browser');
+				}
+				worker_.onmessage = listener;
+				if (SafeExit.instance) {
+					SafeExit.instance.addCallback(async () => {
+						worker_.onmessage = null;
+					});
+				}
+			},
+			nonBrowser: async () => {
+				const worker_ = (worker.#worker.value = new workerClass(resolvedPath, {
+					...options,
+					...WorkerMainThread.#options,
+				}));
+				if ('addEventListener' in worker_) {
+					worker_.addEventListener('message', listener);
+					if (SafeExit.instance) {
+						SafeExit.instance.addCallback(async () => {
+							worker_.removeEventListener('message', listener);
+						});
+					}
+				} else if ('addListener' in worker_) {
+					worker_.addListener('message', listener);
+					if (SafeExit.instance) {
+						SafeExit.instance.addCallback(async () => {
+							worker_.removeListener('message', listener);
+						});
+					}
+				} else {
+					throw new Error('not a standard non browser');
+				}
+			},
+		});
+		if (errorCreatingWorker) {
+			Console.error(errorCreatingWorker);
+			return;
+		}
+		if (SafeExit.instance) {
+			SafeExit.instance.addCallback(async () => {
+				if (worker.#worker.value) {
+					worker.#worker.value.postMessage(closeWorkerThreadEventObject);
+				}
+				worker.terminate();
+			});
+		}
+	};
+	/**
+	 * lazyly generated because node version need to await
+	 * @type {Signal<Worker | import('worker_threads').Worker>}
+	 */
+	#worker = new Signal(undefined);
+	/**
+	 * @type {Signal<WT["RECEIVE"]>}
+	 */
+	#proxyPost = new Signal(undefined);
+	#handler = new Effect(async ({ subscribe }) => {
+		const postData = subscribe(this.#proxyPost).value;
+		const worker = subscribe(this.#worker).value;
+		if (!worker || postData === undefined) {
+			return;
+		}
+		worker.postMessage(postData);
+	});
+	/**
+	 * @type {()=>void}
+	 */
+	terminate = () => {
+		/**
+		 * this is more for browser, as most of this are automatically cleaned with `SafeExit`;
+		 */
+		this.#worker.value?.terminate();
+		this.#worker.remove.ref();
+		this.#handler.options.removeEffect();
+		this.#proxyPost.remove.ref();
+		this.#proxyReceiver.remove.ref();
+		this.receiverSignal.remove.ref();
+	};
+	/**
+	 * @type {Derived<WorkerResult<WT["POST"]>>}
+	 */
+	receiverSignal = new Derived(async ({ subscribe }) => {
+		const val = subscribe(this.#proxyReceiver).value;
+		if (val instanceof MessageEvent) {
+			return val.data;
+		}
+		return val;
+	});
+	/**
+	 * @type {(event: WT["RECEIVE"])=>void}
+	 */
+	postMessage = (data) => {
+		this.#proxyPost.value = data;
+	};
+}