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

package/dist/node/file/blob-stream-controller.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobStreamController = void 0;
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+class BlobStreamController {
+    /**
+     * @param chunks
+     */
+    constructor(chunks) {
+        this.isWorking = false;
+        this.isCancelled = false;
+        this.chunks = chunks;
+    }
+    /**
+     * @param controller
+     */
+    start(controller) {
+        this.work(controller); // eslint-disable-line @typescript-eslint/no-floating-promises
+    }
+    /**
+     *
+     * @param controller
+     */
+    async work(controller) {
+        const { chunks } = this;
+        this.isWorking = true;
+        while (!this.isCancelled && (controller.desiredSize || 0) > 0) {
+            let next;
+            try {
+                next = chunks.next();
+            }
+            catch (error) {
+                controller.error(error);
+                break;
+            }
+            if (next) {
+                if (!next.done && !this.isCancelled) {
+                    controller.enqueue(next.value);
+                }
+                else {
+                    controller.close();
+                }
+            }
+        }
+        this.isWorking = false;
+    }
+    /**
+     *
+     * @param {ReadableStreamDefaultController} controller
+     */
+    pull(controller) {
+        if (!this.isWorking) {
+            this.work(controller); // eslint-disable-line @typescript-eslint/no-floating-promises
+        }
+    }
+    cancel() {
+        this.isCancelled = true;
+    }
+}
+exports.BlobStreamController = BlobStreamController;

package/dist/node/file/blob-stream.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+import { ReadableStreamPolyfill } from './readable-stream';
+/**
+ * Blob stream is a `ReadableStream` extension optimized to have minimal
+ * overhead when consumed as `AsyncIterable<Uint8Array>`.
+ * extends {ReadableStream<Uint8Array>}
+ * implements {AsyncIterable<Uint8Array>}
+ */
+export declare class BlobStream<T> extends ReadableStreamPolyfill<T> {
+    private readonly _chunks;
+    /**
+     * @param chunks
+     */
+    constructor(chunks: any);
+    /**
+     * @property [_options.preventCancel]
+     */
+    [Symbol.asyncIterator](_options?: {
+        preventCancel?: boolean;
+    }): AsyncIterable<Uint8Array>;
+}
+//# sourceMappingURL=blob-stream.d.ts.map

package/dist/node/file/blob-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-stream.d.ts","sourceRoot":"","sources":["../../../src/node/file/blob-stream.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAC,sBAAsB,EAAC,MAAM,mBAAmB,CAAC;AAGzD;;;;;GAKG;AAEH,qBAAa,UAAU,CAAC,CAAC,CAAE,SAAQ,sBAAsB,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC;;OAEG;gBACS,MAAM,KAAA;IAOlB;;OAEG;IAEI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,EAAE;QAAC,aAAa,CAAC,EAAE,OAAO,CAAA;KAAC,GAAG,aAAa,CAAC,UAAU,CAAC;CAK/F"}

package/dist/node/file/blob-stream.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobStream = void 0;
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+const readable_stream_1 = require("./readable-stream");
+const blob_stream_controller_1 = require("./blob-stream-controller");
+/**
+ * Blob stream is a `ReadableStream` extension optimized to have minimal
+ * overhead when consumed as `AsyncIterable<Uint8Array>`.
+ * extends {ReadableStream<Uint8Array>}
+ * implements {AsyncIterable<Uint8Array>}
+ */
+// @ts-ignore
+class BlobStream extends readable_stream_1.ReadableStreamPolyfill {
+    /**
+     * @param chunks
+     */
+    constructor(chunks) {
+        // @ts-ignore
+        super(new blob_stream_controller_1.BlobStreamController(chunks.values()), { type: 'bytes' });
+        /** @private */
+        this._chunks = chunks;
+    }
+    /**
+     * @property [_options.preventCancel]
+     */
+    // @ts-ignore
+    async *[Symbol.asyncIterator](_options) {
+        const reader = this.getReader();
+        yield* this._chunks;
+        reader.releaseLock();
+    }
+}
+exports.BlobStream = BlobStream;

package/dist/node/file/blob.d.ts

