@alienkarma/archiver 7.0.1-fork.1

package/lib/error.js

@@ -0,0 +1,37 @@
+import util from "util";
+
+const ERROR_CODES = {
+  ABORTED: "archive was aborted",
+  DIRECTORYDIRPATHREQUIRED:
+    "diretory dirpath argument must be a non-empty string value",
+  DIRECTORYFUNCTIONINVALIDDATA:
+    "invalid data returned by directory custom data function",
+  ENTRYNAMEREQUIRED: "entry name must be a non-empty string value",
+  FILEFILEPATHREQUIRED:
+    "file filepath argument must be a non-empty string value",
+  FINALIZING: "archive already finalizing",
+  QUEUECLOSED: "queue closed",
+  NOENDMETHOD: "no suitable finalize/end method defined by module",
+  DIRECTORYNOTSUPPORTED: "support for directory entries not defined by module",
+  FORMATSET: "archive format already set",
+  INPUTSTEAMBUFFERREQUIRED:
+    "input source must be valid Stream or Buffer instance",
+  MODULESET: "module already set",
+  SYMLINKNOTSUPPORTED: "support for symlink entries not defined by module",
+  SYMLINKFILEPATHREQUIRED:
+    "symlink filepath argument must be a non-empty string value",
+  SYMLINKTARGETREQUIRED:
+    "symlink target argument must be a non-empty string value",
+  ENTRYNOTSUPPORTED: "entry not supported",
+};
+
+function ArchiverError(code, data) {
+  Error.captureStackTrace(this, this.constructor);
+  //this.name = this.constructor.name;
+  this.message = ERROR_CODES[code] || code;
+  this.code = code;
+  this.data = data;
+}
+util.inherits(ArchiverError, Error);
+
+export { ArchiverError };

package/lib/plugins/json.js

@@ -0,0 +1,79 @@
+import { Transform } from "readable-stream";
+import crc32 from "buffer-crc32";
+import { collectStream } from "../utils.js";
+
+/**
+ * JSON Format Plugin
+ *
+ * @module plugins/json
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+export default class Json extends Transform {
+  /**
+   * @constructor
+   * @param {(JsonOptions|TransformOptions)} options
+   */
+  constructor(options) {
+    super({ ...options });
+    this.files = [];
+  }
+  /**
+   * [_transform description]
+   *
+   * @private
+   * @param  {Buffer}   chunk
+   * @param  {String}   encoding
+   * @param  {Function} callback
+   * @return void
+   */
+  _transform(chunk, encoding, callback) {
+    callback(null, chunk);
+  }
+  /**
+   * [_writeStringified description]
+   *
+   * @private
+   * @return void
+   */
+  _writeStringified() {
+    var fileString = JSON.stringify(this.files);
+    this.write(fileString);
+  }
+  /**
+   * [append description]
+   *
+   * @param  {(Buffer|Stream)}   source
+   * @param  {EntryData}   data
+   * @param  {Function} callback
+   * @return void
+   */
+  append(source, data, callback) {
+    var self = this;
+    data.crc32 = 0;
+    function onend(err, sourceBuffer) {
+      if (err) {
+        callback(err);
+        return;
+      }
+      data.size = sourceBuffer.length || 0;
+      data.crc32 = crc32.unsigned(sourceBuffer);
+      self.files.push(data);
+      callback(null, data);
+    }
+    if (data.sourceType === "buffer") {
+      onend(null, source);
+    } else if (data.sourceType === "stream") {
+      collectStream(source, onend);
+    }
+  }
+  /**
+   * [finalize description]
+   *
+   * @return void
+   */
+  finalize() {
+    this._writeStringified();
+    this.end();
+  }
+}

package/lib/plugins/tar.js

