@node-projects/jszip 4.0.0

package/lib/object.js

@@ -0,0 +1,375 @@
+import utf8 from "./utf8.js";
+import utils from "./utils.js";
+import generate from "./generate/index.js";
+import { GenericWorker } from "./stream/GenericWorker.js";
+import { StreamHelper } from "./stream/StreamHelper.js";
+import defaults from "./defaults.js";
+import { ZipObject } from "./zipObject.js";
+import nodejsUtils from "./nodejsUtils.js";
+import { NodejsStreamInputAdapter } from "./nodejs/NodejsStreamInputAdapter.js";
+import { CompressedObject } from "./compressedObject.js";
+
+/**
+ * Add a file in the current folder.
+ * @private
+ * @param {string} name the name of the file
+ * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file
+ * @param {Object} originalOptions the options of the file
+ * @return {Object} the new file.
+ */
+var fileAdd = function (name, data, originalOptions) {
+    // be sure sub folders exist
+    var dataType = utils.getTypeOf(data),
+        parent;
+
+
+    /*
+     * Correct options.
+     */
+
+    var o = utils.extend(originalOptions || {}, defaults);
+    o.date = o.date || new Date();
+    if (o.compression !== null) {
+        o.compression = o.compression.toUpperCase();
+    }
+
+    if (typeof o.unixPermissions === "string") {
+        o.unixPermissions = parseInt(o.unixPermissions, 8);
+    }
+
+    // UNX_IFDIR  0040000 see zipinfo.c
+    if (o.unixPermissions && (o.unixPermissions & 0x4000)) {
+        o.dir = true;
+    }
+    // Bit 4    Directory
+    if (o.dosPermissions && (o.dosPermissions & 0x0010)) {
+        o.dir = true;
+    }
+
+    if (o.dir) {
+        name = forceTrailingSlash(name);
+    }
+    if (o.createFolders && (parent = parentFolder(name))) {
+        folderAdd.call(this, parent, true);
+    }
+
+    var isUnicodeString = dataType === "string" && o.binary === false && o.base64 === false;
+    if (!originalOptions || typeof originalOptions.binary === "undefined") {
+        o.binary = !isUnicodeString;
+    }
+
+
+    var isCompressedEmpty = (data instanceof CompressedObject) && data.uncompressedSize === 0;
+
+    if (isCompressedEmpty || o.dir || !data || data.length === 0) {
+        o.base64 = false;
+        o.binary = true;
+        data = "";
+        o.compression = "STORE";
+        dataType = "string";
+    }
+
+    /*
+     * Convert content to fit.
+     */
+
+    var zipObjectContent = null;
+    if (data instanceof CompressedObject || data instanceof GenericWorker) {
+        zipObjectContent = data;
+    } else if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
+        zipObjectContent = new NodejsStreamInputAdapter(name, data);
+    } else {
+        zipObjectContent = utils.prepareContent(name, data, o.binary, o.optimizedBinaryString, o.base64);
+    }
+
+    var object = new ZipObject(name, zipObjectContent, o);
+    this.files[name] = object;
+    /*
+    TODO: we can't throw an exception because we have async promises
+    (we can have a promise of a Date() for example) but returning a
+    promise is useless because file(name, data) returns the JSZip
+    object for chaining. Should we break that to allow the user
+    to catch the error ?
+
+    return external.Promise.resolve(zipObjectContent)
+    .then(function () {
+        return object;
+    });
+    */
+};
+
+/**
+ * Find the parent folder of the path.
+ * @private
+ * @param {string} path the path to use
+ * @return {string} the parent folder, or ""
+ */
+var parentFolder = function (path) {
+    if (path.slice(-1) === "/") {
+        path = path.substring(0, path.length - 1);
+    }
+    var lastSlash = path.lastIndexOf("/");
+    return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
+};
+
+/**
+ * Returns the path with a slash at the end.
+ * @private
+ * @param {String} path the path to check.
+ * @return {String} the path with a trailing slash.
+ */
+var forceTrailingSlash = function (path) {
+    // Check the name ends with a /
+    if (path.slice(-1) !== "/") {
+        path += "/"; // IE doesn't like substr(-1)
+    }
+    return path;
+};
+
+/**
+ * Add a (sub) folder in the current folder.
+ * @private
+ * @param {string} name the folder's name
+ * @param {boolean=} [createFolders] If true, automatically create sub
+ *  folders. Defaults to false.
+ * @return {Object} the new folder.
+ */
+var folderAdd = function (name, createFolders) {
+    createFolders = (typeof createFolders !== "undefined") ? createFolders : defaults.createFolders;
+
+    name = forceTrailingSlash(name);
+
+    // Does this folder already exist?
+    if (!this.files[name]) {
+        fileAdd.call(this, name, null, {
+            dir: true,
+            createFolders: createFolders
+        });
+    }
+    return this.files[name];
+};
+
+/**
+* Cross-window, cross-Node-context regular expression detection
+* @param  {Object}  object Anything
+* @return {Boolean}        true if the object is a regular expression,
+* false otherwise
+*/
+function isRegExp(object) {
+    return Object.prototype.toString.call(object) === "[object RegExp]";
+}
+
+// return the actual prototype of JSZip
+export default class JSZipPrototype {
+    /**
+     * Call a callback function for each entry at this folder level.
+     * @param {Function} cb the callback function:
+     * function (relativePath, file) {...}
+     * It takes 2 arguments : the relative path and the file.
+     */
+    forEach(cb) {
+        var filename, relativePath, file;
+        // ignore warning about unwanted properties because this.files is a null prototype object
+        /* eslint-disable-next-line guard-for-in */
+        for (filename in this.files) {
+            file = this.files[filename];
+            relativePath = filename.slice(this.root.length, filename.length);
+            if (relativePath && filename.slice(0, this.root.length) === this.root) { // the file is in the current root
+                cb(relativePath, file); // TODO reverse the parameters ? need to be clean AND consistent with the filter search fn...
+            }
+        }
+    }
+
+    /**
+     * Filter nested files/folders with the specified function.
+     * @param {Function} search the predicate to use :
+     * function (relativePath, file) {...}
+     * It takes 2 arguments : the relative path and the file.
+     * @return {Array} An array of matching elements.
+     */
+    filter(search) {
+        var result = [];
+        this.forEach(function (relativePath, entry) {
+            if (search(relativePath, entry)) { // the file matches the function
+                result.push(entry);
+            }
+
+        });
+        return result;
+    }
+
+    /**
+     * Add a file to the zip file, or search a file.
+     * @param   {string|RegExp} name The name of the file to add (if data is defined),
+     * the name of the file to find (if no data) or a regex to match files.
+     * @param   {String|ArrayBuffer|Uint8Array|Buffer} data  The file data, either raw or base64 encoded
+     * @param   {Object} o     File options
+     * @return  {JSZip|Object|Array} this JSZip object (when adding a file),
+     * a file (when searching by string) or an array of files (when searching by regex).
+     */
+    file(name, data, o) {
+        if (arguments.length === 1) {
+            if (isRegExp(name)) {
+                var regexp = name;
+                return this.filter(function (relativePath, file) {
+                    return !file.dir && regexp.test(relativePath);
+                });
+            }
+            else { // text
+                var obj = this.files[this.root + name];
+                if (obj && !obj.dir) {
+                    return obj;
+                } else {
+                    return null;
+                }
+            }
+        }
+        else { // more than one argument : we have data !
+            name = this.root + name;
+            fileAdd.call(this, name, data, o);
+        }
+        return this;
+    }
+
+    /**
+     * Add a directory to the zip file, or search.
+     * @param   {String|RegExp} arg The name of the directory to add, or a regex to search folders.
+     * @return  {JSZip} an object with the new directory as the root, or an array containing matching folders.
+     */
+    folder(arg) {
+        if (!arg) {
+            return this;
+        }
+
+        if (isRegExp(arg)) {
+            return this.filter(function (relativePath, file) {
+                return file.dir && arg.test(relativePath);
+            });
+        }
+
+        // else, name is a new folder
+        var name = this.root + arg;
+        var newFolder = folderAdd.call(this, name);
+
+        // Allow chaining by returning a new object with this folder as the root
+        var ret = this.clone();
+        ret.root = newFolder.name;
+        return ret;
+    }
+
+    /**
+     * Delete a file, or a directory and all sub-files, from the zip
+     * @param {string} name the name of the file to delete
+     * @return {JSZip} this JSZip object
+     */
+    remove(name) {
+        name = this.root + name;
+        var file = this.files[name];
+        if (!file) {
+            // Look for any folders
+            if (name.slice(-1) !== "/") {
+                name += "/";
+            }
+            file = this.files[name];
+        }
+
+        if (file && !file.dir) {
+            // file
+            delete this.files[name];
+        } else {
+            // maybe a folder, delete recursively
+            var kids = this.filter(function (relativePath, file) {
+                return file.name.slice(0, name.length) === name;
+            });
+            for (var i = 0; i < kids.length; i++) {
+                delete this.files[kids[i].name];
+            }
+        }
+
+        return this;
+    }
+
+    /**
+     * @deprecated This method has been removed in JSZip 3.0, please check the upgrade guide.
+     */
+    generate() {
+        throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
+    }
+
+    /**
+     * Generate the complete zip file as an internal stream.
+     * @param {Object} options the options to generate the zip file :
+     * - compression, "STORE" by default.
+     * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
+     * @return {StreamHelper} the streamed zip file.
+     */
+    generateInternalStream(options) {
+        var worker, opts = {};
+        try {
+            opts = utils.extend(options || {}, {
+                streamFiles: false,
+                compression: "STORE",
+                compressionOptions: null,
+                type: "",
+                platform: "DOS",
+                comment: null,
+                mimeType: "application/zip",
+                encodeFileName: utf8.utf8encode
+            });
+
+            opts.type = opts.type.toLowerCase();
+            opts.compression = opts.compression.toUpperCase();
+
+            // "binarystring" is preferred but the internals use "string".
+            if (opts.type === "binarystring") {
+                opts.type = "string";
+            }
+
+            if (!opts.type) {
+                throw new Error("No output type specified.");
+            }
+
+            utils.checkSupport(opts.type);
+
+            // accept nodejs `process.platform`
+            if (
+                opts.platform === "darwin" ||
+                opts.platform === "freebsd" ||
+                opts.platform === "linux" ||
+                opts.platform === "sunos"
+            ) {
+                opts.platform = "UNIX";
+            }
+            if (opts.platform === "win32") {
+                opts.platform = "DOS";
+            }
+
+            var comment = opts.comment || this.comment || "";
+            worker = generate.generateWorker(this, opts, comment);
+        } catch (e) {
+            worker = new GenericWorker("error");
+            worker.error(e);
+        }
+        return new StreamHelper(worker, opts.type || "string", opts.mimeType);
+    }
+
+    /**
+     * Generate the complete zip file asynchronously.
+     * @see generateInternalStream
+     */
+    generateAsync(options, onUpdate) {
+        return this.generateInternalStream(options).accumulate(onUpdate);
+    }
+
+    /**
+     * Generate the complete zip file asynchronously.
+     * @see generateInternalStream
+     */
+    generateNodeStream(options, onUpdate) {
+        options = options || {};
+        if (!options.type) {
+            options.type = "nodebuffer";
+        }
+        return this.generateInternalStream(options).toNodejsStream(onUpdate);
+    }
+};