@@ -0,0 +1,58 @@
+import { BlobStream } from './blob-stream';
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+export declare class BlobPolyfill {
+    /** The MIME type of the data contained in the Blob. If type is unknown, string is empty. */
+    readonly type: string;
+    /** The size, in bytes, of the data contained in the Blob object. */
+    size: number;
+    private parts;
+    /**
+     * @param [init]
+     * @param [options]
+     */
+    constructor(init?: BlobPart[], options?: BlobPropertyBag);
+    /**
+     * Returns a new Blob object containing the data in the specified range of
+     * bytes of the blob on which it's called.
+     * @param start=0 - An index into the Blob indicating the first
+     * byte to include in the new Blob. If you specify a negative value, it's
+     * treated as an offset from the end of the Blob toward the beginning. For
+     * example, `-10` would be the 10th from last byte in the Blob. The default
+     * value is `0`. If you specify a value for start that is larger than the
+     * size of the source Blob, the returned Blob has size 0 and contains no
+     * data.
+     * @param end - An index into the `Blob` indicating the first byte
+     *  that will *not* be included in the new `Blob` (i.e. the byte exactly at
+     * this index is not included). If you specify a negative value, it's treated
+     * as an offset from the end of the Blob toward the beginning. For example,
+     * `-10` would be the 10th from last byte in the `Blob`. The default value is
+     * size.
+     * @param type - The content type to assign to the new Blob;
+     * this will be the value of its type property. The default value is an empty
+     * string.
+     */
+    slice(start?: number, end?: number, type?: string): Blob;
+    /**
+     * Returns a promise that resolves with an ArrayBuffer containing the entire
+     * contents of the Blob as binary data.
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Returns a promise that resolves with a USVString containing the entire
+     * contents of the Blob interpreted as UTF-8 text.
+     */
+    text(): Promise<string>;
+    /**
+     */
+    stream(): BlobStream<any>;
+    /**
+     * @returns {string}
+     */
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+    _toArrayBuffer(): ArrayBuffer;
+}
+//# sourceMappingURL=blob.d.ts.map

package/dist/node/file/blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../../../src/node/file/blob.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC;;;GAGG;AACH,qBAAa,YAAY;IAEvB,4FAA4F;IAC5F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,KAAK,CAAe;IAC5B;;;OAGG;gBACS,IAAI,GAAE,QAAQ,EAAO,EAAE,OAAO,GAAE,eAAoB;IAmChE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,CAAC,KAAK,GAAE,MAAU,EAAE,GAAG,GAAE,MAAkB,EAAE,IAAI,GAAE,MAAW,GAAG,IAAI;IAyC1E;;;OAGG;IAEG,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAIzC;;;OAGG;IAEG,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAS7B;OACG;IAEH,MAAM,IAAI,UAAU,CAAC,GAAG,CAAC;IAIzB;;OAEG;IACH,QAAQ;IAIR,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAEvB;IAED,cAAc,IAAI,WAAW;CAU9B"}

