vivth 1.2.3 → 1.3.0

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

@@ -1,5 +1,5 @@
 /**
- * @type {Set<Signal>}
+ * @type {Set<Signal<any>>}
  */
 export const setOFSignals: Set<Signal<any>>;
 /**
@@ -149,9 +149,9 @@ export class Signal<VALUE> {
     /**
      * @description
      * - value before change;
-     * @returns {VALUE}
+     * @returns {VALUE|undefined}
      */
-    get prev(): VALUE;
+    get prev(): VALUE | undefined;
     /**
      * @description
      * - assign new value then automatically notify all subscribers;

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

@@ -3,16 +3,20 @@
  * @typedef {import('./WorkerResult.mjs').WorkerResult<POST>} WorkerResult
  */
 /**
- * @typedef {import('./WorkerThread.mjs').WorkerThread} WorkerThread
+ * @template RECEIVE
+ * @template POST
+ * @typedef {import('./WorkerThread.mjs').WorkerThread<RECEIVE, POST>} 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
+ * @template {WorkerThread<any, any>} WT
  */
-export class WorkerMainThread<WT extends WorkerThread> {
+export class WorkerMainThread<WT extends WorkerThread<any, any>> {
     /**
      * @type {boolean}
      */
@@ -79,7 +83,7 @@ export class WorkerMainThread<WT extends WorkerThread> {
         type?: "module";
     };
     /**
-     * @template {WorkerThread} WT
+     * @template {WorkerThread<any, any>} WT
      * @description
      * - create Worker_instance;
      * @param {string} handler
@@ -90,16 +94,17 @@ export class WorkerMainThread<WT extends WorkerThread> {
      *
      * export const myDoubleWorker = WorkerMainThread.newVivthWorker('./doubleWorkerThread.mjs');
      */
-    static newVivthWorker: (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("worker_threads").WorkerOptions, "eval" | "type">): WorkerMainThread<WT_1>;
     /**
+     * @template {WorkerThread<any, any>} WT
      * @param {string} handler
      * @param { WorkerOptions
      * | import('worker_threads').WorkerOptions} options
-     * @param {WorkerMainThread} worker
+     * @param {WorkerMainThread<WT>} worker
      * @param {(any:any)=>void} listener
      * @returns {Promise<void>}
      */
-    static #workerFilehandler: (handler: string, options: WorkerOptions | import("worker_threads").WorkerOptions, worker: WorkerMainThread<any>, listener: (any: any) => void) => Promise<void>;
+    static #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>;
     /**
      * @private
      * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[0]} handler
@@ -144,6 +149,6 @@ export class WorkerMainThread<WT extends WorkerThread> {
     #private;
 }
 export type WorkerResult<POST> = import("./WorkerResult.mjs").WorkerResult<POST>;
-export type WorkerThread = import("./WorkerThread.mjs").WorkerThread<any, any>;
+export type WorkerThread<RECEIVE, POST> = import("./WorkerThread.mjs").WorkerThread<RECEIVE, POST>;
 export type unwrapLazy = "vivth:unwrapLazy;";
 import { Derived } from './Derived.mjs';

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

@@ -3,13 +3,17 @@
  * @typedef {import('./WorkerResult.mjs').WorkerResult<POST>} WorkerResult
  */
 /**
- * @typedef {import('./WorkerThread.mjs').WorkerThread} WorkerThread
+ * @template RECEIVE
+ * @template POST
+ * @typedef {import('./WorkerThread.mjs').WorkerThread<RECEIVE, POST>} WorkerThread
+ */
+/**
  * @typedef {import('../common/lazie.mjs').unwrapLazy} unwrapLazy
  */
 /**
- * @template {WorkerThread} WT
+ * @template {WorkerThread<any, any>} WT
  */
-export class WorkerMainThread<WT extends WorkerThread> {
+export class WorkerMainThread<WT extends WorkerThread<any, any>> {
     /**
      * @type {boolean}
      */
@@ -38,21 +42,22 @@ export class WorkerMainThread<WT extends WorkerThread> {
         type?: "module";
     };
     /**
-     * @template {WorkerThread} WT
+     * @template {WorkerThread<any, any>} WT
      * @param {string} handler
      * @param {Omit<WorkerOptions|import('worker_threads').WorkerOptions, 'eval'|'type'>} [options]
      * @returns {WorkerMainThread<WT>}
      */
-    static newVivthWorker: (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("worker_threads").WorkerOptions, "eval" | "type">): WorkerMainThread<WT_1>;
     /**
+     * @template {WorkerThread<any, any>} WT
      * @param {string} handler
      * @param { WorkerOptions
      * | import('worker_threads').WorkerOptions} options
-     * @param {WorkerMainThread} worker
+     * @param {WorkerMainThread<WT>} worker
      * @param {(any:any)=>void} listener
      * @returns {Promise<void>}
      */
-    static #workerFilehandler: (handler: string, options: WorkerOptions | import("worker_threads").WorkerOptions, worker: WorkerMainThread<any>, listener: (any: any) => void) => Promise<void>;
+    static #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>;
     /**
      * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[0]} handler
      * @param {Parameters<typeof WorkerMainThread<WT>["newVivthWorker"]>[1]} [options]
@@ -73,6 +78,6 @@ export class WorkerMainThread<WT extends WorkerThread> {
     #private;
 }
 export type WorkerResult<POST> = import("./WorkerResult.mjs").WorkerResult<POST>;
-export type WorkerThread = import("./WorkerThread.mjs").WorkerThread<any, any>;
+export type WorkerThread<RECEIVE, POST> = import("./WorkerThread.mjs").WorkerThread<RECEIVE, POST>;
 export type unwrapLazy = "vivth:unwrapLazy;";
 import { Derived } from './Derived.mjs';

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

@@ -10,9 +10,9 @@ export class WorkerThread<RECEIVE, POST> {
      * @typedef {import('../types/QCBReturn.mjs').QCBReturn} QCBReturn
      */
     /**
-     * @type {Parameters<typeof WorkerThread["setup"]>[0]}
+     * @type {Parameters<typeof WorkerThread["setup"]>[0]|undefined}
      */
-    static #refs: Parameters<(typeof WorkerThread)["setup"]>[0];
+    static #refs: Parameters<(typeof WorkerThread)["setup"]>[0] | undefined;
     /**
      * @description
      * - need to be called and exported as new `WorkerThread` class reference;
@@ -40,7 +40,7 @@ export class WorkerThread<RECEIVE, POST> {
     /**
      * @description
      * - instantiate via created class from `setup` static method;
-     * @param {WorkerThread["handler"]} handler
+     * @param {WorkerThread<RECEIVE, POST>["handler"]} handler
      * @example
      * import { MyWorkerThread } from './MyWorkerThread.mjs';
      *
@@ -55,7 +55,7 @@ export class WorkerThread<RECEIVE, POST> {
      * 	return ev = ev \* 2;
      * });
      */
-    constructor(handler: (ev: any, isLastOnQ: () => boolean) => any);
+    constructor(handler: WorkerThread<RECEIVE, POST>["handler"]);
     /**
      * @description
      * - type helper;

package/types/src/common/Base64URL.d.mts

@@ -12,11 +12,11 @@
  * (str, prevBufferEncoding) =>
  * 	Buffer.from(str, prevBufferEncoding).toString('base64')
  * ```
- * @returns {Base64URLString}
+ * @returns {string}
  * @example
  * import { Base64URL } from 'vivth'
  * import fileString from './fileString.mjs';
  *
  * Base64URL(fileString, 'application/javascript', btoa);
  */
-export function Base64URL(fileString: string, mimeType: string, btoaFunction: (string: string) => string): Base64URLString;
+export function Base64URL(fileString: string, mimeType: string, btoaFunction: (string: string) => string): string;

package/types/src/common/Base64URLFromFile.d.mts

@@ -5,7 +5,7 @@
  * >- can be extremely usefull to display file on desktop app webview, without exposing http server;
  * >- when using `FSInline`, use [Base64URL](#base64url) instead;
  * @param {string} filePath
- * @returns {Promise<Base64URLString>}
+ * @returns {Promise<string>}
  * @example
  * import { join } from 'node:path'
  *
@@ -13,4 +13,4 @@
  *
  * await Base64URLFromFile(join(Paths.root, '/path/to/file'));
  */
-export function Base64URLFromFile(filePath: string): Promise<Base64URLString>;
+export function Base64URLFromFile(filePath: string): Promise<string>;

package/types/src/doc/JSautoDOC.d.mts

@@ -15,21 +15,24 @@
  * >>- first `"at"${string}` after `"at"description` until `"at"example` will be treated as `javascript` comment block on the `markdown`;
  * >>- `"at"example` are treated as `javascript` block on the `markdown` file, and should be placed last on the same comment block;
  * >>- you can always look at `vivth/src` files to check how the source, and the `README.md` and `index.mjs` documentation/generation results;
+ * >6) this types of arrow functions will be converted to regullar function, for concise type emition:
+ * >>- validly exported function;
+ * >>- static/instance method(s) with generic template;
  */
 export class JSautoDOC {
     /**
-     * @type {JSautoDOC}
+     * @type {JSautoDOC|undefined}
      */
-    static #instance: JSautoDOC;
+    static #instance: JSautoDOC | undefined;
     /**
      * @description
      * @param {Object} [options]
      * @param {Object} [options.paths]
-     * @param {string} [options.paths.file]
+     * @param {string} options.paths.file
      * - entry point;
-     * @param {string} [options.paths.readMe]
+     * @param {string} options.paths.readMe
      * - readme target;
-     * @param {string} [options.paths.dir]
+     * @param {string} options.paths.dir
      * - source directory;
      * @param {string} [options.copyright]
      * @param {string} [options.tableOfContentTitle]
@@ -47,13 +50,31 @@ export class JSautoDOC {
      */
     constructor({ paths, tableOfContentTitle, copyright, option, }?: {
         paths?: {
-            file?: string;
-            readMe?: string;
-            dir?: string;
-        };
-        copyright?: string;
-        tableOfContentTitle?: string;
-        option?: import("chokidar").ChokidarOptions;
+            file: string;
+            readMe: string;
+            dir: string;
+        } | undefined;
+        copyright?: string | undefined;
+        tableOfContentTitle?: string | undefined;
+        option?: Partial<{
+            persistent: boolean;
+            ignoreInitial: boolean;
+            followSymlinks: boolean;
+            cwd?: string;
+            usePolling: boolean;
+            interval: number;
+            binaryInterval: number;
+            alwaysStat?: boolean;
+            depth?: number;
+            ignorePermissionErrors: boolean;
+            atomic: boolean | number;
+        } & {
+            ignored: import("chokidar").Matcher | import("chokidar").Matcher[];
+            awaitWriteFinish: boolean | Partial<{
+                stabilityThreshold: number;
+                pollInterval: number;
+            }>;
+        }> | undefined;
     });
     #private;
 }

package/types/src/doc/correctBeforeParse.d.mts

@@ -0,0 +1,2 @@
+export function correctBeforeParse(path: string, encoding?: BufferEncoding): Promise<RetType>;
+export type RetType = "shouldProceedNextCheck" | "waitForRewrite" | "doNotProcess";

package/types/src/doc/parsedFile.d.mts

@@ -22,15 +22,16 @@ export class parsedFile {
      */
     /**
      * @param {string} path__
+     * @param {import('fs').Stats} _stats
      * @param {BufferEncoding} [encoding]
      */
-    constructor(path__: string, encoding?: BufferEncoding);
+    constructor(path__: string, _stats: import("fs").Stats, encoding?: BufferEncoding);
     parse: () => Promise<void>;
     documented: {
         typedef: () => Promise<{
             module: string;
             readme: string;
-        }>;
+        } | undefined>;
         /**
          * @type {Set<refType>}
          */
@@ -54,7 +55,7 @@ export class parsedFile {
             typedef: () => Promise<{
                 module: string;
                 readme: string;
-            }>;
+            } | undefined>;
             /**
              * @type {Set<refType>}
              */
@@ -153,11 +154,6 @@ export class parsedFile {
          */
         readonly noDot: string | undefined;
     };
-    /**
-     * @private
-     * @returns {Promise<Stats>}
-     */
-    private stats;
     get timeStamp(): {
         /**
          * @returns {Promise<number>}
@@ -206,8 +202,9 @@ export class parsedFile {
         };
     };
     /**
-     * @returns {[Promise<any>, undefined]|[undefined, Error]}
+     * @returns {ReturnType<typeof TryAsync<any>>}
      */
-    get importAsModuleJS(): [Promise<any>, undefined] | [undefined, Error];
+    importAsModuleJS: () => ReturnType<typeof TryAsync<any>>;
     #private;
 }
+import { TryAsync } from '../function/TryAsync.mjs';

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

@@ -23,6 +23,6 @@
  * 	getMap(name_) => mappedObject.get(name_),
  * })
  */
-export function CreateImmutable<PARENT extends unknown, OBJECT extends unknown>(parent: PARENT, keyName: string, object: (this: PARENT) => OBJECT, { lazy }?: {
-    lazy?: boolean;
+export function CreateImmutable<PARENT extends Object, OBJECT extends Object>(parent: PARENT, keyName: string, object: (this: PARENT) => OBJECT, { lazy }?: {
+    lazy?: boolean | undefined;
 }): OBJECT;

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

@@ -14,7 +14,7 @@
  * @param {RecordTryType} tryRecord
  * @returns {Promise<
  * 	[[keyof RecordTryType, RETURNTYPE], undefined]
- * 	| [[undefined, undefined], Error]
+ * 	| [[undefined, undefined], Error|undefined]
  * >}
  * @example
  * import { Try } from 'vivth';
@@ -49,4 +49,4 @@
  */
 export function Try<KEY extends string, RETURNTYPE, RecordTryType extends Record<KEY, (err: {
     prevError: undefined | Error;
-}) => Promise<RETURNTYPE>>>(tryRecord: RecordTryType): Promise<[[keyof RecordTryType, RETURNTYPE], undefined] | [[undefined, undefined], Error]>;
+}) => Promise<RETURNTYPE>>>(tryRecord: RecordTryType): Promise<[[keyof RecordTryType, RETURNTYPE], undefined] | [[undefined, undefined], Error | undefined]>;

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

@@ -4,7 +4,7 @@
  * - usefull to flatten indentation for error handlings;
  * @template RESULT
  * @param {()=>Promise<RESULT>} asyncFunction_
- * @returns {Promise<[RESULT|undefined, Error|undefined]>}
+ * @returns {Promise<[RESULT,undefined]|[undefined,Error]>}
  * @example
  * import { TryAsync } from 'vivth';
  *
@@ -19,4 +19,4 @@
  * 	return await res.json();
  * })
  */