package/lib/reader/ArrayReader.js

@@ -0,0 +1,59 @@
+import { DataReader } from "./DataReader.js";
+
+export class ArrayReader extends DataReader {
+    constructor(data) {
+        super(data);
+        for (var i = 0; i < this.data.length; i++) {
+            data[i] = data[i] & 0xFF;
+        }
+    }
+
+    /**
+     * @see DataReader.byteAt
+     */
+    byteAt(i) {
+        return this.data[this.zero + i];
+    }
+
+    /**
+     * @see DataReader.lastIndexOfSignature
+     */
+    lastIndexOfSignature(sig) {
+        var sig0 = sig.charCodeAt(0),
+            sig1 = sig.charCodeAt(1),
+            sig2 = sig.charCodeAt(2),
+            sig3 = sig.charCodeAt(3);
+        for (var i = this.length - 4; i >= 0; --i) {
+            if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
+                return i - this.zero;
+            }
+        }
+
+        return -1;
+    }
+
+    /**
+     * @see DataReader.readAndCheckSignature
+     */
+    readAndCheckSignature(sig) {
+        var sig0 = sig.charCodeAt(0),
+            sig1 = sig.charCodeAt(1),
+            sig2 = sig.charCodeAt(2),
+            sig3 = sig.charCodeAt(3),
+            data = this.readData(4);
+        return sig0 === data[0] && sig1 === data[1] && sig2 === data[2] && sig3 === data[3];
+    }
+
+    /**
+     * @see DataReader.readData
+     */
+    readData(size) {
+        this.checkOffset(size);
+        if (size === 0) {
+            return [];
+        }
+        var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
+        this.index += size;
+        return result;
+    }
+}

