univ-conv/commonjs/converters/URLConverter.js

The universal binary and text converter

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.URLConverter = void 0;
const AbstractConverter_1 = require("./AbstractConverter");
const core_1 = require("./core");
const Environment_1 = require("./Environment");
const StringUtil_1 = require("./StringUtil");
let nodeFetchReady = false;
class URLConverter extends AbstractConverter_1.AbstractConverter {
    constructor() {
        super();
        this.type = "url";
        if (Environment_1.isNode && !nodeFetchReady) {
            Promise.resolve().then(() => require("node-fetch")).then((module) => {
                globalThis.fetch = module.default;
                nodeFetchReady = true;
            })
                .catch((e) => console.warn(e));
        }
    }
    empty() {
        return "";
    }
    is(input, options) {
        return typeof input === "string" && options.inputStringType === "url";
    }
    async _from(input, options) {
        let url = options.outputURL ?? "data";
        if (url.startsWith("file:")) {
            const readable = await (0, AbstractConverter_1._)().convert("readable", input, options);
            await (0, Environment_1.writeToFile)(readable, url);
        }
        else if (/^https?:/.test(url)) {
            if (Environment_1.hasReadableStream) {
                const body = await (0, AbstractConverter_1._)().convert("readablestream", input, options);
                await fetch(url, { ...options.fetchRequestInit, body });
            }
            else if (Environment_1.hasReadable) {
                const body = await (0, AbstractConverter_1._)().convert("readable", input, options);
                await fetch(url, { ...options.fetchRequestInit, body: body });
            }
            else {
                throw new Error("ReadableStream or Readable not found: " + url);
            }
        }
        else if (url === "blob" && typeof URL?.createObjectURL === "function") {
            const blob = await (0, AbstractConverter_1._)().convert("blob", input, options);
            url = URL.createObjectURL(blob);
        }
        else {
            const base64 = await (0, AbstractConverter_1._)().convert("base64", input, options);
            url = "data:application/octet-stream;base64," + base64;
        }
        return url;
    }
    async _getStartEnd(input, options) {
        const size = await this._size(input);
        return (0, core_1.getStartEnd)(options, size);
    }
    _isEmpty(input) {
        return !/^(file:|https?:|blob|data)/.test(input);
    }
    async _merge(urls, options) {
        if (Environment_1.hasReadable) {
            const merged = await (0, AbstractConverter_1._)().merge("readable", urls, options);
            return await this._from(merged, options);
        }
        else if (Environment_1.hasReadableStream) {
            const merged = await (0, AbstractConverter_1._)().merge("readablestream", urls, options);
            return await this._from(merged, options);
        }
        else {
            const merged = await (0, AbstractConverter_1._)().merge("arraybuffer", urls, options);
            return await this._from(merged, options);
        }
    }
    async _size(input) {
        if (input.startsWith("file:") && Environment_1.getFileSize) {
            return await (0, Environment_1.getFileSize)(input);
        }
        else if (input.startsWith("blob:") && Environment_1.isBrowser) {
            const res = await fetch(input);
            const blob = await res.blob();
            return blob.size;
        }
        else if (input.startsWith("data:")) {
            const base64 = (0, StringUtil_1.dataUrlToBase64)(input);
            return await (0, AbstractConverter_1._)()._of("base64").size(base64);
        }
        else {
            const resp = await fetch(input, { method: "HEAD" });
            const str = resp.headers.get("Content-Length");
            const length = Math.trunc(str);
            if (!isNaN(length)) {
                return length;
            }
        }
        throw new Error(`Cannot get size of ${input}`);
    }
    async _toArrayBuffer(input, options) {
        if (input.startsWith("file:") && Environment_1.fileURLToReadable) {
            const readable = await (0, Environment_1.fileURLToReadable)(input);
            return await (0, AbstractConverter_1._)()._of("readable").toArrayBuffer(readable, options);
        }
        else {
            const resp = await fetch(input);
            return await (0, AbstractConverter_1._)()
                ._of("readablestream")
                .toArrayBuffer(resp.body, options);
        }
    }
    async _toBase64(input, options) {
        const u8 = await this._toUint8Array(input, options);
        return await (0, AbstractConverter_1._)()._of("uint8array").toBase64(u8, (0, core_1.deleteStartLength)(options));
    }
    async _toText(input, options) {
        const ab = await this._toArrayBuffer(input, options);
        return (0, AbstractConverter_1._)()._of("text").from(ab, (0, core_1.deleteStartLength)(options));
    }
    async _toUint8Array(input, options) {
        const ab = await this._toArrayBuffer(input, options);
        return (0, Environment_1.newBufferFrom)(ab);
    }
}
exports.URLConverter = URLConverter;
//# sourceMappingURL=URLConverter.js.map