package/dist/node/file/blob.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobPolyfill = void 0;
+// Forked from @gozala's web-blob under MIT license https://github.com/Gozala/web-blob
+const blob_stream_1 = require("./blob-stream");
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+class BlobPolyfill {
+    /**
+     * @param [init]
+     * @param [options]
+     */
+    constructor(init = [], options = {}) {
+        this.parts = [];
+        this.size = 0;
+        for (const part of init) {
+            if (typeof part === 'string') {
+                const bytes = new TextEncoder().encode(part);
+                this.parts.push(bytes);
+                this.size += bytes.byteLength;
+            }
+            else if (part instanceof BlobPolyfill) {
+                this.size += part.size;
+                // @ts-ignore - `parts` is marked private so TS will complain about
+                // accessing it.
+                this.parts.push(...part.parts);
+            }
+            else if (part instanceof ArrayBuffer) {
+                this.parts.push(new Uint8Array(part));
+                this.size += part.byteLength;
+            }
+            else if (part instanceof Uint8Array) {
+                this.parts.push(part);
+                this.size += part.byteLength;
+            }
+            else if (ArrayBuffer.isView(part)) {
+                const { buffer, byteOffset, byteLength } = part;
+                this.parts.push(new Uint8Array(buffer, byteOffset, byteLength));
+                this.size += byteLength;
+            }
+            else {
+                const bytes = new TextEncoder().encode(String(part));
+                this.parts.push(bytes);
+                this.size += bytes.byteLength;
+            }
+        }
+        /** @private */
+        this.type = readType(options.type);
+    }
+    /**
+     * Returns a new Blob object containing the data in the specified range of
+     * bytes of the blob on which it's called.
+     * @param start=0 - An index into the Blob indicating the first
+     * byte to include in the new Blob. If you specify a negative value, it's
+     * treated as an offset from the end of the Blob toward the beginning. For
+     * example, `-10` would be the 10th from last byte in the Blob. The default
+     * value is `0`. If you specify a value for start that is larger than the
+     * size of the source Blob, the returned Blob has size 0 and contains no
+     * data.
+     * @param end - An index into the `Blob` indicating the first byte
+     *  that will *not* be included in the new `Blob` (i.e. the byte exactly at
+     * this index is not included). If you specify a negative value, it's treated
+     * as an offset from the end of the Blob toward the beginning. For example,
+     * `-10` would be the 10th from last byte in the `Blob`. The default value is
+     * size.
+     * @param type - The content type to assign to the new Blob;
+     * this will be the value of its type property. The default value is an empty
+     * string.
+     */
+    slice(start = 0, end = this.size, type = '') {
+        const { size, parts: parts } = this;
+        let offset = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+        let limit = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+        const span = Math.max(limit - offset, 0);
+        const blob = new BlobPolyfill([], { type });
+        if (span === 0) {
+            // @ts-ignore
+            return blob;
+        }
+        let blobSize = 0;
+        const blobParts = [];
+        for (const part of parts) {
+            const { byteLength } = part;
+            if (offset > 0 && byteLength <= offset) {
+                offset -= byteLength;
+                limit -= byteLength;
+            }
+            else {
+                const chunk = part.subarray(offset, Math.min(byteLength, limit));
+                blobParts.push(chunk);
+                blobSize += chunk.byteLength;
+                // no longer need to take that into account
+                offset = 0;
+                // don't add the overflow to new blobParts
+                if (blobSize >= span) {
+                    break;
+                }
+            }
+        }
+        blob.parts = blobParts;
+        blob.size = blobSize;
+        // @ts-ignore
+        return blob;
+    }
+    /**
+     * Returns a promise that resolves with an ArrayBuffer containing the entire
+     * contents of the Blob as binary data.
+     */
+    // eslint-disable-next-line require-await
+    async arrayBuffer() {
+        return this._toArrayBuffer();
+    }
+    /**
+     * Returns a promise that resolves with a USVString containing the entire
+     * contents of the Blob interpreted as UTF-8 text.
+     */
+    // eslint-disable-next-line require-await
+    async text() {
+        const decoder = new TextDecoder();
+        let text = '';
+        for (const part of this.parts) {
+            text += decoder.decode(part);
+        }
+        return text;
+    }
+    /**
+     */
+    // @ts-ignore
+    stream() {
+        return new blob_stream_1.BlobStream(this.parts);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        return '[object Blob]';
+    }
+    get [Symbol.toStringTag]() {
+        return 'Blob';
+    }
+    _toArrayBuffer() {
+        const buffer = new ArrayBuffer(this.size);
+        const bytes = new Uint8Array(buffer);
+        let offset = 0;
+        for (const part of this.parts) {
+            bytes.set(part, offset);
+            offset += part.byteLength;
+        }
+        return buffer;
+    }
+}
+exports.BlobPolyfill = BlobPolyfill;
+/**
+ */
+function readType(input = '') {
+    const type = String(input).toLowerCase();
+    return /[^\u0020-\u007E]/.test(type) ? '' : type;
+}

package/dist/node/file/file-reader.d.ts

@@ -0,0 +1,24 @@
+export declare class FileReaderPolyfill implements FileReader {
+    onload: any;
+    onabort: any;
+    onerror: any;
+    error: any;
+    onloadstart: any;
+    onloadend: any;
+    onprogress: any;
+    readyState: any;
+    result: any;
+    DONE: any;
+    EMPTY: any;
+    LOADING: any;
+    addEventListener: any;
+    removeEventListener: any;
+    dispatchEvent: any;
+    constructor();
+    abort(): void;
+    readAsArrayBuffer(blob: Blob): Promise<void>;
+    readAsBinaryString(blob: any): Promise<void>;
+    readAsDataURL(blob: any): Promise<void>;
+    readAsText(blob: any): Promise<void>;
+}
+//# sourceMappingURL=file-reader.d.ts.map

