fake-node 0.1.1 → 0.3.0

package/src/process.ts

@@ -0,0 +1,263 @@
+
+import {platform as _platform} from './os';
+
+export function abort(): void {
+    __fakeNode__.window.close();
+}
+   
+export const allowedNodeEnvironmentFlags = new Set<never>();
+
+export const arch = 'fake';
+
+// export const argv = __fakeNode_process__.argv;
+
+// export const argv0 = __fakeNode_process__.argv0;
+
+export const channel = undefined;
+
+export function chdir(path: string): void {
+    __fakeNode_process__.cwd = path;
+}
+
+export const config = {};
+
+export const connected = undefined;
+
+export function constrainedMemory(): number {
+    return 0;
+}
+
+export function availableMemory(): number {
+    throw new TypeError('process.availableMemory is not available in fake-node');
+}
+
+export function cpuUsage(previousValue?: {user: number, system: number}): {user: number, system: number} {
+    throw new TypeError('process.cpuUsage is not available in fake-node');
+}
+
+export function cwd(): string {
+    return __fakeNode_process__.cwd;
+}
+
+export let debugPort = -1;
+
+export const disconnect = undefined;
+
+export function dlopen(module: object, filename: string, flags: any /* typeof os.constants.dlopen[keyof typeof os.constants.dlopen] = os.constants.dlopen.RTLD_LAZY */): void {
+    throw new TypeError('process.dlopen is not supported in fake-node');
+}
+
+export function emitWarning(warning: string | Error, type_or_options: string | {type?: string, code?: string, ctor?: Function, detail?: string}, code?: string, ctor: Function = emitWarning, detail?: string): void {
+    throw new TypeError('process.emitWarning is not supported in fake-node');
+}
+
+// export const env = __fakeNode_process__.env;
+
+// export const execArgv = __fakeNode_process__.execArgv;
+
+// export const execPath = __fakeNode_process__.execPath;
+
+export function exit(code: number = 0): void {
+    window.console.log('Exit code', code);
+    window.close();
+}
+
+export let exitCode = 0;
+
+export const features = {
+    cached_builtins: true,
+    debug: false,
+    inspector: false,
+    ipv6: true,
+    require_module: true,
+    tls: false,
+    tls_alpn: false,
+    tls_ocsp: false,
+    tls_sni: false,
+    typescript: false,
+    uv: false,
+};
+
+export const finalization = {
+
+    register(ref: object, callback: (ref: object, event: string) => void): void {
+        throw new TypeError('process.finalization is not supported in fake-node');
+    },
+
+    registerBeforeExit(ref: object, callback: (ref: object, event: string) => void): void {
+        throw new TypeError('process.finalization is not supported in fake-node');
+    },
+
+    unregister(ref: object): void {
+        throw new TypeError('process.finalization is not supported in fake-node');
+    },
+
+};
+
+export function getActiveResourcesInfo(): string[] {
+    return [];
+}
+
+export function getBuiltinModule(id: string): any {
+    return __fakeNode_process__.fakeNode.modules.get(id);
+}
+
+export function getegid(): number {
+    return __fakeNode_process__.gid;
+}
+
+export function geteuid(): number {
+    return __fakeNode_process__.uid;
+}
+
+export function getgid(): number {
+    return __fakeNode_process__.gid;
+}
+
+export function getgroups(): number[] {
+    return [__fakeNode_process__.gid].concat(__fakeNode_process__.groups);
+}
+
+export function getuid(): number {
+    return __fakeNode_process__.uid;
+}
+
+let errorCallback: null | number = null;
+
+export function hasUncaughtExecptionCaptureCallback(): boolean {
+    return errorCallback !== null;
+}
+
+export function hrtime(time?: [number, number]): [number, number] {
+    let value = window.performance.now();
+    if (time !== undefined) {
+        value -= time[0] + time[1] / 1000000;
+    }
+    return [Math.floor(value), (value - Math.floor(value) * 1000000)];
+}
+
+hrtime.bigint = function(): bigint {
+    return BigInt(window.performance.now());
+}
+
+export function initgroups(user: string | number, extraGroup: string | number): void {
+    throw new TypeError('process.initgroups is not supported in fake-node');
+}
+
+export function kill(pid: number, signal: string | number): void {
+    throw new TypeError('process.kill is not supported in fake-node');
+}
+
+export function loadEnvFile(path: string = './.env'): void {
+    throw new TypeError('process.loadEnvFile is not supported in fake-node');
+}
+
+// export const mainModule = __fakeNode_process__.path === '' ? undefined : __fakeNode_process__.path;
+
+export function memoryUsage(): {rss: number, heapTotal: number, heapUsed: number, external: number, arrayBuffers: number} {
+    throw new TypeError('process.memoryUsage is not supported in fake-node');
+}
+
+memoryUsage.rss = function(): number {
+    throw new TypeError('process.memoryUsage.rss is not supported in fake-node');
+}
+
+export function nextTick(callback: Function, ...args: any[]): void {
+    window.setTimeout(callback, 0, ...args);
+}
+
+export const noDeprecation = false;
+
+export const permission = {
+
+    has(scope: string, reference?: string): void {
+        throw new TypeError('process.permission.has is not supported in fake-node');
+    }
+
+};
+
+export function ref(maybeRefable: any): void {
+    throw new TypeError('process.ref is not supported in fake-node');
+}
+
+export const pid = 1;
+
+// export const platform = _platform();
+
+export const ppid = 1;
+
+export const release = {
+    name: 'fake-node',
+    sourceUrl: '', // todo: add something here
+    headersUrl: '',
+    lts: 'Hydrogen',
+};
+
+export function setegid(id: string | number): void {
+    __fakeNode_process__.gid = __fakeNode__.getGIDFromGroup(id);
+}
+
+export function seteuid(id: string | number): void {
+    __fakeNode_process__.uid = __fakeNode__.getUIDFromUser(id);
+}
+
+export function setgid(id: string | number): void {
+    __fakeNode_process__.gid = __fakeNode__.getGIDFromGroup(id);
+}
+
+export function setgroups(groups: (string | number)[]): void {
+    __fakeNode_process__.groups = groups.map(__fakeNode__.getGIDFromGroup);
+}
+
+export function setuid(id: string | number): void {
+    __fakeNode_process__.uid = __fakeNode__.getUIDFromUser(id);
+}
+
+export function setSourceMapsEnabledVal(val: boolean): void {
+    throw new TypeError('process.setSourceMapsEnabledVal is not supported in fake-node');
+}
+
+export function setUncaughtExceptionCaptureCallback(func: Function | null): void {
+    if (errorCallback !== null) {
+        __fakeNode__.removeErrorCallback(errorCallback);
+    }
+    if (func !== null) {
+        errorCallback = __fakeNode__.addErrorCallback(func);
+    }
+}
+
+export const sourceMapsEnabled = false;
+
+export const stderr = undefined; // todo: put stuff here
+
+export const stdin = undefined;
+
+export const stdout = undefined;
+
+export let throwDeprecation = false;
+
+export let title = ''; // todo: put something here
+
+export const traceDeprecation = false;
+
+export function umask(): number;
+export function umask(mask: number): void;
+export function umask(mask?: number): number | void {
+    if (mask === undefined) {
+        return __fakeNode_process__.umask;
+    } else {
+        __fakeNode_process__.umask = mask;
+    }
+}
+
+export function unref(maybeRefable: any): void {
+    throw new TypeError('process.unref is not supported in fake-node');
+}
+
+export function uptime(): number {
+    return __fakeNode_process__.fakeNode.window.performance.now() / 1000;
+}
+
+// export const version = __fakeNode__.version;
+
+// export const versions = [version];

