archiver-node 8.0.4 → 8.0.6

package/cjs/exports/zip.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ZipArchive = _interopRequireDefault(require("../archivers/ZipArchive.js"));
+var _stream = _interopRequireWildcard(require("stream"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // `WritableStream` doesn't work well with `archiver`.
+// It breaks in certain cases. Use `PassThrough` stream instead.
+// https://github.com/archiverjs/node-archiver/issues/336
+// https://github.com/catamphetamine/archiver-bug
+// import { WritableStream } from 'memory-streams'
+var ZipArchive = exports["default"] = /*#__PURE__*/function () {
+  /**
+   * @param {object} [options] — Node.js `zlib` options such as compression level. https://nodejs.org/api/zlib. Example: `{ zlib: { level: 9 } }`.
+   */
+  function ZipArchive(options) {
+    var _this = this;
+    _classCallCheck(this, ZipArchive);
+    // this._outputStream = new WritableStream()
+    this._outputStream = new _stream.PassThrough();
+    var archive = new _ZipArchive["default"](options);
+    this._archive = archive;
+
+    // `archive` has a `.pipe()` method which kinda makes it usable as a readable stream.
+    // Although it's still not a "proper" implementation of a `Readable` stream.
+    // https://github.com/archiverjs/node-archiver/issues/765
+    // To get a "proper" implementation of a `Readable` stream, people use a workaround:
+    // `const passThroughStream = new PassThrough()` and then `archive.pipe(passThroughStream)`.
+
+    // An alternative way of how to create a `ReadableStream` from an `archive`.
+    // https://github.com/archiverjs/node-archiver/issues/759
+    //
+    // const readableStream = new ReadableStream({
+    //   start(controller) {
+    //     archive.on('data', chunk => controller.enqueue(chunk));
+    //     archive.on('end', () => controller.close());
+    //     archive.on('error', error => controller.error(error));
+    //
+    //     archive.append(...);
+    //     archive.append(...);
+    //     archive.finalize();
+    //   }
+    // });
+
+    // The size of the resulting archive (in bytes).
+    // Is `undefined` until the archive has been written.
+    this.size = undefined;
+
+    // A `Promise<void>` that resolves when the archive has been written.
+    this.promise = new Promise(function (resolve, reject) {
+      // Listens for all archive data to be written.
+      // 'close' event is fired when all data has been written.
+      _this._outputStream.on('close', function () {
+        _this.size = archive.pointer();
+        resolve();
+      });
+
+      // // Listens for all archive data to be written.
+      // // `end` event is fired when all archive data has been consumed by a consumer stream.
+      // // @see: https://nodejs.org/api/stream.html#stream_event_end
+      // archive.on('end', function() {
+      //   this.size = archive.pointer()
+      //   resolve()
+      // })
+
+      // Catch "warnings", whatever those're.
+      archive.on('warning', function (error) {
+        reject(error);
+        // The following code sample is from `archiver` README:
+        // if (error.code === 'ENOENT') {
+        //   // `ENOENT` errors happen when a file or folder doesn't exist.
+        //   // It's not clear what are the cases when it could happen.
+        //   // And it's not clear why they're dismissed as unimportant here.
+        //   console.warn(error)
+        // } else {
+        //   reject(error)
+        // }
+      });
+
+      // Catch errors.
+      archive.on('error', reject);
+
+      // Pipe archive data to the output stream.
+      archive.pipe(_this._outputStream);
+    });
+  }
+
+  /**
+   * @param {(stream.Readable|Buffer|string)} content
+   * @param {string} internalPath — Path inside the archive
+   */
+  return _createClass(ZipArchive, [{
+    key: "add",
+    value: function add(content, internalPath) {
+      if (content instanceof _stream["default"]) {
+        // `Stream` is allowed.
+      } else if (content instanceof Buffer) {
+        // `Buffer` is allowed.
+      } else if (typeof content === 'string') {
+        // `string` is allowed.
+      } else {
+        var message = 'Unsupported type of content attempted to be added to a .zip archive';
+        console.log(message + ':');
+        console.log(content);
+        throw new Error(message);
+      }
+      this._archive.append(content, {
+        name: internalPath
+      });
+    }
+
+    /**
+     * @param {string} pathToFile — Path to file in the filesystem
+     * @param {string} internalPath — Path inside the archive
+     */
+  }, {
+    key: "includeFile",
+    value: function includeFile(pathToFile, internalPath) {
+      this._archive.file(pathToFile, {
+        name: internalPath
+      });
+    }
+
+    /**
+     * @param {string} pathToDirectory — Path to directory in the filesystem.
+     * @param {string} filePathPattern — File path "glob" pattern. Example: "file*.txt".
+     */
+  }, {
+    key: "includeFilesByMatch",
+    value: function includeFilesByMatch(pathToDirectory, filePathPattern) {
+      this._archive.glob(filePathPattern, {
+        cwd: pathToDirectory
+      });
+    }
+
+    /**
+     * @param {string} pathToDirectory — Path to directory in the filesystem
+     * @param {string} [internalPath] — Path inside the archive. Omitting this argument will put the contents of the directory to the root of the archive.
+     */
+  }, {
+    key: "includeDirectory",
+    value: function includeDirectory(pathToDirectory, internalPath) {
+      this._archive.directory(pathToDirectory, internalPath || false);
+    }
+
+    /**
+     * Starts the process of writing the archive file data.
+     * @returns {stream.Readable}
+     */
+  }, {
+    key: "write",
+    value: function write() {
+      // `.finalize()` starts the process of writing the archive file.
+      //
+      // `.finalize()` also returns some kind of `Promise` but it's some kind of a weird one
+      // and is not meant to be `await`ed or anything like that.
+      // https://github.com/archiverjs/node-archiver/issues/772
+      //
+      // "close", "end" or "finish" events may be fired on `this._archive`
+      // right after calling this method, so any required event handlers
+      // should have been added beforehand.
+      //
+      this._archive.finalize();
+
+      // Returns a readable `Stream` with the `.zip` archive data.
+      return this._outputStream;
+    }
+  }]);
+}();

package/index.d.ts

@@ -73,7 +73,7 @@ interface TransformOptions {
 	objectmode?: boolean | undefined;
 }
 
-interface ZipOptions {
+export interface ZipOptions {
 	comment?: string | undefined;
 	forceLocalTime?: boolean | undefined;
 	forceZip64?: boolean | undefined;

package/lib/Archiver.js

@@ -1,11 +1,6 @@
 import { createReadStream, lstat, readlinkSync, Stats } from "fs";
 import { isStream } from "is-stream";
-// `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 readdirGlob from "readdir-glob";
 import { Readable } from "./lazystream.js";
 import { queue } from "async";
 import {

package/lib/archivers/TarArchive.js

@@ -2,12 +2,12 @@ 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();
-	}
+  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

@@ -2,12 +2,12 @@ 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();
-	}
+  constructor(options) {
+    super(options);
+    this._format = "zip";
+    this._module = new Zip(options);
+    this._supportsDirectory = true;
+    this._supportsSymlink = true;
+    this._modulePipe();
+  }
 }

package/lib/exports/zip.js

@@ -0,0 +1,151 @@
+import ZipArchive_ from '../archivers/ZipArchive.js'
+
+// `WritableStream` doesn't work well with `archiver`.
+// It breaks in certain cases. Use `PassThrough` stream instead.
+// https://github.com/archiverjs/node-archiver/issues/336
+// https://github.com/catamphetamine/archiver-bug
+// import { WritableStream } from 'memory-streams'
+
+import Stream, { PassThrough } from 'stream'
+
+export default class ZipArchive {
+  /**
+   * @param {object} [options] — Node.js `zlib` options such as compression level. https://nodejs.org/api/zlib. Example: `{ zlib: { level: 9 } }`.
+   */
+  constructor(options) {
+    // this._outputStream = new WritableStream()
+    this._outputStream = new PassThrough()
+
+    const archive = new ZipArchive_(options)
+
+    this._archive = archive
+
+    // `archive` has a `.pipe()` method which kinda makes it usable as a readable stream.
+    // Although it's still not a "proper" implementation of a `Readable` stream.
+    // https://github.com/archiverjs/node-archiver/issues/765
+    // To get a "proper" implementation of a `Readable` stream, people use a workaround:
+    // `const passThroughStream = new PassThrough()` and then `archive.pipe(passThroughStream)`.
+
+    // An alternative way of how to create a `ReadableStream` from an `archive`.
+    // https://github.com/archiverjs/node-archiver/issues/759
+    //
+    // const readableStream = new ReadableStream({
+    //   start(controller) {
+    //     archive.on('data', chunk => controller.enqueue(chunk));
+    //     archive.on('end', () => controller.close());
+    //     archive.on('error', error => controller.error(error));
+    //
+    //     archive.append(...);
+    //     archive.append(...);
+    //     archive.finalize();
+    //   }
+    // });
+
+    // The size of the resulting archive (in bytes).
+    // Is `undefined` until the archive has been written.
+    this.size = undefined
+
+    // A `Promise<void>` that resolves when the archive has been written.
+    this.promise = new Promise((resolve, reject) => {
+      // Listens for all archive data to be written.
+      // 'close' event is fired when all data has been written.
+      this._outputStream.on('close', () => {
+        this.size = archive.pointer()
+        resolve()
+      })
+
+      // // Listens for all archive data to be written.
+      // // `end` event is fired when all archive data has been consumed by a consumer stream.
+      // // @see: https://nodejs.org/api/stream.html#stream_event_end
+      // archive.on('end', function() {
+      //   this.size = archive.pointer()
+      //   resolve()
+      // })
+
+      // Catch "warnings", whatever those're.
+      archive.on('warning', function(error) {
+        reject(error)
+        // The following code sample is from `archiver` README:
+        // if (error.code === 'ENOENT') {
+        //   // `ENOENT` errors happen when a file or folder doesn't exist.
+        //   // It's not clear what are the cases when it could happen.
+        //   // And it's not clear why they're dismissed as unimportant here.
+        //   console.warn(error)
+        // } else {
+        //   reject(error)
+        // }
+      })
+
+      // Catch errors.
+      archive.on('error', reject)
+
+      // Pipe archive data to the output stream.
+      archive.pipe(this._outputStream)
+    })
+  }
+
+  /**
+   * @param {(stream.Readable|Buffer|string)} content
+   * @param {string} internalPath — Path inside the archive
+   */
+  add(content, internalPath) {
+    if (content instanceof Stream) {
+      // `Stream` is allowed.
+    } else if (content instanceof Buffer) {
+      // `Buffer` is allowed.
+    } else if (typeof content === 'string') {
+      // `string` is allowed.
+    } else {
+      const message = 'Unsupported type of content attempted to be added to a .zip archive'
+      console.log(message + ':')
+      console.log(content)
+      throw new Error(message)
+    }
+    this._archive.append(content, { name: internalPath })
+  }
+
+  /**
+   * @param {string} pathToFile — Path to file in the filesystem
+   * @param {string} internalPath — Path inside the archive
+   */
+  includeFile(pathToFile, internalPath) {
+    this._archive.file(pathToFile, { name: internalPath })
+  }
+
+  /**
+   * @param {string} pathToDirectory — Path to directory in the filesystem.
+   * @param {string} filePathPattern — File path "glob" pattern. Example: "file*.txt".
+   */
+  includeFilesByMatch(pathToDirectory, filePathPattern) {
+    this._archive.glob(filePathPattern, { cwd: pathToDirectory })
+  }
+
+  /**
+   * @param {string} pathToDirectory — Path to directory in the filesystem
+   * @param {string} [internalPath] — Path inside the archive. Omitting this argument will put the contents of the directory to the root of the archive.
+   */
+  includeDirectory(pathToDirectory, internalPath) {
+    this._archive.directory(pathToDirectory, internalPath || false);
+  }
+
+  /**
+   * Starts the process of writing the archive file data.
+   * @returns {stream.Readable}
+   */
+  write() {
+    // `.finalize()` starts the process of writing the archive file.
+    //
+    // `.finalize()` also returns some kind of `Promise` but it's some kind of a weird one
+    // and is not meant to be `await`ed or anything like that.
+    // https://github.com/archiverjs/node-archiver/issues/772
+    //
+    // "close", "end" or "finish" events may be fired on `this._archive`
+    // right after calling this method, so any required event handlers
+    // should have been added beforehand.
+    //
+    this._archive.finalize()
+
+    // Returns a readable `Stream` with the `.zip` archive data.
+    return this._outputStream
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archiver-node",
-  "version": "8.0.4",
+  "version": "8.0.6",
   "description": "a streaming interface for archive generation",
   "homepage": "https://github.com/catamphetamine/node-archiver",
   "author": {
@@ -24,13 +24,6 @@
     },
     "./package.json": "./package.json"
   },
-  "files": [
-    "index.js",
-    "index.cjs",
-    "index.d.ts",
-    "lib",
-    "cjs"
-  ],
   "engines": {
     "node": ">=18"
   },
@@ -49,7 +42,7 @@
     "minimatch": "^10.2.2",
     "normalize-path": "^3.0.0",
     "readable-stream": "^4.7.0",
-    "readdir-glob": "^2.0.2",
+    "readdir-glob": "^3.0.0",
     "tar-stream": "^3.1.7",
     "zip-stream": "^7.0.2"
   },

package/zip/index.cjs

@@ -0,0 +1 @@
+module.exports = require("../cjs/exports/zip.js").default;

package/zip/index.d.ts

@@ -0,0 +1,14 @@
+import * as stream from 'stream'
+
+import { ZipOptions } from '../index.d.js';
+
+export default class ZipArchive {
+	constructor(options?: ZipOptions);
+	add(content: stream.Readable | Buffer | string, internalPath: string): void;
+	includeFile(pathToFile: string, internalPath: string): void;
+	includeFilesByMatch(pathToDirectory: string, filePathPattern: string): void;
+	includeDirectory(pathToDirectory: string, internalPath?: string): void;
+	write(): stream.Readable;
+	promise: Promise<void>;
+	size?: number;
+}

package/zip/index.js

@@ -0,0 +1 @@
+export { default } from "../lib/exports/zip.js";

package/zip/package.json

@@ -0,0 +1,14 @@
+{
+  "private": true,
+  "name": "archiver-node/zip",
+  "version": "1.0.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    }
+  },
+  "sideEffects": false
+}