quickjs-zig 1.0.2 → 1.0.4

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,8 +1,8 @@
 import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
 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';
 
 // --- PATH CONFIGURATION ---
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -24,19 +24,36 @@ if (!existsSync(USER_PKG_PATH)) {
 
 const userPackageJson = JSON.parse(readFileSync(USER_PKG_PATH, 'utf8'));
 const customModules = userPackageJson.quickJs?.modules || {};
+
+for (const [name, relativePath] of Object.entries(customModules)) {
+    const absolutePath = path.resolve(USER_CWD, relativePath);
+    if (!existsSync(absolutePath)) {
+        console.error(`\n❌ Error: Custom module "${name}" source file not found!`);
+        console.error(`   Expected path: ${absolutePath}`);
+        console.error(`   Please check your package.json configuration.`);
+        process.exit(1);
+    }
+}
+
 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';
 
 /**
  * Recursively scan and transform imports to platform-specific ones.
- * Filters out files from other platforms and prevents duplicates.
+ * 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 });
 
-    readdirSync(currentDir).forEach(file => {
+    const filesInSource = readdirSync(currentDir);
+
+    filesInSource.forEach(file => {
         const fullPath = path.join(currentDir, file);
         const destPath = path.join(targetDir, file);
 
@@ -56,17 +73,18 @@ function processDirectory(currentDir, targetDir, targetPlat) {
                 return;
             }
 
-            // 2. If it's a generic file, skip it if a platform-specific version exists in the same folder
+            // 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 (readdirSync(currentDir).includes(specFile)) {
+                if (filesInSource.includes(specFile)) {
                     return;
                 }
             }
 
             let content = readFileSync(fullPath, 'utf8');
 
-            // 3. Transform generic imports to platform-specific ones if they exist
+            // 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);
@@ -185,8 +203,11 @@ 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} (Suffix: ${t.plat}) ---`);
+    console.log(`\n--- Compiling for: ${t.id} ---`);
 
     // --- PLATFORM SPECIFIC BUILD RESOLUTION ---
     const PLATFORM_BUILD_DIR = path.join(USER_CWD, 'build', t.id);
@@ -200,7 +221,10 @@ targets.forEach(t => {
 
     const TARGET_INPUT_ABS = path.join(PLATFORM_BUILD_DIR, path.basename(INPUT_FILE_RELATIVE));
 
-    const cmdBase = `${ZIG_PATH} cc -target ${t.id} -I${QUICKJS_DIR} -O2 ${t.cflags} -Wno-ignored-attributes -DCONFIG_VERSION=\\"${VERSION}\\" ${t.libs} -s`;
+    // Dynamic Optimization Flags
+    let optFlags = IS_OPTIMIZED && 'darwin' !== t.plat ? '-O3 -flto' : '-O2';
+
+    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')}"`);
@@ -209,11 +233,11 @@ targets.forEach(t => {
 
         const tempC = path.join(BIN_DIR, `${t.id}_app.c`);
 
-        // Use host qjsc to compile the platform-specific source
-        execSync(`"${hostQjscPath}" -e -o "${tempC}" "${TARGET_INPUT_ABS}"`, { 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);
@@ -242,4 +266,5 @@ binFiles.forEach(file => {
 });
 if (existsSync(stubPath)) unlinkSync(stubPath);
 
-console.log("🚀 Build process complete. Platform sources kept in build/ subfolders.");
+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.2",
+  "version": "1.0.4",
   "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",