vivth 1.4.9 → 1.5.0

package/{types → generated/types}/src/bundler/EsBundler.d.mts

@@ -1,22 +1,24 @@
 /**
  * @description
- * - opinionated bundler for extension below using esbuild;
+ * - opinionated bundler for limited extensions using esbuild;
  * - bundles all imports into a single output string;
  * @param {Object} options
  * @param {string} options.content
  * - the code can also uses composites from the result from multiple readFiles;
  * @param {string} options.root
  * - use dirname of said fileString path;
- * @param {'.mts'|'.ts'|'.mjs'|'.cjs'} options.extension
+ * @param {'.mts'|'.ts'|'.mjs'} options.extension
+ * - supported extension;
  * @param {boolean} [options.withBinHeader]
  * @param {Omit<Parameters<build>[0],
- * 'entryPoints'|'bundle'|'write'|'sourcemap'>
+ * 'entryPoints'|'bundle'|'write'|'sourcemap'|'outdir'|'splitting'|'format'>
  * } [esbuildOptions]
+ * - assume `esm`;
  * @returns {ReturnType<typeof TryAsync<string>>}
  * @example
- * import { EsBundler } from 'vivth';
+ * import { EsBundler } from 'vivth/node';
  *
- * const bundledString = EsBundler(
+ * const [bundledString, errorBundling] = EsBundler(
  * 	{
  * 		content: ``,
  * 		extension: '.mts',
@@ -29,8 +31,8 @@
 export function EsBundler({ content, extension, root, withBinHeader }: {
     content: string;
     root: string;
-    extension: ".mts" | ".ts" | ".mjs" | ".cjs";
+    extension: ".mts" | ".ts" | ".mjs";
     withBinHeader?: boolean | undefined;
-}, esbuildOptions?: Omit<Parameters<typeof build>[0], "entryPoints" | "bundle" | "write" | "sourcemap">): ReturnType<typeof TryAsync<string>>;
+}, esbuildOptions?: Omit<Parameters<typeof build>[0], "entryPoints" | "bundle" | "write" | "sourcemap" | "outdir" | "splitting" | "format">): ReturnType<typeof TryAsync<string>>;
 import { build } from 'esbuild';
 import { TryAsync } from '../function/TryAsync.mjs';

package/generated/types/src/bundler/FSAnalyzer.d.mts

@@ -0,0 +1,58 @@
+/**
+ * @description
+ * - collections of static method to process content for:
+ * >- `FSasar`;
+ * - mostly used internally;
+ */
+export class FSAnalyzer {
+    /**
+     * @typedef {typeof import('@electron/asar')["createPackageFromFiles"]} createPackageFromFiles
+     */
+    /**
+     * @description
+     * - to be used on bundled content;
+     * @param {string} entryPoint
+     * @param {string} content
+     * @param {Object} asarConfig
+     * @param {Parameters<createPackageFromFiles>[3]} [asarConfig.InputMetadata]
+     * @param {Parameters<createPackageFromFiles>[4]} [asarConfig.options]
+     * @param {string} bundledJSFilePath
+     * @returns {ReturnType<typeof TryAsync<string>>}
+     * @example
+     * import { readFile } from 'node:fs/promises';
+     *
+     * import { FSAnalyzer } from 'vivth/node';
+     * import { Preferrence } from 'vivth/neutral';
+     *
+     * const filePath = 'README.md';
+     * const [resultFinalContent, errorFinalContent] = await FSAnalyzer.finalContent(
+     * 	filePath,
+     * 	await readFile(filePath, {encoding: Preferrence.encoding}),
+     * 	'esm',
+     * 	{},
+     * 	...args
+     * );
+     */
+    static finalContent: (entryPoint: string, content: string, asarConfig: {
+        InputMetadata?: Parameters<typeof createPackageFromFiles>[3];
+        options?: Parameters<typeof createPackageFromFiles>[4];
+    }, bundledJSFilePath: string) => ReturnType<typeof TryAsync<string>>;
+    /**
+     * return regex as string from template literal that are supposed to be regex
+     * @param {string} str
+     * @returns {RegExp}
+     */
+    static #hydrateRegex: (str: string) => RegExp;
+    /**
+     * @param {string} rootPath
+     * @param {string} content
+     * @param {Parameters<typeof FSAnalyzer["finalContent"]>[2]} asarConfig
+     * @param {string} bundledJSFile
+     * @returns {Promise<void>}
+     */
+    static #analyze_asarFile: (rootPath: string, content: string, asarConfig: Parameters<(typeof FSAnalyzer)["finalContent"]>[2], bundledJSFile: string) => Promise<void>;
+}
+import { TryAsync } from '../function/TryAsync.mjs';
+type createPackageFromFiles = typeof import("@electron/asar")["createPackageFromFiles"];
+import { createPackageFromFiles } from '@electron/asar';
+export {};

