@loaders.gl/zip 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/tar/tar.js

@@ -0,0 +1,131 @@
+"use strict";
+// This file is derived from the tar-js code base under MIT license
+// See https://github.com/beatgammit/tar-js/blob/master/LICENSE
+/*
+ * tar-js
+ * MIT (c) 2011 T. Jameson Little
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+const header_1 = require("./header");
+let blockSize;
+let headerLength;
+let inputLength;
+const recordSize = 512;
+class Tar {
+    /**
+     * @param [recordsPerBlock]
+     */
+    constructor(recordsPerBlock) {
+        this.blocks = [];
+        this.written = 0;
+        blockSize = (recordsPerBlock || 20) * recordSize;
+        this.out = (0, utils_1.clean)(blockSize);
+        this.blocks = [];
+        this.length = 0;
+        this.save = this.save.bind(this);
+        this.clear = this.clear.bind(this);
+        this.append = this.append.bind(this);
+    }
+    /**
+     * Append a file to the tar archive
+     * @param filepath
+     * @param input
+     * @param [opts]
+     */
+    // eslint-disable-next-line complexity
+    append(filepath, input, opts) {
+        let checksum;
+        if (typeof input === 'string') {
+            input = (0, utils_1.stringToUint8)(input);
+        }
+        else if (input.constructor && input.constructor !== Uint8Array.prototype.constructor) {
+            // @ts-ignore
+            const errorInputMatch = /function\s*([$A-Za-z_][0-9A-Za-z_]*)\s*\(/.exec(input.constructor.toString());
+            const errorInput = errorInputMatch && errorInputMatch[1];
+            const errorMessage = `Invalid input type. You gave me: ${errorInput}`;
+            throw errorMessage;
+        }
+        opts = opts || {};
+        const mode = opts.mode || parseInt('777', 8) & 0xfff;
+        const mtime = opts.mtime || Math.floor(Number(new Date()) / 1000);
+        const uid = opts.uid || 0;
+        const gid = opts.gid || 0;
+        const data = {
+            fileName: filepath,
+            fileMode: (0, utils_1.pad)(mode, 7),
+            uid: (0, utils_1.pad)(uid, 7),
+            gid: (0, utils_1.pad)(gid, 7),
+            fileSize: (0, utils_1.pad)(input.length, 11),
+            mtime: (0, utils_1.pad)(mtime, 11),
+            checksum: '        ',
+            // 0 = just a file
+            type: '0',
+            ustar: 'ustar  ',
+            owner: opts.owner || '',
+            group: opts.group || ''
+        };
+        // calculate the checksum
+        checksum = 0;
+        Object.keys(data).forEach((key) => {
+            let i;
+            const value = data[key];
+            let length;
+            for (i = 0, length = value.length; i < length; i += 1) {
+                checksum += value.charCodeAt(i);
+            }
+        });
+        data.checksum = `${(0, utils_1.pad)(checksum, 6)}\u0000 `;
+        const headerArr = (0, header_1.format)(data);
+        headerLength = Math.ceil(headerArr.length / recordSize) * recordSize;
+        inputLength = Math.ceil(input.length / recordSize) * recordSize;
+        this.blocks.push({
+            header: headerArr,
+            input,
+            headerLength,
+            inputLength
+        });
+    }
+    /**
+     * Compiling data to a Blob object
+     * @returns {Blob}
+     */
+    save() {
+        const buffers = [];
+        const chunks = new Array();
+        let length = 0;
+        const max = Math.pow(2, 20);
+        let chunk = new Array();
+        this.blocks.forEach((b = []) => {
+            if (length + b.headerLength + b.inputLength > max) {
+                chunks.push({ blocks: chunk, length });
+                chunk = [];
+                length = 0;
+            }
+            chunk.push(b);
+            length += b.headerLength + b.inputLength;
+        });
+        chunks.push({ blocks: chunk, length });
+        chunks.forEach((c = []) => {
+            const buffer = new Uint8Array(c.length);
+            let written = 0;
+            c.blocks.forEach((b = []) => {
+                buffer.set(b.header, written);
+                written += b.headerLength;
+                buffer.set(b.input, written);
+                written += b.inputLength;
+            });
+            buffers.push(buffer);
+        });
+        buffers.push(new Uint8Array(2 * recordSize));
+        return new Blob(buffers, { type: 'octet/stream' });
+    }
+    /**
+     * Clear the data by its blocksize
+     */
+    clear() {
+        this.written = 0;
+        this.out = (0, utils_1.clean)(blockSize);
+    }
+}
+exports.default = Tar;

