fake-node 0.3.0 → 0.4.0

package/src/util.ts

@@ -1,15 +1,15 @@
 
-import {env, emitWarning} from './process';
+/// <reference path="./in_fake_node.d.ts" />
+import {emitWarning} from './process';
 
+export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array;
 
-type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array;
-type Callback = (error: Error | null, value: any) => void;
+export type Callback = (error: Error | null, value: unknown) => void;
 
 function shouldBeCloneable(value: unknown): boolean {
     return value?.constructor === Object || value === undefined || value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string' || typeof value === 'bigint' || Array.isArray(value) || value instanceof ArrayBuffer || value instanceof Boolean || value instanceof DataView || value instanceof Date || value instanceof Error || value instanceof Map || value instanceof Number || value instanceof RegExp || value instanceof Set || value instanceof String || value instanceof Object.getPrototypeOf(Uint8Array) || value instanceof AudioData || value instanceof Blob || value instanceof CryptoKey || value instanceof DOMException || value instanceof DOMMatrix || value instanceof DOMMatrixReadOnly || value instanceof DOMPoint || value instanceof DOMPointReadOnly || value instanceof DOMQuad || value instanceof DOMRect || value instanceof DOMRectReadOnly || value instanceof EncodedAudioChunk || value instanceof EncodedVideoChunk || value instanceof File || value instanceof FileList || value instanceof FileSystemDirectoryHandle || value instanceof FileSystemFileHandle || value instanceof FileSystemHandle || value instanceof ImageBitmap || value instanceof ImageData || value instanceof RTCCertificate || value instanceof RTCEncodedAudioFrame || value instanceof RTCEncodedVideoFrame || value instanceof VideoFrame || value instanceof WebTransportError;
 }
 