@@ -0,0 +1,118 @@
+import zlib from "zlib";
+import engine from "tar-stream";
+import { collectStream } from "../utils.js";
+
+/**
+ * TAR Format Plugin
+ *
+ * @module plugins/tar
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+export default class Tar {
+  /**
+   * @constructor
+   * @param {TarOptions} options
+   */
+  constructor(options) {
+    options = this.options = {
+      gzip: false,
+      ...options,
+    };
+    if (typeof options.gzipOptions !== "object") {
+      options.gzipOptions = {};
+    }
+    this.engine = engine.pack(options);
+    this.compressor = false;
+    if (options.gzip) {
+      this.compressor = zlib.createGzip(options.gzipOptions);
+      this.compressor.on("error", this._onCompressorError.bind(this));
+    }
+  }
+  /**
+   * [_onCompressorError description]
+   *
+   * @private
+   * @param  {Error} err
+   * @return void
+   */
+  _onCompressorError(err) {
+    this.engine.emit("error", err);
+  }
+  /**
+   * [append description]
+   *
+   * @param  {(Buffer|Stream)} source
+   * @param  {TarEntryData} data
+   * @param  {Function} callback
+   * @return void
+   */
+  append(source, data, callback) {
+    var self = this;
+    data.mtime = data.date;
+    function append(err, sourceBuffer) {
+      if (err) {
+        callback(err);
+        return;
+      }
+      self.engine.entry(data, sourceBuffer, function (err) {
+        callback(err, data);
+      });
+    }
+    if (data.sourceType === "buffer") {
+      append(null, source);
+    } else if (data.sourceType === "stream" && data.stats) {
+      data.size = data.stats.size;
+      var entry = self.engine.entry(data, function (err) {
+        callback(err, data);
+      });
+      source.pipe(entry);
+    } else if (data.sourceType === "stream") {
+      collectStream(source, append);
+    }
+  }
+  /**
+   * [finalize description]
+   *
+   * @return void
+   */
+  finalize() {
+    this.engine.finalize();
+  }
+  /**
+   * [on description]
+   *
+   * @return this.engine
+   */
+  on() {
+    return this.engine.on.apply(this.engine, arguments);
+  }
+  /**
+   * [pipe description]
+   *
+   * @param  {String} destination
+   * @param  {Object} options
+   * @return this.engine
+   */
+  pipe(destination, options) {
+    if (this.compressor) {
+      return this.engine.pipe
+        .apply(this.engine, [this.compressor])
+        .pipe(destination, options);
+    } else {
+      return this.engine.pipe.apply(this.engine, arguments);
+    }
+  }
+  /**
+   * [unpipe description]
+   *
+   * @return this.engine
+   */
+  unpipe() {
+    if (this.compressor) {
+      return this.compressor.unpipe.apply(this.compressor, arguments);
+    } else {
+      return this.engine.unpipe.apply(this.engine, arguments);
+    }
+  }
+}

package/lib/plugins/zip.js

@@ -0,0 +1,72 @@
+import engine from "zip-stream";
+
+/**
+ * ZIP Format Plugin
+ *
+ * @module plugins/zip
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+export default class Zip {
+  /**
+   * @constructor
+   * @param {ZipOptions} [options]
+   * @param {String} [options.comment] Sets the zip archive comment.
+   * @param {Boolean} [options.forceLocalTime=false] Forces the archive to contain local file times instead of UTC.
+   * @param {Boolean} [options.forceZip64=false] Forces the archive to contain ZIP64 headers.
+   * @param {Boolean} [options.namePrependSlash=false] Prepends a forward slash to archive file paths.
+   * @param {Boolean} [options.store=false] Sets the compression method to STORE.
+   * @param {Object} [options.zlib] Passed to [zlib]{@link https://nodejs.org/api/zlib.html#zlib_class_options}
+   */
+  constructor(options) {
+    options = this.options = {
+      comment: "",
+      forceUTC: false,
+      namePrependSlash: false,
+      store: false,
+      ...options,
+    };
+    this.engine = new engine(options);
+  }
+  /**
+   * @param  {(Buffer|Stream)} source
+   * @param  {ZipEntryData} data
+   * @param  {String} data.name Sets the entry name including internal path.
+   * @param  {(String|Date)} [data.date=NOW()] Sets the entry date.
+   * @param  {Number} [data.mode=D:0755/F:0644] Sets the entry permissions.
+   * @param  {String} [data.prefix] Sets a path prefix for the entry name. Useful
+   * when working with methods like `directory` or `glob`.
+   * @param  {fs.Stats} [data.stats] Sets the fs stat data for this entry allowing
+   * for reduction of fs stat calls when stat data is already known.
+   * @param  {Boolean} [data.store=ZipOptions.store] Sets the compression method to STORE.
+   * @param  {Function} callback
+   * @return void
+   */
+  append(source, data, callback) {
+    this.engine.entry(source, data, callback);
+  }
+  /**
+   * @return void
+   */
+  finalize() {
+    this.engine.finalize();
+  }
+  /**
+   * @return this.engine
+   */
+  on() {
+    return this.engine.on.apply(this.engine, arguments);
+  }
+  /**
+   * @return this.engine
+   */
+  pipe() {
+    return this.engine.pipe.apply(this.engine, arguments);
+  }
+  /**
+   * @return this.engine
+   */
+  unpipe() {
+    return this.engine.unpipe.apply(this.engine, arguments);
+  }
+}

