3bacbca325
Fixed by returning the original buffer from `fs.read` and then just using whatever encoding was passed in to iconv, so this should all work exactly the same now as it does on native Node.
100 lines
2.9 KiB
TypeScript
100 lines
2.9 KiB
TypeScript
/**
|
|
* Return true if we're in a browser environment (including web workers).
|
|
*/
|
|
export const isBrowserEnvironment = (): boolean => {
|
|
return typeof process === "undefined" || typeof process.stdout === "undefined";
|
|
};
|
|
|
|
/**
|
|
* Escape a path. This prevents any issues with file names that have quotes,
|
|
* spaces, braces, etc.
|
|
*/
|
|
export const escapePath = (path: string): string => {
|
|
return `'${path.replace(/'/g, "'\\''")}'`;
|
|
};
|
|
|
|
export type IEncodingOptions = {
|
|
encoding?: string | null;
|
|
flag?: string;
|
|
mode?: string;
|
|
persistent?: boolean;
|
|
recursive?: boolean;
|
|
} | string | undefined | null;
|
|
|
|
// tslint:disable-next-line no-any
|
|
export type IEncodingOptionsCallback = IEncodingOptions | ((err: NodeJS.ErrnoException, ...args: any[]) => void);
|
|
|
|
/**
|
|
* Stringify an event argument. isError is because although methods like
|
|
* `fs.stat` are supposed to throw Error objects, they currently throw regular
|
|
* objects when running tests through Jest.
|
|
*/
|
|
export const stringify = (arg: any, isError?: boolean): string => { // tslint:disable-line no-any
|
|
if (arg instanceof Error || isError) {
|
|
// Errors don't stringify at all. They just become "{}".
|
|
return JSON.stringify({
|
|
type: "Error",
|
|
data: {
|
|
message: arg.message,
|
|
stack: arg.stack,
|
|
code: (arg as NodeJS.ErrnoException).code,
|
|
},
|
|
});
|
|
} else if (arg instanceof Uint8Array) {
|
|
// With stringify, these get turned into objects with each index becoming a
|
|
// key for some reason. Then trying to do something like write that data
|
|
// results in [object Object] being written. Stringify them like a Buffer
|
|
// instead.
|
|
return JSON.stringify({
|
|
type: "Buffer",
|
|
data: Array.from(arg),
|
|
});
|
|
}
|
|
|
|
return JSON.stringify(arg);
|
|
};
|
|
/**
|
|
* Parse an event argument.
|
|
*/
|
|
export const parse = (arg: string): any => { // tslint:disable-line no-any
|
|
const convert = (value: any): any => { // tslint:disable-line no-any
|
|
if (value && value.data && value.type) {
|
|
switch (value.type) {
|
|
// JSON.stringify turns a Buffer into an object but JSON.parse doesn't
|
|
// turn it back, it just remains an object.
|
|
case "Buffer":
|
|
if (Array.isArray(value.data)) {
|
|
return Buffer.from(value);
|
|
}
|
|
break;
|
|
// Errors apparently can't be stringified, so we do something similar to
|
|
// what happens to buffers and stringify them as regular objects.
|
|
case "Error":
|
|
if (value.data.message) {
|
|
const error = new Error(value.data.message);
|
|
// TODO: Can we set the stack? Doing so seems to make it into an
|
|
// "invalid object".
|
|
if (typeof value.data.code !== "undefined") {
|
|
(error as NodeJS.ErrnoException).code = value.data.code;
|
|
}
|
|
// tslint:disable-next-line no-any
|
|
(error as any).originalStack = value.data.stack;
|
|
|
|
return error;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (value && typeof value === "object") {
|
|
Object.keys(value).forEach((key) => {
|
|
value[key] = convert(value[key]);
|
|
});
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
return arg ? convert(JSON.parse(arg)) : arg;
|
|
};
|