archiver-node 8.0.0 → 8.0.2

package/cjs/utils.js

@@ -0,0 +1,92 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 utils_exports = {};
+__export(utils_exports, {
+  collectStream: () => collectStream,
+  dateify: () => dateify,
+  normalizeInputSource: () => normalizeInputSource,
+  sanitizePath: () => sanitizePath,
+  trailingSlashIt: () => trailingSlashIt
+});
+module.exports = __toCommonJS(utils_exports);
+var import_normalize_path = __toESM(require("normalize-path"), 1);
+var import_readable_stream = require("readable-stream");
+var import_is_stream = require("is-stream");
+function collectStream(source, callback) {
+  var collection = [];
+  var size = 0;
+  source.on("error", callback);
+  source.on("data", function(chunk) {
+    collection.push(chunk);
+    size += chunk.length;
+  });
+  source.on("end", function() {
+    var buf = Buffer.alloc(size);
+    var offset = 0;
+    collection.forEach(function(data) {
+      data.copy(buf, offset);
+      offset += data.length;
+    });
+    callback(null, buf);
+  });
+}
+function dateify(dateish) {
+  dateish = dateish || /* @__PURE__ */ new Date();
+  if (dateish instanceof Date) {
+    dateish = dateish;
+  } else if (typeof dateish === "string") {
+    dateish = new Date(dateish);
+  } else {
+    dateish = /* @__PURE__ */ new Date();
+  }
+  return dateish;
+}
+function normalizeInputSource(source) {
+  if (source === null) {
+    return Buffer.alloc(0);
+  } else if (typeof source === "string") {
+    return Buffer.from(source);
+  } else if ((0, import_is_stream.isStream)(source, { canOpen: false })) {
+    return source.pipe(new import_readable_stream.PassThrough());
+  }
+  return source;
+}
+function sanitizePath(filepath) {
+  return (0, import_normalize_path.default)(filepath, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
+}
+function trailingSlashIt(str) {
+  return str.slice(-1) !== "/" ? str + "/" : str;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectStream,
+  dateify,
+  normalizeInputSource,
+  sanitizePath,
+  trailingSlashIt
+});

package/index.cjs

@@ -0,0 +1,4 @@
+exports.Archiver = require("./cjs/Archiver.js").default;
+exports.JsonArchive = require("./cjs/archivers/JsonArchive.js").default;
+exports.TarArchive = require("./cjs/archivers/TarArchive.js").default;
+exports.ZipArchive = require("./cjs/archivers/ZipArchive.js").default;

package/index.d.ts

@@ -0,0 +1,138 @@
+// Copy-pasted from `DefinitelyTyped` on 23.02.2026:
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/archiver/index.d.ts
+
+import * as fs from "fs";
+import * as stream from "stream";
+import * as ReaddirGlob from "readdir-glob";
+import { ZlibOptions } from "zlib";
+
+// This library adds `cwd` to the options
+type GlobOptions = ReaddirGlob.Options & { cwd?: string };
+
+interface EntryData {
+	/** Sets the entry name including internal path */
+	name: string;
+	/** Sets the entry date */
+	date?: Date | string | undefined;
+	/** Sets the entry permissions */
+	mode?: number | undefined;
+	/**
+	 * Sets a path prefix for the entry name.
+	 * Useful when working with methods like `directory` or `glob`
+	 */
+	prefix?: string | undefined;
+	/**
+	 * Sets the fs stat data for this entry allowing
+	 * for reduction of fs stat calls when stat data is already known
+	 */
+	stats?: fs.Stats | undefined;
+}
+
+interface ZipEntryData extends EntryData {
+	/** Sets the compression method to STORE */
+	store?: boolean | undefined;
+}
+
+type TarEntryData = EntryData;
+
+interface ProgressData {
+	entries: {
+		total: number;
+		processed: number;
+	};
+	fs: {
+		totalBytes: number;
+		processedBytes: number;
+	};
+}
+
+/** A function that lets you either opt out of including an entry (by returning false), or modify the contents of an entry as it is added (by returning an EntryData) */
+type EntryDataFunction = (entry: EntryData) => false | EntryData;
+
+class ArchiverError extends Error {
+	code: string; // Since archiver format support is modular, we cannot enumerate all possible error codes, as the modules can throw arbitrary ones.
+	data: any;
+	path?: any;
+
+	constructor(code: string, data: any);
+}
+
+type ArchiverOptions = CoreOptions & TransformOptions;
+
+interface CoreOptions {
+	statConcurrency?: number | undefined;
+}
+
+interface TransformOptions {
+	allowHalfOpen?: boolean | undefined;
+	readableObjectMode?: boolean | undefined;
+	writeableObjectMode?: boolean | undefined;
+	decodeStrings?: boolean | undefined;
+	encoding?: string | undefined;
+	highWaterMark?: number | undefined;
+	objectmode?: boolean | undefined;
+}
+
+interface ZipOptions {
+	comment?: string | undefined;
+	forceLocalTime?: boolean | undefined;
+	forceZip64?: boolean | undefined;
+	/** @default false */
+	namePrependSlash?: boolean | undefined;
+	store?: boolean | undefined;
+	zlib?: ZlibOptions | undefined;
+}
+
+interface TarOptions {
+	gzip?: boolean | undefined;
+	gzipOptions?: ZlibOptions | undefined;
+}
+
+export class Archiver extends stream.Transform {
+	_format: string;
+	_module: Module;
+	_supportsDirectory: boolean;
+	_supportsSymlink: boolean;
+	_modulePipe: () => void;
+
+	constructor(options?: ArchiverOptions);
+
+	abort(): this;
+	append(source: stream.Readable | Buffer | string, data?: EntryData | ZipEntryData | TarEntryData): this;
+
+	/** if false is passed for destpath, the path of a chunk of data in the archive is set to the root */
+	directory(dirpath: string, destpath: false | string, data?: Partial<EntryData> | EntryDataFunction): this;
+	file(filename: string, data: EntryData): this;
+	glob(pattern: string, options?: GlobOptions, data?: Partial<EntryData>): this;
+	finalize(): Promise<void>;
+
+	setFormat(format: string): this;
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	setModule(module: Function): this;
+
+	pointer(): number;
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	use(plugin: Function): this;
+
+	symlink(filepath: string, target: string, mode?: number): this;
+
+	on(event: "error" | "warning", listener: (error: ArchiverError) => void): this;
+	on(event: "data", listener: (data: Buffer) => void): this;
+	on(event: "progress", listener: (progress: ProgressData) => void): this;
+	on(event: "close" | "drain" | "finish", listener: () => void): this;
+	on(event: "pipe" | "unpipe", listener: (src: stream.Readable) => void): this;
+	on(event: "entry", listener: (entry: EntryData) => void): this;
+	on(event: string, listener: (...args: any[]) => void): this;
+}
+
+export class ZipArchive extends Archiver {
+	constructor(options?: ArchiverOptions & ZipOptions);
+}
+
+export class TarArchive extends Archiver {
+	constructor(options?: ArchiverOptions & TarOptions);
+}
+
+export class JsonArchive extends Archiver {
+	constructor(options?: ArchiverOptions);
+}