-export function TryAsync<RESULT>(asyncFunction_: () => Promise<RESULT>): Promise<[RESULT | undefined, Error | undefined]>;
+export function TryAsync<RESULT>(asyncFunction_: () => Promise<RESULT>): Promise<[RESULT, undefined] | [undefined, Error]>;

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

@@ -4,7 +4,8 @@
  * - usefull to flatten indentation for error handlings;
  * @template RESULT
  * @param {()=>RESULT} function_
- * @returns {[RESULT|undefined, Error|undefined]}
+ * @returns {[RESULT,undefined]|
+ * [undefined,Error]}
  * @example
  * import { readFileSync } from 'fs';
  * import { TrySync } from './yourModule.js';
@@ -13,4 +14,4 @@
  * 	return readFileSync('./some/file.txt', 'utf-8');
  * });
  */
-export function TrySync<RESULT>(function_: () => RESULT): [RESULT | undefined, Error | undefined];
+export function TrySync<RESULT>(function_: () => RESULT): [RESULT, undefined] | [undefined, Error];

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

@@ -18,6 +18,6 @@
  * TsToMjs('./myFile.mts', { encoding: 'utf-8', overrideDir: './other/dir' });
  */
 export function TsToMjs(path_: string, { overrideDir, encoding }?: {
-    overrideDir?: string;
-    encoding?: BufferEncoding;
+    overrideDir?: string | undefined;
+    encoding?: BufferEncoding | undefined;
 }): Promise<void>;

package/types/src/types/LitExpResultType.d.mts

@@ -0,0 +1,7 @@
+export type LitExpResultType<KEYS extends import("./LitExpKeyType.mjs").LitExpKeyType> = {
+    result: {
+        whole: string[];
+        named: Array<Record<keyof KEYS, string>>;
+    };
+    regexp: RegExp;
+};