package/lib/reader/DataReader.js

@@ -0,0 +1,125 @@
+import { transformTo } from "../utils.js";
+
+export class DataReader {
+    constructor(data) {
+        this.data = data; // type : see implementation
+        this.length = data.length;
+        this.index = 0;
+        this.zero = 0;
+    }
+
+    /**
+     * Check that the offset will not go too far.
+     * @param {string} offset the additional offset to check.
+     * @throws {Error} an Error if the offset is out of bounds.
+     */
+    checkOffset(offset) {
+        this.checkIndex(this.index + offset);
+    }
+
+    /**
+     * Check that the specified index will not be too far.
+     * @param {string} newIndex the index to check.
+     * @throws {Error} an Error if the index is out of bounds.
+     */
+    checkIndex(newIndex) {
+        if (this.length < this.zero + newIndex || newIndex < 0) {
+            throw new Error("End of data reached (data length = " + this.length + ", asked index = " + (newIndex) + "). Corrupted zip ?");
+        }
+    }
+
+    /**
+     * Change the index.
+     * @param {number} newIndex The new index.
+     * @throws {Error} if the new index is out of the data.
+     */
+    setIndex(newIndex) {
+        this.checkIndex(newIndex);
+        this.index = newIndex;
+    }
+
+    /**
+     * Skip the next n bytes.
+     * @param {number} n the number of bytes to skip.
+     * @throws {Error} if the new index is out of the data.
+     */
+    skip(n) {
+        this.setIndex(this.index + n);
+    }
+
+    /**
+     * Get the byte at the specified index.
+     * @param {number} i the index to use.
+     * @return {number} a byte.
+     */
+    byteAt() {
+        // see implementations
+    }
+
+    /**
+     * Get the next number with a given byte size.
+     * @param {number} size the number of bytes to read.
+     * @return {number} the corresponding number.
+     */
+    readInt(size) {
+        var result = 0,
+            i;
+        this.checkOffset(size);
+        for (i = this.index + size - 1; i >= this.index; i--) {
+            result = (result << 8) + this.byteAt(i);
+        }
+        this.index += size;
+        return result;
+    }
+
+    /**
+     * Get the next string with a given byte size.
+     * @param {number} size the number of bytes to read.
+     * @return {string} the corresponding string.
+     */
+    readString(size) {
+        return transformTo("string", this.readData(size));
+    }
+
+    /**
+     * Get raw data without conversion, <size> bytes.
+     * @param {number} size the number of bytes to read.
+     * @return {Object} the raw data, implementation specific.
+     */
+    readData() {
+        // see implementations
+    }
+
+    /**
+     * Find the last occurrence of a zip signature (4 bytes).
+     * @param {string} sig the signature to find.
+     * @return {number} the index of the last occurrence, -1 if not found.
+     */
+    lastIndexOfSignature() {
+        // see implementations
+    }
+
+    /**
+     * Read the signature (4 bytes) at the current position and compare it with sig.
+     * @param {string} sig the expected signature
+     * @return {boolean} true if the signature matches, false otherwise.
+     */
+    readAndCheckSignature() {
+        // see implementations
+    }
+
+    /**
+     * Get the next date.
+     * @return {Date} the date.
+     */
+    readDate() {
+        var dostime = this.readInt(4);
+        return new Date(Date.UTC(
+            ((dostime >> 25) & 0x7f) + 1980, // year
+            ((dostime >> 21) & 0x0f) - 1, // month
+            (dostime >> 16) & 0x1f, // day
+            (dostime >> 11) & 0x1f, // hour
+            (dostime >> 5) & 0x3f, // minute
+            (dostime & 0x1f) << 1)); // second
+    }
+}

