vivth 1.4.10 → 1.5.0

package/src/bundler/CompileJS.mjs

@@ -1,20 +1,21 @@
 // @ts-check
 
+import { spawnSync } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { join, extname, basename, dirname } from 'node:path';
 import { platform } from 'node:os';
 
-import { exec } from 'pkg';
-
 import { EsBundler } from './EsBundler.mjs';
 import { FileSafe } from '../class/FileSafe.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
-import { FSInlineAnalyzer } from './FSInlineAnalyzer.mjs';
-import { removeVivthDevCodeBlock } from './adds/ToBundledJSPlugin.mjs';
+import { commonContentFixesBundled } from './adds/ToBundledJSPlugin.mjs';
+import { Preferrence } from '../common/Preferrence.mjs';
+import { ForInSync } from '../function/ForInSync.mjs';
+import { FSAnalyzer } from './FSAnalyzer.mjs';
 
 /**
  * @typedef {'win32' | 'linux' | 'darwin' | string} PlatformKey
- * @typedef {import('./CreateESPlugin.mjs')["CreateESPlugin"]} CreateESPlugin
+ * @typedef {typeof import('./CreateESPlugin.mjs')["CreateESPlugin"]} CreateESPlugin
  */
 
 /**
@@ -23,24 +24,28 @@ import { removeVivthDevCodeBlock } from './adds/ToBundledJSPlugin.mjs';
 let binaryExtension;
 
 /**
- * @param {Record<string, string[]|string>} compilerOptions
+ * @param {Record<string, string[]|string>} bunCompilerArguments
  * @returns {string[]}
  */