package/generated/types/src/bundler/FSasar.bundled.d.mts

@@ -0,0 +1,28 @@
+export class FSasar {
+    /**
+     * @typedef {import('./adds/PathFSDir.mjs').PathFSDir} PathFSDir
+     */
+    /**
+     * @param {PathFSFile} filePathFromProject
+     * @returns {Promise<undefined|Buffer<ArrayBufferLike>>}
+     */
+    static file: (filePathFromProject: PathFSFile) => Promise<undefined | Buffer<ArrayBufferLike>>;
+    /**
+     * @description
+     * - helper function for asar dir;
+     * @param {PathFSDir} pathFSDirInstance
+     * @returns {{
+     * forEachFiles:(loopCallback:(pathDetail:{inputRelative:string, asar:string})=>void)=>void,
+     * getFile:(relativeFromDir:string)=> ReturnType<typeof FSasar["file"]>
+     * }}
+     * - forEachFiles are looped async without awaiting any iterations;
+     */
+    static dir: (pathFSDirInstance: import("./adds/PathFSDir.mjs").PathFSDir) => {
+        forEachFiles: (loopCallback: (pathDetail: {
+            inputRelative: string;
+            asar: string;
+        }) => void) => void;
+        getFile: (relativeFromDir: string) => ReturnType<(typeof FSasar)["file"]>;
+    };
+}
+import { PathFSFile } from './adds/PathFSFile.mjs';

package/generated/types/src/bundler/FSasar.d.mts

@@ -0,0 +1,51 @@
+/**
+ * @description
+ * - class helper to bundle assets files as `.asar`;
+ * >- as `type: "buffer"`;
+ * >- uses `[at]electron/asar` under the hood;
+ * - use only if you are planning to use [CompileJS](#compilejs);
+ * >- the class static methods don't obfuscate target file;
+ * >- don't embed any sensitive content using this methods of `CompileJS`;
+ * >- it's better to place it on `.env`;
+ */
+export class FSasar {
+    /**
+     * @typedef {import('./adds/PathFSDir.mjs').PathFSDir} PathFSDir
+     */
+    /**
+     * @description
+     * @param {PathFSFile} pathFSFPathFSFileInstance
+     * @returns {Promise<Buffer<ArrayBufferLike>>}
+     * @example
+     * import { FSasar, PathFSFile } from 'vivth/node';
+     *
+     * const fileBuffer = await FSasar.file(PathFSFile.vivth[blank]File('../function/myModule.mjs'));
+     */
+    static file(pathFSFPathFSFileInstance: PathFSFile): Promise<Buffer<ArrayBufferLike>>;
+    /**
+     * @description
+     * - helper function for asar dir;
+     * @param {PathFSDir} pathFSDirInstance
+     * @returns {{
+     * forEachFiles:(loopCallback:(pathDetail:{inputRelative:string, asar:string})=>void)=>void,
+     * getFile:(relativeFromDir:string)=> ReturnType<typeof FSasar["file"]>
+     * }}
+     * - forEachFiles are looped async without awaiting any iterations;
+     * @example
+     * import { FSasar, PathFSDir } from 'vivth/node';
+     *
+     * const { forEachFiles, getFile } = FSasar.dir(PathFSDir.vivthDir('../function/', /[\s\S]\*[noblank]/)); // without `[noblank]`;
+     * forEachFiles(async ({ inputRelative, asar }) => {
+     * 	// handle `inputRelative` with getFile; OR
+     * 	// handle `asar` with FSasar.file
+     * });
+     */
+    static dir: (pathFSDirInstance: import("./adds/PathFSDir.mjs").PathFSDir) => {
+        forEachFiles: (loopCallback: (pathDetail: {
+            inputRelative: string;
+            asar: string;
+        }) => void) => void;
+        getFile: (relativeFromDir: string) => ReturnType<(typeof FSasar)["file"]>;
+    };
+}
+import { PathFSFile } from './adds/PathFSFile.mjs';

