@node-projects/jszip 4.0.0

package/lib/stream/Crc32Probe.js

@@ -0,0 +1,21 @@
+import { GenericWorker } from "./GenericWorker.js";
+import crc32 from "../crc32.js";
+
+export class Crc32Probe extends GenericWorker {
+    /**
+     * A worker which calculate the crc32 of the data flowing through.
+     * @constructor
+     */
+    constructor() {
+        super("Crc32Probe");
+        this.withStreamInfo("crc32", 0);
+    }
+
+    /**
+     * @see GenericWorker.processChunk
+     */
+    processChunk(chunk) {
+        this.streamInfo.crc32 = crc32(chunk.data, this.streamInfo.crc32 || 0);
+        this.push(chunk);
+    }
+}

package/lib/stream/DataLengthProbe.js

@@ -0,0 +1,25 @@
+import { GenericWorker } from "./GenericWorker.js";
+
+export class DataLengthProbe extends GenericWorker {
+    /**
+     * A worker which calculate the total length of the data flowing through.
+     * @constructor
+     * @param {String} propName the name used to expose the length
+     */
+    constructor(propName) {
+        super("DataLengthProbe for " + propName);
+        this.propName = propName;
+        this.withStreamInfo(propName, 0);
+    }
+
+    /**
+     * @see GenericWorker.processChunk
+     */
+    processChunk(chunk) {
+        if (chunk) {
+            var length = this.streamInfo[this.propName] || 0;
+            this.streamInfo[this.propName] = length + chunk.data.length;
+        }
+        GenericWorker.prototype.processChunk.call(this, chunk);
+    };
+}

package/lib/stream/DataWorker.js

@@ -0,0 +1,112 @@
+import utils from "../utils.js";
+import { GenericWorker } from "./GenericWorker.js";
+
+// the size of the generated chunks
+// TODO expose this as a public variable
+const DEFAULT_BLOCK_SIZE = 16 * 1024;
+
+export class DataWorker extends GenericWorker {
+    /**
+     * A worker that reads a content and emits chunks.
+     * @constructor
+     * @param {Promise} dataP the promise of the data to split
+     */
+    constructor(dataP) {
+        super("DataWorker");
+        var self = this;
+        this.dataIsReady = false;
+        this.index = 0;
+        this.max = 0;
+        this.data = null;
+        this.type = "";
+
+        this._tickScheduled = false;
+
+        dataP.then(function (data) {
+            self.dataIsReady = true;
+            self.data = data;
+            self.max = data && data.length || 0;
+            self.type = utils.getTypeOf(data);
+            if (!self.isPaused) {
+                self._tickAndRepeat();
+            }
+        }, function (e) {
+            self.error(e);
+        });
+    }
+
+    /**
+     * @see GenericWorker.cleanUp
+     */
+    cleanUp() {
+        GenericWorker.prototype.cleanUp.call(this);
+        this.data = null;
+    };
+
+    /**
+     * @see GenericWorker.resume
+     */
+    resume() {
+        if (!GenericWorker.prototype.resume.call(this)) {
+            return false;
+        }
+
+        if (!this._tickScheduled && this.dataIsReady) {
+            this._tickScheduled = true;
+            utils.delay(this._tickAndRepeat, [], this);
+        }
+        return true;
+    };
+
+    /**
+     * Trigger a tick a schedule an other call to this function.
+     */
+    _tickAndRepeat() {
+        this._tickScheduled = false;
+        if (this.isPaused || this.isFinished) {
+            return;
+        }
+        this._tick();
+        if (!this.isFinished) {
+            utils.delay(this._tickAndRepeat, [], this);
+            this._tickScheduled = true;
+        }
+    };
+
+    /**
+     * Read and push a chunk.
+     */
+    _tick() {
+
+        if (this.isPaused || this.isFinished) {
+            return false;
+        }
+
+        var size = DEFAULT_BLOCK_SIZE;
+        var data = null, nextIndex = Math.min(this.max, this.index + size);
+        if (this.index >= this.max) {
+            // EOF
+            return this.end();
+        } else {
+            switch (this.type) {
+                case "string":
+                    data = this.data.substring(this.index, nextIndex);
+                    break;
+                case "uint8array":
+                    data = this.data.subarray(this.index, nextIndex);
+                    break;
+                case "array":
+                case "nodebuffer":
+                    data = this.data.slice(this.index, nextIndex);
+                    break;
+            }
+            this.index = nextIndex;
+            return this.push({
+                data: data,
+                meta: {
+                    percent: this.max ? this.index / this.max * 100 : 0
+                }
+            });
+        }
+    };
+}

