@node-projects/jszip 4.0.0

package/lib/index.js

@@ -0,0 +1,63 @@
+import object from './object.js'
+import load from './load.js'
+import support from './support.js'
+import defaults from './defaults.js'
+
+export class JSZip extends object {
+
+    /**
+     * Representation a of zip file in js
+     * @constructor
+     */
+    constructor() {
+        super();
+
+        // if this constructor is used without `new`, it adds `new` before itself:
+        if (!(this instanceof JSZip)) {
+            return new JSZip();
+        }
+
+        if (arguments.length) {
+            throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
+        }
+
+        // object containing the files :
+        // {
+        //   "folder/" : {...},
+        //   "folder/data.txt" : {...}
+        // }
+        // NOTE: we use a null prototype because we do not
+        // want filenames like "toString" coming from a zip file
+        // to overwrite methods and attributes in a normal Object.
+        this.files = Object.create(null);
+
+        this.comment = null;
+
+        // Where we are in the hierarchy
+        this.root = "";
+        this.clone = function () {
+            var newObj = new JSZip();
+            for (var i in this) {
+                if (typeof this[i] !== "function") {
+                    newObj[i] = this[i];
+                }
+            }
+            return newObj;
+        };
+    }
+
+    static support = support;
+    static defaults = defaults;
+
+    // TODO find a better way to handle this version,
+    // a require('package.json').version doesn't work with webpack, see #327
+    static version = "4.0.0";
+
+    loadAsync(content, options) {
+        return load(this, content, options);
+    };
+
+    static loadAsync(content, options) {
+        return new JSZip().loadAsync(content, options);
+    };
+}

package/lib/license_header.js

@@ -0,0 +1,11 @@
+/*!
+
+JSZip v__VERSION__ - A JavaScript class for generating and reading zip files
+<http://stuartk.com/jszip>
+
+(c) 2009-2016 Stuart Knightley <stuart [at] stuartk.com>
+Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/main/LICENSE.markdown.
+
+JSZip uses the library pako released under the MIT license :
+https://github.com/nodeca/pako/blob/main/LICENSE
+*/

package/lib/load.js

@@ -0,0 +1,85 @@
+import utils from "./utils.js";
+import utf8 from "./utf8.js";
+import { ZipEntries } from "./zipEntries.js";
+import { Crc32Probe } from "./stream/Crc32Probe.js";
+import nodejsUtils from "./nodejsUtils.js";
+
+/**
+ * Check the CRC32 of an entry.
+ * @param {ZipEntry} zipEntry the zip entry to check.
+ * @return {Promise} the result.
+ */
+function checkEntryCRC32(zipEntry) {
+    return new Promise(function (resolve, reject) {
+        var worker = zipEntry.decompressed.getContentWorker().pipe(new Crc32Probe());
+        worker.on("error", function (e) {
+            reject(e);
+        })
+            .on("end", function () {
+                if (worker.streamInfo.crc32 !== zipEntry.decompressed.crc32) {
+                    reject(new Error("Corrupted zip : CRC32 mismatch"));
+                } else {
+                    resolve();
+                }
+            })
+            .resume();
+    });
+}
+
+export default function (zip, data, options) {
+    options = utils.extend(options || {}, {
+        base64: false,
+        checkCRC32: false,
+        optimizedBinaryString: false,
+        createFolders: false,
+        decodeFileName: utf8.utf8decode
+    });
+
+    if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
+        return Promise.reject(new Error("JSZip can't accept a stream when loading a zip file."));
+    }
+
+    return utils.prepareContent("the loaded zip file", data, true, options.optimizedBinaryString, options.base64)
+        .then(function (data) {
+            var zipEntries = new ZipEntries(options);
+            zipEntries.load(data);
+            return zipEntries;
+        }).then(function checkCRC32(zipEntries) {
+            var promises = [Promise.resolve(zipEntries)];
+            var files = zipEntries.files;
+            if (options.checkCRC32) {
+                for (var i = 0; i < files.length; i++) {
+                    promises.push(checkEntryCRC32(files[i]));
+                }
+            }
+            return Promise.all(promises);
+        }).then(function addFiles(results) {
+            var zipEntries = results.shift();
+            var files = zipEntries.files;
+            for (var i = 0; i < files.length; i++) {
+                var input = files[i];
+
+                var unsafeName = input.fileNameStr;
+                var safeName = utils.resolve(input.fileNameStr);
+
+                zip.file(safeName, input.decompressed, {
+                    binary: true,
+                    optimizedBinaryString: true,
+                    date: input.date,
+                    dir: input.dir,
+                    comment: input.fileCommentStr.length ? input.fileCommentStr : null,
+                    unixPermissions: input.unixPermissions,
+                    dosPermissions: input.dosPermissions,
+                    createFolders: options.createFolders
+                });
+                if (!input.dir) {
+                    zip.file(safeName).unsafeOriginalName = unsafeName;
+                }
+            }
+            if (zipEntries.zipComment.length) {
+                zip.comment = zipEntries.zipComment;
+            }
+
+            return zip;
+        });
+};