package/generated/types/src/bundler/FileSelfMapper.d.mts

@@ -0,0 +1,137 @@
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - each file can define it's own `targetPaths` inline by adding comment then fullpath on the begining of the file:
+ * >- `mjs`;
+ * ```js
+ * // D://my/path/something.mjs
+ * // D://my/path/something-else.mjs
+ *
+ * console.log('hello');
+ * ```
+ * >- `scss`;
+ * ```scss
+ * /*[blank] D://my/path/something.css *[blank]/
+ *
+ * $somecolor: black;
+ *
+ * body {
+ * 	background-color: $somecolor;
+ * }
+ * ```
+ * >- `.ignore`;
+ * ```.ignore
+ * # D:/my/project/root/.gitignore
+ * # D:/my/project/root/.npmignore
+ *
+ * /dev/
+ * ```
+ * - files extention:
+ * >- `js`/`ts` files will be compiled with `vivth/node.EsWathcer`, using `option.esbuild` as argument;
+ * >- `sass`/`scss` it will be compiled to `css` first;
+ * >- other than those files, they will be just copied to `targetPaths`;
+ * - for runtime example see file `/dev/auto/` on source code;
+ * @implements {VivthCleanup}
+ */
+export class FileSelfMapper implements VivthCleanup {
+    /**
+     * @param { string } path
+     * @param { (path:{mapTo:string, src:string}, content:string)=>(string|false) } [postprosess]
+     * @returns { Promise<void> }
+     */
+    static #writeCommon: (path: string, postprosess?: (path: {
+        mapTo: string;
+        src: string;
+    }, content: string) => (string | false)) => Promise<void>;
+    /**
+     * @param { string } path
+     * @returns { Promise<void> }
+     */
+    static #bundleSCSS: (path: string) => Promise<void>;
+    /**
+     * @param {string[]} esbuildExternal
+     * @returns {Set<string>}
+     */
+    static #createBrowserExternals: (esbuildExternal: string[]) => Set<string>;
+    /**
+     * @param {()=>boolean} isLastOnQ
+     * @param {string} path
+     * @param {string} tempPath
+     * @param {string} target
+     * @returns {Promise<void>}
+     */
+    static #onJSDependencyChanges1: (isLastOnQ: () => boolean, path: string, tempPath: string, target: string) => Promise<void>;
+    /**
+     * @param {()=>boolean} isLastOnQ
+     * @param {string} path
+     * @param {string} tempPath
+     * @param {QChannel<string>} q
+     * @returns {Promise<void>}
+     */
+    static #onJSDependencyChanges0: (isLastOnQ: () => boolean, path: string, tempPath: string, q: QChannel<string>) => Promise<void>;
+    /**
+     * @param {string} tempPath
+     * @param {string} path
+     * @param {QChannel<string>} q
+     * @returns {Promise<void>}
+     */
+    static #onJSDependencyChanges: (tempPath: string, path: string, q: QChannel<string>) => Promise<void>;
+    /**
+     * @param { string } path
+     * @returns { Promise<{
+     * 	targetPaths: Set<string>,
+     * 	content: string,
+     * }> }
+     */
+    static #getTargetPath: (path: string) => Promise<{
+        targetPaths: Set<string>;
+        content: string;
+    }>;
+    /**
+     * @param {string} watcherFullPath
+     * @param {string} path
+     * @returns { string }
+     */
+    static #getRelative: (watcherFullPath: string, path: string) => string;
+    /**
+     * @description
+     * @param {string} watchPath
+     * - `relative`(to `Paths.root`) OR `absolute`, both are accepted;
+     * @param {Object} options
+     * @param {Omit<Parameters<import('esbuild')["context"]>[0], "write"|"minify"|"format"|"mainFields"|"outfile"|"bundle">} [options.esbuild]
+     * - `logLimit`: default = `3`;
+     * - `outFile`: auto determined by comment line on top level of each files;
+     * - `minify`: determined by file `relativePath`(to dirname of `watchpath`) name included `.min.`;
+     * - `format`: determined by file `relativePath`(to dirname of `watchpath`) name included `.esm.` or `.iife.`;
+     * - `mainFields`: `module,main`;
+     * - `bundle`: automatically added by `vivth.FileSelfMapper`;
+     * - `write`: automatically added by `vivth.FileSelfMapper`;
+     * @param {boolean} [options.deleteTempFilesAfterExit]
+     * @param {(path:{mapTo:string, src:string}, content:string)=>(string|false)} [options.postProcessDirectCopy]
+     * - works for:
+     * >- `.js`;
+     * >- anything that are not `sass` and `module js/ts`;
+     * - return `false` to exclude `target` from mapping;
+     * @example
+     * import { FileSelfMapper } from 'vivth/node';
+     *
+     * new FileSelfMapper('../ssg-assets/', {
+     * 	esbuild: {},
+     * 	// deleteTempFilesAfterExit: true,
+     * });
+     */
+    constructor(watchPath: string, options: {
+        esbuild?: Omit<import("esbuild").SameShape<import("esbuild").BuildOptions, import("esbuild").BuildOptions>, "bundle" | "outfile" | "mainFields" | "write" | "format" | "minify"> | undefined;
+        deleteTempFilesAfterExit?: boolean | undefined;
+        postProcessDirectCopy?: ((path: {
+            mapTo: string;
+            src: string;
+        }, content: string) => (string | false)) | undefined;
+    });
+    vivthCleanup: () => Promise<void>;
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
+import { QChannel } from '../class/QChannel.mjs';

