vivth 1.4.3 → 1.4.5

package/README.md

@@ -92,6 +92,7 @@ npm i vivth
 - [GetRuntime](#getruntime)
 - [IsAsync](#isasync)
 - [LazyFactory](#lazyfactory)
+- [TemplateLiteral](#templateliteral)
 - [Timeout](#timeout)
 - [Tries](#tries)
 - [TryAsync](#tryasync)
@@ -2547,7 +2548,7 @@ WorkerMainThread.setup({
 
 ```js
 /**
- * @type {typeof Worker|typeof import('worker_threads').Worker}
+ * @type {typeof Worker|typeof import('node:worker_threads').Worker}
  */
 ```
 
@@ -2569,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>}
  */
 ```
@@ -2694,7 +2695,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';
@@ -2727,7 +2728,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;
   // }
@@ -2736,7 +2737,8 @@ const doubleWorker = new MyWorkerThread((ev, isLastOnQ) => {
   // 	return;
   // }
   return (ev = ev * 2);
-});
+};
+new MyWorkerThread(handler);
 ```
 
 #### reference:`WorkerThread_instance.handler`
@@ -2745,7 +2747,7 @@ const doubleWorker = new MyWorkerThread((ev, isLastOnQ) => {
 
 ```js
 /**
- * @type {(ev: RECEIVE, isLastOnQ:QCBReturn["isLastOnQ"]) => POST}
+ * @type {(ev: RECEIVE, isLastOnQ:QCBReturn["isLastOnQ"]) => Promise<POST>}
  */
 ```
 
@@ -3272,6 +3274,41 @@ myInstance["vivth:unwrapLazy;"](); // forcefully call factory generator;
 
 \*) <sub>[go to list of exported API and typehelpers](#list-of-exported-api-and-typehelpers)</sub>
 
+<h2 id="templateliteral">TemplateLiteral</h2>
+
+#### reference:`TemplateLiteral`
+
+- function helper to create template literal with VALUEhandler to handle each values;
+
+```js
+/**
+ * @template {(input:any)=>string|Promise<string>} VALUEHANDLER
+ * @param {VALUEHANDLER} valueHandler
+ * @param {(result:string)=>string} [postProcess]
+ * @returns {(strings:TemplateStringsArray,
+ * ...values:(Parameters<VALUEHANDLER>[0])[])=>
+ * ReturnType<VALUEHANDLER>}
+ */
+```
+
+- <i>example</i>:
+
+```js
+ import { TemplateLiteral } form 'vivth';
+
+ export const html = TemplateLiteral(
+  (val) => val,
+  // optional
+  (res) => return window.body.innerHTML = res
+ );
+
+ html`<div>${`<button>innerButton</button>`}</div>`;
+ // this will set innerHTML of body to '<div><button>innerButton</button></div>'
+
+```
+
+\*) <sub>[go to list of exported API and typehelpers](#list-of-exported-api-and-typehelpers)</sub>
+
 <h2 id="timeout">Timeout</h2>
 
 #### reference:`Timeout`

package/index.mjs

@@ -45,6 +45,7 @@ export { GetNamedImportAlias } from './src/function/GetNamedImportAlias.mjs';
 export { GetRuntime } from './src/function/GetRuntime.mjs';
 export { IsAsync } from './src/function/IsAsync.mjs';
 export { LazyFactory } from './src/function/LazyFactory.mjs';
+export { TemplateLiteral } from './src/function/TemplateLiteral.mjs';
 export { Timeout } from './src/function/Timeout.mjs';
 export { Tries } from './src/function/Tries.mjs';
 export { TryAsync } from './src/function/TryAsync.mjs';

package/package.json

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

package/src/class/LitExp.mjs

@@ -132,7 +132,7 @@ export class LitExp {
 					throw new Error('string undefined');
 				}
 				if (i + 1 == stringsLength && string === '') {
-					result.push('(?:\\s+?|;|,|$|)');
+					result.push('(?:\\s+?|;|,|$|\/\/)');
 				} else {
 					result.push(LitExp.escape(string));
 				}

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>}
@@ -246,7 +247,7 @@ export class WorkerMainThread {
 	}
 	/**
 	 * 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);

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>}
@@ -179,7 +180,7 @@ export class WorkerMainThread {
 	}
 	/**
 	 * 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);

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/src/function/TemplateLiteral.mjs

@@ -0,0 +1,67 @@
+// @ts-check
+
+import { IsAsync } from './IsAsync.mjs';
+
+/**
+ * @description
+ * - function helper to create template literal with VALUEhandler to handle each values;
+ * @template {(input:any)=>string|Promise<string>} VALUEHANDLER
+ * @param {VALUEHANDLER} valueHandler
+ * @param {(result:string)=>string} [postProcess]
+ * @returns {(strings:TemplateStringsArray,
+ * ...values:(Parameters<VALUEHANDLER>[0])[])=>
+ * ReturnType<VALUEHANDLER>}
+ * @example
+ * import { TemplateLiteral } form 'vivth';
+ *
+ * export const html = TemplateLiteral(
+ *  (val) => val,
+ *  // optional
+ *  (res) => return window.body.innerHTML = res
+ * );
+ *
+ * html`<div>${`<button>innerButton</button>`}</div>`;
+ * // this will set innerHTML of body to '<div><button>innerButton</button></div>'
+ */
+export function TemplateLiteral(valueHandler, postProcess = undefined) {
+	if (IsAsync(valueHandler)) {
+		// @ts-expect-error
+		return async (strings, ...values) => {
+			const result = [];
+			for (let i = 0; i < strings.length; i++) {
+				result.push(strings[i]);
+				if (i < values.length) {
+					const value = values[i];
+					if (value === undefined) {
+						continue;
+					}
+					result.push(await valueHandler(value));
+				}
+			}
+			const resTrue = result.join('');
+			if (!postProcess) {
+				return resTrue;
+			}
+			return postProcess(resTrue);
+		};
+	}
+	// @ts-expect-error
+	return (strings, ...values) => {
+		const result = [];
+		for (let i = 0; i < strings.length; i++) {
+			result.push(strings[i]);
+			if (i < values.length) {
+				const value = values[i];
+				if (value === undefined) {
+					continue;
+				}
+				result.push(valueHandler(value));
+			}
+		}
+		const resTrue = result.join('');
+		if (!postProcess) {
+			return resTrue;
+		}
+		return postProcess(resTrue);
+	};
+}

package/types/index.d.mts

@@ -37,6 +37,7 @@ export { GetNamedImportAlias } from "./src/function/GetNamedImportAlias.mjs";
 export { GetRuntime } from "./src/function/GetRuntime.mjs";
 export { IsAsync } from "./src/function/IsAsync.mjs";
 export { LazyFactory } from "./src/function/LazyFactory.mjs";
+export { TemplateLiteral } from "./src/function/TemplateLiteral.mjs";
 export { Timeout } from "./src/function/Timeout.mjs";
 export { Tries } from "./src/function/Tries.mjs";
 export { TryAsync } from "./src/function/TryAsync.mjs";

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

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,26 +38,26 @@ 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]

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;

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

@@ -0,0 +1,22 @@
+/**
+ * @description
+ * - function helper to create template literal with VALUEhandler to handle each values;
+ * @template {(input:any)=>string|Promise<string>} VALUEHANDLER
+ * @param {VALUEHANDLER} valueHandler
+ * @param {(result:string)=>string} [postProcess]
+ * @returns {(strings:TemplateStringsArray,
+ * ...values:(Parameters<VALUEHANDLER>[0])[])=>
+ * ReturnType<VALUEHANDLER>}
+ * @example
+ * import { TemplateLiteral } form 'vivth';
+ *
+ * export const html = TemplateLiteral(
+ *  (val) => val,
+ *  // optional
+ *  (res) => return window.body.innerHTML = res
+ * );
+ *
+ * html`<div>${`<button>innerButton</button>`}</div>`;
+ * // this will set innerHTML of body to '<div><button>innerButton</button></div>'
+ */
+export function TemplateLiteral<VALUEHANDLER extends (input: any) => string | Promise<string>>(valueHandler: VALUEHANDLER, postProcess?: (result: string) => string): (strings: TemplateStringsArray, ...values: (Parameters<VALUEHANDLER>[0])[]) => ReturnType<VALUEHANDLER>;