@nwutils/builder 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nwutils/builder",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Build NW.js applications for Linux, MacOS and Windows.",
   "keywords": [
     "NW.js",
@@ -46,13 +46,13 @@
     "test": "node --test \"../../tests/specs/builder/*.test.js\""
   },
   "dependencies": {
-    "archiver": "^8.0.0",
-    "glob": "^13.0.6",
+    "glob": "^14.0.3",
     "pe-library": "^2.0.1",
     "plist": "^5.0.0",
     "resedit": "^3.1.0",
     "semver": "^7.8.5",
-    "tar": "^7.5.22"
+    "tar": "^7.5.22",
+    "zip-stream": "^7.0.5"
   },
   "devEngines": {
     "runtime": {

package/src/main.js

@@ -4,7 +4,6 @@ import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 
-import { ZipArchive } from "archiver";
 import * as resedit from "resedit";
 // pe-library is a direct dependency of resedit
 import * as peLibrary from "pe-library";
@@ -149,16 +148,7 @@ async function build({
   await fs.promises.mkdir(nwProjectDir, { recursive: true });
 
   if (glob) {
-    for (let file of /** @type {string[]} */ (files)) {
-      const stats = await fs.promises.stat(file);
-      if (stats.isDirectory()) {
-        continue;
-      }
-      await fs.promises.cp(file, path.resolve(nwProjectDir, file), {
-        recursive: true,
-        force: true,
-      });
-    }
+    await util.copyGlobFiles(/** @type {string[]} */ (files), nwProjectDir);
   } else {
     await fs.promises.cp(
       /** @type {string} */ (files),
@@ -404,11 +394,7 @@ const setWinConfig = async ({ app, outDir }) => {
  */
 const compress = async ({ zip, outDir }) => {
   if (zip === true || zip === "zip") {
-    const archive = new ZipArchive();
-    const writeStream = fs.createWriteStream(`${outDir}.zip`);
-    archive.pipe(writeStream);
-    archive.directory(outDir, false);
-    await archive.finalize();
+    await util.zipDirectory(outDir, `${outDir}.zip`);
   } else if (zip === "tar") {
     await tar.create(
       {

package/src/util.js

@@ -1,4 +1,10 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pipeline } from "node:stream/promises";
+
 import * as GlobModule from "glob";
+import ZipStream from "zip-stream";
 
 const PLATFORM_KV = {
   darwin: "osx",
@@ -44,8 +50,166 @@ async function globFiles({ srcDir, glob }) {
   return files;
 }
 
+/**
+ * Recursively list a directory without following symlinks. A directory is
+ * yielded before its contents, and entries are sorted so output is stable.
+ * @param  {string} absDir  - directory to walk
+ * @param  {string} relDir  - path of `absDir` relative to the walk root, using `/`
+ * @returns {AsyncGenerator<{ absolute: string, relative: string, stats: fs.Stats }>}
+ */
+async function* walkDirectory(absDir, relDir) {
+  const names = (await fs.promises.readdir(absDir)).sort();
+  for (const name of names) {
+    const absolute = path.join(absDir, name);
+    const relative = relDir === "" ? name : `${relDir}/${name}`;
+    const stats = await fs.promises.lstat(absolute);
+    yield { absolute, relative, stats };
+    if (stats.isDirectory()) {
+      yield* walkDirectory(absolute, relative);
+    }
+  }
+}
+
+/**
+ * Zip the contents of a directory, so its children sit at the archive root.
+ *
+ * Matches what `archiver`'s `directory(srcDir, false)` produced: directories
+ * get their own entries, symlinks are stored as symlinks (relative to the
+ * link's directory) instead of being followed, and each entry keeps its
+ * permission bits and mtime. Other file types (sockets, FIFOs) are skipped.
+ * @async
+ * @function
+ * @param  {string} srcDir    - directory to compress
+ * @param  {string} destFile  - path of the zip file to write
+ * @returns {Promise<void>}   - resolves once the zip file is fully written
+ */
+async function zipDirectory(srcDir, destFile) {
+  const isWin = process.platform === "win32";
+  const archive = new ZipStream();
+  const written = pipeline(archive, fs.createWriteStream(destFile));
+
+  /**
+   * @param {Buffer | fs.ReadStream} source
+   * @param {import("zip-stream").FileDataInput} data
+   * @returns {Promise<void>}
+   */
+  const addEntry = (source, data) =>
+    new Promise((resolve, reject) => {
+      archive.entry(source, data, (error) =>
+        error ? reject(error) : resolve(),
+      );
+    });
+
+  try {
+    for await (const { absolute, relative, stats } of walkDirectory(
+      srcDir,
+      "",
+    )) {
+      const date = stats.mtime;
+      let mode = stats.mode & (isWin ? 0o777 : 0o7777);
+      if (stats.isFile()) {
+        await addEntry(fs.createReadStream(absolute), {
+          name: relative,
+          type: "file",
+          date,
+          mode,
+        });
+      } else if (stats.isDirectory()) {
+        // stat is unreliable for directories on Windows
+        if (isWin) mode = 0o755;
+        await addEntry(Buffer.alloc(0), {
+          name: `${relative}/`,
+          type: "directory",
+          date,
+          mode,
+        });
+      } else if (stats.isSymbolicLink()) {
+        const linkDir = path.dirname(absolute);
+        const target = await fs.promises.readlink(absolute);
+        const linkname = path
+          .relative(linkDir, path.resolve(linkDir, target))
+          .replace(/\\/g, "/");
+        await addEntry(Buffer.alloc(0), {
+          name: relative,
+          type: "symlink",
+          linkname,
+          date,
+          mode,
+        });
+      }
+    }
+    archive.finalize();
+  } catch (error) {
+    archive.destroy(/** @type {Error} */ (error));
+  }
+  await written;
+}
+
+/**
+ * Copy globbed files into the NW.js project directory.
+ *
+ * In glob mode the current working directory is the app root: each file keeps
+ * its path relative to `cwd`, so `package.json src/**` produces
+ * `package.json` and `src/...` at the top of `destDir`. Absolute matches
+ * inside `cwd` are placed the same way.
+ *
+ * A match outside `cwd` (for example from `../app/**`) has no place in that
+ * layout, so this rejects before copying anything instead of writing files
+ * next to, or outside, `destDir`.
+ * @async
+ * @function
+ * @param  {string[]} files    - paths returned by `globFiles`
+ * @param  {string}   destDir  - NW.js project directory (`package.nw` / `app.nw`)
+ * @param  {string}   [cwd]    - app root the files are relative to
+ * @returns {Promise<void>}
+ */
+async function copyGlobFiles(files, destDir, cwd = process.cwd()) {
+  /** @type {{ src: string, dest: string }[]} */
+  const copies = [];
+  /** @type {string[]} */
+  const outside = [];
+  for (const file of files) {
+    const src = path.resolve(cwd, file);
+    const relative = path.relative(cwd, src);
+    // ".." or "../x" escapes cwd; an absolute result means another drive on Windows.
+    if (
+      relative === ".." ||
+      relative.startsWith(`..${path.sep}`) ||
+      path.isAbsolute(relative)
+    ) {
+      outside.push(file);
+      continue;
+    }
+    copies.push({ src, dest: path.join(destDir, relative) });
+  }
+
+  if (outside.length > 0) {
+    const shown = outside.slice(0, 5).join(", ");
+    const more = outside.length > 5 ? ` and ${outside.length - 5} more` : "";
+    throw new Error(
+      `srcDir glob matched files outside the current working directory (${cwd}): ${shown}${more}. ` +
+        "With glob enabled, paths are kept relative to the current working directory, which becomes the app root, " +
+        "so these files have no place in the build. Run nwbuild from the app directory, " +
+        'or set glob to false and srcDir to the app directory (for example srcDir: "../app").',
+    );
+  }
+
+  for (const { src, dest } of copies) {
+    const stats = await fs.promises.stat(src);
+    if (stats.isDirectory()) {
+      continue;
+    }
+    await fs.promises.cp(src, dest, {
+      recursive: true,
+      force: true,
+    });
+  }
+}
+
 export default {
   PLATFORM_KV,
   ARCH_KV,
   globFiles,
+  zipDirectory,
+  copyGlobFiles,
 };

package/types/main.d.ts

@@ -230,7 +230,7 @@ export type BuildOptions = {
     /**
      * Target arch
      */
-    arch?: "x64" | "ia32" | "arm64" | undefined;
+    arch?: "arm64" | "ia32" | "x64" | undefined;
     /**
      * Versions manifest URI, https or file path
      */

package/types/util.d.ts

@@ -2,6 +2,8 @@ declare namespace _default {
     export { PLATFORM_KV };
     export { ARCH_KV };
     export { globFiles };
+    export { zipDirectory };
+    export { copyGlobFiles };
 }
 export default _default;
 declare namespace PLATFORM_KV {
@@ -27,3 +29,36 @@ declare function globFiles({ srcDir, glob }: {
     srcDir: string | string[];
     glob: boolean;
 }): Promise<string[] | string>;
+/**
+ * Zip the contents of a directory, so its children sit at the archive root.
+ *
+ * Matches what `archiver`'s `directory(srcDir, false)` produced: directories
+ * get their own entries, symlinks are stored as symlinks (relative to the
+ * link's directory) instead of being followed, and each entry keeps its
+ * permission bits and mtime. Other file types (sockets, FIFOs) are skipped.
+ * @async
+ * @function
+ * @param  {string} srcDir    - directory to compress
+ * @param  {string} destFile  - path of the zip file to write
+ * @returns {Promise<void>}   - resolves once the zip file is fully written
+ */
+declare function zipDirectory(srcDir: string, destFile: string): Promise<void>;
+/**
+ * Copy globbed files into the NW.js project directory.
+ *
+ * In glob mode the current working directory is the app root: each file keeps
+ * its path relative to `cwd`, so `package.json src/**` produces
+ * `package.json` and `src/...` at the top of `destDir`. Absolute matches
+ * inside `cwd` are placed the same way.
+ *
+ * A match outside `cwd` (for example from `../app/**`) has no place in that
+ * layout, so this rejects before copying anything instead of writing files
+ * next to, or outside, `destDir`.
+ * @async
+ * @function
+ * @param  {string[]} files    - paths returned by `globFiles`
+ * @param  {string}   destDir  - NW.js project directory (`package.nw` / `app.nw`)
+ * @param  {string}   [cwd]    - app root the files are relative to
+ * @returns {Promise<void>}
+ */
+declare function copyGlobFiles(files: string[], destDir: string, cwd?: string): Promise<void>;