package/lib/nodejs/NodejsStreamInputAdapter.js

@@ -0,0 +1,71 @@
+import { GenericWorker } from "../stream/GenericWorker.js";
+
+export class NodejsStreamInputAdapter extends GenericWorker {
+    /**
+     * A worker that use a nodejs stream as source.
+     * @constructor
+     * @param {String} filename the name of the file entry for this stream.
+     * @param {Readable} stream the nodejs stream.
+     */
+    constructor(filename, stream) {
+        super("Nodejs stream input adapter for " + filename);
+        this._upstreamEnded = false;
+        this._bindStream(stream);
+    }
+
+    /**
+     * Prepare the stream and bind the callbacks on it.
+     * Do this ASAP on node 0.10 ! A lazy binding doesn't always work.
+     * @param {Stream} stream the nodejs stream to use.
+     */
+    _bindStream(stream) {
+        var self = this;
+        this._stream = stream;
+        stream.pause();
+        stream
+            .on("data", function (chunk) {
+                self.push({
+                    data: chunk,
+                    meta: {
+                        percent: 0
+                    }
+                });
+            })
+            .on("error", function (e) {
+                if (self.isPaused) {
+                    this.generatedError = e;
+                } else {
+                    self.error(e);
+                }
+            })
+            .on("end", function () {
+                if (self.isPaused) {
+                    self._upstreamEnded = true;
+                } else {
+                    self.end();
+                }
+            });
+    };
+
+    pause() {
+        if (!GenericWorker.prototype.pause.call(this)) {
+            return false;
+        }
+        this._stream.pause();
+        return true;
+    };
+
+    resume() {
+        if (!GenericWorker.prototype.resume.call(this)) {
+            return false;
+        }
+
+        if (this._upstreamEnded) {
+            this.end();
+        } else {
+            this._stream.resume();
+        }
+
+        return true;
+    };
+}

package/lib/nodejs/NodejsStreamOutputAdapter.js

@@ -0,0 +1,42 @@
+
+//import { Readable } from "readable-stream";
+//var Readable = require("readable-stream").Readable;
+
+//import utils from "../utils.js";
+//utils.inherits(NodejsStreamOutputAdapter, Readable);
+
+// export class NodejsStreamOutputAdapter extends Readable {
+//     /**
+//     * A nodejs stream using a worker as source.
+//     * @see the SourceWrapper in http://nodejs.org/api/stream.html
+//     * @constructor
+//     * @param {StreamHelper} helper the helper wrapping the worker
+//     * @param {Object} options the nodejs stream options
+//     * @param {Function} updateCb the update callback.
+//     */
+//     constructor(helper, options, updateCb) {
+//         Readable.call(this, options);
+//         this._helper = helper;
+
+//         var self = this;
+//         helper.on("data", function (data, meta) {
+//             if (!self.push(data)) {
+//                 self._helper.pause();
+//             }
+//             if (updateCb) {
+//                 updateCb(meta);
+//             }
+//         })
+//             .on("error", function (e) {
+//                 self.emit("error", e);
+//             })
+//             .on("end", function () {
+//                 self.push(null);
+//             });
+//     }
+
+
+//     _read() {
+//         this._helper.resume();
+//     };
+// }

package/lib/nodejsUtils.js

@@ -0,0 +1,55 @@
+export default {
+    /**
+     * True if this is running in Nodejs, will be undefined in a browser.
+     * In a browser, browserify won't include this file and the whole module
+     * will be resolved an empty object.
+     */
+    isNode : typeof Buffer !== "undefined",
+    /**
+     * Create a new nodejs Buffer from an existing content.
+     * @param {Object} data the data to pass to the constructor.
+     * @param {String} encoding the encoding to use.
+     * @return {Buffer} a new Buffer.
+     */
+    newBufferFrom: function(data, encoding) {
+        if (Buffer.from && Buffer.from !== Uint8Array.from) {
+            return Buffer.from(data, encoding);
+        } else {
+            if (typeof data === "number") {
+                // Safeguard for old Node.js versions. On newer versions,
+                // Buffer.from(number) / Buffer(number, encoding) already throw.
+                throw new Error("The \"data\" argument must not be a number");
+            }
+            return new Buffer(data, encoding);
+        }
+    },
+    /**
+     * Create a new nodejs Buffer with the specified size.
+     * @param {Integer} size the size of the buffer.
+     * @return {Buffer} a new Buffer.
+     */
+    allocBuffer: function (size) {
+        if (Buffer.alloc) {
+            return Buffer.alloc(size);
+        } else {
+            var buf = new Buffer(size);
+            buf.fill(0);
+            return buf;
+        }
+    },
+    /**
+     * Find out if an object is a Buffer.
+     * @param {Object} b the object to test.
+     * @return {Boolean} true if the object is a Buffer, false otherwise.
+     */
+    isBuffer : function(b){
+        return Buffer.isBuffer(b);
+    },
+
+    isStream : function (obj) {
+        return obj &&
+            typeof obj.on === "function" &&
+            typeof obj.pause === "function" &&
+            typeof obj.resume === "function";
+    }
+};