-
 export function callbackify(original: (...args: any[]) => Promise<any>): (...args: [...any[], Callback]) => void {
     return function(...args: [...any[], Callback]): void {
         const callback = args[args.length - 1];
@@ -19,9 +19,9 @@ export function callbackify(original: (...args: any[]) => Promise<any>): (...arg
 }
 
 export function debuglog(section: string, callback: (message: string) => void = console.log): ((message: string) => void) & {enabled: boolean} {
-    if (typeof env.NODE_DEBUG === 'string' && env.NODE_DEBUG.includes(section)) {
+    if (typeof __fakeNode_process__.env.NODE_DEBUG === 'string' && __fakeNode_process__.env.NODE_DEBUG.includes(section)) {
         return Object.assign(function(message: string): void {
-            callback(`${env.NODE_DEBUG.toUpperCase()} ${__fakeNode_process__.pid}: ${message}`);
+            callback(`${__fakeNode_process__.env.NODE_DEBUG.toUpperCase()} ${__fakeNode_process__.pid}: ${message}`);
         }, {enabled: true});
     } else {
         return Object.assign(() => {}, {enabled: true});
@@ -132,10 +132,12 @@ export function inherits(constructor: Function, superConstructor: Function) {
     Object.setPrototypeOf(constructor.prototype, superConstructor.prototype);
 }
 
-type InspectOptions = {};
+interface InspectOptions {
+
+}
 
 export function inspect(value: unknown, options: InspectOptions = {}): string {
-    return String(value);
+    throw new TypeError('util.inspect is not supported in fake-node');
 }
 
 export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean {
@@ -143,7 +145,10 @@ export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean {
         if (!(typeof val2 === 'object' && val2 !== null) && !(typeof val2 === 'function')) {
             return false;
         }
-        if ((val1[Symbol.toStringTag] !== val2[Symbol.toStringTag]) || Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+        if ((Symbol.toStringTag in val1 && Symbol.toStringTag in val2) && val1[Symbol.toStringTag] !== val2[Symbol.toStringTag]) {
+            return false;
+        }
+        if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
             return false;
         }
         if (val1 instanceof Map) {
@@ -175,12 +180,13 @@ export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean {
             }
             return true;
         }
-        const properties = (Object.getOwnPropertyNames(val1) as (string | symbol)[]).concat(Object.getOwnPropertySymbols(val1));
+        const properties = Reflect.ownKeys(val1);
         const val2Properties = (Object.getOwnPropertyNames(val2) as (string | symbol)[]).concat(Object.getOwnPropertySymbols(val2));
         if (!properties.every((prop: string | symbol) => val2Properties.includes(prop))) {
             return false;
         }
         for (const property of properties) {
+            // @ts-ignore
             if (!isDeepStrictEqual(val1[property], val2[property])) {
                 return false;
             }
@@ -199,6 +205,114 @@ export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean {
     }
 }
 
+export class MIMEType {
+
+    constructor() {
+        throw new TypeError('util.MIMEType is not supported in fake-node');
+    }
+
+}
+
+export class MIMEParams {
+
+    constructor() {
+        throw new TypeError('util.MIMEParams is not supported in fake-node');
+    }
+
+}
+
+interface ParseArgsConfig {
+    args?: string[];
+    options: {
+        [key: string]: {
+            short?: string;
+        } & (({multiple: false} & ({
+                type: 'string';
+                default?: string;
+            } | {
+                type: 'boolean';
+                default?: boolean;
+            })) | ({multiple: true} & ({
+                type: 'string';
+                default?: string[];
+            } | {
+                type: 'boolean';
+                default?: boolean[];
+            }))
+        );
+    };
+    strict?: boolean;
+    allowPositionals?: boolean;
+    allowNegative?: boolean;
+    tokens?: boolean;
+}
+
+export function parseArgs(config?: ParseArgsConfig): {values: {[key: string]: string | boolean}, positionals: string[], tokens?: object[]} {
+    throw new TypeError('util.parseArgs is not supported in fake-node');
+}
+
+export function parseEnv(content: string): {[key: string]: string} {
+    throw new TypeError('util.parseEnv is not supported in fake-node');
+}
+
+export function promisify(original: ((...args: [...any[], Callback]) => void) & {[func: typeof promisify.custom]: (...args: any[]) => Promise<any>}): (...args: any[]) => Promise<any> {
+    if (promisify.custom in original) {
+        return original[promisify.custom];
+    }
+    return function(...args: any[]): Promise<any> {
+        return new Promise((resolve, reject) => {
+            original(args, (error: Error | null, value: unknown) => {
+                if (error instanceof Error) {
+                    reject(error);
+                } else {
+                    resolve(value);
+                }
+            });
+        });
+    };
+}
+promisify.custom = Symbol.for('nodejs.util.promisify.custom');
+
+export function stripVTControlCharacters(str: string): string {
+    throw new TypeError('util.stripVTControlCharacters is not supported in fake-node');
+}
+
+export function styleText(format: string | Array<unknown>, text: string, options?: {validateStream: boolean, stream: unknown}): string {
+    throw new TypeError('util.styleText is not supported in fake-node');
+}
+
+const TextDecoder_ = TextDecoder;
+const TextEncoder_ = TextEncoder;
+export {
+    TextDecoder_ as TextDecoder,
+    TextEncoder_ as TextEncoder,
+};
+
+export function toUSVString(string: string): string {
+    let out = '';
+    for (let i = 0; i < string.length; i++) {
+        const code = string.charCodeAt(i);
+        if (code >= 0xD800 && code < 0xDFFF) {
+            out += '\uFFFD';
+        } else {
+            out += string[i];
+        }
+    }
+    return out;
+}
+
+export function transferableAbortController(): AbortController {
+    throw new TypeError('util.transferableAbortController is not supported in fake-node');
+}
+
+export function transferableAbortSignal(): AbortSignal {
+    throw new TypeError('util.transferableAbortSignal is not supported in fake-node');
+}
+
+export function aborted(signal: AbortSignal, resource: object): Promise<undefined> {
+    throw new TypeError('util.aborted is not supported in fake-node');
+}
+
 export const types = {
 
     isAnyArrayBuffer(value: unknown): value is (ArrayBuffer | SharedArrayBuffer) {
@@ -210,15 +324,14 @@ export const types = {
     },
 
     isArgumentsObject(value: unknown): value is typeof arguments {
-        if (typeof value !== 'object' || value === null || !Object.hasOwn(value, 'length') || !Object.hasOwn(value, 'callee')) {
+        if (typeof value !== 'object' || value === null || !('length' in value) || !('callee' in value)) {
             return false;
         }
         try {
-            // @ts-ignore
             value.callee;
             return false;
         } catch (error) {
-            if (error.message === "TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them" || error.message === "TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in this context.") {
+            if (error instanceof Error && (error.message === "TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them" || error.message === "TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in this context.")) {
                 return types.isProxy(value) !== true;
             } else {
                 throw error;