vivth 1.4.10 → 1.5.0

package/src/bundler/adds/CreateTransform.mjs

@@ -0,0 +1,36 @@
+// @ts-check
+
+import { Transform } from 'node:stream';
+
+/**
+ * @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) {
+	return new Transform({
+		transform(_chunk, _encoding, callback) {
+			this.push(content);
+			callback();
+		},
+	});
+}

package/src/bundler/adds/LastEditedUnix.mjs

@@ -0,0 +1,12 @@
+// @ts-check
+
+import { stat } from 'node:fs/promises';
+
+/**
+ * @param {any} fullPath
+ * @returns {Promise<number>}
+ */
+export async function LastEditedUnix(fullPath) {
+	const stats = await stat(fullPath);
+	return Math.floor(stats.mtimeMs / 1000);
+}

package/src/bundler/adds/NodeModuleList.mjs

@@ -0,0 +1,33 @@
+// @ts-check
+
+import { builtinModules } from 'node:module';
+import { ForOfSync } from '../../function/ForOfSync.mjs';
+
+/**
+ * @type {Set<string>}
+ */
+const list = new Set();
+
+/**
+ * @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() {
+	if (!list.size) {
+		ForOfSync(builtinModules, (module) => {
+			list.add(module);
+			list.add(`node:${module}`);
+		});
+	}
+	return list;
+}

package/src/bundler/adds/PathFSBundles.bundled.mjs

@@ -0,0 +1,41 @@
+// @ts-check
+
+export class PathFSBundles {
+	/**
+	 * @param {string} relativePath
+	 * @param {{shouldNotIncludes:string}} [options]
+	 * @returns {PathFSBundles}
+	 */
+	static vivthBundles = (relativePath, options) => {
+		return new PathFSBundles(relativePath, options);
+	};
+	/**
+	 * @private
+	 * @param {Parameters<typeof PathFSBundles["vivthBundles"]>[0]} relativePath
+	 * @param {Parameters<typeof PathFSBundles["vivthBundles"]>[1]} [_options]
+	 */
+	constructor(relativePath, _options) {
+		this.#path = relativePath;
+		this.#callerPath = '';
+	}
+	/**
+	 * @type {string}
+	 */
+	#path;
+	/**
+	 * @returns {string}
+	 */
+	get path() {
+		return this.#path;
+	}
+	/**
+	 * @type {string}
+	 */
+	#callerPath;
+	/**
+	 * @returns {string}
+	 */
+	get callerPath() {
+		return this.#callerPath;
+	}
+}

package/src/bundler/adds/PathFSBundles.mjs

@@ -0,0 +1,91 @@
+// @ts-check
+
+import { join, dirname, relative } from 'node:path';
+
+import { Paths } from '../../class/Paths.mjs';
+import { TracePath } from '../../common/TracePath.mjs';
+
+/**
+ * @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, options) => {
+		return new PathFSBundles(relativePath, options);
+	};
+	/**
+	 * @private
+	 * @param {Parameters<typeof PathFSBundles["vivthBundles"]>[0]} relativePath
+	 * @param {Parameters<typeof PathFSBundles["vivthBundles"]>[1]} [options]
+	 */
+	constructor(relativePath, options) {
+		const shouldNotIncludes = new Set([
+			'/vivth/src/common/TracePath.mjs',
+			'/vivth/src/bundler/adds/PathFSBundles.mjs',
+		]);
+		if (options) {
+			let { shouldNotIncludes: traceShouldNotIncludes_ } = options;
+			traceShouldNotIncludes_ = traceShouldNotIncludes_.trim();
+			if (traceShouldNotIncludes_) {
+				shouldNotIncludes.add(traceShouldNotIncludes_);
+			}
+		}
+		this.#callerPath =
+			TracePath((filePath) => {
+				for (const shouldNotInclude_ of shouldNotIncludes) {
+					if (!filePath.includes(shouldNotInclude_)) {
+						continue;
+					}
+					return false;
+				}
+				return true;
+			}) ?? '';
+		this.#path = Paths.normalize(
+			relative(Paths.root, join(dirname(this.callerPath), relativePath)),
+		);
+	}
+	/**
+	 * @type {string}
+	 */
+	#path;
+	/**
+	 * @description
+	 * - relative path of the target to the project root;
+	 * @returns {string}
+	 */
+	get path() {
+		return this.#path;
+	}
+	/**
+	 * @type {string}
+	 */
+	#callerPath;
+	/**
+	 * @description
+	 * - depending on whether running on bundled or not;
+	 * @returns {string}
+	 * - unBundled: `absolutePath` on disk of the file caller;
+	 * - bundled: `blankString`;
+	 */
+	get callerPath() {
+		return this.#callerPath;
+	}
+}