package/dist/node/file/file-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-reader.d.ts","sourceRoot":"","sources":["../../../src/node/file/file-reader.ts"],"names":[],"mappings":"AAEA,qBAAa,kBAAmB,YAAW,UAAU;IAEnD,MAAM,MAAC;IACP,OAAO,MAAC;IACR,OAAO,MAAC;IACR,KAAK,MAAC;IACN,WAAW,MAAC;IACZ,SAAS,MAAC;IACV,UAAU,MAAC;IAEX,UAAU,MAAC;IACX,MAAM,MAAC;IACP,IAAI,MAAC;IACL,KAAK,MAAC;IACN,OAAO,MAAC;IACR,gBAAgB,MAAC;IACjB,mBAAmB,MAAC;IACpB,aAAa,MAAC;;IAMd,KAAK,IAAI,IAAI;IAIP,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5C,kBAAkB,CAAC,IAAI,KAAA;IAIvB,aAAa,CAAC,IAAI,KAAA;IAQlB,UAAU,CAAC,IAAI,KAAA;CAMtB"}

package/dist/node/file/file-reader.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileReaderPolyfill = void 0;
+const btoa_node_1 = require("../buffer/btoa.node");
+class FileReaderPolyfill {
+    constructor() {
+        this.onload = null;
+    }
+    abort() {
+        return;
+    }
+    async readAsArrayBuffer(blob) {
+        const arrayBuffer = await blob.arrayBuffer();
+        if (this.onload) {
+            this.onload({ target: { result: arrayBuffer } });
+        }
+    }
+    async readAsBinaryString(blob) {
+        throw Error('Not implemented');
+    }
+    async readAsDataURL(blob) {
+        const text = await blob.text();
+        const dataUrl = `data://;base64,${(0, btoa_node_1.atob)(text)}`;
+        if (this.onload) {
+            this.onload({ target: { result: dataUrl } });
+        }
+    }
+    async readAsText(blob) {
+        const text = await blob.text();
+        if (this.onload) {
+            this.onload({ target: { result: text } });
+        }
+    }
+}
+exports.FileReaderPolyfill = FileReaderPolyfill;

package/dist/node/file/file.d.ts

