vivth 1.4.10 → 1.5.0

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

@@ -0,0 +1,172 @@
+export const multiExportEntryPointsPath: "./generated/vivth/exports/";
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - class for auto documenting mjs package/project, using jsdoc;
+ * - this autodocumenter uses [chokidar](https://npmjs.com/package/chokidar) under the hood;
+ * - this class also is used to generate this `README.md`;
+ * - behaviours:
+ * >- auto export must follows the following rules;
+ * >1) add `"at"noautodoc` on self closing jsdoc comment to opt out from generating documentation on said file;
+ * >2) will (generate) export all named exported 'const'|'function'|'async function'|'class', alphanumeric name, started with Capital letter, same name with fileName on `options.paths.file`;
+ * >3) will (generate) declare typedef of existing typedef with alphanumeric name, started with Capital letter, same name with fileName, and have no valid export like on point <sup>1</sup> on `options.paths.file`;
+ * >4) will (generate) create `README.md` based on, `options.paths.dir` and `README.src.md`;
+ * >5) extract `"at"description` jsdoc:
+ * >>- on static/prop that have depths, all of children should have `"at"static`/`"at"instance` `nameOfImmediateParent`, same block but before `"at"description` comment line;
+ * >>- `"at"description` are treated as plain `markdown`;
+ * >>- 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, includes:
+ * >>- validly exported function;
+ * >>- static/instance method with generic template;
+ * >7) transpile `.ts` and `.mts` to `.mjs` with same name and directory;
+ * >>- use `"at"preserve` to preserve tsdoc comment section;
+ * >8) integrated with assembly script to wasm compiler on the doc;
+ * >>- see [AssemblyScript](#assemblyscript);
+ * >9) modify following root json files:
+ * >>- `package.json`: assign `exports`, `main`, `module`;
+ * >>- `tsconfig.json`: assign `includes`, anything passed on `options.jstsconfigs`;
+ * >>- `jsconfig.json`: assign `includes`, anything passed on `options.jstsconfigs`;
+ * >10) generates files to `/generated/vivth/exports/`:
+ * >>- `./browser.mjs`: able to be called on `browser` platform;
+ * >>- `./node.mjs`:  able to be called on `node` platform;
+ * >>- `./neutral.mjs`: able to be called on `node` and `browser` platform;
+ * >>- `./unsupported.mjs`: most likely will throw error when called, it is more of a logged error to be managed;
+ * >>- `./all.mjs`: collections of all platform;
+ * >11) doesn't support accessor;
+ * >>- due to how TLS way accessor type not casting its getter and setter working around accessor requires ignoring this specific error, and it might become ugly real quick;
+ * >>- we recomend to stick with getter and setter;
+ * - for runtime example see file `/dev/auto-doc.mjs` on source code;
+ * @implements {VivthCleanup}
+ */
+export class JSautoDOC implements VivthCleanup {
+    /**
+     * @typedef {'readme' |
+     *  'handledJS'
+     * } returnTypeStringType
+     */
+    /**
+     * @typedef {FSDirArchWatcher<{
+     *     path: string;
+     *     parsed: undefined;
+     *     ext: `.${string}`;
+     *     type: returnTypeStringType;
+     *     readme?:string;
+     * } | {
+     *     path: string;
+     *     parsed: parsedFileForDOC;
+     *     ext: string;
+     *     type: returnTypeStringType;
+     *     readme?:string;
+     * }>} FSDirArchWatcher__
+     */
+    /**
+     * @type {JSautoDOC|undefined}
+     */
+    static #instance: JSautoDOC | undefined;
+    /**
+     * @description
+     * @param {Object} options
+     * @param {string} options.src
+     * - source directory;
+     * @param {string} [options.copyright]
+     * @param {string} [options.tableOfContentTitle]
+     * @param {number} [options.maxDebounceForGeneratingDocAndExport]
+     * - default `10_000`;
+     * @param {import('chokidar').ChokidarOptions} [options.chokidarOptions]
+     * - ChokidarOptions;
+     * @param {import('../typehints/AutoDocASOptions.mjs').AutoDocASOptions} [options.assemblyScriptOptions]
+     * - abstracted details to handle `.as.ts` file;
+     * @param {(arg0:{map:Map<string, {
+     *     path: string;
+     *     parsed: undefined;
+     *     ext: `.${string}`;
+     *     type: returnTypeStringType;
+     *     readme?:string;
+     * } | {
+     *     path: string;
+     *     parsed: parsedFileForDOC;
+     *     ext: string;
+     *     type: returnTypeStringType;
+     *     readme?:string;
+     * }>})=>Promise<void>} [options.onLastGeneratedCallback]
+     * - callback to be run on finishing generating document AND exports;
+     * - only handle that marked as `isLastCalled`;
+     * @param { import('typescript').CompilerOptions |
+     * 	import('typescript').ParsedCommandLine
+     * } [options.jstsconfigs]
+     * - type of `ts/jsconfig` to be assigned to existing respective `.json` file;
+     * @example
+     * import { JSautoDOC } from 'vivth/node';
+     *
+     * new JSautoDOC({
+     * 	src: '/src',
+     * 	copyright: 'this library is made and distributed under MIT license;',
+     * 	tableOfContentTitle: 'list of exported API and typehelpers',
+     * 	// assemblyScriptOptions: {},
+     * 	// onLastGeneratedCallback: async (options) => {
+     * 	// 	Console.log(options);
+     * 	// },
+     * });
+     */
+    constructor({ src, onLastGeneratedCallback, tableOfContentTitle, copyright, maxDebounceForGeneratingDocAndExport, assemblyScriptOptions, chokidarOptions, jstsconfigs, }: {
+        src: string;
+        copyright?: string | undefined;
+        tableOfContentTitle?: string | undefined;
+        maxDebounceForGeneratingDocAndExport?: number | undefined;
+        chokidarOptions?: 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<import("chokidar").AWF>;
+        }> | undefined;
+        assemblyScriptOptions?: import("../typehints/AutoDocASOptions.mjs").AutoDocASOptions | undefined;
+        onLastGeneratedCallback?: ((arg0: {
+            map: Map<string, {
+                path: string;
+                parsed: undefined;
+                ext: `.${string}`;
+                type: "readme" | "handledJS";
+                readme?: string;
+            } | {
+                path: string;
+                parsed: parsedFileForDOC;
+                ext: string;
+                type: "readme" | "handledJS";
+                readme?: string;
+            }>;
+        }) => Promise<void>) | undefined;
+        jstsconfigs?: import("typescript").CompilerOptions | import("typescript").ParsedCommandLine | undefined;
+    });
+    vivthCleanup: () => Promise<void>;
+    /**
+     * @type { FSDirArchWatcher<any>|undefined }
+     */
+    watcher: FSDirArchWatcher<any> | undefined;
+    /**
+     * @param {string} path
+     * @returns {Promise<{isBeingHandled:boolean, content?: string}>}
+     * - is being handled;
+     */
+    checkReadmeFile: (path: string) => Promise<{
+        isBeingHandled: boolean;
+        content?: string;
+    }>;
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
+import { FSDirArchWatcher } from '../class/FSDirArchWatcher.mjs';
+import { parsedFileForDOC } from './parsedFileForDOC.mjs';