package/src/bundler/adds/PathFSDir.bundled.mjs

@@ -0,0 +1,53 @@
+// @ts-check
+
+export class PathFSDir {
+	/**
+	 * @param {string} relativePath
+	 * @param {RegExp} rule
+	 * @param {{shouldNotIncludes:string}} [options]
+	 * @returns {PathFSDir}
+	 */
+	static vivthDir = (relativePath, rule, options = undefined) => {
+		return new PathFSDir(relativePath, options, rule);
+	};
+	/**
+	 * @param {Parameters<typeof PathFSDir["vivthDir"]>[0]} relativePath
+	 * @param {Parameters<typeof PathFSDir["vivthDir"]>[2]} [_options]
+	 * @param {Parameters<typeof PathFSDir["vivthDir"]>[1]} [rule]
+	 */
+	constructor(relativePath, _options, rule = /[\s\S]*/) {
+		this.#rule = rule;
+		this.#path = relativePath;
+		this.#callerPath = '';
+	}
+	/**
+	 * @type {RegExp}
+	 */
+	#rule;
+	/**
+	 * @type {RegExp}
+	 */
+	get rule() {
+		return this.#rule;
+	}
+	/**
+	 * @type {string}
+	 */
+	#path;
+	/**
+	 * @returns {string}
+	 */
+	get path() {
+		return this.#path;
+	}
+	/**
+	 * @type {string}
+	 */
+	#callerPath;
+	/**
+	 * @returns {string}
+	 */
+	get callerPath() {
+		return this.#callerPath;
+	}
+}

package/src/bundler/adds/PathFSDir.mjs

@@ -0,0 +1,100 @@
+// @ts-check
+
+import { join, dirname, relative } from 'node:path';
+
+import { Paths } from '../../class/Paths.mjs';
+import { TracePath } from '../../common/TracePath.mjs';
+
+/**
+ * @description
+ * - includes all files, that match the rule to `.asar` specification;
+ */
+export class PathFSDir {
+	/**
+	 * @description
+	 * @param {string} relativePath
+	 * - relativePath to the `dirname` of the file you are calling this method;
+	 * @param {RegExp} rule
+	 * @param {Parameters<typeof import('./PathFSBundles.mjs').PathFSBundles["vivthBundles"]>[1]} [options]
+	 * @returns {PathFSDir}
+	 * @example
+	 * import { PathFSDir } from 'vivth/node';
+	 *
+	 * PathFSDir.vivthDir('../src/', /[\s\S]\*[blank]/);
+	 * // visible for ide inline check: without `[blank]`;
+	 */
+	static vivthDir = (relativePath, rule, options = undefined) => {
+		return new PathFSDir(relativePath, options, rule);
+	};
+	/**
+	 * @private
+	 * @param {Parameters<typeof PathFSDir["vivthDir"]>[0]} relativePath
+	 * @param {Parameters<typeof PathFSDir["vivthDir"]>[2]} [options]
+	 * @param {Parameters<typeof PathFSDir["vivthDir"]>[1]} [rule]
+	 */
+	constructor(relativePath, options, rule = /[\s\S]*/) {
+		this.#rule = rule;
+		const shouldNotIncludes = new Set([
+			'/vivth/src/common/TracePath.mjs',
+			'/vivth/src/bundler/adds/PathFSDir.mjs',
+		]);
+		if (options) {
+			let { shouldNotIncludes: traceShouldNotIncludes_ } = options;
+			traceShouldNotIncludes_ = traceShouldNotIncludes_.trim();
+			if (traceShouldNotIncludes_) {
+				shouldNotIncludes.add(traceShouldNotIncludes_);
+			}
+		}
+		this.#callerPath =
+			TracePath((filePath) => {
+				for (const shouldNotInclude_ of shouldNotIncludes) {
+					if (!filePath.includes(shouldNotInclude_)) {
+						continue;
+					}
+					return false;
+				}
+				return true;
+			}) ?? '';
+		this.#path = Paths.normalize(
+			relative(Paths.root, join(dirname(this.callerPath), relativePath)),
+		);
+	}
+	/**
+	 * @type {RegExp}
+	 */
+	#rule;
+	/**
+	 * @description
+	 * - rule for dir, to get file any file match the rule inside that directory;
+	 * @type {RegExp}
+	 */
+	get rule() {
+		return this.#rule;
+	}
+	/**
+	 * @type {string}
+	 */
+	#path;
+	/**
+	 * @description
+	 * - relative path of the target to the project root;
+	 * @returns {string}
+	 */
+	get path() {
+		return this.#path;
+	}
+	/**
+	 * @type {string}
+	 */
+	#callerPath;
+	/**
+	 * @description
+	 * - depending on whether running on bundled or not;
+	 * - unBundled: absolute disk path of the file caller;
+	 * - bundled: `blankstring`;
+	 * @returns {string}
+	 */
+	get callerPath() {
+		return this.#callerPath;
+	}
+}

