quickjs-zig 1.0.1 → 1.0.3

package/README.md

@@ -5,9 +5,10 @@ A high-performance build system for **QuickJS**, powered by the **Zig** compiler
 ## Features
 
 * **Zero Config Cross-Compilation**: Build for Windows, Linux, and macOS from any host (Intel or Apple Silicon).
-* **Zig-Powered**: Uses **Zig 0.15.2** as a C compiler for modern, safe, and highly optimized binaries.
+* **Zig-Powered Optimization**: Uses **Zig 0.15.2** with LTO (Link Time Optimization) to produce small binaries.
 * **Custom C Modules**: Easily inject and register your own C modules into the QuickJS engine.
 * **Native Windows Support**: Includes a custom `exec` implementation for Windows, bypassing typical QuickJS POSIX limitations.
+* **Platform-Specific Swapping**: Automatically replaces generic JS files with platform-specific ones (e.g., `index.mjs` → `index.darwin.mjs`) during build.
 * **Clean Source Management**: Automatically patches and restores QuickJS source files to keep the core library pristine.
 
 ---
@@ -35,17 +36,40 @@ npm link
 
 ```
 
+---
+
+## Platform-Specific File Swapping
+
+The build system supports platform-specific file resolution. This is useful when you need different JS logic for different operating systems while maintaining a single development entry point for IDE completion.
+
+### How it works
+
+1. **Generic file**: Create a base file (e.g., `index.mjs` or `dialogs.mjs`). This is your reference for IDE completion and IntelliSense.
+2. **Specific files**: Create files with the platform suffix:
+* `filename.win32.mjs`
+* `filename.darwin.mjs`
+* `filename.linux.mjs`
+
+
+3. **Build Logic**:
+* The `build/` folder is cleaned at the start of each execution.
+* If a platform-specific version exists, the generic version is **excluded** from the build folder to avoid duplicates.
+* The script automatically rewrites `import` statements in your code to point to the correct suffix during the build process.
+
+
+
 ---
 
 ## Configuration
 
-Configure your entry point and custom C modules in your project's `package.json`:
+Configure your entry point, optimization, and custom C modules in your project's `package.json`:
 
 ```json
 {
   "name": "my-app",
   "quickJs": {
     "input": "app/index.mjs",
+    "optimization": true,
     "modules": {
       "my_module": "src/my_module.c"
     }
@@ -55,8 +79,11 @@ Configure your entry point and custom C modules in your project's `package.json`
 ```
 
 * **`input`**: The entry point of your JavaScript application (defaults to `app/index.mjs`).
+* **`optimization`**: When `true`, enables **LTO**, aggressive inlining (`-O3`), and strips unused features like `eval` or `Promises` via `qjsc` flags.
 * **`modules`**: A key-value map of custom C modules (Module Name -> C Source Path).
 
+**Note**: The system always applies `-s` (strip symbols) regardless of the optimization flag to ensure no `.pdb` or debug tables are generated.
+
 ---
 
 ## Example Usage
@@ -130,9 +157,9 @@ The build system generates binaries for the following platforms in the `dist/` f
 
 Zig is not just a language; it's a powerful C/C++ toolchain. It allows `quickjs-zig` to:
 
-* Cross-compile to Windows (MinGW) from macOS/Linux without installing complex toolchains.
-* Provide a consistent `libc` environment across different platforms.
-* Produce small, fast, and statically linked binaries.
+* **Cross-compile** to Windows (MinGW) or Linux from any host without installing complex toolchains.
+* **Size matters**: By using `-flto` and `-O3`, Zig can discard unused parts of the engine, bringing the footprint down by nearly 95% compared to Node.js standalone binaries.
+* **macOS LTO Support**: On Apple targets, we automatically force `-fuse-ld=lld` when optimized to ensure the LLVM Linker handles the bitcode correctly.
 
 ### Windows Patching
 
@@ -144,4 +171,4 @@ QuickJS is designed for POSIX systems. This tool automatically patches `quickjs-
 
 MIT - Created by **eid-app**.
 
----
+---

package/build.mjs

@@ -1,5 +1,5 @@
 import { execSync } from 'child_process';
-import { writeFileSync, mkdirSync, unlinkSync, existsSync, readdirSync, cpSync, readFileSync, renameSync } from 'fs';
+import { writeFileSync, mkdirSync, unlinkSync, existsSync, readdirSync, cpSync, readFileSync, renameSync, statSync, rmSync } from 'fs';
 import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
@@ -7,6 +7,13 @@ import { fileURLToPath } from 'url';
 // --- PATH CONFIGURATION ---
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const USER_CWD = process.cwd();
+const PLATFORM = os.platform();
+
+// Clean global build directory at the very beginning
+const GLOBAL_BUILD_DIR = path.join(USER_CWD, 'build');
+if (existsSync(GLOBAL_BUILD_DIR)) {
+    rmSync(GLOBAL_BUILD_DIR, { recursive: true });
+}
 
 // Load the user project's package.json
 const USER_PKG_PATH = path.join(USER_CWD, 'package.json');
@@ -19,13 +26,71 @@ const userPackageJson = JSON.parse(readFileSync(USER_PKG_PATH, 'utf8'));
 const customModules = userPackageJson.quickJs?.modules || {};
 const APP_NAME = userPackageJson.name || 'app';
 
+// Optimization flag from package.json
+const IS_OPTIMIZED = userPackageJson.quickJs?.optimization === true;
+
 // Input file from package.json or default to app/index.mjs
 const INPUT_FILE_RELATIVE = userPackageJson.quickJs?.input || 'app/index.mjs';
-const INPUT_FILE_ABS = path.resolve(USER_CWD, INPUT_FILE_RELATIVE);
 
-if (!existsSync(INPUT_FILE_ABS)) {
-    console.error(`❌ Error: Input file not found at ${INPUT_FILE_ABS}`);
-    process.exit(1);
+/**
+ * Recursively scan and transform imports to platform-specific ones.
+ * Filters out files from other platforms and ensures specific versions
+ * replace generic ones (like index.mjs) in the build folder.
+ */
+function processDirectory(currentDir, targetDir, targetPlat) {
+    if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
+
+    const filesInSource = readdirSync(currentDir);
+
+    filesInSource.forEach(file => {
+        const fullPath = path.join(currentDir, file);
+        const destPath = path.join(targetDir, file);
+
+        if (statSync(fullPath).isDirectory()) {
+            return processDirectory(fullPath, destPath, targetPlat);
+        }
+
+        const isMjs = file.endsWith('.mjs') || file.endsWith('.js');
+        const knownPlats = ['win32', 'darwin', 'linux'];
+
+        if (isMjs) {
+            const parts = file.split('.');
+            const filePlat = parts.length > 2 ? parts[parts.length - 2] : null;
+
+            // 1. Skip files belonging to OTHER platforms
+            if (filePlat && knownPlats.includes(filePlat) && filePlat !== targetPlat) {
+                return;
+            }
+
+            // 2. Logic for generic files (like index.mjs):
+            // If a specific version (index.darwin.mjs) exists, we skip the generic one.
+            if (!filePlat || !knownPlats.includes(filePlat)) {
+                const specFile = file.replace(/\.mjs$/, `.${targetPlat}.mjs`);
+                if (filesInSource.includes(specFile)) {
+                    return;
+                }
+            }
+
+            let content = readFileSync(fullPath, 'utf8');
+
+            // 3. Transform generic imports to platform-specific ones if they exist physically
+            content = content.replace(/(import\s+.+?\s+from\s+['"])(.+?)\.mjs(['"])/g, (match, before, importPath, after) => {
+                const platFile = `${importPath}.${targetPlat}.mjs`;
+                const platformFullPath = path.resolve(currentDir, platFile);
+
+                if (existsSync(platformFullPath)) {
+                    console.log(`✨ [${targetPlat}] Swapping import: ${importPath}.mjs -> ${platFile}`);
+                    return `${before}${importPath}.${targetPlat}.mjs${after}`;
+                }
+                return match;
+            });
+
+            writeFileSync(destPath, content);
+        } else {
+            // Copy assets and other files as is
+            cpSync(fullPath, destPath);
+        }
+    });
 }
 
 const QUICKJS_DIR = path.resolve(__dirname, 'quickjs');
@@ -46,13 +111,11 @@ if (!existsSync(BIN_DIR)) mkdirSync(BIN_DIR, { recursive: true });
 if (!existsSync(DIST_DIR)) mkdirSync(DIST_DIR, { recursive: true });
 
 // Detect the host architecture to find the correct qjsc binary
-const platform = os.platform();
 const arch = os.arch();
 let hostQjscName = '';
-
-if (platform === 'darwin') hostQjscName = (arch === 'arm64') ? 'qjsc_mac_arm' : 'qjsc_mac_intel';
-else if (platform === 'linux') hostQjscName = (arch === 'arm64' || arch === 'aarch64') ? 'qjsc_linux_arm' : 'qjsc_linux64';
-else if (platform === 'win32') hostQjscName = 'qjsc_win64.exe';
+if (PLATFORM === 'darwin') hostQjscName = (arch === 'arm64') ? 'qjsc_mac_arm' : 'qjsc_mac_intel';
+else if (PLATFORM === 'linux') hostQjscName = (arch === 'arm64' || arch === 'aarch64') ? 'qjsc_linux_arm' : 'qjsc_linux64';
+else if (PLATFORM === 'win32') hostQjscName = 'qjsc_win64.exe';
 
 const hostQjscPath = path.join(BIN_DIR, hostQjscName);
 
@@ -114,13 +177,13 @@ const baseSources = ['quickjs.c', 'libregexp.c', 'libunicode.c', 'cutils.c', 'qu
     .join(' ');
 
 const targets = [
-  { id: 'x86_64-windows-gnu', qjs: 'qjs_win64.exe', qjsc: 'qjsc_win64.exe', app: `${APP_NAME}_win64.exe`, libs: '-lm', cflags: '-D_GNU_SOURCE' },
-  { id: 'x86-windows-gnu',    qjs: 'qjs_win32.exe', qjsc: 'qjsc_win32.exe', app: `${APP_NAME}_win32.exe`, libs: '-lm', cflags: '-D_GNU_SOURCE' },
-  { id: 'x86_64-linux-gnu',   qjs: 'qjs_linux64',   qjsc: 'qjsc_linux64',   app: `${APP_NAME}_linux64`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' },
-  { id: 'x86-linux-gnu',     qjs: 'qjs_linux32',   qjsc: 'qjsc_linux32',   app: `${APP_NAME}_linux32`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' },
-  { id: 'aarch64-linux-gnu',  qjs: 'qjs_linux_arm64', qjsc: 'qjsc_linux_arm64', app: `${APP_NAME}_linux_arm64`, libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' },
-  { id: 'aarch64-macos',      qjs: 'qjs_mac_arm',   qjsc: 'qjsc_mac_arm',   app: `${APP_NAME}_mac_arm`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' },
-  { id: 'x86_64-macos',       qjs: 'qjs_mac_intel', qjsc: 'qjsc_mac_intel', app: `${APP_NAME}_mac_intel`, libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' }
+  { id: 'x86_64-windows-gnu', qjs: 'qjs_win64.exe', qjsc: 'qjsc_win64.exe', app: `${APP_NAME}_win64.exe`, libs: '-lm', cflags: '-D_GNU_SOURCE', plat: 'win32' },
+  { id: 'x86-windows-gnu',    qjs: 'qjs_win32.exe', qjsc: 'qjsc_win32.exe', app: `${APP_NAME}_win32.exe`, libs: '-lm', cflags: '-D_GNU_SOURCE', plat: 'win32' },
+  { id: 'x86_64-linux-gnu',   qjs: 'qjs_linux64',   qjsc: 'qjsc_linux64',   app: `${APP_NAME}_linux64`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD', plat: 'linux' },
+  { id: 'x86-linux-gnu',      qjs: 'qjs_linux32',   qjsc: 'qjsc_linux32',   app: `${APP_NAME}_linux32`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD', plat: 'linux' },
+  { id: 'aarch64-linux-gnu',  qjs: 'qjs_linux_arm64', qjsc: 'qjsc_linux_arm64', app: `${APP_NAME}_linux_arm64`, libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD', plat: 'linux' },
+  { id: 'aarch64-macos',      qjs: 'qjs_mac_arm',   qjsc: 'qjsc_mac_arm',   app: `${APP_NAME}_mac_arm`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD', plat: 'darwin' },
+  { id: 'x86_64-macos',       qjs: 'qjs_mac_intel', qjsc: 'qjsc_mac_intel', app: `${APP_NAME}_mac_intel`, libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD', plat: 'darwin' }
 ];
 
 // ==========================================================
@@ -129,9 +192,33 @@ const targets = [
 const stubPath = path.join(QUICKJS_DIR, 'repl_stub.c');
 writeFileSync(stubPath, `const unsigned char qjsc_repl[] = {0}; const unsigned int qjsc_repl_size = 0;`);
 
+// Feature optimization flags for qjsc
+const qjscFlags = IS_OPTIMIZED ? '-fno-eval -fno-regexp -fno-proxy -fno-map -fno-typedarray -fno-promise' : '';
+
 targets.forEach(t => {
     console.log(`\n--- Compiling for: ${t.id} ---`);
-    const cmdBase = `${ZIG_PATH} cc -target ${t.id} -I${QUICKJS_DIR} -O2 ${t.cflags} -Wno-ignored-attributes -DCONFIG_VERSION=\\"${VERSION}\\" ${t.libs} -s`;
+
+    // --- PLATFORM SPECIFIC BUILD RESOLUTION ---
+    const PLATFORM_BUILD_DIR = path.join(USER_CWD, 'build', t.id);
+    const inputBaseDir = path.dirname(path.resolve(USER_CWD, INPUT_FILE_RELATIVE));
+
+    if (existsSync(PLATFORM_BUILD_DIR)) {
+        rmSync(PLATFORM_BUILD_DIR, { recursive: true });
+    }
+
+    processDirectory(inputBaseDir, PLATFORM_BUILD_DIR, t.plat);
+
+    const TARGET_INPUT_ABS = path.join(PLATFORM_BUILD_DIR, path.basename(INPUT_FILE_RELATIVE));
+
+    // Dynamic Optimization Flags
+    let optFlags = IS_OPTIMIZED ? '-O3 -flto' : '-O2';
+
+    // -fuse-ld=lld is mandatory for macOS LTO, but causes warnings on other platforms
+    if (IS_OPTIMIZED && t.plat === 'darwin') {
+        optFlags += ' -fuse-ld=lld';
+    }
+
+    const cmdBase = `${ZIG_PATH} cc -target ${t.id} -I${QUICKJS_DIR} ${optFlags} ${t.cflags} -Wno-ignored-attributes -DCONFIG_VERSION=\\"${VERSION}\\" ${t.libs} -s`;
 
     try {
         execSync(`${cmdBase} -o "${path.join(BIN_DIR, t.qjs)}" ${baseSources} ${stubPath} "${path.join(QUICKJS_DIR, 'qjs.c')}"`);
@@ -139,12 +226,12 @@ targets.forEach(t => {
         console.log(`✅ Build tools generated.`);
 
         const tempC = path.join(BIN_DIR, `${t.id}_app.c`);
-        const relativeInput = path.relative(USER_CWD, INPUT_FILE_ABS);
 
-        execSync(`"${hostQjscPath}" -e -o "${tempC}" "${relativeInput}"`, { cwd: USER_CWD });
+        // Use host qjsc to compile the platform-resolved source
+        execSync(`"${hostQjscPath}" ${qjscFlags} -e -o "${tempC}" "${TARGET_INPUT_ABS}"`, { cwd: USER_CWD });
 
         execSync(`${cmdBase} -o "${path.join(DIST_DIR, t.app)}" "${tempC}" ${baseSources} -I${QUICKJS_DIR}`);
-        console.log(`✅ Binary built: ${t.app}`);
+        console.log(`✅ Binary built${IS_OPTIMIZED ? ' and optimized' : ''}: ${t.app}`);
     } catch (e) {
         console.error(`❌ Compilation failed for ${t.id}`);
         console.error(e.stderr?.toString() || e.message);
@@ -172,4 +259,6 @@ binFiles.forEach(file => {
     }
 });
 if (existsSync(stubPath)) unlinkSync(stubPath);
-console.log("🚀 Build process complete.");
+
+console.log(`🚀 Build process complete. (Optimization: ${IS_OPTIMIZED ? 'ON' : 'OFF'})`);
+console.log("Platform sources kept in build/ subfolders.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickjs-zig",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A generic build engine to compile QuickJS scripts into standalone native binaries using Zig for multi-platform cross-compilation.",
   "type": "module",
   "main": "index.mjs",