@@ -0,0 +1,25 @@
+import { BlobPolyfill } from './blob';
+/**
+ * Forked from @gozala's web-file under MIT license
+ * @see https://github.com/Gozala/web-file
+ */
+export declare class FilePolyfill extends BlobPolyfill {
+    /** The name of the file referenced by the File object. */
+    name: string;
+    /** The path the URL of the File is relative to. */
+    webkitRelativePath: string;
+    /**
+     * Returns the last modified time of the file, in millisecond since the UNIX
+     * epoch (January 1st, 1970 at Midnight).
+     */
+    lastModified: number;
+    /**
+     * @param init
+     * @param name - A USVString representing the file name or the path
+     * to the file.
+     * @param [options]
+     */
+    constructor(init: BlobPart[], name: string, options?: FilePropertyBag);
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=file.d.ts.map

package/dist/node/file/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../src/node/file/file.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAC,MAAM,QAAQ,CAAC;AAEpC;;;GAGG;AAEH,qBAAa,YAAa,SAAQ,YAAY;IAG5C,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAM;IAClB,mDAAmD;IACnD,kBAAkB,EAAE,MAAM,CAAM;IAEhC;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;gBACS,IAAI,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB;IAUzE,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAEvB;CACF"}

package/dist/node/file/file.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilePolyfill = void 0;
+// Forked from @gozala's web-file under MIT license https://github.com/Gozala/web-file
+const blob_1 = require("./blob");
+/**
+ * Forked from @gozala's web-file under MIT license
+ * @see https://github.com/Gozala/web-file
+ */
+// @ts-ignore
+class FilePolyfill extends blob_1.BlobPolyfill {
+    /**
+     * @param init
+     * @param name - A USVString representing the file name or the path
+     * to the file.
+     * @param [options]
+     */
+    constructor(init, name, options = {}) {
+        super(init, options);
+        // implements File {
+        // public API
+        /** The name of the file referenced by the File object. */
+        this.name = '';
+        /** The path the URL of the File is relative to. */
+        this.webkitRelativePath = '';
+        // Per File API spec https://w3c.github.io/FileAPI/#file-constructor
+        // Every "/" character of file name must be replaced with a ":".
+        /** @private */
+        this.name = String(name).replace(/\//g, ':');
+        /** @private */
+        this.lastModified = options?.lastModified || Date.now();
+    }
+    get [Symbol.toStringTag]() {
+        return 'File';
+    }
+}
+exports.FilePolyfill = FilePolyfill;

package/dist/node/file/install-file-polyfills.d.ts

@@ -0,0 +1,2 @@
+export declare function installFilePolyfills(): void;
+//# sourceMappingURL=install-file-polyfills.d.ts.map

package/dist/node/file/install-file-polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-file-polyfills.d.ts","sourceRoot":"","sources":["../../../src/node/file/install-file-polyfills.ts"],"names":[],"mappings":"AAKA,wBAAgB,oBAAoB,SAqBnC"}

package/dist/node/file/install-file-polyfills.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installFilePolyfills = void 0;
+const readable_stream_1 = require("./readable-stream");
+const blob_1 = require("./blob");
+const file_reader_1 = require("./file-reader");
+const file_1 = require("./file");
+function installFilePolyfills() {
+    if (typeof ReadableStream === 'undefined' && global) {
+        // @ts-ignore;
+        global.ReadableStream = readable_stream_1.ReadableStreamPolyfill;
+    }
+    if (typeof Blob === 'undefined' && global) {
+        // @ts-ignore;
+        global.Blob = blob_1.BlobPolyfill;
+    }
+    if (typeof FileReader === 'undefined' && global) {
+        // @ts-ignore;
+        global.FileReader = file_reader_1.FileReaderPolyfill;
+    }
+    // Install minimal Node.js File polyfill
+    if (typeof File === 'undefined' && global) {
+        // @ts-ignore;
+        global.File = file_1.FilePolyfill;
+    }
+}
+exports.installFilePolyfills = installFilePolyfills;

package/dist/node/file/readable-stream.d.ts

@@ -0,0 +1,4 @@
+import { ReadableStream as WSPReadableStream } from 'web-streams-polyfill';
+export declare class ReadableStreamPolyfill<T> extends WSPReadableStream<T> implements ReadableStream {
+}
+//# sourceMappingURL=readable-stream.d.ts.map

package/dist/node/file/readable-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readable-stream.d.ts","sourceRoot":"","sources":["../../../src/node/file/readable-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,IAAI,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAOzE,qBAAa,sBAAsB,CAAC,CAAC,CAAE,SAAQ,iBAAiB,CAAC,CAAC,CAAE,YAAW,cAAc;CAAG"}

package/dist/node/file/readable-stream.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadableStreamPolyfill = void 0;
+const web_streams_polyfill_1 = require("web-streams-polyfill");
+// Want a polyfill, but please don't install it
+// @ts-ignore
+delete global.ReadableStream;
+// @ts-ignore
+class ReadableStreamPolyfill extends web_streams_polyfill_1.ReadableStream {
+}
+exports.ReadableStreamPolyfill = ReadableStreamPolyfill;

package/dist/node/images/encode-image.node.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns data bytes representing a compressed image in PNG or JPG format,
+ * This data can be saved using file system (f) methods or
+ * used in a request.
+ * @param image to save
+ * @param options
+ * @param options.type='png' - png, jpg or image/png, image/jpg are valid
+ * @param options.dataURI - Whether to include a data URI header
+ * @return {*} bytes
+ */
+export declare function encodeImageToStreamNode(image: {
+    data: any;
+    width: number;
+    height: number;
+}, options: {
+    type?: string;
+    dataURI?: string;
+}): any;
+export declare function encodeImageNode(image: any, options: any): Promise<unknown>;
+//# sourceMappingURL=encode-image.node.d.ts.map

package/dist/node/images/encode-image.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-image.node.d.ts","sourceRoot":"","sources":["../../../src/node/images/encode-image.node.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE;IAAC,IAAI,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,EACjD,OAAO,EAAE;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,OAQ3C;AAED,wBAAgB,eAAe,CAAC,KAAK,KAAA,EAAE,OAAO,KAAA,oBAY7C"}

package/dist/node/images/encode-image.node.js

@@ -0,0 +1,41 @@
+"use strict";
+// Use stackgl modules for DOM-less reading and writing of images
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeImageNode = exports.encodeImageToStreamNode = void 0;
+const save_pixels_1 = __importDefault(require("save-pixels"));
+const ndarray_1 = __importDefault(require("ndarray"));
+const to_array_buffer_node_1 = require("../buffer/to-array-buffer.node");
+/**
+ * Returns data bytes representing a compressed image in PNG or JPG format,
+ * This data can be saved using file system (f) methods or
+ * used in a request.
+ * @param image to save
+ * @param options
+ * @param options.type='png' - png, jpg or image/png, image/jpg are valid
+ * @param options.dataURI - Whether to include a data URI header
+ * @return {*} bytes
+ */
+function encodeImageToStreamNode(image, options) {
+    // Support MIME type strings
+    const type = options.type ? options.type.replace('image/', '') : 'jpeg';
+    const pixels = (0, ndarray_1.default)(image.data, [image.width, image.height, 4], [4, image.width * 4, 1], 0);
+    // Note: savePixels returns a stream
+    return (0, save_pixels_1.default)(pixels, type, options);
+}
+exports.encodeImageToStreamNode = encodeImageToStreamNode;
+function encodeImageNode(image, options) {
+    const imageStream = encodeImageToStreamNode(image, options);
+    return new Promise((resolve) => {
+        const buffers = [];
+        imageStream.on('data', (buffer) => buffers.push(buffer));
+        // TODO - convert to arraybuffer?
+        imageStream.on('end', () => {
+            const buffer = Buffer.concat(buffers);
+            resolve((0, to_array_buffer_node_1.bufferToArrayBuffer)(buffer));
+        });
+    });
+}
+exports.encodeImageNode = encodeImageNode;

package/dist/node/images/parse-image.node.d.ts

@@ -0,0 +1,11 @@
+declare type NDArray = {
+    shape: number[];
+    data: Uint8Array;
+    width: number;
+    height: number;
+    components: number;
+    layers: number[];
+};
+export declare function parseImageNode(arrayBuffer: ArrayBuffer, mimeType: string): Promise<NDArray>;
+export {};
+//# sourceMappingURL=parse-image.node.d.ts.map

package/dist/node/images/parse-image.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-image.node.d.ts","sourceRoot":"","sources":["../../../src/node/images/parse-image.node.ts"],"names":[],"mappings":"AAKA,aAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,wBAAsB,cAAc,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAuBjG"}

package/dist/node/images/parse-image.node.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseImageNode = void 0;
+const get_pixels_1 = __importDefault(require("get-pixels"));
+const assert_1 = require("../../utils/assert");
+const util_1 = __importDefault(require("util"));
+async function parseImageNode(arrayBuffer, mimeType) {
+    (0, assert_1.assert)(mimeType, 'MIMEType is required to parse image under Node.js');
+    // TODO - check if getPixels callback is asynchronous if provided with buffer input
+    // if not, parseImage can be a sync function
+    const getPixelsAsync = util_1.default.promisify(get_pixels_1.default);
+    const buffer = arrayBuffer instanceof Buffer ? arrayBuffer : Buffer.from(arrayBuffer);
+    const ndarray = await getPixelsAsync(buffer, mimeType);
+    const shape = [...ndarray.shape];
+    const layers = ndarray.shape.length === 4 ? ndarray.shape.shift() : 1;
+    // extract width/height etc
+    return {
+        shape,
+        data: ndarray.data,
+        width: ndarray.shape[0],
+        height: ndarray.shape[1],
+        components: ndarray.shape[2],
+        layers
+    };
+}
+exports.parseImageNode = parseImageNode;