package/lib/reader/NodeBufferReader.js

@@ -0,0 +1,17 @@
+import { Uint8ArrayReader } from "./Uint8ArrayReader.js";
+
+export class NodeBufferReader extends Uint8ArrayReader {
+    constructor(data) {
+        super(data);
+    }
+
+    /**
+     * @see DataReader.readData
+     */
+    readData(size) {
+        this.checkOffset(size);
+        var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
+        this.index += size;
+        return result;
+    }
+}

package/lib/reader/StringReader.js

@@ -0,0 +1,40 @@
+import { DataReader } from "./DataReader.js";
+
+export class StringReader extends DataReader {
+    constructor(data) {
+        super(data);
+    }
+
+    /**
+     * @see DataReader.byteAt
+     */
+    byteAt(i) {
+        return this.data.charCodeAt(this.zero + i);
+    }
+
+    /**
+     * @see DataReader.lastIndexOfSignature
+     */
+    lastIndexOfSignature(sig) {
+        return this.data.lastIndexOf(sig) - this.zero;
+    }
+
+    /**
+     * @see DataReader.readAndCheckSignature
+     */
+    readAndCheckSignature(sig) {
+        var data = this.readData(4);
+        return sig === data;
+    }
+
+    /**
+     * @see DataReader.readData
+     */
+    readData(size) {
+        this.checkOffset(size);
+        // this will work because the constructor applied the "& 0xff" mask.
+        var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
+        this.index += size;
+        return result;
+    }
+}

