univ-conv
Version:
The universal binary and text converter
162 lines • 6.49 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.getUnivConv = void 0;
const AbstractConverter_1 = require("./converters/AbstractConverter");
const ArrayBufferConverter_1 = require("./converters/ArrayBufferConverter");
const Base64Converter_1 = require("./converters/Base64Converter");
const BinaryConverter_1 = require("./converters/BinaryConverter");
const core_1 = require("./converters/core");
const Environment_1 = require("./converters/Environment");
const FalseConverter_1 = require("./converters/FalseConverter");
const HexConverter_1 = require("./converters/HexConverter");
const TextConverter_1 = require("./converters/TextConverter");
const Uint8ArrayConverter_1 = require("./converters/Uint8ArrayConverter");
const URLConverter_1 = require("./converters/URLConverter");
class DefaultUnivConv {
constructor() {
this.converters = new Map();
}
_empty(input) {
if (typeof input === "string") {
return "";
}
const converter = this._find(input);
return converter.empty();
}
_emptyOf(type) {
const converter = this._of(type);
return converter.empty();
}
_find(input, options) {
for (const converter of this.converters.values()) {
if (converter.is(input, options)) {
return converter;
}
}
throw new Error(`No converter: input=${(0, core_1.getType)(input)}, srcStringType=${options?.inputStringType}`);
}
_of(type) {
const converter = this.converters.get(type);
if (converter) {
return converter;
}
throw new Error(`No converter: type=${type}`);
}
addConverter(name, converter) {
this.converters.set(name, converter);
}
async convert(returnType, input, options) {
if (options?.length === 0) {
return this._emptyOf(returnType);
}
const converter = this._of(returnType);
return await converter.from(input, options);
}
is(type, input, options) {
const converter = this._of(type);
return converter.is(input, options);
}
async merge(to, chunks, options) {
const results = await this._convertAll(to, chunks, options);
const converter = this._of(to);
return await converter.merge(results, options);
}
async pipe(input, output, options) {
if ((0, Environment_1.isWritable)(output)) {
const readable = await this._of("readable").from(input, options);
try {
await (0, Environment_1.pipeNodeStream)(readable, output);
}
catch (e) {
(0, Environment_1.closeStream)(output, e);
}
}
else if ((0, Environment_1.isWritableStream)(output)) {
let stream;
try {
stream = await this._of("readablestream").from(input, options);
await (0, Environment_1.pipeWebStream)(stream, output);
(0, Environment_1.closeStream)(output);
}
catch (e) {
(0, Environment_1.closeStream)(output, e);
}
}
else if (typeof output === "string") {
await this._of("url").from(input, {
...options,
outputURL: output,
});
}
else {
throw new Error("Illegal output type: " + (0, core_1.getType)(output));
}
}
removeConverter(name) {
this.converters.delete(name);
}
async size(input, options) {
const converter = this._find(input, options);
return await converter.size(input, options);
}
async slice(input, options) {
if (typeof options.start !== "number" &&
typeof options.length !== "number") {
throw new Error("Illegal argument: options.start and options.length are undefined.");
}
if ((0, core_1.isEmpty)(input, options)) {
return Promise.resolve(this._empty(input));
}
const converter = this._find(input, options);
if (converter) {
return await converter.from(input, options);
}
throw new Error("Illegal output type: " + (0, core_1.getType)(input));
}
async _convertAll(returnType, chunks, options) {
const results = [];
for (const chunk of chunks) {
const converted = await this.convert(returnType, chunk, options);
results.push(converted);
}
return results;
}
}
const getUnivConv = async () => {
if (AbstractConverter_1.AbstractConverter._UNIV_CONV) {
return AbstractConverter_1.AbstractConverter._UNIV_CONV;
}
const univConv = new DefaultUnivConv();
univConv.addConverter("base64", new Base64Converter_1.Base64Converter());
univConv.addConverter("binary", new BinaryConverter_1.BinaryConverter());
univConv.addConverter("hex", new HexConverter_1.HexConverter());
univConv.addConverter("url", new URLConverter_1.URLConverter());
univConv.addConverter("text", new TextConverter_1.TextConverter());
univConv.addConverter("arraybuffer", new ArrayBufferConverter_1.ArrayBufferConverter());
univConv.addConverter("uint8array", new Uint8ArrayConverter_1.Uint8ArrayConverter());
if (Environment_1.hasBlob) {
const bc = new (await Promise.resolve().then(() => require("./converters/BlobConverter"))).BlobConverter();
univConv.addConverter("blob", bc);
}
else {
univConv.addConverter("blob", new FalseConverter_1.FalseConverter("Blob"));
}
try {
const rc = new (await Promise.resolve().then(() => require("./converters/ReadableConverter"))).ReadableConverter();
univConv.addConverter("readable", rc);
}
catch {
univConv.addConverter("readable", new FalseConverter_1.FalseConverter("Readable"));
}
if (Environment_1.hasReadableStream) {
const rsc = new (await Promise.resolve().then(() => require("./converters/ReadableStreamConverter"))).ReadableStreamConverter();
univConv.addConverter("readablestream", rsc);
}
else {
univConv.addConverter("readablestream", new FalseConverter_1.FalseConverter("ReadableStream"));
}
AbstractConverter_1.AbstractConverter._UNIV_CONV = univConv;
return AbstractConverter_1.AbstractConverter._UNIV_CONV;
};
exports.getUnivConv = getUnivConv;
//# sourceMappingURL=UnivConv.js.map