package/generated/types/src/doc/cleanPreserveTypedef.d.mts

@@ -0,0 +1 @@
+export function cleanPreserveTypedef(sourceCode: string): string | false;

package/{types/src/doc/parsedFile.d.mts → generated/types/src/doc/parsedFileForDOC.d.mts}

@@ -1,9 +1,9 @@
-export class parsedFile {
+export class parsedFileForDOC {
     /**
      * @param {string} exportName
      * @returns {boolean}
      */
-    static "__#private@#isExportNameValid": (exportName: string) => boolean;
+    static #isExportNameValid: (exportName: string) => boolean;
     /**
      * @param {string} content
      * @returns { RegExpExecArray[] }
@@ -21,13 +21,25 @@ export class parsedFile {
      * }} refType
      */
     /**
-     * @param {string} path__
-     * @param {import('fs').Stats} _stats
+     * @param {string} path
+     * - `relative`(to `Paths.root`) OR `absolute`, both are accepted;
+     * @param {import('fs').Stats} [stats]
      * @param {BufferEncoding} [encoding]
      */
-    constructor(path__: string, _stats: import("fs").Stats, encoding?: BufferEncoding);
+    constructor(path: string, stats?: import("fs").Stats, encoding?: BufferEncoding);
+    /**
+     * @type {Promise<"browser" | "node" | "neutral" | "unsupported">}
+     */
+    platform: Promise<"browser" | "node" | "neutral" | "unsupported">;
     parse: () => Promise<void>;
     documented: {
+        /**
+         *
+         * @returns {Promise<{
+         * 	module: string;
+         * 	readme: string;
+         * } | undefined>}
+         */
         typedef: () => Promise<{
             module: string;
             readme: string;
@@ -51,7 +63,14 @@ export class parsedFile {
             reference: string;
         }>;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
+            /**
+             *
+             * @returns {Promise<{
+             * 	module: string;
+             * 	readme: string;
+             * } | undefined>}
+             */
             typedef: () => Promise<{
                 module: string;
                 readme: string;
@@ -85,32 +104,32 @@ export class parsedFile {
     };
     hasValidExportObject: boolean;
     /**
-     * @returns {Promise<boolean>}
+     * @returns {boolean|undefined}
      */
-    isFile: () => Promise<boolean>;
+    get isFile(): boolean | undefined;
     /**
-     * @returns {Promise<boolean>}
+     * @returns {boolean|undefined}
      */
-    isDirectory: () => Promise<boolean>;
+    get isDirectory(): boolean | undefined;
     baseName: {
         /**
          * @returns {string}
          */
-        readonly withExt: string;
+        withExt: string;
         /**
          * @returns {string}
          */
-        readonly noExt: string;
+        noExt: string;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @returns {string}
              */
-            readonly withExt: string;
+            withExt: string;
             /**
              * @returns {string}
              */
-            readonly noExt: string;
+            noExt: string;
         };
     };
     path: {
@@ -123,7 +142,7 @@ export class parsedFile {
          */
         readonly full: string;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @returns {string}
              */
@@ -138,37 +157,42 @@ export class parsedFile {
         /**
          * @returns {string}
          */
-        readonly relative: string;
+        relative: string;
         /**
          * @returns {string}
          */
-        readonly full: string;
+        full: string;
     };
     get ext(): {
         /**
          * @returns {string|undefined}
          */
-        readonly withDot: string | undefined;
+        withDot: string;
         /**
          * @returns {string|undefined}
          */
-        readonly noDot: string | undefined;
+        noDot: string;
     };
     get timeStamp(): {
         /**
-         * @returns {Promise<number>}
+         * @returns {Promise<number|undefined>}
          */
-        lastModified: () => Promise<number>;
+        lastModified: () => Promise<number | undefined>;
         /**
-         * @returns {Promise<number>}
+         * @returns {Promise<number|undefined>}
          */
-        createdAt: () => Promise<number>;
+        createdAt: () => Promise<number | undefined>;
     };
     content: {
         /**
          * @return {Promise<string|undefined>}
          */
         string: () => Promise<string | undefined>;
+        /**
+         *
+         * @returns {Promise<{exportName:undefined, details:undefined, error:{fullpath:string, message:string}}|
+         *  {exportName:string|undefined, details:ReturnType<typeof parsedFileForDOC["getDescription"]>, error:undefined}>}
+         */
         parsed: () => Promise<{
             exportName: undefined;
             details: undefined;
@@ -178,15 +202,20 @@ export class parsedFile {
             };
         } | {
             exportName: string | undefined;
-            details: ReturnType<(typeof parsedFile)["getDescription"]>;
+            details: ReturnType<(typeof parsedFileForDOC)["getDescription"]>;
             error: undefined;
         }>;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @return {Promise<string|undefined>}
              */
             string: () => Promise<string | undefined>;
+            /**
+             *
+             * @returns {Promise<{exportName:undefined, details:undefined, error:{fullpath:string, message:string}}|
+             *  {exportName:string|undefined, details:ReturnType<typeof parsedFileForDOC["getDescription"]>, error:undefined}>}
+             */
             parsed: () => Promise<{
                 exportName: undefined;
                 details: undefined;
@@ -196,7 +225,7 @@ export class parsedFile {
                 };
             } | {
                 exportName: string | undefined;
-                details: ReturnType<(typeof parsedFile)["getDescription"]>;
+                details: ReturnType<(typeof parsedFileForDOC)["getDescription"]>;
                 error: undefined;
             }>;
         };

package/generated/types/src/function/ClearRequireCache.d.mts

@@ -0,0 +1 @@
+export function ClearRequireCache(path: string): void;

package/{types → generated/types}/src/function/CreateImmutable.d.mts

@@ -10,13 +10,13 @@
  * @param {(this:PARENT)=>OBJECT} object
  * @param {Object} [options]
  * @param {boolean} [options.lazy]
- * @return {OBJECT}
+ * @return {ReturnType<typeof TrySync<OBJECT>>}
  * @example
- * import { CreateImmutable } from 'vivth';
+ * import { CreateImmutable } from 'vivth/neutral';
  *
  * const mappedObject = new Map();
  *
- * CreateImmutable(window, 'mySharedObject', {
+ * const [object, errorCreatingImmutable] = CreateImmutable(window, 'mySharedObject', {
  * 	setMap(name_, value) => {
  * 		mappedObject.set(name_, value)
  * 	},
@@ -25,4 +25,5 @@
  */
 export function CreateImmutable<PARENT extends Object, OBJECT extends Object>(parent: PARENT, keyName: string, object: (this: PARENT) => OBJECT, { lazy }?: {
     lazy?: boolean | undefined;
-}): OBJECT;
+}): ReturnType<typeof TrySync<OBJECT>>;
+import { TrySync } from './TrySync.mjs';

package/{types → generated/types}/src/function/EventCheck.d.mts

@@ -5,10 +5,12 @@
  * @param {Record<typeof EventNameSpace, string>} eventObject
  * @returns {boolean}
  * @example
- * import { EventCheck } from 'vivth';
+ * import { EventCheck } from 'vivth/neutral';
  * import { incomingMessage } from './some/where.mjs';
  *
  * const eventObjectPayload = EventObject('worker:exit');
+ *
+ * console.log(EventCheck(incomingMessage, eventObjectPayload));
  * // assuming `incomingMessage`, also created using EventObject('worker:exit');
  * // or manually {[EventNameSpace]:'worker:exit'};
  * // which either will result true;

package/{types → generated/types}/src/function/EventObject.d.mts

@@ -5,13 +5,9 @@
  * @param {NAME} name
  * @returns {{[EventNameSpace]: NAME}}
  * @example
- * import { EventCheck } from 'vivth';
- * import { incomingMessage } from './some/where.mjs';
+ * import { EventObject } from 'vivth/neutral';
  *
- * const eventObjectPayload = EventObject('worker:exit');
- * // assuming `incomingMessage`, also created using EventObject('worker:exit');
- * // or manually {[EventNameSpace]:'worker:exit'};
- * // which either will result true;
+ * export const eventObjectPayload = EventObject('worker:exit');
  */
 export function EventObject<NAME extends string>(name: NAME): {
     [EventNameSpace]: NAME;

package/generated/types/src/function/ForInAsync.d.mts

@@ -0,0 +1,36 @@
+/**
+ * @description
+ * - safe `Object` async iterator helper;
+ * >- collect errors then returns it as Set<Error>;
+ * @template {Record<string|number|symbol, any>} OBJECT
+ * @template {any} RETURNTYPE
+ * @param {OBJECT} object
+ * @param {(
+ * key:keyof OBJECT,
+ * value:OBJECT[keyof OBJECT],
+ * options:{
+ * prevError:Error|undefined,
+ * breakEarly:()=>void,
+ * },
+ * )=>Promise<RETURNTYPE|undefined>} handlerCallback
+ * - when `breakEarly` is called, the loop will break at the begining of the next iteration;
+ * - typehint according to your js flavor, so the function make setOfResult typed;
+ * @returns {Promise<[Set<RETURNTYPE>, Set<Error>]>}
+ * @example
+ * import { ForInAsync } from 'vivth/neutral';
+ *
+ * const object = { A: 'a', B: 'b' };
+ * const setOfError = await ForInAsync(
+ * 	object,
+ * 	async (key, value, { prevError, breakEarly }) => {
+ * 		// if(prevError) {
+ * 		// 	breakEarly(); // imperative break;
+ * 		// 	return; // undefined return will not be added to result;
+ * 		// }
+ * 	}
+ * );
+ */
+export function ForInAsync<OBJECT extends Record<string | number | symbol, any>, RETURNTYPE extends unknown>(object: OBJECT, handlerCallback: (key: keyof OBJECT, value: OBJECT[keyof OBJECT], options: {
+    prevError: Error | undefined;
+    breakEarly: () => void;
+}) => Promise<RETURNTYPE | undefined>): Promise<[Set<RETURNTYPE>, Set<Error>]>;

package/generated/types/src/function/ForInSync.d.mts

@@ -0,0 +1,36 @@
+/**
+ * @description
+ * - safe `Object` iterator helper;
+ * >- collect errors then returns it as Set<Error>;
+ * @template {Record<string|number|symbol, any>} OBJECT
+ * @template {any} RETURNTYPE
+ * @param {OBJECT} object
+ * @param {(
+ * key:keyof OBJECT,
+ * value:OBJECT[keyof OBJECT],
+ * options:{
+ * prevError:Error|undefined,
+ * breakEarly:()=>void,
+ * },
+ * )=>RETURNTYPE|undefined} handlerCallback
+ * - when `breakEarly` is called, the loop will break at the begining of the next iteration;
+ * - typehint according to your js flavor, so the function make setOfResult typed;
+ * @returns {[Set<RETURNTYPE>, Set<Error>]}
+ * @example
+ * import { ForInSync } from 'vivth/neutral';
+ *
+ * const object = { A: 'a', B: 'b' };
+ * const [setOfResult , setOfError] = ForInSync(
+ * 	object,
+ * 	(key, value, { prevError, breakEarly }) => {
+ * 		// if(prevError) {
+ * 		// 	breakEarly(); // imperative break;
+ * 		// 	return; // undefined return will not be added to result;
+ * 		// }
+ * 	}
+ * );
+ */
+export function ForInSync<OBJECT extends Record<string | number | symbol, any>, RETURNTYPE extends unknown>(object: OBJECT, handlerCallback: (key: keyof OBJECT, value: OBJECT[keyof OBJECT], options: {
+    prevError: Error | undefined;
+    breakEarly: () => void;
+}) => RETURNTYPE | undefined): [Set<RETURNTYPE>, Set<Error>];

package/generated/types/src/function/ForOfAsync.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @description
+ * - loop through iterable safely;
+ * @template {any} T
+ * @template {any} RETURNTYPE
+ * @param {Iterable<T>} iterable
+ * @param {(value: T,
+ * options:{
+ * prevError:Error|undefined,
+ * breakEarly:()=>void,
+ * }) => Promise<RETURNTYPE|undefined>} handlerCallback
+ * - when `breakEarly` is called, the loop will break at the begining of the next iteration;
+ * - typehint according to your js flavor, so the function make setOfResult typed;
+ * @returns {Promise<[Set<RETURNTYPE>, Set<Error>]>}
+ * @example
+ * import { ForOfAsync } from 'vivth/neutral';
+ *
+ * await ForOfAsync(iterable, async(value, { prevError, breakEarly })=>{
+ * 	// code
+ * })
+ */
+export function ForOfAsync<T extends unknown, RETURNTYPE extends unknown>(iterable: Iterable<T>, handlerCallback: (value: T, options: {
+    prevError: Error | undefined;
+    breakEarly: () => void;
+}) => Promise<RETURNTYPE | undefined>): Promise<[Set<RETURNTYPE>, Set<Error>]>;

package/generated/types/src/function/ForOfSync.d.mts

@@ -0,0 +1,36 @@
+/**
+ * @description
+ * - loop through iterable safely;
+ * @template {any} T
+ * @template {any} RETURNTYPE
+ * @param {Iterable<T>} iterable
+ * @param {(value: T,
+ * options:{
+ * prevError:Error|undefined,
+ * breakEarly:()=>void,
+ * }) => RETURNTYPE|undefined} handlerCallback
+ * - when `breakEarly` is called, the loop will break at the begining of the next iteration;
+ * - typehint according to your js flavor, so the function make setOfResult typed;
+ * @returns {[Set<RETURNTYPE>, Set<Error>]}
+ * @example
+ * import { ForOfSync, TryAsync } from 'vivth/neutral';
+ *
+ * ForOfSync(iterable, (value, { prevError, breakEarly })=>{
+ * 	// code
+ * });
+ *
+ * await Promise.all(ForOfSync([
+ * 	async()=>{
+ * 		// code to run pararelly
+ * 	},
+ * 	async()=>{
+ * 		// code to run pararelly
+ * 	},
+ * ], async(cb)=>{
+ * 	return await cb();
+ * })[0])
+ */
+export function ForOfSync<T extends unknown, RETURNTYPE extends unknown>(iterable: Iterable<T>, handlerCallback: (value: T, options: {
+    prevError: Error | undefined;
+    breakEarly: () => void;
+}) => RETURNTYPE | undefined): [Set<RETURNTYPE>, Set<Error>];

package/generated/types/src/function/GetBufferFromRelativePath.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @description
+ * - get content from relativePath;
+ * - only usefull to unbundled environtment;
+ * - if your goal is to include on the `.asar`, use [FSasar](#fsasar) instead;
+ * @param {string} relativePath
+ * - relative path from the caller;
+ * @returns {ReturnType<typeof FSasar.file>}
+ * @example
+ * import { GetContentFromRelativePath } from 'vivth/node';
+ *
+ * await GetContentFromRelativePath('../doc/parsedFile.mjs', 'utf-8');
+ */
+export function GetBufferFromRelativePath(relativePath: string): ReturnType<typeof FSasar.file>;
+import { FSasar } from '../bundler/FSasar.mjs';

package/generated/types/src/function/GetFilesFromDir.d.mts

@@ -0,0 +1,14 @@
+/**
+ * @description
+ * - helper function to get file from dir;
+ * @param {string} dirAbsolutePath
+ * @param {RegExp} pathRule
+ * @param {Set<string>} [fileNames]
+ * - fill manually to imediately add result to existing `Set` without expecting return;
+ * @returns {Promise<Set<string>>}
+ * @example
+ * import { GetFilesFromDir } from 'vivth/node';
+ *
+ * const files = await GetFilesFromDir(join(Paths.root, '/dev/'), /[\s\S]\*[noblank]/); // without \[noblank]
+ */
+export function GetFilesFromDir(dirAbsolutePath: string, pathRule: RegExp, fileNames?: Set<string>): Promise<Set<string>>;

package/generated/types/src/function/GetMaxFilenameLength.d.mts

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * - Get OS-specific max filename length;
+ * - On POSIX: fs.constants.NAME_MAX;
+ * - On Windows: 255 (per component, unless long paths enabled);
+ * - used internally to validate name length for [`UniqueFSTempName`](#uniquefstempname);
+ * @returns {number}
+ */
+export function GetMaxFilenameLength(): number;

package/generated/types/src/function/GetModuleEsbuildPlatform.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @description
+ * - get valid esbuild platform name for a module path;
+ * @param { string } path
+ * @returns { Promise<'browser'|'node'|'neutral'|'unsupported'> }
+ * @example
+ * // D://lib-root/myModule.mjs
+ * import process from 'node:process'; // lookupA;
+ * import { GetModuleEsbuildPlatform } from "vivth/node";
+ *
+ * await GetModuleEsbuildPlatform('./myModule.mjs'); // 'node'; caused of lookupA;
+ */
+export function GetModuleEsbuildPlatform(path: string): Promise<"browser" | "node" | "neutral" | "unsupported">;

package/{types → generated/types}/src/function/GetNamedImportAlias.d.mts

@@ -8,7 +8,7 @@
  * @param {string} packageName
  * @returns {string|undefined}
  * @example
- * import { GetNamedImportAlias } from 'vivth';
+ * import { GetNamedImportAlias } from 'vivth/neutral';
  *
  * const checkNoAlias = `
  * import { something } from 'packageName';

package/generated/types/src/function/GetRuntime.d.mts

@@ -0,0 +1,2 @@
+export function GetRuntime(): Runtime;
+export type Runtime = import("../typehints/Runtime.mjs").Runtime;

package/generated/types/src/function/InstantiateAssemblyScript.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @description
+ * - function wrapper for `.asar` `.wasm` from `AssemblyScript` asset;
+ * - conventions for using this class in conjuction with `JSautoDOC`:
+ * @template {Record<string, unknown>} RESULTTYPE
+ * @param {import('../bundler/adds/PathFSFile.mjs').PathFSFile} filePathFromProject
+ * - call `PathFSFile.vivthFile`;
+ * @param {Parameters<import('../typehints/AssemblyScriptLoaderInstantiate.mjs').AssemblyScriptLoaderInstantiate<RESULTTYPE>>[1]} [imports]
+ * @returns {Promise<import('../typehints/AssemblyScriptExportsType.mjs').AssemblyScriptExportsType<RESULTTYPE>>}
+ * @example
+ * import { PathFSFile, InstantiateAssemblyScript } from 'vivth/node';
+ *
+ * InstantiateAssemblyScript(PathFSFile.vivthFile('../function/myAsm.wasm'));;
+ */
+export function InstantiateAssemblyScript<RESULTTYPE extends Record<string, unknown>>(filePathFromProject: import("../bundler/adds/PathFSFile.mjs").PathFSFile, imports?: Parameters<import("../typehints/AssemblyScriptLoaderInstantiate.mjs").AssemblyScriptLoaderInstantiate<RESULTTYPE>>[1]): Promise<import("../typehints/AssemblyScriptExportsType.mjs").AssemblyScriptExportsType<RESULTTYPE>>;

package/{types → generated/types}/src/function/IsAsync.d.mts

@@ -4,7 +4,7 @@
  * @param {(...any:any)=>(any|Promise<any>)} functionReference
  * @returns {boolean}
  * @example
- * import { IsAsync } from 'vivth';
+ * import { IsAsync } from 'vivth/neutral';
  *
  * const a = function (params) {
  * 	// code