package/index.js

@@ -1,39 +1,4 @@
-import Archiver from "./lib/core.js";
-import Zip from "./lib/plugins/zip.js";
-import Tar from "./lib/plugins/tar.js";
-import Json from "./lib/plugins/json.js";
-
-export { Archiver };
-
-export class ZipArchive extends Archiver {
-  constructor(options) {
-    super(options);
-    this._format = "zip";
-    this._module = new Zip(options);
-    this._supportsDirectory = true;
-    this._supportsSymlink = true;
-    this._modulePipe();
-  }
-}
-
-export class TarArchive extends Archiver {
-  constructor(options) {
-    super(options);
-    this._format = "tar";
-    this._module = new Tar(options);
-    this._supportsDirectory = true;
-    this._supportsSymlink = true;
-    this._modulePipe();
-  }
-}
-
-export class JsonArchive extends Archiver {
-  constructor(options) {
-    super(options);
-    this._format = "json";
-    this._module = new Json(options);
-    this._supportsDirectory = true;
-    this._supportsSymlink = true;
-    this._modulePipe();
-  }
-}
+export { default as Archiver } from "./lib/Archiver.js";
+export { default as JsonArchive } from "./lib/archivers/JsonArchive.js";
+export { default as TarArchive } from "./lib/archivers/TarArchive.js";
+export { default as ZipArchive } from "./lib/archivers/ZipArchive.js";

package/lib/{core.js → Archiver.js}

@@ -1,7 +1,7 @@
 import { createReadStream, lstat, readlinkSync, Stats } from "fs";
 import { isStream } from "is-stream";
 import { readdirGlob } from "readdir-glob";
