fake-node 0.2.0 → 0.4.0

package/src/os.ts

@@ -0,0 +1,259 @@
+
+/// <reference path="./in_fake_node.d.ts" />
+
+export const EOL = '\n';
+
+export function availableParallelism(): number {
+    return 1;
+}
+
+export function arch(): string {
+    return 'web';
+}
+
+enum signals {
+    SIGHUP = 1,
+    SIGINT,
+    SIGQUIT,
+    SIGILL,
+    SIGTRAP,
+    SIGABRT,
+    SIGIOT = SIGABRT,
+    SIGBUS,
+    SIGFPE,
+    SIGKILL,
+    SIGUSR1,
+    SIGUSR2,
+    SIGSEGV,
+    SIGPIPE,
+    SIGALRM,
+    SIGTERM,
+    SIGCHLD,
+    SIGSTKFLT,
+    SIGCONT,
+    SIGSTOP,
+    SIGTSTP,
+    SIGBREAK,
+    SIGTTIN,
+    SIGTTOU,
+    SIGURG,
+    SIGXCPU,
+    SIGXFSZ,
+    SIGVTALRM,
+    SIGPROF,
+    SIGWINCH,
+    SIGIO,
+    SIGPOLL = SIGIO,
+    SIGLOST,
+    SIGPWR,
+    SIGINFO = SIGPWR,
+    SIGSYS,
+    SIGUNUSED = SIGSYS,
+}
+
+enum errno {
+    E2BIG,
+    EACCES,
+    EADDRINUSE,
+    EADDRNONOTAVAIL,
+    EAFNOSUPPORT,
+    EAGAIN,
+    EALREADY,
+    EBADF,
+    EBADMSG,
+    EBUSY,
+    ECANCELED,
+    ECHILD,
+    ECONNABORTED,
+    ECONNREFUSED,
+    ECONNRESET,
+    EDEADLK,
+    EDESTADDRREQ,
+    EDOM,
+    EDQUOT,
+    EEXIST,
+    EFAULT,
+    EFBIG,
+    EHOSTUNREACH,
+    EIDRM,
+    EILSEQ,
+    EINPROGRESS,
+    EINTR,
+    EINVAL,
+    EIO,
+    EISCONN,
+    EISDIR,
+    ELOOP,
+    EMFILE,
+    EMLINK,
+    EMGSIZE,
+    EMULTIHOP,
+    ENAMETOOLONG,
+    ENETDOWN,
+    ENETRESET,
+    ENETUNREACH,
+    ENFILE,
+    ENOBUFS,
+    ENODATA,
+    ENODEV,
+    ENOENT,
+    ENOEXEC,
+    ENOLCK,
+    ENOLINK,
+    ENOMEM,
+    ENOMSG,
+    ENOPROTOOPT,
+    ENOSPC,
+    ENOSR,
+    ENOSTR,
+    ENOSYS,
+    ENOTCONN,
+    ENOTDIR,
+    ENOTEMPTY,
+    ENOTSOCK,
+    ENOTSUP,
+    ENOTTY,
+    ENXIO,
+    EOPNOTSUPP,
+    EOVERFLOW,
+    EPERM,
+    EPIPE,
+    EPROTO,
+    EPROTONOSUPPORT,
+    EPROTOTYPE,
+    ERANGE,
+    EROFS,
+    ESPIPE,
+    ESRCH,
+    ESTALE,
+    ETIME,
+    ETIMEDOUT,
+    ETXTBSY,
+    EWOULDBLOCK,
+    EXDEV,
+}
+
+enum dlopen {
+    RTLD_LAZY = 1,
+    RTLD_NOW,
+    RTLD_GLOBAL,
+    RTLD_LOCAL,
+    RTLD_DEEPBIND,
+}
+
+enum priority {
+    PRIORITY_LOW = 1,
+    PRIORITY_BELOW_NORMAL,
+    PRIORITY_NORMAL,
+    PRIORITY_ABOVE_NORMAL,
+    PRIORITY_HIGH,
+    PRIORITY_HIGHEST,
+}
+
+export const constants = {signals, errno, dlopen, priority};
+
+export function cpus(): {model: string, speed: number, times: {user: number, nice: number, sys: number, idle: number, irq: number}}[] {
+    return [];
+}
+
+export const devNull = '/dev/null';
+
+export function endianness(): string {
+    return 'LE';
+}
+
+export function freemem(): number {
+    return Infinity;
+}
+
+export function getPriority(pid: number = -1): number {
+    if (pid === -1) {
+        return __fakeNode_process__.priority;
+    }
+    const process = __fakeNode__.processes.get(pid);
+    if (process === undefined) {
+        throw new TypeError(`invalid PID: ${pid}`);
+    }
+    return process.priority;
+}
+
+export function homedir(): string {
+    return '/home/' + __fakeNode__.getUserFromUID(__fakeNode_process__.uid);
+}
+
+export function hostname(): string {
+    return __fakeNode__.globalenv.HOSTNAME;
+}
+
+export function loadavg(): [number, number, number] {
+    return [-1, -1, -1];
+}
+
+export function machine(): string {
+    return 'x86_64';
+}
+
+export function networkInterfaces(): {[key: string]: {address: string, netmask: string, family: 'IPV4' | 'IPV6', mac: string, internal: boolean, scopeid: number, cidr: string}} {
+    return {};
+}
+
+export function platform(): string {
+    return __fakeNode__.getPlatform();
+}
+
+export function release(): string {
+    return platform();
+}
+
+export function setPriority(priority: number): void;
+export function setPriority(pid: number, priority: number): void;
+export function setPriority(pid_or_priority: number, priority?: number): void {
+    if (priority === undefined) {
+        __fakeNode_process__.priority = pid_or_priority;
+    } else {
+        const process = __fakeNode__.processes.get(pid_or_priority);
+        if (process === undefined) {
+            throw new TypeError(`invalid PID: ${pid_or_priority}`);
+        }
+        process.priority = priority;
+    }
+}
+
+export function tmpdir(): string {
+    return __fakeNode__.globalenv.TMPDIR;
+}
+
+export function totalmem(): number {
+    return Infinity;
+}
+
+export function type(): string {
+    const data = navigator.userAgent.slice('Mozilla/5.0 ('.length, navigator.userAgent.indexOf(')'));
+    if (data.includes('Windows NT')) {
+        return 'Windows_NT';
+    } else if (data.includes('Linux')) {
+        return 'Linux';
+    } else if (data.includes('Mac')) {
+        return 'Darwin';
+    } else {
+        return 'unknown';
+    }
+}
+
+export function uptime(): number {
+    return (__fakeNode__.window.performance.now() - __fakeNode__.window.performance.timeOrigin) / 1000;
+}
+
+export function userInfo(): {username: string, uid: number, gid: number, shell: string, homedir: string} {
+    return {
+        username: __fakeNode_process__.fakeNode.getUserFromUID(__fakeNode_process__.uid),
+        uid: __fakeNode_process__.uid,
+        gid: __fakeNode_process__.gid,
+        shell: '/bin/sh',
+        homedir: homedir(),
+    }
+}
+
+export function version(): string {
+    return __fakeNode__.version;
+}