package/src/querystring.ts

@@ -0,0 +1,36 @@
+
+export function parse(str: string): {[key: string]: string | string[]} {
+    let out: {[key: string]: string | string[]} = {}
+    for (const [key, value] of (new URLSearchParams(str)).entries()) {
+        if (key in out) {
+            if (typeof out[key] === 'string') {
+                out[key] = [out[key], value];
+            } else {
+                out[key].push(value);
+            }
+        } else {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+
+export function stringify(obj: {[key: string]: string | number | bigint | boolean | string[] | number[] | bigint[] | boolean[]}): string {
+    let params = new URLSearchParams();
+    for (const key in Object.entries(obj)) {
+        const value = obj[key];
+        if (typeof value === 'string') {
+            params.set(key, value);
+        } else if (value instanceof Array) {
+            for (const item of value) {
+                params.append(key, String(item));
+            }
+        }
+    }
+    return params.toString();
+}
+
+export {
+    parse as decode,
+    stringify as encode,
+}

package/src/util.ts

@@ -0,0 +1,408 @@
+
+import {env, emitWarning} from './process';
+
+
+type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array;
+type Callback = (error: Error | null, value: any) => 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];
+        original(...args.slice(0, -1)).then((value: any) => callback(null, value)).catch((reason) => callback(reason instanceof Error ? 
+        reason : new Error(reason), null));
+    };
+}
+
+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)) {
+        return Object.assign(function(message: string): void {
+            callback(`${env.NODE_DEBUG.toUpperCase()} ${__fakeNode_process__.pid}: ${message}`);
+        }, {enabled: true});
+    } else {
+        return Object.assign(() => {}, {enabled: true});
+    }
+}
+
+export {debuglog as debug};
+
+export function deprecate(fn: Function, msg: string, code?: string): Function {
+    return function(...args: any[]): any {
+        emitWarning('DeprecationWarning', {type: msg, code: code});
+        return fn(...args);
+    }
+}
+
+export function format(format: string, ...args: unknown[]) {
+    return formatWithOptions({}, format, ...args);
+}
+
+export function formatWithOptions(inspectOptions: InspectOptions, format: string, ...args: unknown[]): string {
+    let out = '';
+    let i = 0;
+    let j = 0;
+    while (i < format.length && j < args.length) {
+        if (format[i] === '%') {
+            i++;
+            const type = format[i];
+            const value = args[j];
+            j++;
+            if (type === 's') {
+                if (typeof value === 'bigint') {
+                    out += value + 'n';
+                } else if (value === 0 && 1 / value === -Infinity) {
+                    out += '-0';
+                } else if ((typeof value === 'object' && value !== null) || typeof value === 'function') {
+                    out += inspect(value, {depth: 0, colors: false, compat: 3});
+                } else {
+                    out += String(i);
+                }
+            } else if (type === 'd') {
+                if (typeof value === 'bigint') {
+                    out += value + 'n';
+                } else if (typeof value === 'symbol') {
+                    out += value.toString();
+                } else {
+                    out += Number(value);
+                }
+            } else if (type === 'i') {
+                if (typeof value === 'bigint') {
+                    out += value + 'n';
+                } else if (typeof value === 'symbol') {
+                    out += value.toString();
+                } else {
+                    out += parseInt(String(value), 10);
+                }
+            } else if (type === 'f') {
+                if (typeof value === 'symbol') {
+                    out += value.toString();
+                } else {
+                    out += parseFloat(String(value));
+                }
+            } else if (type === 'j') {
+                try {
+                    out += JSON.stringify(value);
+                } catch (error) {
+                    if (error instanceof TypeError && (error.message.includes('circular') || error.message.includes('cyclic'))) {
+                        out += '[Circular]';
+                    } else {
+                        throw error;
+                    }
+                }
+            } else if (type === 'o') {
+                out += inspect(value, {showHidden: true, showProxy: true});
+            } else if (type === 'O') {
+                out += inspect(value, inspectOptions);
+            } else {
+                j--;
+            }
+        } else {
+            out += format[i];
+        }
+        i++;
+    }
+    return out + format.slice(i);
+}
+
+type CallSites = {functionName: string, scriptName: string, scriptId: string, lineNumber: number, columnNumber: number}[];
+
+export function getCallSites(options?: {sourceMap?: boolean}): CallSites;
+export function getCallSites(frameCount: number, options?: {sourceMap?: boolean}): CallSites;
+export function getCallSites(frameCountOrOptions?: number | {sourceMap?: boolean}, options: {sourceMap?: boolean} = {}): CallSites {
+    throw new TypeError('util.getCallSites is not supported in fake-node');
+}
+
+export function getSystemErrorName(error: number): string {
+    throw new TypeError('util.getSystemErrorName is not supported in fake-node');
+}
+
+export function getSystemErrorMap(): Map<number, string> {
+    throw new TypeError('util.getSystemErrorMap is not supported in fake-node');
+}
+
+export function getSystemErrorMessage(error: number): string {
+    throw new TypeError('util.getSystemErrorMessage is not supported in fake-node');
+}
+
+export function inherits(constructor: Function, superConstructor: Function) {
+    Object.setPrototypeOf(constructor.prototype, superConstructor.prototype);
+}
+
+type InspectOptions = {};
+
+export function inspect(value: unknown, options: InspectOptions = {}): string {
+    return String(value);
+}
+
+export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean {
+    if ((typeof val1 === 'object' && val1 !== null) || typeof val1 === 'function') {
+        if (!(typeof val2 === 'object' && val2 !== null) && !(typeof val2 === 'function')) {
+            return false;
+        }
+        if ((val1[Symbol.toStringTag] !== val2[Symbol.toStringTag]) || Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+            return false;
+        }
+        if (val1 instanceof Map) {
+            if (!(val2 instanceof Map)) {
+                throw new TypeError(`this error should not occur`);
+            }
+            for (const [key, value] of val1.entries()) {
+                if (!val2.has(key)) {
+                    return false;
+                }
+                return isDeepStrictEqual(value, val2.get(key));
+            }
+        }
+        if (val1 instanceof Set) {
+            if (!(val2 instanceof Set)) {
+                throw new TypeError(`this error should not occur`);
+            }
+            for (const item of val1) {
+                let found = false;
+                for (const item2 of val2) {
+                    if (item === item2) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        const properties = (Object.getOwnPropertyNames(val1) as (string | symbol)[]).concat(Object.getOwnPropertySymbols(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) {
+            if (!isDeepStrictEqual(val1[property], val2[property])) {
+                return false;
+            }
+        }
+        if (types.isBoxedPrimitive(val1)) {
+            if (!types.isBoxedPrimitive(val2)) {
+                return false;
+            }
+            return Object.is(val1.constructor(val1), val2.constructor(val2));
+        }
+        return true;
+    } else if ((typeof val2 === 'object' && val2 !== null) || typeof val2 === 'function') {
+        return false;
+    } else {
+        return Object.is(val1, val2);
+    }
+}
+
+export const types = {
+
+    isAnyArrayBuffer(value: unknown): value is (ArrayBuffer | SharedArrayBuffer) {
+        return types.isArrayBuffer(value) || types.isSharedArrayBuffer(value);
+    },
+
+    isArrayBufferView(value: unknown): value is (DataView | TypedArray) {
+        return ArrayBuffer.isView(value);
+    },
+
+    isArgumentsObject(value: unknown): value is typeof arguments {
+        if (typeof value !== 'object' || value === null || !Object.hasOwn(value, 'length') || !Object.hasOwn(value, 'callee')) {
+            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.") {
+                return types.isProxy(value) !== true;
+            } else {
+                throw error;
+            }
+        }
+    },
+
+    isArrayBuffer(value: unknown): value is ArrayBuffer {
+        return value instanceof ArrayBuffer;
+    },
+
+    isAsyncFunction(value: unknown): value is (...args: unknown[]) => Promise<unknown> {
+        return value instanceof (async () => {}).constructor;
+    },
+
+    isBigInt64Array(value: unknown): value is BigInt64Array {
+        return value instanceof BigInt64Array;
+    },
+
+    isBigIntObject(value: unknown): boolean {
+        return value instanceof Object(0n).constructor;
+    },
+
+    isBigUint64Array(value: unknown): value is BigUint64Array {
+        return value instanceof BigUint64Array;
+    },
+
+    isBooleanObject(value: unknown): value is Boolean {
+        return value instanceof Boolean;
+    },
+
+    isBoxedPrimitive(value: unknown): value is Boolean | Number | String {
+        return value instanceof Boolean || value instanceof Number || value instanceof String || value instanceof Object(0n).constructor || value instanceof Object(Symbol()).constructor;
+    },
+
+    isCryptoKey(value: unknown): value is CryptoKey {
+        return value instanceof CryptoKey;
+    },
+
+    isDataView(value: unknown): value is DataView {
+        return value instanceof DataView;
+    },
+
+    isDate(value: unknown): value is Date {
+        return value instanceof Date;
+    },
+
+    isExternal(value: unknown): boolean {
+        return false;
+    },
+
+    isFloat32Array(value: unknown): value is Float32Array {
+        return value instanceof Float32Array;
+    },
+
+    isFloat64Array(value: unknown): value is Float64Array {
+        return value instanceof Float64Array;
+    },
+
+    isGeneratorFunction(value: unknown): value is GeneratorFunction {
+        return value instanceof (function*() {}).constructor;
+    },
+
+    isGeneratorObject(value: unknown): value is Generator {
+        return value?.constructor === (function*() {}).constructor.prototype;
+    },
+
+    isInt8Array(value: unknown): value is Int8Array {
+        return value instanceof Int8Array;
+    },
+
+    isInt16Array(value: unknown): value is Int16Array {
+        return value instanceof Int16Array;
+    },
+
+    isInt32Array(value: unknown): value is Int32Array {
+        return value instanceof Int32Array;
+    },
+
+    isKeyObject(value: unknown): boolean {
+        return false;
+    },
+
+    isMap(value: unknown): value is Map<unknown, unknown> {
+        return value instanceof Map;
+    },
+
+    isMapIterator(value: unknown): value is MapIterator<unknown> {
+        return value instanceof (new Map()).keys().constructor;
+    },
+
+    isModuleNamespaceObject(value: unknown): boolean {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        return Object.isSealed(value) && Object.getOwnPropertyDescriptor(value, Object.keys(value)[0])?.writable === true;
+    },
+
+    isNativeError(value: unknown): value is Error {
+        return value instanceof Error;
+    },
+
+    isNumberObject(value: unknown): value is Number {
+        return value instanceof Number;
+    },
+
+    isPromise(value: unknown): value is Promise<unknown> {
+        return value instanceof Promise;
+    },
+
+    isProxy(value: unknown): boolean | 'maybe' {
+        try {
+            structuredClone(value);
+            return false;
+        } catch (error) {
+            if (!(error instanceof DOMException && error.name === 'DataCloneError')) {
+                throw error;
+            }
+        }
+        if (shouldBeCloneable(value)) {
+            return true;
+        } else {
+            return 'maybe';
+        }
+    },
+
+    isRegExp(value: unknown): value is RegExp {
+        return value instanceof RegExp;
+    },
+
+    isSet(value: unknown): value is Set<unknown> {
+        return value instanceof Set;
+    },
+
+    isSetIterator(value: unknown): value is SetIterator<unknown> {
+        return value instanceof (new Set()).keys().constructor;
+    },
+
+    isSharedArrayBuffer(value: unknown): value is SharedArrayBuffer {
+        return value instanceof SharedArrayBuffer;
+    },
+
+    isStringObject(value: unknown): value is String {
+        return value instanceof String;
+    },
+
+    isSymbolObject(value: unknown): boolean {
+        return value instanceof Object(Symbol()).constructor;
+    },
+
+    isTypedArray(value: unknown): value is TypedArray {
+        return value instanceof Int8Array || value instanceof Uint8Array || value instanceof Int16Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Float64Array || value instanceof BigInt64Array;
+    },
+
+    isUint8Array(value: unknown): value is Uint8Array {
+        return value instanceof Uint8Array;
+    },
+
+    isUint8ClampedArray(value: unknown): value is Uint8ClampedArray {
+        return value instanceof Uint8ClampedArray;
+    },
+
+    isUint16Array(value: unknown): value is Uint16Array {
+        return value instanceof Uint16Array;
+    },
+
+    isUint32Array(value: unknown): value is Uint32Array {
+        return value instanceof Uint32Array;
+    },
+
+    isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown> {
+        return value instanceof WeakMap;
+    },
+
+    isWeakSet(value: unknown): value is WeakSet<WeakKey> {
+        return value instanceof WeakSet;
+    },
+
+};
+
+export function _extend(target: Object, source: Object): Object {
+    return Object.assign(target, source);
+}
+
+export function isArray(object: unknown): boolean {
+    return Array.isArray(object);
+}