univ-conv/commonjs/converters/BlobConverter.js

The universal binary and text converter

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BlobConverter = void 0;
const AbstractConverter_1 = require("./AbstractConverter");
const core_1 = require("./core");
const Environment_1 = require("./Environment");
const StringUtil_1 = require("./StringUtil");
class BlobConverter extends AbstractConverter_1.AbstractConverter {
    constructor() {
        super(...arguments);
        this.type = "blob";
    }
    empty() {
        return Environment_1.EMPTY_BLOB;
    }
    is(input) {
        return Environment_1.hasBlob && input instanceof Blob;
    }
    async _from(input, options) {
        if (this.is(input)) {
            if ((0, core_1.hasNoStartLength)(options)) {
                return input;
            }
            const { start, end } = await this._getStartEnd(input, options);
            return input.slice(start, end);
        }
        const u8 = await (0, AbstractConverter_1._)().convert("uint8array", input, options);
        return new Blob([u8]);
    }
    _getStartEnd(input, options) {
        return Promise.resolve((0, core_1.getStartEnd)(options, input.size));
    }
    _isEmpty(input) {
        return input.size === 0;
    }
    _merge(chunks) {
        return Promise.resolve(new Blob(chunks));
    }
    _size(input) {
        return Promise.resolve(input.size);
    }
    async _toArrayBuffer(input, options) {
        const u8 = await this._toUint8Array(input, options);
        return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
    }
    async _toBase64(input, options) {
        const startEnd = await this._getStartEnd(input, options);
        let start = startEnd.start;
        const end = startEnd.end;
        const chunks = [];
        const bufferSize = options.bufferSize;
        for (; start < end; start += bufferSize) {
            let e = start + bufferSize;
            if (end < e)
                e = end;
            const blobChunk = input.slice(start, e);
            const chunk = await (0, Environment_1.handleFileReader)((reader) => reader.readAsDataURL(blobChunk), (data) => (0, StringUtil_1.dataUrlToBase64)(data));
            chunks.push(chunk);
        }
        return chunks.join("");
    }
    async _toText(input, options) {
        if (options.bufferToTextCharset === "utf8") {
            if (Environment_1.hasTextOnBlob) {
                return await input.text();
            }
            return await (0, Environment_1.handleFileReader)((reader) => reader.readAsText(input), (data) => data);
        }
        const u8 = await this._toUint8Array(input, options);
        const textHelper = await (0, StringUtil_1.getTextHelper)();
        return await textHelper.bufferToText(u8, options);
    }
    async _toUint8Array(input, options) {
        if (Environment_1.hasArrayBufferOnBlob) {
            const ab = await input.arrayBuffer();
            return (0, Environment_1.newBufferFrom)(ab);
        }
        const startEnd = await this._getStartEnd(input, options);
        let start = startEnd.start;
        const end = startEnd.end;
        const bufferSize = options.bufferSize;
        if (Environment_1.hasReadAsArrayBufferOnBlob) {
            const u8 = (0, Environment_1.newBuffer)(end - start);
            for (let index = 0; start < end; start += bufferSize) {
                let e = start + bufferSize;
                if (end < e)
                    e = end;
                const blobChunk = input.slice(start, e);
                const chunk = await (0, Environment_1.handleFileReader)((reader) => reader.readAsArrayBuffer(blobChunk), (data) => data);
                u8.set((0, Environment_1.newBufferFrom)(chunk), index);
                index += chunk.byteLength;
            }
            return u8;
        }
        const u8ac = (0, AbstractConverter_1._)()._of("uint8array");
        if (Environment_1.hasStreamOnBlob) {
            const readable = input.stream();
            const chunks = [];
            let index = 0;
            await (0, Environment_1.handleReadableStream)(readable, (u8) => {
                const size = u8.byteLength;
                if (start < index + size) {
                    let e = index + size;
                    if (end < e)
                        e = end;
                    if (index < start && start < e) {
                        chunks.push(u8.subarray(start, e));
                    }
                    else if (start <= index) {
                        chunks.push(u8);
                    }
                }
                index += size;
                return Promise.resolve(end == null || index < end);
            });
            return await u8ac.merge(chunks, options);
        }
        const base64 = await this._toBase64(input, options);
        return await u8ac.from(base64);
    }
}
exports.BlobConverter = BlobConverter;
//# sourceMappingURL=BlobConverter.js.map