package/lib/reader/Uint8ArrayReader.js

@@ -0,0 +1,22 @@
+import { ArrayReader } from "./ArrayReader.js";
+
+export class Uint8ArrayReader extends ArrayReader {
+    constructor(data) {
+        super(data);
+    }
+
+    /**
+     * @see DataReader.readData
+     */
+
+    readData(size) {
+        this.checkOffset(size);
+        if (size === 0) {
+            // in IE10, when using subarray(idx, idx), we get the array [0x00] instead of [].
+            return new Uint8Array(0);
+        }
+        var result = this.data.subarray(this.zero + this.index, this.zero + this.index + size);
+        this.index += size;
+        return result;
+    }
+}

package/lib/reader/readerFor.js

@@ -0,0 +1,26 @@
+import { getTypeOf, checkSupport, transformTo } from "../utils.js";
+import support from "../support.js";
+import { ArrayReader } from "./ArrayReader.js";
+import { StringReader } from "./StringReader.js";
+import { NodeBufferReader } from "./NodeBufferReader.js";
+import { Uint8ArrayReader } from "./Uint8ArrayReader.js";
+
+/**
+ * Create a reader adapted to the data.
+ * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data to read.
+ * @return {DataReader} the data reader.
+ */
+export default function (data) {
+    var type = getTypeOf(data);
+    checkSupport(type);
+    if (type === "string" && !support.uint8array) {
+        return new StringReader(data);
+    }
+    if (type === "nodebuffer") {
+        return new NodeBufferReader(data);
+    }
+    if (support.uint8array) {
+        return new Uint8ArrayReader(transformTo("uint8array", data));
+    }
+    return new ArrayReader(transformTo("array", data));
+};

package/lib/signature.js

@@ -0,0 +1,10 @@
+export const LOCAL_FILE_HEADER = "PK\x03\x04";
+export const CENTRAL_FILE_HEADER = "PK\x01\x02";
+export const CENTRAL_DIRECTORY_END = "PK\x05\x06";
+export const ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07";
+export const ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06";
+export const DATA_DESCRIPTOR = "PK\x07\x08";
+
+export default {
+    LOCAL_FILE_HEADER, CENTRAL_FILE_HEADER, CENTRAL_DIRECTORY_END, ZIP64_CENTRAL_DIRECTORY_LOCATOR, ZIP64_CENTRAL_DIRECTORY_END, DATA_DESCRIPTOR
+}

package/lib/stream/ConvertWorker.js

@@ -0,0 +1,24 @@
+import { GenericWorker } from "./GenericWorker.js";
+import utils from "../utils.js";
+
+export class ConvertWorker extends GenericWorker {
+    /**
+     * A worker which convert chunks to a specified type.
+     * @constructor
+     * @param {String} destType the destination type.
+     */
+    constructor(destType) {
+        super("ConvertWorker to " + destType);
+        this.destType = destType;
+    }
+
+    /**
+     * @see GenericWorker.processChunk
+     */
+    processChunk(chunk) {
+        this.push({
+            data: utils.transformTo(this.destType, chunk.data),
+            meta: chunk.meta
+        });
+    }
+}