package/lib/stream/GenericWorker.js

@@ -0,0 +1,273 @@
+/**
+ * A worker that does nothing but passing chunks to the next one. This is like
+ * a nodejs stream but with some differences. On the good side :
+ * - it works on IE 6-9 without any issue / polyfill
+ * - it weights less than the full dependencies bundled with browserify
+ * - it forwards errors (no need to declare an error handler EVERYWHERE)
+ *
+ * A chunk is an object with 2 attributes : `meta` and `data`. The former is an
+ * object containing anything (`percent` for example), see each worker for more
+ * details. The latter is the real data (String, Uint8Array, etc).
+ *
+ * @constructor
+ * @param {String} name the name of the stream (mainly used for debugging purposes)
+ */
+export class GenericWorker {
+
+    constructor(name) {
+        // the name of the worker
+        this.name = name || "default";
+        // an object containing metadata about the workers chain
+        this.streamInfo = {};
+        // an error which happened when the worker was paused
+        this.generatedError = null;
+        // an object containing metadata to be merged by this worker into the general metadata
+        this.extraStreamInfo = {};
+        // true if the stream is paused (and should not do anything), false otherwise
+        this.isPaused = true;
+        // true if the stream is finished (and should not do anything), false otherwise
+        this.isFinished = false;
+        // true if the stream is locked to prevent further structure updates (pipe), false otherwise
+        this.isLocked = false;
+        // the event listeners
+        this._listeners = {
+            "data": [],
+            "end": [],
+            "error": []
+        };
+        // the previous worker, if any
+        this.previous = null;
+    }
+
+    /**
+     * Push a chunk to the next workers.
+     * @param {Object} chunk the chunk to push
+     */
+    push(chunk) {
+        this.emit("data", chunk);
+    }
+
+    /**
+     * End the stream.
+     * @return {Boolean} true if this call ended the worker, false otherwise.
+     */
+    end() {
+        if (this.isFinished) {
+            return false;
+        }
+
+        this.flush();
+        try {
+            this.emit("end");
+            this.cleanUp();
+            this.isFinished = true;
+        } catch (e) {
+            this.emit("error", e);
+        }
+        return true;
+    }
+
+    /**
+     * End the stream with an error.
+     * @param {Error} e the error which caused the premature end.
+     * @return {Boolean} true if this call ended the worker with an error, false otherwise.
+     */
+    error(e) {
+        if (this.isFinished) {
+            return false;
+        }
+
+        if (this.isPaused) {
+            this.generatedError = e;
+        } else {
+            this.isFinished = true;
+
+            this.emit("error", e);
+
+            // in the workers chain exploded in the middle of the chain,
+            // the error event will go downward but we also need to notify
+            // workers upward that there has been an error.
+            if (this.previous) {
+                this.previous.error(e);
+            }
+
+            this.cleanUp();
+        }
+        return true;
+    }
+
+    /**
+     * Add a callback on an event.
+     * @param {String} name the name of the event (data, end, error)
+     * @param {Function} listener the function to call when the event is triggered
+     * @return {GenericWorker} the current object for chainability
+     */
+    on(name, listener) {
+        this._listeners[name].push(listener);
+        return this;
+    }
+
+    /**
+     * Clean any references when a worker is ending.
+     */
+    cleanUp() {
+        this.streamInfo = this.generatedError = this.extraStreamInfo = null;
+        this._listeners = [];
+    }
+
+    /**
+     * Trigger an event. This will call registered callback with the provided arg.
+     * @param {String} name the name of the event (data, end, error)
+     * @param {Object} arg the argument to call the callback with.
+     */
+    emit(name, arg) {
+        if (this._listeners[name]) {
+            for (var i = 0; i < this._listeners[name].length; i++) {
+                this._listeners[name][i].call(this, arg);
+            }
+        }
+    }
+
+    /**
+     * Chain a worker with an other.
+     * @param {Worker} next the worker receiving events from the current one.
+     * @return {worker} the next worker for chainability
+     */
+    pipe(next) {
+        return next.registerPrevious(this);
+    }
+
+    /**
+     * Same as `pipe` in the other direction.
+     * Using an API with `pipe(next)` is very easy.
+     * Implementing the API with the point of view of the next one registering
+     * a source is easier, see the ZipFileWorker.
+     * @param {Worker} previous the previous worker, sending events to this one
+     * @return {Worker} the current worker for chainability
+     */
+    registerPrevious(previous) {
+        if (this.isLocked) {
+            throw new Error("The stream '" + this + "' has already been used.");
+        }
+
+        // sharing the streamInfo...
+        this.streamInfo = previous.streamInfo;
+        // ... and adding our own bits
+        this.mergeStreamInfo();
+        this.previous = previous;
+        var self = this;
+        previous.on("data", function (chunk) {
+            self.processChunk(chunk);
+        });
+        previous.on("end", function () {
+            self.end();
+        });
+        previous.on("error", function (e) {
+            self.error(e);
+        });
+        return this;
+    }
+
+    /**
+     * Pause the stream so it doesn't send events anymore.
+     * @return {Boolean} true if this call paused the worker, false otherwise.
+     */
+    pause() {
+        if (this.isPaused || this.isFinished) {
+            return false;
+        }
+        this.isPaused = true;
+
+        if (this.previous) {
+            this.previous.pause();
+        }
+        return true;
+    }
+
+    /**
+     * Resume a paused stream.
+     * @return {Boolean} true if this call resumed the worker, false otherwise.
+     */
+    resume() {
+        if (!this.isPaused || this.isFinished) {
+            return false;
+        }
+        this.isPaused = false;
+
+        // if true, the worker tried to resume but failed
+        var withError = false;
+        if (this.generatedError) {
+            this.error(this.generatedError);
+            withError = true;
+        }
+        if (this.previous) {
+            this.previous.resume();
+        }
+
+        return !withError;
+    }
+
+    /**
+     * Flush any remaining bytes as the stream is ending.
+     */
+    flush() { }
+
+    /**
+     * Process a chunk. This is usually the method overridden.
+     * @param {Object} chunk the chunk to process.
+     */
+    processChunk(chunk) {
+        this.push(chunk);
+    }
+
+    /**
+     * Add a key/value to be added in the workers chain streamInfo once activated.
+     * @param {String} key the key to use
+     * @param {Object} value the associated value
+     * @return {Worker} the current worker for chainability
+     */
+    withStreamInfo(key, value) {
+        this.extraStreamInfo[key] = value;
+        this.mergeStreamInfo();
+        return this;
+    }
+
+    /**
+     * Merge this worker's streamInfo into the chain's streamInfo.
+     */
+    mergeStreamInfo() {
+        for (var key in this.extraStreamInfo) {
+            if (!Object.prototype.hasOwnProperty.call(this.extraStreamInfo, key)) {
+                continue;
+            }
+            this.streamInfo[key] = this.extraStreamInfo[key];
+        }
+    }
+
+    /**
+     * Lock the stream to prevent further updates on the workers chain.
+     * After calling this method, all calls to pipe will fail.
+     */
+    lock() {
+        if (this.isLocked) {
+            throw new Error("The stream '" + this + "' has already been used.");
+        }
+        this.isLocked = true;
+        if (this.previous) {
+            this.previous.lock();
+        }
+    }
+
+    /**
+     *
+     * Pretty print the workers chain.
+     */
+    toString() {
+        var me = "Worker " + this.name;
+        if (this.previous) {
+            return this.previous + " -> " + me;
+        } else {
+            return me;
+        }
+    }
+}