-const generateFlagsValue = (compilerOptions) => {
+const generateFlagsValue = (bunCompilerArguments = {}) => {
+	/**
+	 * @type {Array<string>}
+	 */
 	const options = [];
-	for (const flag in compilerOptions) {
-		const value = compilerOptions[flag];
+	ForInSync(bunCompilerArguments, (flag, value) => {
 		options.push(`--${flag}`);
-		if (Array.isArray(value) === false) {
+		if (!Array.isArray(value)) {
+			value = value.trim();
 			if (value) {
 				options.push(value);
 			}
-			continue;
+			return;
 		}
 		options.push(value.filter((val) => !!val).join(','));
-	}
+	});
 	return options;
 };
+
 /**
  * Maps Node.js platform to binary file extension.
  *
@@ -53,11 +58,7 @@ const getBinaryExtension = () => {
 				binaryExtension = '.exe';
 				break;
 			case 'linux':
-				binaryExtension = ''; // Linux binaries typically have no extension
-				break;
 			case 'darwin':
-				binaryExtension = ''; // macOS binaries typically have no extension
-				break;
 			default:
 				binaryExtension = ''; // fallback for unknown platforms
 				break;
@@ -65,25 +66,26 @@ const getBinaryExtension = () => {
 	}
 	return binaryExtension;
 };
+
 /**
  * @description
  * - function to compile `.ts`|`.mts`|`.mjs` file, into a single executable;
  * - also generate js representation of the `bundled` version of the target;
- * - uses [pkg](https://www.npmjs.com/package/pkg), [bun](https://bun.com/docs/bundler/executables), and [deno](https://docs.deno.com/runtime/reference/cli/compile/) compiler under the hood;
- * >- they are used only as packaging/compiler agent, and doesn't necessarily supports their advanced feature, such as, assets bundling(use [`FSInline`](#fsinline) instead);
- * >- `WorkerThread` will be converted to inline using `FSInline` too;
+ * - uses [bun](https://bun.com/docs/bundler/executables) compiler under the hood;
+ * >- it is used only as packaging/compiler agent, and doesn't necessarily supports their advanced feature, such as, assets bundling(use [`FSasar`](#fsasar) instead);
+ * >- `WorkerThread` will be converted to inline using `FSasar` too;
  *
- * !!!WARNING!!!
- * !!!WARNING!!!
- * !!!WARNING!!!
+ * ---
+ * ---
+ * ---
  *
  * - This function does not obfuscate and will not prevent decompilation. Do not embed environment variables or sensitive information inside `options.entryPoint`;
- * - It is designed for quick binarization, allowing execution on machines without `Node.js`, `Bun`, or `Deno` installed;
- * - The resulting binary will contain `FSInline` and `WorkerMainThread` target paths Buffers, which are loaded into memory at runtime. If your logic depends on the file system, use `node:fs` or `node:fs/promises` APIs and ship external files alongside the binary (not compiled);
+ * - It is designed for quick binarization, allowing execution on machines without `Bun` installed;
+ * - The resulting binary will contain `FSasar` and `WorkerMainThread` target paths Buffers, which are loaded into memory at runtime. If your logic depends on the file system, use `node:fs` or `node:fs/promises` APIs and ship external files alongside the `binary` and `.asar` file (not compiled);
  *
- * !!!WARNING!!!
- * !!!WARNING!!!
- * !!!WARNING!!!
+ * ---
+ * ---
+ * ---
  *
  * @param {Object} options
  * @param {string} options.entryPoint
@@ -95,105 +97,74 @@ const getBinaryExtension = () => {
  * - to modify entry point before bundling;
  * - `entryPointContent` is the original string of the entry point;
  * - returned value then passed to `ESBundler`;
- * @param {boolean} options.minifyFirst
+ * @param {boolean} [options.minifyFirst]
  * - minify the bundle before compilation;
+ * @param {Object} [options.asar]
+ * @param {Parameters<typeof import('@electron/asar')["createPackageFromFiles"]>[3]} [options.asar.InputMetadata]
+ * @param {Parameters<typeof import('@electron/asar')["createPackageFromFiles"]>[4]} [options.asar.options]
  * @param {string} options.outDir
  * - need manual prefix;
- * @param {'pkg'|'bun'|'deno'} [options.compiler]
- * - default: no comilation, just bundling;
- * - `bun` and `pkg` is checked, if there's bug on `deno`, please report on github for issues;
- * @param {Record<string, string>} [options.compilerArguments]
+ * @param {Record<string, string[]|string>} [options.bunCompilerArguments]
  * - `key` are to used as `--keyName`;
- * - value are the following value of the key;
+ * - value are the `value` of the `key`;
+ * >- `string`: will be inputed as is;
+ * >- `string[]`: will be joined with `,`;
  * - no need to add the output/outdir, as it use the `options.outDir`;
  * @param {ReturnType<CreateESPlugin>[]} [options.esBundlerPlugins]
  * - plugins for `EsBundler`;
- * @return {ReturnType<typeof TryAsync<{compileResult:Promise<any>|undefined,
+ * @param {Parameters<typeof EsBundler>[1]} [options.esbuildOptions]
+ * - options for `EsBundler`;
+ * @param {string[]} [options.additionalCommandArgument]
+ * - argument to be passed process generator;
+ * @return {ReturnType<typeof TryAsync<{compileResult: any,
  * commandCalled: string|undefined;
  * compiledBinFile: string|undefined;
- * bundledJSFile:string|undefined
+ * bundledJSFile: string|undefined
  * }>>}
  * @example
  * import process from 'node:process';
  * import { join } from 'node:path';
  *
- * import { CompileJS, Console, Paths, Setup } from 'vivth';
+ * import { CompileJS, SafeExit } from 'vivth/node';
+ * import { Console, Paths } from 'vivth/neutral';
  *
- * const { paths, safeExit } = Setup;
- * new paths({
+ * new Paths({
  * 	root: process.env.INIT_CWD ?? process.cwd(),
  * });
- * new safeExit({
- * 	eventNames: ['SIGINT', 'SIGTERM'],
- * 	terminator: () => process.exit(0),
- * 	listener: (eventName) => {
- * 		process.once(eventName, function () {
- * 			if (!safeExit.instance) {
- * 				return;
- * 			}
- * 			safeExit.instance.exiting.correction(true);
- * 			Console.log(`safe exit via "${eventName}"`);
- * 		});
+ *
+ * new SafeExit('SIGINT', 'SIGTERM');
+ *
+ * const pathRoot = Paths.root;
+ *
+ * const [,errorbun] = await CompileJS({
+ * 	entryPoint: join(pathRoot, '/dev/myEntryPoint.mjs'),
+ * 	minifyFirst: true,
+ * 	outDir: join(pathRoot, '/dev-bun/'),
+ * 	compiler: 'bun',
+ * 	compilerArguments: {
+ * 		target: 'bun-win-x64',
  * 	},
+ * 	asar: {},
+ * 	encoding: 'utf-8',
  * });
- * const pathRoot = Paths.root;
- * if (pathRoot) {
- * 	const [[, error], [, errorbun]] = await Promise.all([
- * 		CompileJS({
- * 			entryPoint: join(pathRoot, '/dev/myEntryPoint.mjs'),
- * 			minifyFirst: true,
- * 			outDir: join(pathRoot, '/dev-pkg/'),
- * 			compiler: 'pkg',
- * 			compilerArguments: {
- * 				target: 'node18-win-x64',
- * 			},
- * 			encoding: 'utf-8',
- * 		}),
- * 		await CompileJS({
- * 			entryPoint: join(pathRoot, '/dev/myEntryPoint.mjs'),
- * 			minifyFirst: true,
- * 			outDir: join(pathRoot, '/dev-bun/'),
- * 			compiler: 'bun',
- * 			compilerArguments: {
- * 				target: 'bun-win-x64',
- * 			},
- * 			encoding: 'utf-8',
- * 		}),
- * 	]);
- * 	if (error || errorbun) {
- * 		Console.error({ error, errorbun });
- * 	}
- * }
  *
+ * if (errorbun) {
+ * 	Console.error({ errorbun });
+ * }
  */
 export async function CompileJS({
 	entryPoint,
-	minifyFirst,
-	encoding = 'utf-8',
+	minifyFirst = true,
+	encoding = Preferrence.encoding,
 	outDir,
+	asar = {},
 	preprocessEntryPoint = undefined,
-	compiler = undefined,
-	compilerArguments = {},
+	bunCompilerArguments = undefined,
 	esBundlerPlugins = [],
+	esbuildOptions = {},
+	additionalCommandArgument = [],
 }) {
 	return await TryAsync(async () => {
-		/**
-		 * @type {'cjs'|'esm'}
-		 */
-		let format;
-		switch (compiler) {
-			case 'pkg':
-				format = 'cjs';
-				break;
-			case 'bun':
-			case 'deno':
-				format = 'esm';
-				break;
-			default:
-				minifyFirst = true;
-				format = 'esm';
-				break;
-		}
 		const extOfSource = extname(entryPoint);
 		switch (extOfSource) {
 			case '.mts':
@@ -201,11 +172,12 @@ export async function CompileJS({
 			case '.mjs':
 				break;
 			default:
-				throw new Error(
-					`extention mismatch: "${extOfSource}", should be one of:".mjs"|".mts"|".ts"`
-				);
+				throw `extention mismatch: "${extOfSource}", should be one of:".mjs"|".mts"|".ts"`;
 		}
-		let sourceText = removeVivthDevCodeBlock(await readFile(entryPoint, { encoding }));
+		let sourceText = commonContentFixesBundled(
+			entryPoint,
+			await readFile(entryPoint, { encoding }),
+		);
 		if (preprocessEntryPoint) {
 			sourceText = preprocessEntryPoint(sourceText);
 		}
@@ -214,89 +186,44 @@ export async function CompileJS({
 				content: sourceText,
 				extension: extOfSource,
 				root: dirname(entryPoint),
-				withBinHeader: compiler ? true : false,
+				withBinHeader: !!bunCompilerArguments,
 			},
 			{
 				minify: minifyFirst,
-				format,
 				plugins: esBundlerPlugins,
-			}
+				...esbuildOptions,
+			},
 		);
 		if (errorPrep) {
 			throw errorPrep;
 		}
-		const [analyzedBundled, errorAnalyze] = await FSInlineAnalyzer.finalContent(
+		const outputBaseNameNoExt = join(outDir, basename(entryPoint).replace(extOfSource, ''));
+		const bundledJSFile = `${outputBaseNameNoExt}.mjs`;
+		const [analyzedBundled, errorAnalyze] = await FSAnalyzer.finalContent(
+			entryPoint,
 			bundledPrep,
-			format
+			asar,
+			bundledJSFile,
 		);
 		if (errorAnalyze) {
 			throw errorAnalyze;
 		}
-		const outputBaseNameNoExt = join(outDir, basename(entryPoint).replace(extOfSource, ''));
-		const bundledJSFile = `${outputBaseNameNoExt}${format === 'cjs' ? '.cjs' : '.mjs'}`;
 		await FileSafe.write(bundledJSFile, analyzedBundled, { encoding });
 		const compiledBinFile = `${outputBaseNameNoExt}${getBinaryExtension()}`;
-		switch (compiler) {
-			case 'pkg': {
-				const commandCalled = [
-					bundledJSFile,
-					...generateFlagsValue(compilerArguments),
-					'--output',
-					compiledBinFile,
-				];
-				return {
-					compileResult: await exec(commandCalled),
-					commandCalled: `pkg ${commandCalled.join(' ')}`,
-					compiledBinFile,
-					bundledJSFile,
-				};
-			}
-			case 'bun': {
-				const commandCalled = [
-					'build',
-					bundledJSFile,
-					'--compile',
-					...generateFlagsValue(compilerArguments),
-					'--outfile',
-					compiledBinFile,
-				];
-				return {
-					compileResult: await Bun.spawn(['bun', ...commandCalled]),
-					commandCalled: `bun ${commandCalled.join(' ')}`,
-					compiledBinFile,
-					bundledJSFile,
-				};
-			}
-			case 'deno': {
-				const commandCalled = [
-					'compile',
-					...generateFlagsValue(compilerArguments),
-					'--output',
-					compiledBinFile,
-					bundledJSFile,
-					'--verbose',
-				];
-				// @ts-expect-error
-				const command = new Deno.Command('deno', {
-					args: commandCalled,
-					stdout: 'piped',
-					stderr: 'piped',
-				});
-				return {
-					compileResult: await command.output(),
-					commandCalled: `deno ${commandCalled.join(' ')}`,
-					compiledBinFile,
-					bundledJSFile,
-				};
-			}
-			default: {
-				return {
-					compileResult: undefined,
-					commandCalled: undefined,
-					compiledBinFile: undefined,
-					bundledJSFile,
-				};
-			}
-		}
+		const commandCalled = [
+			'build',
+			bundledJSFile,
+			'--compile',
+			...generateFlagsValue(bunCompilerArguments ?? {}),
+			'--outfile',
+			compiledBinFile,
+			...additionalCommandArgument,
+		];
+		return {
+			compileResult: spawnSync('bun', commandCalled),
+			commandCalled: `bun ${commandCalled.join(' ')}`,
+			compiledBinFile,
+			bundledJSFile,
+		};
 	});
 }

package/src/bundler/CreateESPlugin.mjs

@@ -7,7 +7,7 @@
  * @param {import('esbuild').Plugin["setup"]} setup
  * @returns {import('esbuild').Plugin}
  * @example
- * import { CreateESPlugin } from 'vivth';
+ * import { CreateESPlugin } from 'vivth/neutral';
  *
  * export const pluginAddCopyRight = CreateESPlugin(
  * 	'MyCopyrightDeclaration',

package/src/bundler/EsBundler.mjs

@@ -6,27 +6,29 @@ import { Console } from '../class/Console.mjs';
 import { Paths } from '../class/Paths.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
 import { pluginVivthBundle } from './adds/pluginVivthBundle.mjs';
-import { externals } from './adds/externals.mjs';
+import { BrowserExternals } from './adds/BrowserExternals.mjs';
 
 /**
  * @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',
@@ -38,7 +40,7 @@ import { externals } from './adds/externals.mjs';
  */
 export async function EsBundler(
 	{ content, extension, root, withBinHeader = false },
-	esbuildOptions = {}
+	esbuildOptions = {},
 ) {
 	return await TryAsync(async () => {
 		/**
@@ -51,7 +53,6 @@ export async function EsBundler(
 				loader = 'ts';
 				break;
 			case '.mjs':
-			case '.cjs':
 				loader = 'js';
 				break;
 			default:
@@ -60,21 +61,31 @@ export async function EsBundler(
 					message: 'Invalid extension passed to EsBundler',
 					acceptedextensions: ['.mts', '.ts', '.mjs'],
 				};
-				Console.error(error);
-				throw new Error(JSON.stringify(error));
+				Console.error(error, { now: true });
+				throw JSON.stringify(error);
+		}
+		const mainFields = esbuildOptions.mainFields;
+		if (!mainFields?.length) {
+			esbuildOptions.mainFields = ['module', 'main'];
+		}
+		esbuildOptions.external = [...(esbuildOptions?.external ?? [])];
+		if (esbuildOptions.platform === 'browser') {
+			esbuildOptions.external = Array.from(
+				new Set(esbuildOptions.external).union(BrowserExternals),
+			);
 		}
-		esbuildOptions.external = [...(esbuildOptions?.external ?? []), ...externals];
 		esbuildOptions.plugins = [...(esbuildOptions?.plugins ?? []), pluginVivthBundle];
 		const result = await build({
 			target: 'esnext',
 			platform: 'node',
-			format: 'esm',
 			...esbuildOptions,
 			stdin: {
 				contents: content,
 				loader,
 				resolveDir: root ?? Paths.root,
 			},
+			loader: esbuildOptions.loader,
+			format: 'esm',
 			bundle: true,
 			write: false,
 			sourcemap: false,
@@ -84,7 +95,21 @@ export async function EsBundler(
 			},
 		});
 		if (result.warnings?.length) {
-			Console.warn(result.warnings.map((w) => w.text).join('\n'));
+			const warningText = result.warnings.map((w) => w.text).join('\n');
+			const warningArray = [warningText];
+			/**
+			 * auto cjs mitigation no longer supported
+			 * ```js
+			 * const regex = /import\.meta[\s\S]*cjs|cjs[\s\S]*import\.meta/i;
+			 * if (regex.test(warningText)) {
+			 * 	warningArray.push(
+			 * 		`⚠️ Note: This is a false positive. 'vivth/node.EsBundler' already mitigates it with __filename.`,
+			 * 		`As long as only 'import.meta.url' is accessed, it is most likely fine.`,
+			 * 	);
+			 * }
+			 * ```
+			 */
+			Console.warn(warningArray, { now: true });
 		}
 		const resString = result.outputFiles?.[0]?.text;
 		if (resString === undefined) {