vivth 1.4.2 → 1.4.4

package/README.md

@@ -92,11 +92,10 @@ npm i vivth
 - [GetRuntime](#getruntime)
 - [IsAsync](#isasync)
 - [LazyFactory](#lazyfactory)
+- [TemplateLiteral](#templateliteral)
 - [Timeout](#timeout)
 - [Tries](#tries)
 - [TryAsync](#tryasync)
-- [TryAsyncCall](#tryasynccall)
-- [TryCall](#trycall)
 - [TryNew](#trynew)
 - [TrySync](#trysync)
 - [TsToMjs](#tstomjs)
@@ -3274,6 +3273,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`
@@ -3399,72 +3433,6 @@ let [res, error] = await TryAsync(async () => {
 
 \*) <sub>[go to list of exported API and typehelpers](#list-of-exported-api-and-typehelpers)</sub>
 
-<h2 id="tryasynccall">TryAsyncCall</h2>
-
-#### reference:`TryAsyncCall`
-
-- function helper to turn unsafe callback into safe one without tryCatch block;
-- usefull to flatten your source code;
-
-```js
-/**
- * @template {(...param:any[])=>Promise<any>} UNSAFEASYNCCALLBACK
- * @param {UNSAFEASYNCCALLBACK} unsafeAsyncCallback
- * @param {Parameters<UNSAFEASYNCCALLBACK>} params
- * @returns {Promise<
- * [Awaited<ReturnType<UNSAFEASYNCCALLBACK>>,undefined]|
- * [undefined,Error]>}
- */
-```
-
-- <i>example</i>:
-
-```js
-import { TryAsyncCall } from "vivth";
-
-(async () => {
-  const [result, error] = await TryAsyncCall(
-    unsafeAsyncCallback,
-    ...unsafeAsyncCallbackParameters,
-  );
-  if (!error) {
-    // do something with result safely;
-  }
-})();
-```
-
-\*) <sub>[go to list of exported API and typehelpers](#list-of-exported-api-and-typehelpers)</sub>
-
-<h2 id="trycall">TryCall</h2>
-
-#### reference:`TryCall`
-
-- function helper to turn unsafe callback into safe one without tryCatch block;
-- usefull to flatten your source code;
-
-```js
-/**
- * @template {(...param:any[])=>any} UNSAFECALLBACK
- * @param {UNSAFECALLBACK} unsafeCallback
- * @param {Parameters<UNSAFECALLBACK>} params
- * @returns {[ReturnType<UNSAFECALLBACK>,undefined]|
- * [undefined, Error]}
- */
-```
-
-- <i>example</i>:
-
-```js
-import { TryCall } from "vivth";
-
-const [result, error] = TryCall(unsafeCallback, ...unsafeCallbackParameters);
-if (!error) {
-  // do something with result safely;
-}
-```
-
-\*) <sub>[go to list of exported API and typehelpers](#list-of-exported-api-and-typehelpers)</sub>
-
 <h2 id="trynew">TryNew</h2>
 
 #### reference:`TryNew`
@@ -3514,7 +3482,7 @@ if (!error) {
 - <i>example</i>:
 
 ```js
-import { readFileSync } from "fs";
+import { readFileSync } from "node:fs";
 import { TrySync } from "./yourModule.js";
 
 const [data, error] = TrySync(() => {

package/index.mjs

@@ -45,11 +45,10 @@ 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';
-export { TryAsyncCall } from './src/function/TryAsyncCall.mjs';
-export { TryCall } from './src/function/TryCall.mjs';
 export { TryNew } from './src/function/TryNew.mjs';
 export { TrySync } from './src/function/TrySync.mjs';
 export { TsToMjs } from './src/function/TsToMjs.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "vivth",
-	"version": "1.4.2",
+	"version": "1.4.4",
 	"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/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/src/function/TryAsync.mjs

@@ -1,5 +1,7 @@
 // @ts-check
 
+import { resolveErrorArray } from './resolveErrorArray.mjs';
+
 /**
  * @description
  * - function for error as value for asynchronous operation;
@@ -26,7 +28,6 @@ export async function TryAsync(asyncFunction_) {
 		const result = await asyncFunction_();
 		return [result, undefined];
 	} catch (error) {
-		// @ts-expect-error
-		return [undefined, error];
+		return resolveErrorArray(error);
 	}
 }

package/src/function/TryNew.mjs

@@ -1,5 +1,7 @@
 // @ts-check
 
+import { resolveErrorArray } from './resolveErrorArray.mjs';
+
 /**
  * @description
  * - function helper to turn unsafe constructor call of classReference into safe one without tryCatch block;
@@ -20,8 +22,7 @@
 export function TryNew(classReference, ...params) {
 	try {
 		return [new classReference(...params), undefined];
-	} catch (err) {
-		// @ts-expect-error
-		return [undefined, err];
+	} catch (error) {
+		return resolveErrorArray(error);
 	}
 }

package/src/function/TrySync.mjs

@@ -1,5 +1,7 @@
 // @ts-check
 
+import { resolveErrorArray } from './resolveErrorArray.mjs';
+
 /**
  * @description
  * - function for error as value for synchronous operation;
@@ -9,7 +11,7 @@
  * @returns {[RESULT,undefined]|
  * [undefined,Error]}
  * @example
- * import { readFileSync } from 'fs';
+ * import { readFileSync } from 'node:fs';
  * import { TrySync } from './yourModule.js';
  *
  * const [data, error] = TrySync(() => {
@@ -21,7 +23,6 @@ export function TrySync(function_) {
 		const result = function_();
 		return [result, undefined];
 	} catch (error) {
-		// @ts-expect-error
-		return [undefined, error];
+		return resolveErrorArray(error);
 	}
 }

package/src/function/resolveErrorArray.mjs

@@ -0,0 +1,9 @@
+// @ts-check
+
+/**
+ * @param {unknown} unknown
+ * @returns {[undefined, Error]}
+ */
+export const resolveErrorArray = (unknown) => {
+	return [undefined, unknown instanceof Error ? unknown : new Error(String(unknown))];
+};

package/types/index.d.mts

@@ -37,11 +37,10 @@ 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";
-export { TryAsyncCall } from "./src/function/TryAsyncCall.mjs";
-export { TryCall } from "./src/function/TryCall.mjs";
 export { TryNew } from "./src/function/TryNew.mjs";
 export { TrySync } from "./src/function/TrySync.mjs";
 export { TsToMjs } from "./src/function/TsToMjs.mjs";

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>;

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

@@ -7,7 +7,7 @@
  * @returns {[RESULT,undefined]|
  * [undefined,Error]}
  * @example
- * import { readFileSync } from 'fs';
+ * import { readFileSync } from 'node:fs';
  * import { TrySync } from './yourModule.js';
  *
  * const [data, error] = TrySync(() => {

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

@@ -0,0 +1 @@
+export function resolveErrorArray(unknown: unknown): [undefined, Error];

package/src/function/TryAsyncCall.mjs

@@ -1,30 +0,0 @@
-// @ts-check
-
-/**
- * @description
- * - function helper to turn unsafe callback into safe one without tryCatch block;
- * - usefull to flatten your source code;
- * @template {(...param:any[])=>Promise<any>} UNSAFEASYNCCALLBACK
- * @param {UNSAFEASYNCCALLBACK} unsafeAsyncCallback
- * @param {Parameters<UNSAFEASYNCCALLBACK>} params
- * @returns {Promise<
- * [Awaited<ReturnType<UNSAFEASYNCCALLBACK>>,undefined]|
- * [undefined,Error]>}
- * @example
- * import { TryAsyncCall } from 'vivth';
- *
- * (async() => {
- *  const [result, error] = await TryAsyncCall(unsafeAsyncCallback, ...unsafeAsyncCallbackParameters);
- *  if (!error) {
- *   // do something with result safely;
- *  }
- * })()
- */
-export async function TryAsyncCall(unsafeAsyncCallback, ...params) {
-	try {
-		return [await unsafeAsyncCallback(...params), undefined];
-	} catch (err) {
-		// @ts-expect-error
-		return [undefined, err];
-	}
-}

package/src/function/TryCall.mjs

@@ -1,27 +0,0 @@
-// @ts-check
-
-/**
- * @description
- * - function helper to turn unsafe callback into safe one without tryCatch block;
- * - usefull to flatten your source code;
- * @template {(...param:any[])=>any} UNSAFECALLBACK
- * @param {UNSAFECALLBACK} unsafeCallback
- * @param {Parameters<UNSAFECALLBACK>} params
- * @returns {[ReturnType<UNSAFECALLBACK>,undefined]|
- * [undefined, Error]}
- * @example
- * import { TryCall } from 'vivth';
- *
- * const [result, error] = TryCall(unsafeCallback, ...unsafeCallbackParameters);
- * if (!error) {
- *   // do something with result safely;
- * }
- */
-export function TryCall(unsafeCallback, ...params) {
-	try {
-		return [unsafeCallback(...params), undefined];
-	} catch (err) {
-		// @ts-expect-error
-		return [undefined, err];
-	}
-}

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

@@ -1,21 +0,0 @@
-/**
- * @description
- * - function helper to turn unsafe callback into safe one without tryCatch block;
- * - usefull to flatten your source code;
- * @template {(...param:any[])=>Promise<any>} UNSAFEASYNCCALLBACK
- * @param {UNSAFEASYNCCALLBACK} unsafeAsyncCallback
- * @param {Parameters<UNSAFEASYNCCALLBACK>} params
- * @returns {Promise<
- * [Awaited<ReturnType<UNSAFEASYNCCALLBACK>>,undefined]|
- * [undefined,Error]>}
- * @example
- * import { TryAsyncCall } from 'vivth';
- *
- * (async() => {
- *  const [result, error] = await TryAsyncCall(unsafeAsyncCallback, ...unsafeAsyncCallbackParameters);
- *  if (!error) {
- *   // do something with result safely;
- *  }
- * })()
- */
-export function TryAsyncCall<UNSAFEASYNCCALLBACK extends (...param: any[]) => Promise<any>>(unsafeAsyncCallback: UNSAFEASYNCCALLBACK, ...params: Parameters<UNSAFEASYNCCALLBACK>): Promise<[Awaited<ReturnType<UNSAFEASYNCCALLBACK>>, undefined] | [undefined, Error]>;

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

@@ -1,18 +0,0 @@
-/**
- * @description
- * - function helper to turn unsafe callback into safe one without tryCatch block;
- * - usefull to flatten your source code;
- * @template {(...param:any[])=>any} UNSAFECALLBACK
- * @param {UNSAFECALLBACK} unsafeCallback
- * @param {Parameters<UNSAFECALLBACK>} params
- * @returns {[ReturnType<UNSAFECALLBACK>,undefined]|
- * [undefined, Error]}
- * @example
- * import { TryCall } from 'vivth';
- *
- * const [result, error] = TryCall(unsafeCallback, ...unsafeCallbackParameters);
- * if (!error) {
- *   // do something with result safely;
- * }
- */
-export function TryCall<UNSAFECALLBACK extends (...param: any[]) => any>(unsafeCallback: UNSAFECALLBACK, ...params: Parameters<UNSAFECALLBACK>): [ReturnType<UNSAFECALLBACK>, undefined] | [undefined, Error];