package/dist/lib/tar/types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Structure of data
+ */
+export declare type TarStructure = {
+    [index: string]: number;
+};
+/**
+ * Image of input data
+ */
+export declare type TarData = {
+    [index: string]: string | any;
+};
+/**
+ * Describes inner content of the blocks in the Tar's constructor
+ */
+export declare type TarBlocks = {
+    [index: string]: any;
+    header?: Uint8Array;
+    input?: string | Uint8Array;
+    headerLength?: number;
+    inputLength?: number;
+};
+/**
+ * Describes additional options for Tar class
+ */
+export declare type TarOptions = {
+    mode?: number;
+    mtime?: number;
+    uid?: number;
+    gid?: number;
+    owner?: any;
+    group?: any;
+};
+/**
+ * Array of numbers for TarChunks
+ */
+export declare type TarChunk = {
+    [index: number]: any;
+};
+/**
+ * Sections of binary data inside the Tar class
+ */
+export declare type TarChunks = {
+    [index: number]: TarChunk;
+    length?: number;
+    blocks?: any;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/tar/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/tar/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,YAAY,GAAG;IACzB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB,CAAC;AACF;;GAEG;AACH,oBAAY,OAAO,GAAG;IACpB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,CAAC;CAC/B,CAAC;AACF;;GAEG;AACH,oBAAY,SAAS,GAAG;IACtB,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC;IACrB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AACF;;GAEG;AACH,oBAAY,UAAU,GAAG;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,KAAK,CAAC,EAAE,GAAG,CAAC;CACb,CAAC;AACF;;GAEG;AACH,oBAAY,QAAQ,GAAG;IACrB,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC;CACtB,CAAC;AACF;;GAEG;AACH,oBAAY,SAAS,GAAG;IACtB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,GAAG,CAAC;CACd,CAAC"}

package/dist/lib/tar/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/tar/utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns the memory area specified by length
+ * @param length
+ * @returns {Uint8Array}
+ */
+export declare function clean(length: number): Uint8Array;
+/**
+ * Converting data to a string
+ * @param num
+ * @param bytes
+ * @param base
+ * @returns string
+ */
+export declare function pad(num: number, bytes: number, base?: number): string;
+/**
+ * Converting input to binary data
+ * @param input
+ * @param out
+ * @param offset
+ * @returns {Uint8Array}
+ */
+export declare function stringToUint8(input: string, out?: Uint8Array, offset?: number): Uint8Array;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/tar/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/tar/utils.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAOhD;AACD;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAGrE;AACD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAa1F"}

package/dist/lib/tar/utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToUint8 = exports.pad = exports.clean = void 0;
+// This file is derived from the tar-js code base under MIT license
+// See https://github.com/beatgammit/tar-js/blob/master/LICENSE
+/*
+ * tar-js
+ * MIT (c) 2011 T. Jameson Little
+ */
+/**
+ * Returns the memory area specified by length
+ * @param length
+ * @returns {Uint8Array}
+ */
+function clean(length) {
+    let i;
+    const buffer = new Uint8Array(length);
+    for (i = 0; i < length; i += 1) {
+        buffer[i] = 0;
+    }
+    return buffer;
+}
+exports.clean = clean;
+/**
+ * Converting data to a string
+ * @param num
+ * @param bytes
+ * @param base
+ * @returns string
+ */
+function pad(num, bytes, base) {
+    const numStr = num.toString(base || 8);
+    return '000000000000'.substr(numStr.length + 12 - bytes) + numStr;
+}
+exports.pad = pad;
+/**
+ * Converting input to binary data
+ * @param input
+ * @param out
+ * @param offset
+ * @returns {Uint8Array}
+ */
+function stringToUint8(input, out, offset) {
+    let i;
+    let length;
+    out = out || clean(input.length);
+    offset = offset || 0;
+    for (i = 0, length = input.length; i < length; i += 1) {
+        out[offset] = input.charCodeAt(i);
+        offset += 1;
+    }
+    return out;
+}
+exports.stringToUint8 = stringToUint8;

package/dist/tar-builder.d.ts

@@ -0,0 +1,28 @@
+import Tar from './lib/tar/tar';
+declare type TarBuilderOptions = {
+    recordsPerBlock?: number;
+};
+/**
+ * Build a tar file by adding files
+ */
+export default class TARBuilder {
+    static get properties(): {
+        id: string;
+        name: string;
+        extensions: string[];
+        mimeTypes: string[];
+        builder: typeof TARBuilder;
+        options: {
+            recordsPerBlock: number;
+        };
+    };
+    options: TarBuilderOptions;
+    tape: Tar;
+    count: number;
+    constructor(options?: Partial<TarBuilderOptions>);
+    /** Adds a file to the archive. */
+    addFile(filename: string, buffer: ArrayBuffer): void;
+    build(): Promise<ArrayBuffer>;
+}
+export {};
+//# sourceMappingURL=tar-builder.d.ts.map

package/dist/tar-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tar-builder.d.ts","sourceRoot":"","sources":["../src/tar-builder.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,eAAe,CAAC;AAMhC,aAAK,iBAAiB,GAAG;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,MAAM,KAAK,UAAU;;;;;;;;;MASpB;IAED,OAAO,EAAE,iBAAiB,CAAC;IAC3B,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,EAAE,MAAM,CAAK;gBAEN,OAAO,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;IAIhD,kCAAkC;IAClC,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW;IAKvC,KAAK,IAAI,OAAO,CAAC,WAAW,CAAC;CAGpC"}

package/dist/tar-builder.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tar_1 = __importDefault(require("./lib/tar/tar"));
+const TAR_BUILDER_OPTIONS = {
+    recordsPerBlock: 20
+};
+/**
+ * Build a tar file by adding files
+ */
+class TARBuilder {
+    constructor(options) {
+        this.count = 0;
+        this.options = { ...TAR_BUILDER_OPTIONS, ...options };
+        this.tape = new tar_1.default(this.options.recordsPerBlock);
+    }
+    static get properties() {
+        return {
+            id: 'tar',
+            name: 'TAR',
+            extensions: ['tar'],
+            mimeTypes: ['application/x-tar'],
+            builder: TARBuilder,
+            options: TAR_BUILDER_OPTIONS
+        };
+    }
+    /** Adds a file to the archive. */
+    addFile(filename, buffer) {
+        this.tape.append(filename, new Uint8Array(buffer));
+        this.count++;
+    }
+    async build() {
+        return new Response(this.tape.save()).arrayBuffer();
+    }
+}
+exports.default = TARBuilder;

package/dist/zip-loader.d.ts

@@ -0,0 +1,18 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+export declare const ZipLoader: {
+    id: string;
+    module: string;
+    name: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    category: string;
+    tests: string[];
+    options: {};
+    parse: typeof parseZipAsync;
+};
+declare type FileMap = Record<string, ArrayBuffer>;
+declare function parseZipAsync(data: any, options?: {}): Promise<FileMap>;
+export declare const _typecheckZipLoader: LoaderWithParser;
+export {};
+//# sourceMappingURL=zip-loader.d.ts.map

package/dist/zip-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-loader.d.ts","sourceRoot":"","sources":["../src/zip-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAO/D,eAAO,MAAM,SAAS;;;;;;;;;;;CAWrB,CAAC;AAEF,aAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAG3C,iBAAe,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CA4BtE;AAeD,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC"}

package/dist/zip-loader.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckZipLoader = exports.ZipLoader = void 0;
+const jszip_1 = __importDefault(require("jszip"));
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+exports.ZipLoader = {
+    id: 'zip',
+    module: 'zip',
+    name: 'Zip Archive',
+    version: VERSION,
+    extensions: ['zip'],
+    mimeTypes: ['application/zip'],
+    category: 'archive',
+    tests: ['PK'],
+    options: {},
+    parse: parseZipAsync
+};
+// TODO - Could return a map of promises, perhaps as an option...
+async function parseZipAsync(data, options = {}) {
+    const promises = [];
+    const fileMap = {};
+    try {
+        const jsZip = new jszip_1.default();
+        const zip = await jsZip.loadAsync(data, options);
+        // start to load each file in this zip
+        zip.forEach((relativePath, zipEntry) => {
+            const subFilename = zipEntry.name;
+            const promise = loadZipEntry(jsZip, subFilename, options).then((arrayBufferOrError) => {
+                fileMap[relativePath] = arrayBufferOrError;
+            });
+            // Ensure Promise.all doesn't ignore rejected promises.
+            promises.push(promise);
+        });
+        await Promise.all(promises);
+        return fileMap;
+    }
+    catch (error) {
+        // @ts-ignore
+        options.log.error(`Unable to read zip archive: ${error}`);
+        throw error;
+    }
+}
+async function loadZipEntry(jsZip, subFilename, options = {}) {
+    // jszip supports both arraybuffer and text, the main loaders.gl types
+    // https://stuk.github.io/jszip/documentation/api_zipobject/async.html
+    try {
+        const arrayBuffer = await jsZip.file(subFilename).async(options.dataType || 'arraybuffer');
+        return arrayBuffer;
+    }
+    catch (error) {
+        options.log.error(`Unable to read ${subFilename} from zip archive: ${error}`);
+        // Store error in place of data in map
+        return error;
+    }
+}
+exports._typecheckZipLoader = exports.ZipLoader;

package/dist/zip-writer.d.ts

@@ -0,0 +1,6 @@
+import type { Writer } from '@loaders.gl/loader-utils';
+/**
+ * Zip exporter
+ */
+export declare const ZipWriter: Writer;
+//# sourceMappingURL=zip-writer.d.ts.map

package/dist/zip-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-writer.d.ts","sourceRoot":"","sources":["../src/zip-writer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAGrD;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,MAOvB,CAAC"}

package/dist/zip-writer.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipWriter = void 0;
+const jszip_1 = __importDefault(require("jszip"));
+/**
+ * Zip exporter
+ */
+exports.ZipWriter = {
+    name: 'Zip Archive',
+    extensions: ['zip'],
+    category: 'archive',
+    mimeTypes: ['application/zip'],
+    // @ts-ignore
+    encode: encodeZipAsync
+};
+async function encodeZipAsync(fileMap, options = {}) {
+    const jsZip = new jszip_1.default();
+    // add files to the zip
+    for (const subFileName in fileMap) {
+        const subFileData = fileMap[subFileName];
+        // jszip supports both arraybuffer and string data (the main loaders.gl types)
+        // https://stuk.github.io/jszip/documentation/api_zipobject/async.html
+        jsZip.file(subFileName, subFileData, options);
+    }
+    // always generate the full zip as an arraybuffer
+    options = Object.assign({}, options, {
+        type: 'arraybuffer'
+    });
+    const { onUpdate = () => { } } = options;
+    return jsZip.generateAsync(options, onUpdate).catch((error) => {
+        options.log.error(`Unable to write zip archive: ${error}`);
+        throw error;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/zip",
-  "version": "3.1.0-alpha.4",
+  "version": "3.1.0-beta.3",
   "description": "Zip Archive Loader",
   "license": "MIT",
   "publishConfig": {
@@ -16,7 +16,7 @@
     "archive",
     "ZIP"
   ],
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "main": "dist/es5/index.js",
   "module": "dist/esm/index.js",
   "sideEffects": false,
@@ -27,11 +27,13 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle",
-    "build-bundle": "webpack --display=minimal --config ../../scripts/webpack/bundle.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js"
   },
   "dependencies": {
-    "@loaders.gl/core": "3.1.0-alpha.4",
     "jszip": "^3.1.5"
   },
-  "gitHead": "e309784af37ef9f3640c7733c7851124c72e1fa3"
+  "peerDependencies": {
+    "@loaders.gl/core": "3.1.0-beta.1"
+  },
+  "gitHead": "3537c382b3ea4e092b24b6f94c3edee72076039c"
 }

package/src/lib/tar/header.ts

@@ -4,7 +4,7 @@
  * tar-js
  * MIT (c) 2011 T. Jameson Little
  */
-
+/* eslint-disable */
 import * as utils from './utils';
 import type {TarStructure, TarData} from './types';
 /*

package/src/lib/tar/tar.ts

@@ -65,7 +65,7 @@ class Tar {
     const uid = opts.uid || 0;
     const gid = opts.gid || 0;
 
-    const data = {
+    const data: Record<string, string> = {
       fileName: filepath,
       fileMode: pad(mode, 7),
       uid: pad(uid, 7),

package/src/zip-loader.ts

@@ -19,10 +19,12 @@ export const ZipLoader = {
   parse: parseZipAsync
 };
 
+type FileMap = Record<string, ArrayBuffer>;
+
 // TODO - Could return a map of promises, perhaps as an option...
-async function parseZipAsync(data: any, options = {}) {
+async function parseZipAsync(data: any, options = {}): Promise<FileMap> {
   const promises: Promise<any>[] = [];
-  const fileMap = {};
+  const fileMap: Record<string, ArrayBuffer> = {};
 
   try {
     const jsZip = new JSZip();