vivth 1.1.2 → 1.2.0

package/types/src/class/LitExp.d.mts

@@ -0,0 +1,361 @@
+/**
+ * @description
+ * - class helper to created opionated regex helper;
+ * - named capture uses `es6+` feature, you might need to add polyfill to target extremely old browser;
+ * - class name refer to `Literal Expression`;
+ * - please be patient when using this class;
+ * >- destructuring is meant for extensive typehelper;
+ * >- and destructuring can lead to unhandled error here and there;
+ * >- therefore error as value is introduced to help to prevent error on runtime;
+ * @template {LitExpKeyType} KEYS
+ */
+export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyType> {
+    /**
+     * @typedef {import("../types/LitExpKeyType.mjs").LitExpKeyType} LitExpKeyType
+     */
+    /**
+     * @description
+     * - constructor helper;
+     * - under the hood it is an abstraction of `RegExp`, with more template literal touch;
+     * >- you can apply inline `RegExp` features on the string template literal(as constructor RegExp arg0);
+     * >>- by doing so you are opting in to make:
+     * >>>- your regex detection more robust; but
+     * >>>- `litExp_instance.make.string` to be `unusable`;
+     * >>- also mind the needs of escape for special characters;
+     * @template {LitExpKeyType} KEYS
+     * @param {KEYS} keysAndDefaultValuePair
+     * - keys and whether to override regex detection;
+     * >- example:
+     * ```js
+     *  myKey: /myCustomCapture/ // all flags will be stripped;
+     * ```
+     * - default value === `false` is "[\\s\\S]*?", as in whiteSpace and nonWhiteSpace 0 to more occurence;
+     * @returns {ReturnType<typeof TrySync<(templateStringArray:TemplateStringsArray,
+     * ...values:(keyof KEYS)[]
+     * )=>LitExp<KEYS>>>}
+     * - placement of `key` will determine the named capture group will be placed in the template literal;
+     * - it is recomended to not end template literal with any of the `key`s as the regex detection might failed to detects the boundary of the end of matched string of that capture group;
+     * @example
+     * import { LitExp } from 'vivth';
+     *
+     * (()=>{
+     * 	const [liteal, errorPrep] = LitExp.prepare({
+     * 		myKey: /myCustomCapture/, // is placed on (?<myKey>myCustomCapture)
+     * 		// use false to place "[\\s\\S]\*?" instead;
+     * 		...keyCaptureLogicPair
+     * 	})
+     * 	if (errorPrep) {
+     * 		console.error(error);
+     * 		return;
+     * 	}
+     * 	 const litExp_instance = liteal`templateLiteral:${'myKey'};`
+     * 	// recommended to end the template literal with any string but `key`;
+     * })()
+     */
+    static prepare: (keysAndDefaultValuePair: KEYS_1) => ReturnType<typeof TrySync<(templateStringArray: TemplateStringsArray, ...values: (keyof KEYS_1)[]) => LitExp<KEYS_1>>>;
+    /**
+     * @template {LitExpKeyType} KEYS
+     * @param {KEYS} instance_rules
+     * @param {(keyof KEYS)[]} intance_values
+     * @param {(value:keyof KEYS, regex:RegExp|false)=>ReturnType<typeof TrySync<string>>} valueHandler
+     * @param {TemplateStringsArray} strings
+     * @returns {ReturnType<typeof TrySync<string[]>>}
+     */
+    static #processTemplate: (instance_rules: KEYS_1, intance_values: (keyof KEYS_1)[], valueHandler: (value: keyof KEYS_1, regex: RegExp | false) => ReturnType<typeof TrySync<string>>, strings: TemplateStringsArray) => ReturnType<typeof TrySync<string[]>>;
+    /**
+     * @template {LitExpKeyType} KEYS
+     * @param {RegExp|false} regex
+     * @param {keyof KEYS} value
+     * @returns {ReturnType<typeof TrySync<string>>}
+     */
+    static #namedChapture: (value: keyof KEYS_1, regex: RegExp | false) => ReturnType<typeof TrySync<string>>;
+    /**
+     * @private
+     * @param {KEYS} keys
+     * @param {TemplateStringsArray} templateStringArray
+     * @param {...(keyof KEYS)} values
+     */
+    private constructor();
+    /**
+     * @description
+     * - instance methods for generating things;
+     */
+    make: {
+        /**
+         * @instance make
+         * @description
+         * - to make string based on the template literal;
+         * @param {Partial<ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>>[0]["result"]} overrides
+         * @returns {string}
+         * @example
+         * import { LitExp } from 'vivth';
+         *
+         * const [literal, errorPreparing] = LitExp.prepare({
+         * 	myKey: false,
+         * 	...keyCaptureLogicPair
+         * })
+         *
+         * // asuming no error
+         * litExp_instance = `templateLiteral:${'myKey'};`;
+         * const [result, error] = litExp_instance.make.string({
+         * 	myKey: 'actualvalue',
+         * });
+         *
+         * console.log(result); // "templateLiteral:actualvalue;"
+         */
+        string: (overrides: Partial<ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>>[0]["result"]) => string;
+    } & {
+        "vivth:unwrapLazy;": () => {
+            /**
+             * @instance make
+             * @description
+             * - to make string based on the template literal;
+             * @param {Partial<ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>>[0]["result"]} overrides
+             * @returns {string}
+             * @example
+             * import { LitExp } from 'vivth';
+             *
+             * const [literal, errorPreparing] = LitExp.prepare({
+             * 	myKey: false,
+             * 	...keyCaptureLogicPair
+             * })
+             *
+             * // asuming no error
+             * litExp_instance = `templateLiteral:${'myKey'};`;
+             * const [result, error] = litExp_instance.make.string({
+             * 	myKey: 'actualvalue',
+             * });
+             *
+             * console.log(result); // "templateLiteral:actualvalue;"
+             */
+            string: (overrides: Partial<ReturnType<LitExp<KEYS>["evaluate"]["execGroups"]>>[0]["result"]) => string;
+        };
+    };
+    /**
+     * @description
+     * - methods collections to evaluate string with `Literal Expression`;
+     */
+    evaluate: {
+        /**
+         * @instance evaluate
+         * @description
+         * - to exec and grouped based on `key`;
+         * @param {string} string
+         * @param {Object} options
+         * @param {ConstructorParameters<typeof RegExp>[1]} options.flags
+         * @param {boolean} options.whiteSpaceSensitive
+         * - true: leave any whitespace as is to be used as regex detection;
+         * - false: convert all whitespace to `\s+`;
+         * @param {boolean} options.absoluteLeadAndFollowing
+         * - false: standard capture;
+         * - true: add `^` and `$` to capture definition:
+         * >- meaning string will have to match starting and end of line from capture definition;
+         * @returns {ReturnType<typeof TrySync<{
+         * result:{ whole:string, named: Record<keyof KEYS, string>},
+         * regexp:RegExp}>>
+         * }
+         * @example
+         * import { LitExp } from 'vivth';
+         *
+         * const [literal, errorPreparing] = LitExp.prepare({
+         * 	myKey: false,
+         * 	...keyCaptureLogicPair
+         * })
+         *
+         * // asuming no eror
+         * const litExp_instance = literal`templateLiteral:${'myKey'};`
+         *
+         * const [{
+         * 		result:{ // asuming there's no error
+         * 			named: { myKey },
+         * 			whole,
+         * 		},
+         * 		regex, // for reference
+         * 	}, error] = litExp_instance.evaluate.execGroups(
+         * 	`templateLiteral:Something;`,
+         * 	{ ...options }
+         * )
+         *
+         * console.log(whole); // "templateLiteral:Something;"
+         * console.log(myKey); // "Something"
+         */
+        execGroups: (string: string, options: {
+            flags: ConstructorParameters<typeof RegExp>[1];
+            whiteSpaceSensitive: boolean;
+            absoluteLeadAndFollowing: boolean;
+        }) => ReturnType<typeof TrySync<{
+            result: {
+                whole: string;
+                named: Record<keyof KEYS, string>;
+            };
+            regexp: RegExp;
+        }>>;
+        /**
+         * @instance evaluate
+         * @description
+         * - to match all and grouped based on `key`;
+         * @param {Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0]} string
+         * @param {Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], 'absoluteLeadAndFollowing'>} options
+         * @returns {ReturnType<typeof TrySync<{result:{whole:string[], named:Array<Record<keyof KEYS, string>>},
+         * regexp: RegExp}>>
+         * }
+         * @example
+         * import { LitExp, Console } from 'vivth';
+         *
+         * const [literal, errorPreparing] = LitExp.prepare({
+         * 	myKey: false,
+         * 	...keyCaptureLogicPair
+         * })
+         *
+         * // asuming no error;
+         * litExp_instance = literal`templateLiteral:${'myKey'};`
+         *
+         * const [resultOfMatchedAllAndGrouped, error] = litExp_instance.evaluate.matchedAllAndGrouped(
+         * 	`templateLiteral:Something;
+         * 	templateLiteral:SomethingElse;`,
+         * 	{ ...options }
+         * )
+         * (()=>{
+         * 	if (error) {
+         * 		Console.error(error);
+         * 		return;
+         * 	}
+         * 	const {
+         * 		result: {
+         * 				whole: [whole0, whole1],
+         * 				named: [
+         * 					{ myKey: myKeyExec0, },
+         * 					{ myKey: myKeyExec1, },
+         * 				],
+         * 			},
+         * 		regexp
+         * 	} = resultOfMatchedAllAndGrouped;
+         *
+         * 	console.log(whole0); // "templateLiteral:Something;"
+         * 	console.log(whole1); // "templateLiteral:SomethingElse;"
+         * 	console.log(myKeyExec0); // "Something"
+         * 	console.log(myKeyExec1); // "SomethingElse"
+         * })()
+         */
+        matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<{
+            result: {
+                whole: string[];
+                named: Array<Record<keyof KEYS, string>>;
+            };
+            regexp: RegExp;
+        }>>;
+    } & {
+        "vivth:unwrapLazy;": () => {
+            /**
+             * @instance evaluate
+             * @description
+             * - to exec and grouped based on `key`;
+             * @param {string} string
+             * @param {Object} options
+             * @param {ConstructorParameters<typeof RegExp>[1]} options.flags
+             * @param {boolean} options.whiteSpaceSensitive
+             * - true: leave any whitespace as is to be used as regex detection;
+             * - false: convert all whitespace to `\s+`;
+             * @param {boolean} options.absoluteLeadAndFollowing
+             * - false: standard capture;
+             * - true: add `^` and `$` to capture definition:
+             * >- meaning string will have to match starting and end of line from capture definition;
+             * @returns {ReturnType<typeof TrySync<{
+             * result:{ whole:string, named: Record<keyof KEYS, string>},
+             * regexp:RegExp}>>
+             * }
+             * @example
+             * import { LitExp } from 'vivth';
+             *
+             * const [literal, errorPreparing] = LitExp.prepare({
+             * 	myKey: false,
+             * 	...keyCaptureLogicPair
+             * })
+             *
+             * // asuming no eror
+             * const litExp_instance = literal`templateLiteral:${'myKey'};`
+             *
+             * const [{
+             * 		result:{ // asuming there's no error
+             * 			named: { myKey },
+             * 			whole,
+             * 		},
+             * 		regex, // for reference
+             * 	}, error] = litExp_instance.evaluate.execGroups(
+             * 	`templateLiteral:Something;`,
+             * 	{ ...options }
+             * )
+             *
+             * console.log(whole); // "templateLiteral:Something;"
+             * console.log(myKey); // "Something"
+             */
+            execGroups: (string: string, options: {
+                flags: ConstructorParameters<typeof RegExp>[1];
+                whiteSpaceSensitive: boolean;
+                absoluteLeadAndFollowing: boolean;
+            }) => ReturnType<typeof TrySync<{
+                result: {
+                    whole: string;
+                    named: Record<keyof KEYS, string>;
+                };
+                regexp: RegExp;
+            }>>;
+            /**
+             * @instance evaluate
+             * @description
+             * - to match all and grouped based on `key`;
+             * @param {Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0]} string
+             * @param {Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], 'absoluteLeadAndFollowing'>} options
+             * @returns {ReturnType<typeof TrySync<{result:{whole:string[], named:Array<Record<keyof KEYS, string>>},
+             * regexp: RegExp}>>
+             * }
+             * @example
+             * import { LitExp, Console } from 'vivth';
+             *
+             * const [literal, errorPreparing] = LitExp.prepare({
+             * 	myKey: false,
+             * 	...keyCaptureLogicPair
+             * })
+             *
+             * // asuming no error;
+             * litExp_instance = literal`templateLiteral:${'myKey'};`
+             *
+             * const [resultOfMatchedAllAndGrouped, error] = litExp_instance.evaluate.matchedAllAndGrouped(
+             * 	`templateLiteral:Something;
+             * 	templateLiteral:SomethingElse;`,
+             * 	{ ...options }
+             * )
+             * (()=>{
+             * 	if (error) {
+             * 		Console.error(error);
+             * 		return;
+             * 	}
+             * 	const {
+             * 		result: {
+             * 				whole: [whole0, whole1],
+             * 				named: [
+             * 					{ myKey: myKeyExec0, },
+             * 					{ myKey: myKeyExec1, },
+             * 				],
+             * 			},
+             * 		regexp
+             * 	} = resultOfMatchedAllAndGrouped;
+             *
+             * 	console.log(whole0); // "templateLiteral:Something;"
+             * 	console.log(whole1); // "templateLiteral:SomethingElse;"
+             * 	console.log(myKeyExec0); // "Something"
+             * 	console.log(myKeyExec1); // "SomethingElse"
+             * })()
+             */
+            matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<{
+                result: {
+                    whole: string[];
+                    named: Array<Record<keyof KEYS, string>>;
+                };
+                regexp: RegExp;
+            }>>;
+        };
+    };
+    #private;
+}
+import { TrySync } from '../function/TrySync.mjs';