package/lib/stream/StreamHelper.js

@@ -0,0 +1,214 @@
+import utils from "../utils.js";
+import { ConvertWorker } from "./ConvertWorker.js";
+import { GenericWorker } from "./GenericWorker.js";
+import base64 from "../base64.js";
+import support from "../support.js";
+
+/*
+var NodejsStreamOutputAdapter = null;
+if (support.nodestream) {
+    try {
+        NodejsStreamOutputAdapter = require("../nodejs/NodejsStreamOutputAdapter");
+    } catch (e) {
+        // ignore
+    }
+}
+*/
+
+/**
+ * Apply the final transformation of the data. If the user wants a Blob for
+ * example, it's easier to work with an U8intArray and finally do the
+ * ArrayBuffer/Blob conversion.
+ * @param {String} type the name of the final type
+ * @param {String|Uint8Array|Buffer} content the content to transform
+ * @param {String} mimeType the mime type of the content, if applicable.
+ * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the content in the right format.
+ */
+function transformZipOutput(type, content, mimeType) {
+    switch (type) {
+        case "blob":
+            return utils.newBlob(utils.transformTo("arraybuffer", content), mimeType);
+        case "base64":
+            return base64.encode(content);
+        default:
+            return utils.transformTo(type, content);
+    }
+}
+
+/**
+ * Concatenate an array of data of the given type.
+ * @param {String} type the type of the data in the given array.
+ * @param {Array} dataArray the array containing the data chunks to concatenate
+ * @return {String|Uint8Array|Buffer} the concatenated data
+ * @throws Error if the asked type is unsupported
+ */
+function concat(type, dataArray) {
+    var i, index = 0, res = null, totalLength = 0;
+    for (i = 0; i < dataArray.length; i++) {
+        totalLength += dataArray[i].length;
+    }
+    switch (type) {
+        case "string":
+            return dataArray.join("");
+        case "array":
+            return Array.prototype.concat.apply([], dataArray);
+        case "uint8array":
+            res = new Uint8Array(totalLength);
+            for (i = 0; i < dataArray.length; i++) {
+                res.set(dataArray[i], index);
+                index += dataArray[i].length;
+            }
+            return res;
+        case "nodebuffer":
+            return Buffer.concat(dataArray);
+        default:
+            throw new Error("concat : unsupported type '" + type + "'");
+    }
+}
+
+/**
+ * Listen a StreamHelper, accumulate its content and concatenate it into a
+ * complete block.
+ * @param {StreamHelper} helper the helper to use.
+ * @param {Function} updateCallback a callback called on each update. Called
+ * with one arg :
+ * - the metadata linked to the update received.
+ * @return Promise the promise for the accumulation.
+ */
+function accumulate(helper, updateCallback) {
+    return new Promise(function (resolve, reject) {
+        var dataArray = [];
+        var chunkType = helper._internalType,
+            resultType = helper._outputType,
+            mimeType = helper._mimeType;
+        helper
+            .on("data", function (data, meta) {
+                dataArray.push(data);
+                if (updateCallback) {
+                    updateCallback(meta);
+                }
+            })
+            .on("error", function (err) {
+                dataArray = [];
+                reject(err);
+            })
+            .on("end", function () {
+                try {
+                    var result = transformZipOutput(resultType, concat(chunkType, dataArray), mimeType);
+                    resolve(result);
+                } catch (e) {
+                    reject(e);
+                }
+                dataArray = [];
+            })
+            .resume();
+    });
+}
+
+export class StreamHelper {
+    /**
+     * An helper to easily use workers outside of JSZip.
+     * @constructor
+     * @param {Worker} worker the worker to wrap
+     * @param {String} outputType the type of data expected by the use
+     * @param {String} mimeType the mime type of the content, if applicable.
+     */
+    constructor(worker, outputType, mimeType) {
+        var internalType = outputType;
+        switch (outputType) {
+            case "blob":
+            case "arraybuffer":
+                internalType = "uint8array";
+                break;
+            case "base64":
+                internalType = "string";
+                break;
+        }
+
+        try {
+            // the type used internally
+            this._internalType = internalType;
+            // the type used to output results
+            this._outputType = outputType;
+            // the mime type
+            this._mimeType = mimeType;
+            utils.checkSupport(internalType);
+            this._worker = worker.pipe(new ConvertWorker(internalType));
+            // the last workers can be rewired without issues but we need to
+            // prevent any updates on previous workers.
+            worker.lock();
+        } catch (e) {
+            this._worker = new GenericWorker("error");
+            this._worker.error(e);
+        }
+    }
+
+    /**
+     * Listen a StreamHelper, accumulate its content and concatenate it into a
+     * complete block.
+     * @param {Function} updateCb the update callback.
+     * @return Promise the promise for the accumulation.
+     */
+    accumulate(updateCb) {
+        return accumulate(this, updateCb);
+    }
+
+    /**
+     * Add a listener on an event triggered on a stream.
+     * @param {String} evt the name of the event
+     * @param {Function} fn the listener
+     * @return {StreamHelper} the current helper.
+     */
+    on(evt, fn) {
+        var self = this;
+
+        if (evt === "data") {
+            this._worker.on(evt, function (chunk) {
+                fn.call(self, chunk.data, chunk.meta);
+            });
+        } else {
+            this._worker.on(evt, function () {
+                utils.delay(fn, arguments, self);
+            });
+        }
+        return this;
+    }
+
+    /**
+     * Resume the flow of chunks.
+     * @return {StreamHelper} the current helper.
+     */
+    resume() {
+        utils.delay(this._worker.resume, [], this._worker);
+        return this;
+    }
+
+    /**
+     * Pause the flow of chunks.
+     * @return {StreamHelper} the current helper.
+     */
+    pause() {
+        this._worker.pause();
+        return this;
+    }
+
+    /**
+     * Return a nodejs stream for this helper.
+     * @param {Function} updateCb the update callback.
+     * @return {NodejsStreamOutputAdapter} the nodejs stream.
+     */
+    toNodejsStream(updateCb) {
+        utils.checkSupport("nodestream");
+        if (this._outputType !== "nodebuffer") {
+            // an object stream containing blob/arraybuffer/uint8array/string
+            // is strange and I don't know if it would be useful.
+            // I you find this comment and have a good usecase, please open a
+            // bug report !
+            throw new Error(this._outputType + " is not supported by this method");
+        }
+
+        return new NodejsStreamOutputAdapter(this, {
+            objectMode: this._outputType !== "nodebuffer"
+        }, updateCb);
+    }
+}

package/lib/support.js

@@ -0,0 +1,42 @@
+export const base64 = true;
+export const array = true;
+export const string = true;
+export const arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
+export const nodebuffer = typeof Buffer !== "undefined";
+// contains true if JSZip can read/generate Uint8Array, false otherwise.
+export const uint8array = typeof Uint8Array !== "undefined";
+
+export let blob = false;
+if (typeof ArrayBuffer === "undefined") {
+    blob = false;
+}
+else {
+    var buffer = new ArrayBuffer(0);
+    try {
+        blob = new Blob([buffer], {
+            type: "application/zip"
+        }).size === 0;
+    }
+    catch (e) {
+        try {
+            var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
+            var builder = new Builder();
+            builder.append(buffer);
+            blob = builder.getBlob("application/zip").size === 0;
+        }
+        catch (e) {
+            blob = false;
+        }
+    }
+}
+
+export let nodestream = false;
+try {
+    nodestream = !!require("readable-stream").Readable;
+} catch(e) {
+    nodestream = false;
+}
+
+export default {
+    base64, array, string, arraybuffer, nodebuffer, uint8array, blob, nodestream
+}