-import { Readable } from "lazystream";
+import { Readable } from "./lazystream.js";
 import { queue } from "async";
 import {
   dirname,

package/lib/archivers/JsonArchive.js

@@ -0,0 +1,13 @@
+import Archiver from "../Archiver.js";
+import Json from "../plugins/json.js";
+
+export default class JsonArchive extends Archiver {
+  constructor(options) {
+    super(options);
+    this._format = "json";
+    this._module = new Json(options);
+    this._supportsDirectory = true;
+    this._supportsSymlink = true;
+    this._modulePipe();
+  }
+}

package/lib/archivers/TarArchive.js

@@ -0,0 +1,13 @@
+import Archiver from "../Archiver.js";
+import Tar from "../plugins/tar.js";
+
+export default class TarArchive extends Archiver {
+	constructor(options) {
+		super(options);
+		this._format = "tar";
+		this._module = new Tar(options);
+		this._supportsDirectory = true;
+		this._supportsSymlink = true;
+		this._modulePipe();
+	}
+}

package/lib/archivers/ZipArchive.js

@@ -0,0 +1,13 @@
+import Archiver from "../Archiver.js";
+import Zip from "../plugins/zip.js";
+
+export default class ZipArchive extends Archiver {
+	constructor(options) {
+		super(options);
+		this._format = "zip";
+		this._module = new Zip(options);
+		this._supportsDirectory = true;
+		this._supportsSymlink = true;
+		this._modulePipe();
+	}
+}

package/lib/lazystream.js

@@ -0,0 +1,91 @@
+// Copy-pasted from an unmerged pull request in `lazystream` repo on 23.02.2026:
+// https://github.com/jpommerening/node-lazystream/pull/9/changes
+//
+// That pull request fixes the dependency on `readable-stream` library.
+// https://github.com/jpommerening/node-lazystream/issues/7
+// It wasn't merged because it would have to be a "breaking change" in term of Node.js version requirement
+// and also `lazystream` package seems to no longer be maintained anyway.
+
+import { PassThrough } from 'stream';
+
+// Patch the given method of instance so that the callback
+// is executed once, before the actual method is called the
+// first time.
+function beforeFirstCall(instance, method, callback) {
+  instance[method] = function(...args) {
+    delete instance[method];
+    callback.apply(this, args);
+    return this[method].apply(this, args);
+  };
+}
+
+export class Readable extends PassThrough {
+  constructor(fn, options) {
+    super(options);
+
+    // Support calling without new
+    if (!(this instanceof Readable)) {
+      return new Readable(fn, options);
+    }
+
+    beforeFirstCall(this, '_read', function() {
+      const source = fn.call(this, options);
+      const emit = this.emit.bind(this, 'error');
+      source.on('error', emit);
+      source.pipe(this);
+    });
+
+    this.emit('readable');
+  }
+}
+
+export class Writable extends PassThrough {
+  constructor(fn, options) {
+    super(options);
+
+    // Support calling without new
+    if (!(this instanceof Writable)) {
+      return new Writable(fn, options);
+    }
+
+    beforeFirstCall(this, '_write', function() {
+      const destination = fn.call(this, options);
+      const emit = this.emit.bind(this, 'error');
+      destination.on('error', emit);
+      this.pipe(destination);
+    });
+
+    this.emit('writable');
+  }
+}
+
+// An alternative suggested by Google AI:
+//
+// function createLazyReadStream(filePath) {
+//   const passthrough = new PassThrough();
+//   let underlyingStream = null;
+//
+//   // This function is called only when the stream is first consumed (e.g., piped or 'data' event listener added)
+//   const initializeStream = () => {
+//     if (!underlyingStream) {
+//       underlyingStream = fs.createReadStream(filePath);
+//       // Pipe the real stream's data through the passthrough stream
+//       underlyingStream.pipe(passthrough);
+//
+//       // Forward error events
+//       underlyingStream.on('error', (err) => passthrough.emit('error', err));
+//     }
+//   };
+//
+//   // Intercept the 'data' event listener or 'pipe' method to initialize the stream
+//   passthrough.on('newListener', (event) => {
+//     if (event === 'data' || event === 'pipe') {
+//       initializeStream();
+//     }
+//   });
+//
+//   // You also need to handle cases where 'read()' is called directly.
+//   // This is a bit more complex, but the 'newListener' approach covers most common use cases.
+//
+//   return passthrough;
+// }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archiver-node",
-  "version": "8.0.0",
+  "version": "8.0.2",
   "description": "a streaming interface for archive generation",
   "homepage": "https://github.com/catamphetamine/node-archiver",
   "author": {
@@ -16,15 +16,29 @@
   },
   "license": "MIT",
   "type": "module",
-  "exports": "./index.js",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "index.js",
-    "lib"
+    "index.cjs",
+    "index.d.ts",
+    "lib",
+    "cjs"
   ],
   "engines": {
     "node": ">=18"
   },
   "scripts": {
+    "build:clean": "rimraf cjs",
+    "build:cjs": "esbuild lib/**/*.js --outdir=cjs --platform=node --format=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"
   },
@@ -32,7 +46,6 @@
     "async": "^3.2.6",
     "buffer-crc32": "^1.0.0",
     "is-stream": "^4.0.1",
-    "lazystream": "^1.0.1",
     "normalize-path": "^3.0.0",
     "readable-stream": "^4.7.0",
     "readdir-glob": "^2.0.2",
@@ -42,11 +55,13 @@
   "devDependencies": {
     "archiver-jsdoc-theme": "1.1.3",
     "chai": "4.5.0",
+    "esbuild": "^0.27.3",
     "jsdoc": "4.0.4",
     "mkdirp": "3.0.1",
     "mocha": "10.8.2",
+    "npm-run-all": "^4.1.5",
     "prettier": "3.5.3",
-    "rimraf": "5.0.10",
+    "rimraf": "^5.0.10",
     "stream-bench": "0.1.2",
     "tar": "6.2.1",
     "yauzl": "3.2.0"