package/types/src/class/Paths.d.mts

@@ -2,6 +2,7 @@
  * @description
  * - class helpers to define pathReference;
  * - is a singleton;
+ * - most of functionality need to access `Paths.root`, if you get warning, you can instantiate `Paths` before running anything;
  */
 export class Paths {
     /**
@@ -25,9 +26,21 @@ export class Paths {
      * @example
      * import { Paths } from 'vivth';
      *
-     * Paths.normalize('file:\\D:\\myFile.mjs'); // return 'file://D://myFile.mjs'
+     * Paths.normalize('file:\\D:\\myFile.mjs'); //  "file://D://myFile.mjs"
      */
     static normalize: (path_: string) => string;
+    /**
+     * @description
+     * - normalize path separator to forward slash `/`;
+     * - then starts with forward slash `/`;
+     * @param {string} path_
+     * @returns {`/${string}`}
+     * @example
+     * import { Paths } from 'vivth';
+     *
+     * Paths.normalizesForRoot('path\\myFile.mjs'); //  "/path/myFile.mjs"
+     */
+    static normalizesForRoot: (path_: string) => `/${string}`;
     /**
      * @description
      * @param {Object} options
@@ -44,6 +57,10 @@ export class Paths {
      * ```js
      * Deno.env.get("INIT_CWD") ?? Deno.cwd()
      * ```
+     * - pkg:
+     * ```js
+     * __dirname
+     * ```
      * - other: you need to check your JSRuntime for the rootPath reference;
      * @example
      * import { Paths } from 'vivth';

package/types/src/class/QChannel.d.mts

@@ -1,9 +1,9 @@
 /**
  * @description
  * - class for `Queue` handling;
- * @template {AnyButUndefined} T
+ * @template {AnyButUndefined} DEFINEDANY
  */
-export class QChannel<T extends import("../types/AnyButUndefined.mjs").AnyButUndefined> {
+export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").AnyButUndefined> {
     /**
      * @typedef {import('../types/AnyButUndefined.mjs').AnyButUndefined} AnyButUndefined
      * @typedef {import('../types/QCBReturn.mjs').QCBReturn} QCBReturn
@@ -15,6 +15,11 @@ export class QChannel<T extends import("../types/AnyButUndefined.mjs").AnyButUnd
      * @param {Map<AnyButUndefined, [Promise<any>, {}]>} uniqueMap
      * @returns {typeof QChannel}
      * - usefull for Queue primitive on multiple library but single reference, like the Web by making the `Map` on `window` object;
+     * @example
+     * import { QChannel } from 'vivth';
+     *
+     * const myMappedQref = (window['myMappedQref'] = new Map());
+     * export const MyQClass = QChannel.makeQClass(myMappedQref);
      */
     static makeQClass: (uniqueMap: Map<import("../types/AnyButUndefined.mjs").AnyButUndefined, [Promise<any>, {}]>) => typeof QChannel;
     /**
@@ -25,9 +30,10 @@ export class QChannel<T extends import("../types/AnyButUndefined.mjs").AnyButUnd
      * - ensures that each id has only one task running at a time.
      * - calls with the same id will wait for the previous call to finish.
      * @param {AnyButUndefined} id
+     * @param {QChannel} instance
      * @returns {Promise<QCBReturn>} Resolves when it's safe to proceed for the given id, returning a cleanup function
      */
-    static #uniqueCB: (id: import("../types/AnyButUndefined.mjs").AnyButUndefined) => Promise<import("../types/QCBReturn.mjs").QCBReturn>;
+    static #uniqueCB: (id: import("../types/AnyButUndefined.mjs").AnyButUndefined, instance: QChannel<any>) => Promise<import("../types/QCBReturn.mjs").QCBReturn>;
     /**
      * @description
      * - first in first out handler
@@ -48,38 +54,76 @@ export class QChannel<T extends import("../types/AnyButUndefined.mjs").AnyButUnd
          * @static fifo
          * @description
          * - blocks execution for subsequent calls until the current one finishes.
-         * @template ResultType
-         * @param {()=>Promise<ResultType>} asyncCallback
-         * @returns {Promise<[ResultType|undefined, Error|undefined]>}
+         * @template RESULT
+         * @param {()=>Promise<RESULT>} asyncCallback
+         * @returns {Promise<[RESULT|undefined, Error|undefined]>}
          * @example
          * const [result, error] = await QChannel.fifo.callback(async () = > {
          * 	// code
          * })
          */
-        callback: <ResultType>(asyncCallback: () => Promise<ResultType>) => Promise<[ResultType | undefined, Error | undefined]>;
+        callback: <RESULT>(asyncCallback: () => Promise<RESULT>) => Promise<[RESULT | undefined, Error | undefined]>;
     } & {
-        "vivth:unwrapLazy;": string;
+        "vivth:unwrapLazy;": () => {
+            /**
+             * @static fifo
+             * @description
+             * - blocks execution for subsequent calls until the current one finishes.
+             * @returns {Promise<QCBFIFOReturn>} Resolves when it's safe to proceed, returning a cleanup function
+             * @example
+             * const { resume } = await QChannel.fifo.key();
+             * // blocks all `FIFO` called using this method and QChannel.fifoCallback;
+             * resume();
+             */
+            key: () => Promise<import("../types/QCBFIFOReturn.mjs").QCBFIFOReturn>;
+            /**
+             * @static fifo
+             * @description
+             * - blocks execution for subsequent calls until the current one finishes.
+             * @template RESULT
+             * @param {()=>Promise<RESULT>} asyncCallback
+             * @returns {Promise<[RESULT|undefined, Error|undefined]>}
+             * @example
+             * const [result, error] = await QChannel.fifo.callback(async () = > {
+             * 	// code
+             * })
+             */
+            callback: <RESULT>(asyncCallback: () => Promise<RESULT>) => Promise<[RESULT | undefined, Error | undefined]>;
+        };
     };
+    /**
+     * @param {string} name
+     * - only used as helper for logging, and has nothing to do with runtime behaviour;
+     */
+    constructor(name: string);
+    name: string;
+    /**
+     * @description
+     * - disable queue;
+     * - when `closed`, `isLastOnQ` will allways return `false`;
+     * @returns {void}
+     */
+    close: () => void;
     /**
      * @description
-     * - clear up all queued on the instance;
-     * - only clear up the reference, the already called will not be stoped;
+     * - enable queue;
+     * - when `opened`, `isLastOnQ` will evaluate whether calls are actually the last of queue;
      * @returns {void}
      */
-    clear: () => void;
+    open: () => void;
     /**
      * @description
      * - each `QChannelInstance` are managing it's own `queue`, and will not `await` for other `QChannelInstance`;
      * - caveat:
      * >- need to manually call resume();
      * >- slightly more performant than `callback`;
-     * @param {T} keyID
+     * @param {DEFINEDANY} keyID
      * @returns {Promise<QCBReturn>}
      * @example
-     * const q = new QChannel();
+     * const q = new QChannel('channel name');
      * const handler = async () => {
      * 	const { resume, isLastOnQ } = await q.key(keyID);
-     * 	// if (!isLastOnQ) { // imperative debounce if needed
+     * 	// if (!isLastOnQ()) { // imperative debounce if needed
      * 	// 	resume();
      * 	// 	return;
      * 	// }
@@ -90,26 +134,29 @@ export class QChannel<T extends import("../types/AnyButUndefined.mjs").AnyButUnd
      * }
      * handler();
      */
-    key: (keyID: T) => Promise<import("../types/QCBReturn.mjs").QCBReturn>;
+    key: (keyID: DEFINEDANY) => Promise<import("../types/QCBReturn.mjs").QCBReturn>;
     /**
      * @description
      * - `callbackBlock` with error as value:
      * - caveat:
      * >- no need to manually call resume();
      * >- slightly less performant than `callback`;
-     * @template ResultType
-     * @param {T} keyID
-     * @param {(options:Omit<QCBReturn, "resume">)=>Promise<ResultType>} asyncCallback
-     * @returns {Promise<[ResultType|undefined, Error|undefined]>}
+     * @template RESULT
+     * @param {DEFINEDANY} keyID
+     * @param {(options:Omit<QCBReturn,
+     * "resume">) =>
+     * Promise<RESULT>} asyncCallback
+     * @returns {ReturnType<typeof TryAsync<RESULT>>}
      * @example
-     * const q = new QChannel();
+     * const q = new QChannel('channel name');
      * const [result, error] = await q.callback(keyID, async ({ isLastOnQ }) = > {
-     * 	// if (!isLastOnQ) { // imperative debounce if needed
+     * 	// if (!isLastOnQ()) { // imperative debounce if needed
      * 	// 	return;
      * 	// }
      * 	// code
      * })
      */
-    callback: (keyID: T, asyncCallback: (options: Omit<import("../types/QCBReturn.mjs").QCBReturn, "resume">) => Promise<ResultType>) => Promise<[ResultType | undefined, Error | undefined]>;
+    callback<RESULT>(keyID: DEFINEDANY, asyncCallback: (options: Omit<import("../types/QCBReturn.mjs").QCBReturn, "resume">) => Promise<RESULT>): ReturnType<typeof TryAsync<RESULT>>;
     #private;
 }
