vivth 1.4.10 → 1.5.0

package/src/bundler/FSAnalyzer.mjs

@@ -0,0 +1,253 @@
+// @ts-check
+
+import { dirname, extname, join } from 'node:path';
+
+import { createPackageFromFiles } from '@electron/asar';
+
+import { Paths } from '../class/Paths.mjs';
+import { LitExp } from '../class/LitExp.mjs';
+import { TryAsync } from '../function/TryAsync.mjs';
+import { commonContentFixesBundled } from './adds/ToBundledJSPlugin.mjs';
+import { Console } from '../class/Console.mjs';
+import { EsBundler } from './EsBundler.mjs';
+import { CreateTransform } from './adds/CreateTransform.mjs';
+import { GetFilesFromDir } from '../function/GetFilesFromDir.mjs';
+import { readFile } from 'node:fs/promises';
+import { Preferrence } from '../common/Preferrence.mjs';
+
+/**
+ * @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 = async (entryPoint, content, asarConfig, bundledJSFilePath) => {
+		return await TryAsync(async () => {
+			content = commonContentFixesBundled(entryPoint, content);
+			FSAnalyzer.#analyze_asarFile(Paths.root, content, asarConfig, bundledJSFilePath);
+			return content;
+		});
+	};
+
+	/**
+	 * return regex as string from template literal that are supposed to be regex
+	 * @param {string} str
+	 * @returns {RegExp}
+	 */
+	static #hydrateRegex = (str) => {
+		const arr = str.split('/');
+		str = `/${arr[1]}/`;
+		const match = str.match(/^\/(.*)\/([a-z]*)$/);
+		if (match === null) {
+			throw { str, message: 'Invalid regex string format' };
+		}
+		const [, pattern = '', flags] = match;
+		return new RegExp(pattern, flags);
+	};
+
+	/**
+	 * @param {string} rootPath
+	 * @param {string} content
+	 * @param {Parameters<typeof FSAnalyzer["finalContent"]>[2]} asarConfig
+	 * @param {string} bundledJSFile
+	 * @returns {Promise<void>}
+	 */
+	static #analyze_asarFile = async (rootPath, content, asarConfig, bundledJSFile) => {
+		rootPath = Paths.normalize(rootPath);
+		const [literalBundle, errorPrepareRegexBundle] = LitExp.prepare({
+			ref: /[\w][\w\d]*/,
+			method: /\.vivthBundles\s*?\(\s*?['"]/,
+			path: /[\w\W\/\.]*/,
+			methodClosing: /['"]/,
+			closing: /\s*[,);]/,
+		});
+		const [literalFile, errorPrepareRegexFile] = LitExp.prepare({
+			ref: /[\w][\w\d]*/,
+			method: /\.vivthFile\s*?\(\s*?['"]/,
+			path: /[\w\W\/\.]*/,
+			methodClosing: /['"]/,
+			closing: /\s*[,);]/,
+		});
+		const [literalDir, errorPrepareRegexDir] = LitExp.prepare({
+			ref: /[\w][\w\d]*/,
+			method: /\.vivthDir\s*?\(\s*?['"]/,
+			path: /[\w\W\/\.]*/,
+			methodClosing: /['"]\s*?,\s*?/,
+			rule: false,
+			closing: /\s*[,);]/,
+		});
+		if (errorPrepareRegexBundle || errorPrepareRegexFile || errorPrepareRegexDir) {
+			Console.error(
+				{
+					errorPrepareRegexBundle,
+					errorPrepareRegexFile,
+					errorPrepareRegexDir,
+				},
+				{ now: true },
+			);
+			return;
+		}
+		const templateBundle = literalBundle`${'ref'}${'method'}${'path'}${'methodClosing'}${'closing'}`;
+		const templateFile = literalFile`${'ref'}${'method'}${'path'}${'methodClosing'}${'closing'}`;
+		const templateDir = literalDir`${'ref'}${'method'}${'path'}${'methodClosing'}${'rule'}${'closing'}`;
+		const [resultMatchingBundle, errorMatchingBundle] =
+			templateBundle.evaluate.matchedAllAndGrouped(content, {
+				flags: 'gm',
+				whiteSpaceSensitive: false,
+			});
+		const [resultMatchingFile, errorMatchingFile] = templateFile.evaluate.matchedAllAndGrouped(
+			content,
+			{
+				flags: 'gm',
+				whiteSpaceSensitive: false,
+			},
+		);
+		const [resultMatchingDir, errorMatchingDir] = templateDir.evaluate.matchedAllAndGrouped(
+			content,
+			{
+				flags: 'gm',
+				whiteSpaceSensitive: false,
+			},
+		);
+		if (errorMatchingBundle || errorMatchingFile || errorMatchingDir) {
+			Console.error({ errorMatchingBundle, errorMatchingFile, errorMatchingDir }, { now: true });
+			return;
+		}
+		const { InputMetadata = {}, options = {} } = asarConfig;
+		const asarPath = bundledJSFile.replace(new RegExp(`${extname(bundledJSFile)}\$`, ''), '.asar');
+		const {
+			result: { named: namedBundle },
+			// regexp: regexBundle,
+		} = resultMatchingBundle;
+		const {
+			result: { named: namedFile },
+			// regexp: regexFile,
+		} = resultMatchingFile;
+		const {
+			result: { named: namedDir },
+			// regexp: regexDir,
+		} = resultMatchingDir;
+		// Console.info({
+		// 	regexBundle,
+		// 	regexFile,
+		// 	regexDir,
+		// });
+		/**
+		 * @type {Set<string>}
+		 */
+		const fileNames = new Set();
+		/**
+		 * @type {Map<string, string>}
+		 */
+		const checkBundle = new Map();
+		/**
+		 * @type {Set<string>}
+		 */
+		const checkFile = new Set();
+		/**
+		 * @type {Set<string>}
+		 */
+		const checkDir = new Set();
+		for (let i = 0; i < namedBundle.length; i++) {
+			const res = namedBundle[i];
+			if (res === undefined) {
+				continue;
+			}
+			const fullPath = Paths.normalize(join(Paths.root, res.path));
+			const extension = extname(fullPath);
+			if (checkBundle.has(fullPath)) {
+				continue;
+			}
+			const [stringRes, errorBundling] = await EsBundler(
+				{
+					content: await readFile(fullPath, { encoding: Preferrence.encoding }),
+					// @ts-expect-error
+					extension,
+					root: dirname(fullPath),
+					withBinHeader: false,
+				},
+				{
+					format: 'esm',
+					minify: true,
+					absWorkingDir: dirname(fullPath),
+				},
+			);
+			if (errorBundling) {
+				Console.error({ errorBundling }, { now: true });
+				continue;
+			}
+			fileNames.add(fullPath);
+			checkBundle.set(fullPath, commonContentFixesBundled(fullPath, stringRes));
+		}
+		for (let i = 0; i < namedDir.length; i++) {
+			const res = namedDir[i];
+			if (res === undefined) {
+				continue;
+			}
+			const { path, rule } = res;
+			const fullPath = Paths.normalize(join(Paths.root, path));
+			if (checkDir.has(fullPath)) {
+				continue;
+			}
+			checkDir.add(fullPath);
+			const rule_ = FSAnalyzer.#hydrateRegex(rule.trim());
+			await GetFilesFromDir(fullPath, rule_, fileNames);
+		}
+		for (let i = 0; i < namedFile.length; i++) {
+			const res = namedFile[i];
+			if (res === undefined) {
+				continue;
+			}
+
+			const fullPath = Paths.normalize(join(Paths.root, res.path));
+			if (checkFile.has(fullPath)) {
+				continue;
+			}
+			checkFile.add(fullPath);
+			fileNames.add(fullPath);
+		}
+		const optionsTransform = options.transform;
+		options.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;
+		};
+		await createPackageFromFiles(rootPath, asarPath, Array.from(fileNames), InputMetadata, options);
+	};
+}

package/src/bundler/FSasar.bundled.mjs

@@ -0,0 +1,128 @@
+// @ts-check
+
+import { extname, join, relative } from 'node:path';
+
+import { extractFile, getRawHeader } from '@electron/asar';
+
+import { TrySync } from '../function/TrySync.mjs';
+import { Console } from '../class/Console.mjs';
+import { emptyBufferValue } from './adds/emptyBufferValue.mjs';
+import { PathFSFile } from './adds/PathFSFile.mjs';
+import { Paths } from '../class/Paths.mjs';
+import { PipeSync } from '../function/PipeSync.mjs';
+import { argv0 } from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+// @ts-check
+
+/**
+ * @type {undefined|string}
+ */
+let archievePath_ = undefined;
+
+const asarPath = () => {
+	if (!archievePath_) {
+		const thisPath = fileURLToPath(import.meta.url);
+		const check0 = argv0.replace(new RegExp(`${extname(argv0)}\$`, ''), '.asar/');
+		const check1 = thisPath.replace(new RegExp(`${extname(thisPath)}\$`, ''), '.asar/');
+		if (check0.startsWith(Paths.root)) {
+			archievePath_ = check0;
+		} else {
+			/**
+			 * ```js
+			 * else if (check1.startsWith(root)) {
+			 * 	archievePath_ = check1;
+			 * }
+			 * ```
+			 */
+			archievePath_ = check1;
+		}
+	}
+	return Paths.normalize(archievePath_);
+};
+
+export class FSasar {
+	/**
+	 * @typedef {import('./adds/PathFSDir.mjs').PathFSDir} PathFSDir
+	 */
+	/**
+	 * @param {PathFSFile} filePathFromProject
+	 * @returns {Promise<undefined|Buffer<ArrayBufferLike>>}
+	 */
+	static file = async (filePathFromProject) => {
+		const [buffer, errorFileNotFound] = TrySync(() => {
+			const archievePath = asarPath();
+			return extractFile(archievePath, Paths.nativeSep(filePathFromProject.path), true);
+		});
+		if (!errorFileNotFound) {
+			return buffer;
+		}
+		Console.error(
+			{ filePathFromProject: filePathFromProject.path, errorFileNotFound },
+			{ now: true },
+		);
+		return emptyBufferValue();
+	};
+	/**
+	 * @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) => {
+		return {
+			forEachFiles: (loopCallback) => {
+				/**
+				 * @param {Record<string, import('@electron/asar').DirectoryRecord | import('@electron/asar').FileRecord>} headerRef
+				 * @param {string} relativePath
+				 */
+				const check = (headerRef, relativePath = './') => {
+					for (const name in headerRef) {
+						if (!Object.hasOwn(headerRef, name)) {
+							continue;
+						}
+						const val = headerRef[name];
+						if (!val) {
+							continue;
+						}
+						if ('files' in val) {
+							check(val.files, join(relativePath, name));
+							continue;
+						}
+						if ('size' in val) {
+							const filePath = Paths.normalize(join(relativePath, name));
+							loopCallback({
+								asar: filePath,
+								inputRelative: Paths.normalize(relative(pathFSDirInstance.path, filePath)),
+							});
+						}
+					}
+				};
+				let files = getRawHeader(asarPath()).header.files;
+				const pathFSDirInstance_ = pathFSDirInstance.path.split('/');
+				for (let i = 0; i < pathFSDirInstance_.length; i++) {
+					const val = pathFSDirInstance_[i];
+					if (!val || !files[val] || !('files' in files[val])) {
+						continue;
+					}
+					files = files[val].files;
+				}
+				check(files, pathFSDirInstance.path);
+			},
+			getFile: async (filePathRelativeFromDir) => {
+				const path_ = PipeSync(
+					Paths.normalize(join(pathFSDirInstance.path, filePathRelativeFromDir)),
+					(path_) => Paths.normalize(relative(Paths.root, path_)),
+				);
+				if (!path_.match(pathFSDirInstance.rule)) {
+					return emptyBufferValue();
+				}
+				return FSasar.file(PathFSFile.vivthFile(path_));
+			},
+		};
+	};
+}