package/src/bundler/adds/PathFSFile.bundled.mjs

@@ -0,0 +1,40 @@
+// @ts-check
+
+export class PathFSFile {
+	/**
+	 * @param {string} relativePath
+	 * @param {{shouldNotIncludes:string}} [options]
+	 * @returns {PathFSFile}
+	 */
+	static vivthFile = (relativePath, options) => {
+		return new PathFSFile(relativePath, options);
+	};
+	/**
+	 * @private
+	 * @param {Parameters<typeof PathFSFile["vivthFile"]>[0]} relativePath
+	 * @param {Parameters<typeof PathFSFile["vivthFile"]>[1]} [_options]
+	 */
+	constructor(relativePath, _options) {
+		((this.#path = relativePath), (this.#callerPath = ''));
+	}
+	/**
+	 * @type {string}
+	 */
+	#path;
+	/**
+	 * @returns {string}
+	 */
+	get path() {
+		return this.#path;
+	}
+	/**
+	 * @type {string}
+	 */
+	#callerPath;
+	/**
+	 * @returns {string}
+	 */
+	get callerPath() {
+		return this.#callerPath;
+	}
+}

package/src/bundler/adds/PathFSFile.mjs

@@ -0,0 +1,85 @@
+// @ts-check
+
+import { join, dirname, relative } from 'node:path';
+
+import { Paths } from '../../class/Paths.mjs';
+import { TracePath } from '../../common/TracePath.mjs';
+
+/**
+ * @description
+ * >- the file are added to `asar` AS IS, OR
+ * >- transformed according to the `asar.options.transform` value;
+ */
+export class PathFSFile {
+	/**
+	 * @description
+	 * @param {string} relativePath
+	 * - to the dirname of the file you are calling this method;
+	 * @param {Parameters<typeof import('./PathFSBundles.mjs').PathFSBundles["vivthBundles"]>[1]} [options]
+	 * @returns {PathFSFile}
+	 * @example
+	 * import { PathFSFile } from 'vivth/node';
+	 *
+	 * PathFSFile.vivthFile('../CompileAS.mjs');
+	 */
+	static vivthFile = (relativePath, options) => {
+		return new PathFSFile(relativePath, options);
+	};
+	/**
+	 * @private
+	 * @param {Parameters<typeof PathFSFile["vivthFile"]>[0]} relativePath
+	 * @param {Parameters<typeof PathFSFile["vivthFile"]>[1]} [options]
+	 */
+	constructor(relativePath, options) {
+		const shouldNotIncludes = new Set([
+			'/vivth/src/common/TracePath.mjs',
+			'/vivth/src/bundler/adds/PathFSFile.mjs',
+		]);
+		if (options) {
+			let { shouldNotIncludes: traceShouldNotIncludes_ } = options;
+			traceShouldNotIncludes_ = traceShouldNotIncludes_.trim();
+			if (traceShouldNotIncludes_) {
+				shouldNotIncludes.add(traceShouldNotIncludes_);
+			}
+		}
+		this.#callerPath =
+			TracePath((filePath) => {
+				for (const shouldNotInclude_ of shouldNotIncludes) {
+					if (!filePath.includes(shouldNotInclude_)) {
+						continue;
+					}
+					return false;
+				}
+				return true;
+			}) ?? '';
+		this.#path = Paths.normalize(
+			relative(Paths.root, join(dirname(this.callerPath), relativePath)),
+		);
+	}
+	/**
+	 * @type {string}
+	 */
+	#path;
+	/**
+	 * @description
+	 * - relative path of the target to the project root;
+	 * @returns {string}
+	 */
+	get path() {
+		return this.#path;
+	}
+	/**
+	 * @type {string}
+	 */
+	#callerPath;
+	/**
+	 * @description
+	 * - depending on whether running on bundled or not;
+	 * - unBundled: absolute disk path of the file caller;
+	 * - bundled: `blankstring`;
+	 * @returns {string}
+	 */
+	get callerPath() {
+		return this.#callerPath;
+	}
+}