archiver-node 8.0.1 → 8.0.3

package/cjs/Archiver.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Archiver_exports = {};
 __export(Archiver_exports, {
@@ -22,14 +32,15 @@ __export(Archiver_exports, {
 module.exports = __toCommonJS(Archiver_exports);
 var import_fs = require("fs");
 var import_is_stream = require("is-stream");
-var import_readdir_glob = require("readdir-glob");
+var import_readdir_glob = __toESM(require("readdir-glob"), 1);
 var import_lazystream = require("./lazystream.js");
 var import_async = require("async");
 var import_path = require("path");
 var import_error = require("./error.js");
 var import_readable_stream = require("readable-stream");
 var import_utils = require("./utils.js");
-const { ReaddirGlob } = import_readdir_glob.readdirGlob;
+const readdirGlob = import_readdir_glob.default || import_readdir_glob.readdirGlob;
+const { ReaddirGlob } = readdirGlob;
 const win32 = process.platform === "win32";
 class Archiver extends import_readable_stream.Transform {
   _supportsDirectory = false;
@@ -589,7 +600,7 @@ class Archiver extends import_readable_stream.Transform {
       }
       this._append(match.absolute, entryData);
     }
-    const globber = (0, import_readdir_glob.readdirGlob)(dirpath, globOptions);
+    const globber = readdirGlob(dirpath, globOptions);
     globber.on("error", onGlobError.bind(this));
     globber.on("match", onGlobMatch.bind(this));
     globber.on("end", onGlobEnd.bind(this));

package/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "archiver-node/cjs",
+  "type": "commonjs",
+  "private": true
+}

package/lib/Archiver.js

@@ -1,6 +1,11 @@
 import { createReadStream, lstat, readlinkSync, Stats } from "fs";
 import { isStream } from "is-stream";
-import { readdirGlob } from "readdir-glob";
+// `readdir-glob` has different exports in `esm` and `cjs`:
+// in `esm` it's a named export but in `cjs` it's a default export.
+// https://github.com/Yqnn/node-readdir-glob/issues/28
+// As a result, this package's code can't be transpiled properly.
+// Copy-pasted `readdir-glob` code here to fix that.
+import{ readdirGlob } from "./readdir-glob.js";
 import { Readable } from "./lazystream.js";
 import { queue } from "async";
 import {

package/lib/readdir-glob.js

@@ -0,0 +1,216 @@
+// `readdir-glob` has different exports in `esm` and `cjs`:
+// in `esm` it's a named export but in `cjs` it's a default export.
+// https://github.com/Yqnn/node-readdir-glob/issues/28
+// As a result, this package's code can't be transpiled properly.
+// Copy-pasted `readdir-glob` code here to fix that.
+
+// Converted TypeScript to Javascript on TypeScript website:
+// https://www.typescriptlang.org/play/?target=9#
+
+import * as fs from 'fs';
+import { EventEmitter } from 'events';
+import { Minimatch } from 'minimatch';
+import { resolve } from 'path';
+function readdir(dir, strict) {
+    return new Promise((resolve, reject) => {
+        fs.readdir(dir, { withFileTypes: true }, (err, files) => {
+            if (err) {
+                switch (err.code) {
+                    case 'ENOTDIR': // Not a directory
+                        if (strict) {
+                            reject(err);
+                        }
+                        else {
+                            resolve([]);
+                        }
+                        break;
+                    case 'ENOTSUP': // Operation not supported
+                    case 'ENOENT': // No such file or directory
+                    case 'ENAMETOOLONG': // Filename too long
+                    case 'UNKNOWN':
+                        resolve([]);
+                        break;
+                    case 'ELOOP': // Too many levels of symbolic links
+                    default:
+                        reject(err);
+                        break;
+                }
+            }
+            else {
+                resolve(files);
+            }
+        });
+    });
+}
+function getStat(file, followSymlinks) {
+    return new Promise((resolve) => {
+        const statFunc = followSymlinks ? fs.stat : fs.lstat;
+        statFunc(file, (err, stats) => {
+            if (err) {
+                switch (err.code) {
+                    case 'ENOENT':
+                        if (followSymlinks) {
+                            // Fallback to lstat to handle broken links as files
+                            resolve(getStat(file, false));
+                        }
+                        else {
+                            resolve(null);
+                        }
+                        break;
+                    default:
+                        resolve(null);
+                        break;
+                }
+            }
+            else {
+                resolve(stats);
+            }
+        });
+    });
+}
+async function* exploreWalkAsync(dir, path, followSymlinks, useStat, shouldSkip, strict) {
+    let files = await readdir(path + dir, strict);
+    for (const file of files) {
+        let name = file.name;
+        const filename = dir + '/' + name;
+        const relative = filename.slice(1); // Remove the leading /
+        const absolute = path + '/' + relative;
+        let stat = file;
+        if (useStat || followSymlinks) {
+            stat = await getStat(absolute, followSymlinks) ?? stat;
+        }
+        if (stat.isDirectory()) {
+            if (!shouldSkip(relative)) {
+                yield { relative, absolute, stat };
+                yield* exploreWalkAsync(filename, path, followSymlinks, useStat, shouldSkip, false);
+            }
+        }
+        else {
+            yield { relative, absolute, stat };
+        }
+    }
+}
+async function* explore(path, followSymlinks, useStat, shouldSkip) {
+    yield* exploreWalkAsync('', path, followSymlinks, useStat, shouldSkip, true);
+}
+function readOptions(options) {
+    return {
+        pattern: options.pattern,
+        dot: !!options.dot,
+        noglobstar: !!options.noglobstar,
+        matchBase: !!options.matchBase,
+        nocase: !!options.nocase,
+        ignore: options.ignore,
+        skip: options.skip,
+        follow: !!options.follow,
+        stat: !!options.stat,
+        nodir: !!options.nodir,
+        mark: !!options.mark,
+        silent: !!options.silent,
+        absolute: !!options.absolute
+    };
+}
+export class ReaddirGlob extends EventEmitter {
+    constructor(cwd, options, cb) {
+        super();
+        if (typeof options === 'function') {
+            cb = options;
+            options = undefined;
+        }
+        this.options = readOptions(options || {});
+        this.matchers = [];
+        if (this.options.pattern) {
+            const matchers = Array.isArray(this.options.pattern) ? this.options.pattern : [this.options.pattern];
+            this.matchers = matchers.map(m => new Minimatch(m, {
+                dot: this.options.dot,
+                noglobstar: this.options.noglobstar,
+                matchBase: this.options.matchBase,
+                nocase: this.options.nocase
+            }));
+        }
+        this.ignoreMatchers = [];
+        if (this.options.ignore) {
+            const ignorePatterns = Array.isArray(this.options.ignore) ? this.options.ignore : [this.options.ignore];
+            this.ignoreMatchers = ignorePatterns.map(ignore => new Minimatch(ignore, { dot: true }));
+        }
+        this.skipMatchers = [];
+        if (this.options.skip) {
+            const skipPatterns = Array.isArray(this.options.skip) ? this.options.skip : [this.options.skip];
+            this.skipMatchers = skipPatterns.map(skip => new Minimatch(skip, { dot: true }));
+        }
+        this.iterator = explore(resolve(cwd || '.'), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
+        this.paused = false;
+        this.inactive = false;
+        this.aborted = false;
+        if (cb) {
+            const nonNullCb = cb;
+            const matches = [];
+            this.on('match', match => matches.push(this.options.absolute ? match.absolute : match.relative));
+            this.on('error', err => nonNullCb(err));
+            this.on('end', () => nonNullCb(null, matches));
+        }
+        setTimeout(() => this._next());
+    }
+    _shouldSkipDirectory(relative) {
+        return this.skipMatchers.some(m => m.match(relative));
+    }
+    _fileMatches(relative, isDirectory) {
+        const file = relative + (isDirectory ? '/' : '');
+        return (this.matchers.length === 0 || this.matchers.some(m => m.match(file)))
+            && !this.ignoreMatchers.some(m => m.match(file))
+            && (!this.options.nodir || !isDirectory);
+    }
+    _next() {
+        if (!this.paused && !this.aborted) {
+            this.iterator.next()
+                .then((obj) => {
+                if (!obj.done) {
+                    const isDirectory = obj.value.stat.isDirectory();
+                    if (this._fileMatches(obj.value.relative, isDirectory)) {
+                        let relative = obj.value.relative;
+                        let absolute = obj.value.absolute;
+                        if (this.options.mark && isDirectory) {
+                            relative += '/';
+                            absolute += '/';
+                        }
+                        if (this.options.stat) {
+                            this.emit('match', { relative, absolute, stat: obj.value.stat });
+                        }
+                        else {
+                            this.emit('match', { relative, absolute });
+                        }
+                    }
+                    this._next();
+                }
+                else {
+                    this.emit('end');
+                }
+            })
+                .catch((err) => {
+                this.abort();
+                this.emit('error', err);
+                if (!err.code && !this.options.silent) {
+                    console.error(err);
+                }
+            });
+        }
+        else {
+            this.inactive = true;
+        }
+    }
+    abort() {
+        this.aborted = true;
+    }
+    pause() {
+        this.paused = true;
+    }
+    resume() {
+        this.paused = false;
+        if (this.inactive) {
+            this.inactive = false;
+            this._next();
+        }
+    }
+}
+export const readdirGlob = (pattern, options, cb) => new ReaddirGlob(pattern, options, cb);
+readdirGlob.ReaddirGlob = ReaddirGlob;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archiver-node",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "description": "a streaming interface for archive generation",
   "homepage": "https://github.com/catamphetamine/node-archiver",
   "author": {
@@ -37,7 +37,8 @@
   "scripts": {
     "build:clean": "rimraf cjs",
     "build:cjs": "esbuild lib/**/*.js --outdir=cjs --platform=node --format=cjs",
-    "build": "npm-run-all build:clean build:cjs",
+    "build:cjs:package.json": "node scripts/create-commonjs-package-json.js",
+    "build": "npm-run-all build:clean build:cjs build:cjs:package.json",
     "test": "mocha --reporter dot",
     "bench": "node benchmark/simple/pack-zip.js"
   },
@@ -45,6 +46,7 @@
     "async": "^3.2.6",
     "buffer-crc32": "^1.0.0",
     "is-stream": "^4.0.1",
+    "minimatch": "^10.2.2",
     "normalize-path": "^3.0.0",
     "readable-stream": "^4.7.0",
     "readdir-glob": "^2.0.2",