package/generated/types/src/bundler/JSDirMapper.d.mts

@@ -0,0 +1,128 @@
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @import {Stats} from 'node:fs'
+ * @import {EventName} from 'chokidar/handler.js'
+ * @import {Plugin,BuildOptions} from 'esbuild'
+ */
+/**
+ * @description
+ * - class helper for one to one Mapping JS files;
+ * - only bundles `.mts` AND `.mjs` in the `path.watch` directory, extension restriction to module as to enforce:
+ * >- `esm` style input;
+ * >- to not confuse IDE and esbuild resolver of extensionless static import;
+ * @template {BuildOptions} OPT
+ * @implements {VivthCleanup}
+ */
+export class JSDirMapper<OPT extends BuildOptions> implements VivthCleanup {
+    /**
+     * @param {string} path
+     * @returns {string}
+     */
+    static #correctEndpointExt: (path: string) => string;
+    /**
+     * @description
+     * @param {Object} path
+     * - `relative`(to `Paths.root`) OR `absolute`, both are accepted;
+     * - handles:
+     * >- `.mts`,`.mjs`: bundled;
+     * >- `.css`: minified;
+     * >-`.scss`, `sass`: two step bundling;
+     * >>- bundle to `.s.css` at source path;
+     * >>- write to `.s.css` on target path;
+     * >- `.as.ts` and it's companion `js` will be dealt accordingly based on `options.asTsToMjsHandler`;
+     * >>- `.ts` and `.js` that are not `.wasm` related are ignored;
+     * >- everything else will be copied as is;
+     * @param {string} path.watch
+     * - watch this path for changes;
+     * @param {string} path.mapTo
+     * - bundles to this path
+     * @param {(
+     * 		arg0:
+     * 			{
+     * 				source:string;
+     * 				target:string;
+     * 				eventName:EventName;
+     * 			}
+     * 	)=>Promise<{
+     * 		shouldProcessDefault:
+     * 			boolean|{selfCleanup:()=>Promise<void>};
+     * 	}>
+     * } [path.filter]
+     * - handler trap before sending it to
+     * @param {Object} options
+     * @param {Object} options.esbuild
+     * @param {Omit<ConstructorParameters<typeof EsWatcher<OPT>>[0],
+     * 	"entryPoints"|
+     * 	"outFile"|
+     * 	"write"|
+     * 	"format"|
+     * 	"bundle"|
+     * 	"logLevel"|
+     * 	"mainFields"
+     * >} options.esbuild.buildOptions
+     * - `logLimit`: default = `3`;
+     * - `entryPoints`: auto filled with `path.watch` + filepath;
+     * - `outFile`: auto filled with `path.mapTo` + filepath(suffixed with `.mjs`);
+     * - `write`: auto filled by `vivth.JSDirMapper`;
+     * - `mainFields`: auto filled by `vivth.JSDirMapper`, ['module', 'main'];
+     * - `format`: auto filled by `vivth.JSDirMapper`, always `esm`;
+     * - `bundle`: auto filled by `vivth.JSDirMapper`, always `true`;
+     * - `logLevel`: auto filled by `vivth.JSDirMapper`;
+     * @param {ConstructorParameters<typeof EsWatcher<OPT>>[1]} [options.esbuild.watchOption]
+     * @param {Parameters<typeof TsToMjs>[1]} [options.asTsToMjsHandler]
+     * - argument[1] used for `.as.ts` extention(assemblyscript to `.wasm` + `.mjs` loader):
+     * >- handled via `vivth.TsToMjs`;
+     * >- preferably to be isolated on a single folder;
+     * - when falsy -> ignore `.as.ts`;
+     * @example
+     * import process from 'node:process';
+     *
+     * import { SafeExit, Paths, JSDirMapper } from 'vivth/node';
+     *
+     * new Paths({
+     * 	root: process.env.INIT_CWD ?? process.cwd(),
+     * });
+     *
+     * new SafeExit('SIGINT', 'SIGTERM');
+     *
+     * new JSDirMapper(
+     * 	{
+     * 		mapTo: '/test/jsdirmapped/',
+     * 		watch: '/test/jsdirmapper/',
+     * 	},
+     * 	{
+     * 		esbuild: { buildOptions: { platform: 'browser' } },
+     * 		asTsToMjsHandler: { assemblyScriptOptions: {} },
+     * 	},
+     * );
+     *
+     */
+    constructor({ mapTo, watch, filter }: {
+        watch: string;
+        mapTo: string;
+        filter?: ((arg0: {
+            source: string;
+            target: string;
+            eventName: EventName;
+        }) => Promise<{
+            shouldProcessDefault: boolean | {
+                selfCleanup: () => Promise<void>;
+            };
+        }>) | undefined;
+    }, { esbuild, asTsToMjsHandler }: {
+        esbuild: {
+            buildOptions: Omit<ConstructorParameters<typeof EsWatcher<OPT>>[0], "entryPoints" | "outFile" | "write" | "format" | "bundle" | "logLevel" | "mainFields">;
+            watchOption?: ConstructorParameters<typeof EsWatcher<OPT>>[1];
+        };
+        asTsToMjsHandler?: Parameters<typeof TsToMjs>[1];
+    });
+    vivthCleanup: () => Promise<void>;
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
+import type { BuildOptions } from 'esbuild';
+import type { EventName } from 'chokidar/handler.js';
+import { EsWatcher } from '../class/EsWatcher.mjs';
+import { TsToMjs } from '../function/TsToMjs.mjs';

package/generated/types/src/bundler/RunWatchThenCompileJSOnSafeExit.d.mts

@@ -0,0 +1,63 @@
+/**
+ * @description
+ * - function to:
+ * >- spawn watcher on `source`;
+ * >- run the `source`;
+ * >- compile `source` to target on `SafeExit`;
+ * - this function assume `Paths` and `SafeExit` to be instantiated;
+ * @param {Object} options
+ * @param {boolean} options.showLog
+ * @param {string} options.source
+ * - filepath for source;
+ * - `relative`(to `Paths.root`) OR `absolute`, both are accepted;
+ * @param {string} options.target
+ * - dirpath for compile target;
+ * - `relative`(to `Paths.root`) OR `absolute`, both are accepted;
+ * @param {string[]} [options.additionalSpawnArgument]
+ * @param {Omit<
+ * 	Parameters<typeof import('./CompileJS.mjs').CompileJS>[0],
+ * 	"entryPoint"|
+ * 	"outDir"
+ * >} [options.compileJSargs]
+ * @returns {ReturnType<typeof TryAsync<import('../typehints/VivthCleanup.mjs').VivthCleanup>>}
+ * @example
+ * import { RunWatchThenCompileJSOnSafeExit } from "vivth/node";
+ *
+ * // assume `Paths` and `SafeExit` to be instantiated;
+ * await RunWatchThenCompileJSOnSafeExit({
+ * 	showLog: false,
+ * 	source: '/test/watchrun/hi.mjs',
+ * 	target: '/test/watchrun/compile-bun/',
+ * 	compileJSargs: {
+ * 		minifyFirst: false,
+ * 		esbuildOptions: {},
+ * 		compilerArguments: {
+ * 			target: 'bun-win-x64',
+ * 		},
+ * 		asar: {},
+ * 		encoding: 'utf-8',
+ * 	},
+ * })
+ */
+export function RunWatchThenCompileJSOnSafeExit({ source, target, additionalSpawnArgument, compileJSargs, showLog, }: {
+    showLog: boolean;
+    source: string;
+    target: string;
+    additionalSpawnArgument?: string[] | undefined;
+    compileJSargs?: Omit<{
+        entryPoint: string;
+        encoding?: BufferEncoding | undefined;
+        preprocessEntryPoint?: ((entryPointContent: string) => string) | undefined;
+        minifyFirst?: boolean | undefined;
+        asar?: {
+            InputMetadata?: Parameters<typeof import("@electron/asar")["createPackageFromFiles"]>[3];
+            options?: Parameters<typeof import("@electron/asar")["createPackageFromFiles"]>[4];
+        } | undefined;
+        outDir: string;
+        bunCompilerArguments?: Record<string, string | string[]> | undefined;
+        esBundlerPlugins?: import("esbuild").Plugin[] | undefined;
+        esbuildOptions?: Parameters<typeof import("./EsBundler.mjs").EsBundler>[1];
+        additionalCommandArgument?: string[] | undefined;
+    }, "entryPoint" | "outDir"> | undefined;
+}): ReturnType<typeof TryAsync<import("../typehints/VivthCleanup.mjs").VivthCleanup>>;
+import { TryAsync } from '../function/TryAsync.mjs';

package/generated/types/src/bundler/adds/BrowserExternals.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @description
+ * - esbuild external `Set` for browser platform;
+ * - this Set is automatically applied to [FileSelfMapper](#fileselfmapper) and [EsBundler](#esbundler) if platform is equal to browser;
+ * - while `vivth` already exports environtment specific(`node`, `browser`, `neutral`) via `vivth/node.JSAutoDoc`, there are possibility of other library might bleeded out when trying to:
+ * >- use esbuild;
+ * >- earlier version of `vivth`;
+ * >- importing from `vivth`, which is definitely bleeded out, and you need to import from proper `exports`;
+ * >- importing from `vivth/all`, which is definitely bleeded out, and you need to import from proper `exports`;
+ * @type {Set<string>}
+ * @example
+ * import { BrowserExternals } from 'vivth/node';
+ * import { build } from 'esbuild';
+ *
+ * await build({
+ * 	...esbuildOptions,
+ * 	platform: 'browser',
+ * 	external: Array.from(BrowserExternals),
+ * });
+ */
+export const BrowserExternals: Set<string>;

package/generated/types/src/bundler/adds/CreateTransform.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @description
+ * - function helper to turn string into `node:stream.Transform` instance;
+ * - usefull for generating return value for `asar.options.transform`;
+ * @param {string} content
+ * @returns {Transform}
+ * @example
+ * import { CreateTransform } from 'vivth/node';
+ *
+ * // asar input context:
+ * const transform = (filePath) => {
+ * 	filePath = Paths.normalize(filePath);
+ * 	const newStringFromBundle = checkBundle.get*(filePath);
+ * 	if (newStringFromBundle) {
+ * 		return CreateTransform(newStringFromBundle);
+ * 	}
+ * 	const res = optionsTransform?.(filePath);
+ * 	if (!res) {
+ * 		return;
+ * 	}
+ * 	return res;
+ * };
+ * //
+ */
+export function CreateTransform(content: string): Transform;
+import { Transform } from 'node:stream';

package/generated/types/src/bundler/adds/LastEditedUnix.d.mts

@@ -0,0 +1,5 @@
+/**
+ * @param {any} fullPath
+ * @returns {Promise<number>}
+ */
+export function LastEditedUnix(fullPath: any): Promise<number>;

package/generated/types/src/bundler/adds/NodeModuleList.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @description
+ * - generate Set of `node` built in modules;
+ * @returns {Set<string>}
+ * @example
+ * import { build } from "esbuild";
+ * import { NodeModuleList } from "vivth/node";
+ *
+ * await build({
+ * 	...buildOptions,
+ * 	platform: "browser",
+ * 	external: Array.from(NodeModuleList()),
+ * });
+ */
+export function NodeModuleList(): Set<string>;

package/generated/types/src/bundler/adds/PathFSBundles.bundled.d.mts

@@ -0,0 +1,25 @@
+export class PathFSBundles {
+    /**
+     * @param {string} relativePath
+     * @param {{shouldNotIncludes:string}} [options]
+     * @returns {PathFSBundles}
+     */
+    static vivthBundles: (relativePath: string, options?: {
+        shouldNotIncludes: string;
+    }) => PathFSBundles;
+    /**
+     * @private
+     * @param {Parameters<typeof PathFSBundles["vivthBundles"]>[0]} relativePath
+     * @param {Parameters<typeof PathFSBundles["vivthBundles"]>[1]} [_options]
+     */
+    private constructor();
+    /**
+     * @returns {string}
+     */
+    get path(): string;
+    /**
+     * @returns {string}
+     */
+    get callerPath(): string;
+    #private;
+}

package/generated/types/src/bundler/adds/PathFSBundles.d.mts

@@ -0,0 +1,48 @@
+/**
+ * @description
+ * - when used with `EsBundler+ToBundledJSPlugin` the file on the dir that are match the rule are `Bundled` first before being put on the `.asar`;
+ */
+export class PathFSBundles {
+    /**
+     * @description
+     * @param {string} relativePath
+     * - to the dirname of the file you are calling this method;
+     * @param {{shouldNotIncludes:string}} [options]
+     * - `shouldNotIncludes`:
+     * >- when this method receive non immediate string(declared on other file),
+     * >- `shouldNotIncludes` should be filled with the string like,
+     * >- `/${libname}/path/to/file/this/method/is/being/called.extname`;
+     * @returns {PathFSBundles}
+     * @example
+     * // D://true/path/mypath.mjs
+     * import { PathFSBundles } from 'vivth/node';
+     *
+     * PathFSBundles.vivthBundles('../src/entryPoint.mjs', {
+     * 	shouldNotIncludes: 'D://true/path/mypath.mjs',
+     * });
+     */
+    static vivthBundles: (relativePath: string, options?: {
+        shouldNotIncludes: string;
+    }) => PathFSBundles;
+    /**
+     * @private
+     * @param {Parameters<typeof PathFSBundles["vivthBundles"]>[0]} relativePath
+     * @param {Parameters<typeof PathFSBundles["vivthBundles"]>[1]} [options]
+     */
+    private constructor();
+    /**
+     * @description
+     * - relative path of the target to the project root;
+     * @returns {string}
+     */
+    get path(): string;
+    /**
+     * @description
+     * - depending on whether running on bundled or not;
+     * @returns {string}
+     * - unBundled: `absolutePath` on disk of the file caller;
+     * - bundled: `blankString`;
+     */
+    get callerPath(): string;
+    #private;
+}