package/src/path.ts

@@ -0,0 +1,141 @@
+
+/// <reference path="./in_fake_node.d.ts" />
+
+
+export interface PathObject {
+    dir: string;
+    root: string;
+    base: string;
+    name: string;
+    ext: string;
+};
+
+
+abstract class PathModule {
+
+    abstract sep: string;
+    abstract delimiter: string;
+    abstract _normalizeSplit: string | RegExp;
+
+    basename(path: string, suffix?: string): string {
+        const split = path.split(this.sep);
+        let out = split[split.length - 1];
+        if (suffix !== undefined && out.endsWith(suffix)) {
+            out = out.slice(0, out.length - suffix.length);
+        }
+        return out;
+    }
+
+    dirname(path: string): string {
+        return path.split('/').slice(0, -1).join('/');
+    }
+
+    extname(path: string): string {
+        let pos = path.indexOf('.');
+        if (pos === -1) {
+            return '';
+        } else {
+            return path.slice(pos);
+        }
+    }
+    
+    format(path: string): string {
+        throw new TypeError('path.format is not supported in fake-node');
+    }
+
+    matchesGlob(path: string, pattern: string): boolean {
+        throw new TypeError('path.matchesGlob is not supported in fake-node');
+    }
+
+    abstract isAbsolute(path: string): boolean;
+
+    join(...paths: string[]) {
+        return this.normalize(paths.join(this.sep));
+    }
+
+    normalize(path: string): string {
+        let out: string[] = [];
+        for (const segment of path.split(this._normalizeSplit)) {
+            if (segment === '' || segment === '.') {
+                continue;
+            } else if (segment === '..') {
+                out.pop();
+            } else {
+                out.push(segment);
+            }
+        }
+        return out.join(this.sep);
+    }
+
+    parse(path: string): PathObject {
+        throw new TypeError('path.parse is not supported in fake-node');
+    }
+
+    relative(from: string, to: string): string {
+        throw new TypeError('path.relative is not supported in fake-node');
+    }
+
+    resolve(...paths: string[]): string {
+        let out = '';
+        for (let i = paths.length - 1; i > 0; i--) {
+            out += paths[i];
+            if (this.isAbsolute(out)) {
+                return out;
+            }
+        }
+        return __fakeNode_process__.cwd + out;
+    }
+
+    abstract toNamespacedPath(path: string): string;
+
+};
+
+
+export const posix = new class extends PathModule {
+
+    sep = '/';
+    delimiter = ':';
+    _normalizeSplit = '/';
+
+    isAbsolute(path: string): boolean {
+        return path.startsWith(this.sep);
+    }
+
+    toNamespacedPath(path: string): string {
+        return path;
+    }
+
+};
+
+
+export const win32 = new class extends PathModule {
+
+    sep = '\\';
+    delimiter = ';';
+    _normalizeSplit = /\/|\\/;
+
+    isAbsolute(path: string): boolean {
+        return 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.includes(path[0]) && path[1] === ':' && path[2] === this.sep;
+    }
+
+    toNamespacedPath(path: string): string {
+        throw new TypeError('path.windows.toNamespacedPath is not supported in fake-node');
+    }
+
+};
+
+
+export const basename = posix.basename;
+export const delimiter = posix.delimiter;
+export const dirname = posix.dirname;
+export const extname = posix.extname;
+export const format = posix.format;
+export const matchesGlob = posix.matchesGlob;
+export const isAbsolute = posix.isAbsolute;
+export const join = posix.join;
+export const normalize = posix.normalize;
+export const parse = posix.parse;
+export const relative = posix.relative;
+export const resolve = posix.resolve;
+export const sep = posix.sep;
+export const toNamespacedPath = posix.toNamespacedPath;

package/src/process.ts

@@ -0,0 +1,245 @@
+
+/// <reference path="./in_fake_node.d.ts" />
+
+export function abort(): void {
+    __fakeNode__.window.close();
+}
+
+export const allowedNodeEnvironmentFlags = new Set<never>();
+
+export const arch = 'fake';
+
+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 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 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 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;
+}

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,
+}