package/lib/utils.js

@@ -0,0 +1,66 @@
+import normalizePath from "normalize-path";
+import { PassThrough } from "readable-stream";
+import { isStream } from "is-stream";
+
+export 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);
+  });
+}
+
+export function dateify(dateish) {
+  dateish = dateish || new Date();
+
+  if (dateish instanceof Date) {
+    dateish = dateish;
+  } else if (typeof dateish === "string") {
+    dateish = new Date(dateish);
+  } else {
+    dateish = new Date();
+  }
+
+  return dateish;
+}
+
+export function normalizeInputSource(source) {
+  if (source === null) {
+    return Buffer.alloc(0);
+  } else if (typeof source === "string") {
+    return Buffer.from(source);
+  } else if (isStream(source)) {
+    // Always pipe through a PassThrough stream to guarantee pausing the stream if it's already flowing,
+    // since it will only be processed in a (distant) future iteration of the event loop, and will lose
+    // data if already flowing now.
+    return source.pipe(new PassThrough());
+  }
+
+  return source;
+}
+
+export function sanitizePath(filepath) {
+  return normalizePath(filepath, false)
+    .replace(/^\w+:/, "")
+    .replace(/^(\.\.\/|\/)+/, "");
+}
+
+export function trailingSlashIt(str) {
+  return str.slice(-1) !== "/" ? str + "/" : str;
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@alienkarma/archiver",
+  "version": "7.0.1-fork.1",
+  "description": "a streaming interface for archive generation",
+  "homepage": "https://github.com/archiverjs/node-archiver",
+  "author": {
+    "name": "Chris Talkington",
+    "url": "http://christalkington.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archiverjs/node-archiver.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archiverjs/node-archiver/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "mocha --reporter dot",
+    "bench": "node benchmark/simple/pack-zip.js"
+  },
+  "dependencies": {
+    "async": "^3.2.4",
+    "buffer-crc32": "^1.0.0",
+    "is-stream": "^4.0.0",
+    "lazystream": "^1.0.0",
+    "minimatch": "^10.2.1",
+    "normalize-path": "^3.0.0",
+    "readable-stream": "^4.0.0",
+    "readdir-glob": "^1.1.3",
+    "tar-stream": "^3.0.0",
+    "zip-stream": "^7.0.2"
+  },
+  "devDependencies": {
+    "archiver-jsdoc-theme": "1.1.3",
+    "chai": "4.5.0",
+    "jsdoc": "4.0.4",
+    "mkdirp": "3.0.1",
+    "mocha": "10.8.2",
+    "prettier": "3.5.3",
+    "rimraf": "5.0.10",
+    "stream-bench": "0.1.2",
+    "tar": "6.2.1",
+    "yauzl": "3.2.0"
+  },
+  "keywords": [
+    "archive",
+    "archiver",
+    "stream",
+    "zip",
+    "tar"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}