vivth 1.3.8 → 1.4.0

package/README.md

@@ -93,8 +93,11 @@ npm i vivth
 - [IsAsync](#isasync)
 - [LazyFactory](#lazyfactory)
 - [Timeout](#timeout)
-- [Try](#try)
+- [Tries](#tries)
 - [TryAsync](#tryasync)
+- [TryAsyncCall](#tryasynccall)
+- [TryCall](#trycall)
+- [TryNew](#trynew)
 - [TrySync](#trysync)
 - [TsToMjs](#tstomjs)
 - [AnyButUndefined](#anybutundefined)
@@ -3300,9 +3303,9 @@ test();
 
 \*) <sub>[go to list of exported API and typehelpers](#list-of-exported-api-and-typehelpers)</sub>
 
-<h2 id="try">Try</h2>
+<h2 id="tries">Tries</h2>
 
-#### reference:`Try`
+#### reference:`Tries`
 
 - function for error as value for chained operations;
 - utility function to brute force which key is able to run;
@@ -3329,9 +3332,9 @@ test();
 - <i>example</i>:
 
 ```js
-import { Try } from "vivth";
+import { Tries } from "vivth";
 
-const [[key, result], error] = await Try({
+const [[key, result], error] = await Tries({
   someRuntime: async ({ prevError }) => {
     // asuming on this one doesn't naturally throw error,
     // yet you need to continue to next key,
@@ -3396,6 +3399,100 @@ 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
+ * @returns {(...param:Parameters<UNSAFEASYNCCALLBACK>)=> 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
+  }
+})();
+```
+
+\*) <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
+ * @returns {(...param:Parameters<UNSAFECALLBACK>)=>
+ * [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
+}
+```
+
+\*) <sub>[go to list of exported API and typehelpers](#list-of-exported-api-and-typehelpers)</sub>
+
+<h2 id="trynew">TryNew</h2>
+
+#### reference:`TryNew`
+
+- function helper to turn unsafe constructor call of classReference into safe one without tryCatch block;
+- usefull to flatten your source code;
+
+```js
+/**
+ * @template {new (...args: any[]) => any} CLASSREF
+ * @param {CLASSREF} classReference
+ * @returns {(...args: ConstructorParameters<CLASSREF>) =>
+ * [InstanceType<CLASSREF>, undefined]|
+ * [undefined, Error]}
+ */
+```
+
+- <i>example</i>:
+
+```js
+import { TryNew } from "vivth";
+
+const [instance, error] = TryNew(ClassReference)(...classConstructorParameters);
+if (!error) {
+  // do something with instance
+}
+```
+
+\*) <sub>[go to list of exported API and typehelpers](#list-of-exported-api-and-typehelpers)</sub>
+
 <h2 id="trysync">TrySync</h2>
 
 #### reference:`TrySync`

package/index.mjs

@@ -46,8 +46,11 @@ export { GetRuntime } from './src/function/GetRuntime.mjs';
 export { IsAsync } from './src/function/IsAsync.mjs';
 export { LazyFactory } from './src/function/LazyFactory.mjs';
 export { Timeout } from './src/function/Timeout.mjs';
-export { Try } from './src/function/Try.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.3.8",
+	"version": "1.4.0",
 	"description": "library primitives",
 	"main": "index.mjs",
 	"types": "./types/index.d.mts",

package/src/class/WorkerMainThread.mjs

@@ -2,7 +2,7 @@
 
 import { closeWorkerThreadEventObject } from '../common/eventObjects.mjs';
 import { GetRuntime } from '../function/GetRuntime.mjs';
-import { Try } from '../function/Try.mjs';
+import { Tries } from '../function/Tries.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
 import { Console } from './Console.mjs';
 import { Derived } from './Derived.mjs';
@@ -179,7 +179,7 @@ export class WorkerMainThread {
 			Console.error('invalid `Worker` inputed to `WorkerMainThread`;');
 			return;
 		}
-		const [, errorCreatingWorker] = await Try({
+		const [, errorCreatingWorker] = await Tries({
 			browser: async () => {
 				if (runtime !== 'browser') {
 					throw new Error('not a browser');

package/src/class/WorkerMainThreadBundled.mjs

@@ -4,7 +4,7 @@ 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 { Tries } from '../function/Tries.mjs';
 import { Console } from './Console.mjs';
 import { Derived } from './Derived.mjs';
 import { Effect } from './Effect.mjs';
@@ -111,7 +111,7 @@ export class WorkerMainThread {
 			Console.error('invalid `Worker` inputed to `WorkerMainThread`;');
 			return;
 		}
-		const [, errorCreatingWorker] = await Try({
+		const [, errorCreatingWorker] = await Tries({
 			browser: async () => {
 				if (runtime !== 'browser') {
 					throw new Error('not a browser');

package/src/class/WorkerThread.mjs

@@ -2,7 +2,7 @@
 
 import { closeWorkerThreadEventObject } from '../common/eventObjects.mjs';
 import { EventCheck } from '../function/EventCheck.mjs';
-import { Try } from '../function/Try.mjs';
+import { Tries } from '../function/Tries.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
 import { Console } from './Console.mjs';
 import { QChannel } from './QChannel.mjs';
@@ -75,7 +75,7 @@ export class WorkerThread {
 	constructor(handler) {
 		this.handler = handler;
 		const this_ = this;
-		Try({
+		Tries({
 			post: async () => {
 				/**
 				 * @param {MessageEvent<RECEIVE>|RECEIVE} ev

package/src/function/{Try.mjs → Tries.mjs}

@@ -21,9 +21,9 @@ import { TryAsync } from './TryAsync.mjs';
  * 	| [[undefined, undefined], Error|undefined]
  * >}
  * @example
- * import { Try } from 'vivth';
+ * import { Tries } from 'vivth';
  *
- * const [[key, result], error] = await Try({
+ * const [[key, result], error] = await Tries({
  * 	someRuntime: async ({ prevError }) => {
  * 		// asuming on this one doesn't naturally throw error,
  * 		// yet you need to continue to next key,
@@ -51,7 +51,7 @@ import { TryAsync } from './TryAsync.mjs';
  * 	},
  * });
  */
-export async function Try(tryRecord) {
+export async function Tries(tryRecord) {
 	/**
 	 * @type {Error|undefined}
 	 */

package/src/function/TryAsyncCall.mjs

@@ -0,0 +1,31 @@
+// @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
+ * @returns {(...param:Parameters<UNSAFEASYNCCALLBACK>)=> 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
+ *  }
+ * })()
+ */
+export function TryAsyncCall(unsafeAsyncCallback) {
+	// @ts-expect-error
+	return async (...params) => {
+		try {
+			return [await unsafeAsyncCallback(...params), undefined];
+		} catch (err) {
+			return [undefined, err];
+		}
+	};
+}

package/src/function/TryCall.mjs

@@ -0,0 +1,29 @@
+// @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
+ * @returns {(...param:Parameters<UNSAFECALLBACK>)=>
+ * [ReturnType<UNSAFECALLBACK>,undefined]|
+ * [undefined,Error]}
+ * @example
+ * import { TryCall } from 'vivth';
+ *
+ * const [result, error] = TryCall(unsafeCallback)(...unsafeCallbackParameters);
+ * if (!error) {
+ *  // do something with result
+ * }
+ */
+export function TryCall(unsafeCallback) {
+	// @ts-expect-error
+	return (...params) => {
+		try {
+			return [unsafeCallback(...params), undefined];
+		} catch (err) {
+			return [undefined, err];
+		}
+	};
+}

package/src/function/TryNew.mjs

@@ -0,0 +1,29 @@
+// @ts-check
+
+/**
+ * @description
+ * - function helper to turn unsafe constructor call of classReference into safe one without tryCatch block;
+ * - usefull to flatten your source code;
+ * @template {new (...args: any[]) => any} CLASSREF
+ * @param {CLASSREF} classReference
+ * @returns {(...args: ConstructorParameters<CLASSREF>) =>
+ * [InstanceType<CLASSREF>, undefined]|
+ * [undefined, Error]}
+ * @example
+ * import { TryNew } from 'vivth';
+ *
+ * const [instance, error] = TryNew(ClassReference)(...classConstructorParameters)
+ * if(!error) {
+ *  // do something with instance
+ * }
+ */
+export function TryNew(classReference) {
+	// @ts-expect-error
+	return (...params) => {
+		try {
+			return [new classReference(...params), undefined];
+		} catch (err) {
+			return [undefined, err];
+		}
+	};
+}

package/types/index.d.mts

@@ -38,8 +38,11 @@ export { GetRuntime } from "./src/function/GetRuntime.mjs";
 export { IsAsync } from "./src/function/IsAsync.mjs";
 export { LazyFactory } from "./src/function/LazyFactory.mjs";
 export { Timeout } from "./src/function/Timeout.mjs";
-export { Try } from "./src/function/Try.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";
 export type AnyButUndefined = import("./src/types/AnyButUndefined.mjs").AnyButUndefined;

package/types/src/function/{Try.d.mts → Tries.d.mts}

@@ -17,9 +17,9 @@
  * 	| [[undefined, undefined], Error|undefined]
  * >}
  * @example
- * import { Try } from 'vivth';
+ * import { Tries } from 'vivth';
  *
- * const [[key, result], error] = await Try({
+ * const [[key, result], error] = await Tries({
  * 	someRuntime: async ({ prevError }) => {
  * 		// asuming on this one doesn't naturally throw error,
  * 		// yet you need to continue to next key,
@@ -47,6 +47,6 @@
  * 	},
  * });
  */
-export function Try<KEY extends string, RETURNTYPE, RecordTryType extends Record<KEY, (err: {
+export function Tries<KEY extends string, RETURNTYPE, RecordTryType extends Record<KEY, (err: {
     prevError: undefined | Error;
 }) => Promise<RETURNTYPE>>>(tryRecord: RecordTryType): Promise<[[keyof RecordTryType, RETURNTYPE], undefined] | [[undefined, undefined], Error | undefined]>;

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

@@ -0,0 +1,20 @@
+/**
+ * @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
+ * @returns {(...param:Parameters<UNSAFEASYNCCALLBACK>)=> 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
+ *  }
+ * })()
+ */
+export function TryAsyncCall<UNSAFEASYNCCALLBACK extends (...param: any[]) => Promise<any>>(unsafeAsyncCallback: UNSAFEASYNCCALLBACK): (...param: Parameters<UNSAFEASYNCCALLBACK>) => Promise<[Awaited<ReturnType<UNSAFEASYNCCALLBACK>>, undefined] | [undefined, Error]>;

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

@@ -0,0 +1,18 @@
+/**
+ * @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
+ * @returns {(...param:Parameters<UNSAFECALLBACK>)=>
+ * [ReturnType<UNSAFECALLBACK>,undefined]|
+ * [undefined,Error]}
+ * @example
+ * import { TryCall } from 'vivth';
+ *
+ * const [result, error] = TryCall(unsafeCallback)(...unsafeCallbackParameters);
+ * if (!error) {
+ *  // do something with result
+ * }
+ */
+export function TryCall<UNSAFECALLBACK extends (...param: any[]) => any>(unsafeCallback: UNSAFECALLBACK): (...param: Parameters<UNSAFECALLBACK>) => [ReturnType<UNSAFECALLBACK>, undefined] | [undefined, Error];

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

@@ -0,0 +1,18 @@
+/**
+ * @description
+ * - function helper to turn unsafe constructor call of classReference into safe one without tryCatch block;
+ * - usefull to flatten your source code;
+ * @template {new (...args: any[]) => any} CLASSREF
+ * @param {CLASSREF} classReference
+ * @returns {(...args: ConstructorParameters<CLASSREF>) =>
+ * [InstanceType<CLASSREF>, undefined]|
+ * [undefined, Error]}
+ * @example
+ * import { TryNew } from 'vivth';
+ *
+ * const [instance, error] = TryNew(ClassReference)(...classConstructorParameters)
+ * if(!error) {
+ *  // do something with instance
+ * }
+ */
+export function TryNew<CLASSREF extends new (...args: any[]) => any>(classReference: CLASSREF): (...args: ConstructorParameters<CLASSREF>) => [InstanceType<CLASSREF>, undefined] | [undefined, Error];