package/src/bundler/FSasar.mjs

@@ -0,0 +1,96 @@
+// @ts-check
+
+import { dirname, join, relative } from 'node:path';
+import { readFile } from 'node:fs/promises';
+
+import { Paths } from '../class/Paths.mjs';
+import { TryAsync } from '../function/TryAsync.mjs';
+import { Console } from '../class/Console.mjs';
+import { emptyBufferValue } from './adds/emptyBufferValue.mjs';
+import { GetFilesFromDir } from '../function/GetFilesFromDir.mjs';
+import { ForOfSync } from '../function/ForOfSync.mjs';
+import { PipeSync } from '../function/PipeSync.mjs';
+import { PathFSFile } from './adds/PathFSFile.mjs';
+
+/**
+ * @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 async file(pathFSFPathFSFileInstance) {
+		const [buffer, errorFileNotFound] = await TryAsync(async () => {
+			const buf = await readFile(join(Paths.root, pathFSFPathFSFileInstance.path));
+			return Buffer.from(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
+		});
+		if (errorFileNotFound) {
+			Console.error({ errorFileNotFound }, { now: true });
+			return emptyBufferValue();
+		}
+		return buffer;
+	}
+	/**
+	 * @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) => {
+		return {
+			forEachFiles: (loopCallback) => {
+				const relativeTo = join(Paths.root, pathFSDirInstance.path);
+				GetFilesFromDir(relativeTo, pathFSDirInstance.rule, new Set()).then((filePaths) => {
+					ForOfSync(filePaths, (filePath) => {
+						loopCallback({
+							inputRelative: Paths.normalize(relative(relativeTo, filePath)),
+							asar: Paths.normalize(relative(Paths.root, filePath)),
+						});
+					});
+				});
+			},
+			getFile: async (filePathRelativeFromDir) => {
+				const path_ = PipeSync(
+					join(pathFSDirInstance.path, filePathRelativeFromDir),
+					(path_) => relative(dirname(pathFSDirInstance.callerPath), path_),
+					(path_) => Paths.normalize(path_),
+				);
+				if (!path_.match(pathFSDirInstance.rule)) {
+					return emptyBufferValue();
+				}
+
+				return FSasar.file(
+					PathFSFile.vivthFile(path_, { shouldNotIncludes: '/vivth/src/bundler/FSasar.mjs' }),
+				);
+			},
+		};
+	};
+}