+import { TryAsync } from '../function/TryAsync.mjs';

package/types/src/class/SafeExit.d.mts

@@ -6,19 +6,25 @@ export const safeCleanUpCBs: Set<() => Promise<void>>;
  * @description
  * - class helper for describing how to Safely Response on exit events
  * - singleton;
- * @template {[string, ...string[]]} eventNames
+ * - most of functionality might need to access `SafeExit.instance.exiting`, if you get warning, you can instantiate `SafeExit` before running anything;
  */
-export class SafeExit<eventNames extends [string, ...string[]]> {
+export class SafeExit {
     /**
      * @description
      * - only accessible after instantiation;
      * @type {SafeExit}
      */
-    static instance: SafeExit<any>;
+    static instance: SafeExit;
     /**
      * @description
      * @param {Object} options
-     * @param {eventNames} options.eventNames
+     * @param {[string, ...string[]]} options.eventNames
+     * - eventNames are blank by default, you need to manually name them all;
+     * - 'exit' will be omited, as it might cause async callbacks failed to execute;
+     * - example:
+     * ```js
+     *  ['SIGINT', 'SIGTERM']
+     * ```
      * @param {()=>void} options.terminator
      * - standard node/bun:
      * ```js
@@ -38,17 +44,26 @@ export class SafeExit<eventNames extends [string, ...string[]]> {
      * 	});
      * };
      * ```
+     * - example Deno:
+     * ```js
+     * (eventName) => {
+     * 	const sig = Deno.signal(eventName);
+     * 		for await (const _ of sig) {
+     * 			exiting.correction(true);
+     * 			sig.dispose();
+     * 			Console.log(`safe exit via "${eventName}"`);
+     * 		}
+     * }
+     * ```
      * - if your exit callback doesn't uses `process` global object you need to input on the SafeExit instantiation
      * @example
      * import { SafeExit, Console } from 'vivth';
      *
      * new SafeExit({
-     * 	// eventNames are blank by default, you need to manually name them all;
-     * 	// 'exit' will be omited, as it might cause async callbacks failed to execute;
      * 	eventNames: ['SIGINT', 'SIGTERM', ...eventNames],
-     * 	terminator = () => process.exit(0), // OR on deno () => Deno.exit(0),
+     * 	terminator : () => process.exit(0), // OR on deno () => Deno.exit(0),
      * 	// optional deno example
-     * 	listener = (eventName) => {
+     * 	listener : (eventName) => {
      * 		const sig = Deno.signal(eventName);
      * 			for await (const _ of sig) {
      * 				exiting.correction(true);
@@ -59,7 +74,7 @@ export class SafeExit<eventNames extends [string, ...string[]]> {
      * });
      */
     constructor({ eventNames, terminator, listener }: {
-        eventNames: eventNames;
+        eventNames: [string, ...string[]];
         terminator: () => void;
         listener?: (eventName: string) => void;
     });

package/types/src/class/Setup.d.mts

@@ -42,9 +42,10 @@ export class Setup {
      * - proxy `WorkerMainThread_instance` for Setup;
      * @example
      * import { Setup } from 'vivth';
+     * import { Worker } from 'node:worker_threads';
      *
      * Setup.workerMain({
-     * 	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}`);
@@ -61,16 +62,16 @@ export class Setup {
     /**
      * @description
      * - correct `parentPort` reference when needed;
+     * - export to create new reference to be use to create new WorkerThread instance;
      * @example
      * import { Setup } from 'vivth';
+     * import { parentPort } from 'node:worker_threads';
      *
-     * Setup.workerThread({ parentPort: async () => (await import('node:worker_threads')).parentPort });
+     * export const MyWorkerThreadRef = Setup.workerThread({parentPort});
      * // that is the default value, if your parentPort/equivalent API is not that;
      * // you need to call this method;
      */
-    static workerThread: <Receive_, Post_>(parentPortRef: {
-        parentPort: () => Promise<any>;
-    }) => typeof WorkerThread<Receive_, Post_>;
+    static workerThread: typeof WorkerThread.setup;
 }
 import { SafeExit } from './SafeExit.mjs';
 import { Paths } from './Paths.mjs';