univ-conv
Version:
The universal binary and text converter
254 lines • 7.23 kB
JavaScript
let _Writable;
let _fileURLToPath;
let _stat;
let _createReadStream;
let _createWriteStream;
let _readFile;
export let isBrowser = false;
export let isReactNative = false;
export let isNode = false;
if (typeof document !== "undefined") {
isBrowser = true;
}
else if (typeof navigator !== "undefined" &&
navigator.product === "ReactNative") {
isReactNative = true;
}
else {
isNode = true;
}
export let hasReadable = false;
export let hasWritable = false;
(async () => {
import("stream").then((stream) => {
hasReadable = typeof stream.Readable === "function";
hasWritable = typeof stream.Writable === "function";
});
})();
export let hasBlob = false;
export let hasTextOnBlob = false;
export let hasStreamOnBlob = false;
export let hasArrayBufferOnBlob = false;
export let hasReadAsArrayBufferOnBlob = false;
export let hasReadAsBinaryStringOnBlob = false;
export let EMPTY_BLOB;
if (typeof Blob === "function") {
hasBlob = true;
EMPTY_BLOB = new Blob([]);
if (Blob.prototype.text != null) {
hasTextOnBlob = true;
}
if (Blob.prototype.stream != null) {
hasStreamOnBlob = true;
}
if (Blob.prototype.arrayBuffer != null) {
hasArrayBufferOnBlob = true;
}
if (!isReactNative) {
hasReadAsArrayBufferOnBlob = FileReader.prototype.readAsArrayBuffer != null;
hasReadAsBinaryStringOnBlob =
FileReader.prototype.readAsBinaryString != null;
}
}
export let hasReadableStream = false;
export let hasWritableStream = false;
if (typeof ReadableStream === "function") {
hasReadableStream = true;
hasWritableStream = true;
}
export let hasBuffer = false;
export let EMPTY_BUFFER;
if (typeof Buffer === "function") {
hasBuffer = true;
EMPTY_BUFFER = Buffer.alloc(0);
}
export function handleFileReader(trigger, transform) {
return new Promise((resolve, reject) => {
const reader = new FileReader();
reader.onerror = function (ev) {
reject(reader.error || ev);
};
reader.onload = function () {
resolve(transform(reader.result));
};
trigger(reader);
});
}
export async function handleReadableStream(source, onData) {
const reader = source.getReader();
try {
let res;
do {
res = await reader.read();
const chunk = res.value;
if (chunk) {
const result = await onData(chunk);
if (!result) {
break;
}
}
} while (!res.done);
reader.releaseLock();
closeStream(source);
}
catch (e) {
reader.releaseLock();
closeStream(source, e);
}
}
export function isReadableStream(stream) {
return (hasReadableStream &&
stream != null &&
typeof stream.getReader === "function" &&
typeof stream.cancel === "function");
}
export function isWritableStream(stream) {
return (hasWritableStream &&
stream != null &&
typeof stream.getWriter === "function" &&
typeof stream.close === "function");
}
export function isReadable(stream) {
return (isNode &&
stream != null &&
typeof stream.pipe === "function" &&
stream.readable);
}
export async function pipeWebStream(readable, writable) {
if (typeof readable.pipeTo === "function") {
await readable.pipeTo(writable);
}
else {
const writer = writable.getWriter();
await handleReadableStream(readable, async (chunk) => {
await writer.write(chunk);
return true;
});
}
}
export function isWritable(stream) {
return (isNode &&
stream != null &&
typeof stream.pipe === "function" &&
stream.writable);
}
export function pipeNodeStream(readable, writable) {
return new Promise((resolve, reject) => {
readable.once("error", reject);
writable.once("error", reject);
writable.once("finish", resolve);
readable.pipe(writable);
});
}
export async function handleReadable(readable, onData) {
if (!_Writable) {
_Writable = (await import("stream")).Writable;
}
if (readable.destroyed) {
return;
}
const writable = new _Writable({
write(chunk, _, next) {
onData(chunk)
.then((result) => {
if (result) {
next();
}
else {
writable.destroy();
}
})
.catch((e) => {
writable.destroy(e);
});
},
});
await pipeNodeStream(readable, writable);
}
export function closeStream(stream, reason) {
if (!stream) {
return;
}
if (isReadable(stream) || isWritable(stream)) {
stream.destroy(reason);
}
else if (isReadableStream(stream)) {
if (reason) {
stream.cancel(reason).catch((e) => console.debug(e));
}
else {
stream.cancel().catch((e) => console.debug(e));
}
}
else if (isWritableStream(stream)) {
if (reason) {
stream.abort(reason).catch((e) => console.debug(e));
}
else {
stream.close().catch((e) => console.debug(e));
}
}
}
export async function getFileSize(fileURL) {
if (!_fileURLToPath) {
_fileURLToPath = (await import("url")).fileURLToPath;
}
if (!_stat) {
_stat = (await import("fs")).stat;
}
const p = _fileURLToPath(fileURL);
return await new Promise((resolve, reject) => {
_stat(p, (err, stats) => {
if (err) {
reject(err);
return;
}
resolve(stats.size);
});
});
}
export async function fileToBuffer(filePath) {
if (!_readFile) {
_readFile = (await import("fs")).readFile;
}
return new Promise((resolve, reject) => {
_readFile(filePath, (err, data) => {
if (err) {
reject(err);
return;
}
resolve(data);
});
});
}
export async function fileURLToReadable(fileURL) {
if (!_fileURLToPath) {
_fileURLToPath = (await import("url")).fileURLToPath;
}
if (!_createReadStream) {
_createReadStream = (await import("fs")).createReadStream;
}
const filePath = _fileURLToPath(fileURL);
return _createReadStream(filePath);
}
export async function writeToFile(readable, fileURL) {
if (!_createWriteStream) {
_createWriteStream = (await import("fs")).createWriteStream;
}
if (!_fileURLToPath) {
_fileURLToPath = (await import("url")).fileURLToPath;
}
const path = _fileURLToPath(fileURL);
const writable = _createWriteStream(path);
await pipeNodeStream(readable, writable);
}
export function isBuffer(input) {
return hasBuffer && input instanceof Buffer;
}
export function newBuffer(size) {
return isNode ? Buffer.alloc(size) : new Uint8Array(size);
}
export function newBufferFrom(ab) {
return isNode ? Buffer.from(ab) : new Uint8Array(ab);
}
//# sourceMappingURL=Environment.js.map