fake-node 0.3.0 → 0.4.0

package/src/in_fake_node.d.ts

@@ -0,0 +1,12 @@
+
+import {FakeNode, Process} from './index';
+
+declare global {
+    var __fakeNode__: FakeNode;
+    var __fakeNode_process__: Process;
+    var module: {
+        exports: {[key: string]: any},
+    };
+    var exports: {[key: string]: any};
+    var require: typeof FakeNode.prototype.require;
+}

package/src/index.ts

@@ -1,18 +1,44 @@
 
+import * as baseProcessObject from './process';
+import {FileSystem} from './_fs';
 import * as module_os from './os';
-import * as module_process from './process';
-import * as module_punycode from 'punycode/';
+import * as module_util from './util';
 import * as module_querystring from './querystring';
+import * as module_punycode from 'punycode/';
+import * as module_path from './path';
+import * as module_buffer from './buffer';
+import * as module_fs from './fs';
 import WEB_ONLY_GLOBALS from './web_only_globals.json';
 
 
-const DEFAULT_GLOBALS = Object.defineProperties({}, Object.fromEntries(WEB_ONLY_GLOBALS.map((name: string) => [name, {get(): void {throw new ReferenceError(`${name} is not defined`);}}])));
+export * as fs from './_fs';
+
+
+const IS_BROWSER = (('window' in globalThis && window === globalThis && 'document' in window && 'navigator' in window && 'window' in window && window.window === window) || ('self' in globalThis && self === globalThis && typeof self.postMessage === 'function' && 'self' in self && self.self === self));
+
+
+type BaseProcessObject = typeof import ('./process');
+interface ProcessObject extends BaseProcessObject {
+    argv: string[];
+    argv0: string;
+    env: {[key: string]: string};
+    execArgv: string[];
+    execPath: string;
+    mainModule: string;
+    platform: string;
+    version: string;
+    versions: {[key: string]: string};
+}
+
 
 const BUILTIN_MODULES: [string, any][] = [
     ['os', module_os],
-    ['process', module_process],
+    ['util', module_util],
     ['querystring', module_querystring],
     ['punycode', module_punycode],
+    ['path', module_path],
+    ['buffer', module_buffer],
+    ['fs', module_fs],
 ];
 
 const DEFAULT_ENV = {
@@ -47,21 +73,21 @@ export class Process {
     argv: string[] = [];
     argv0: string = '';
     execArgv: string[] = [];
-    execArgv0: string = '/usr/bin/local/node';
+    execPath: string = '/usr/bin/local/node';
 
     path: string;
     module: false | string;
-    code: string;
+    code?: string;
 
-    constructor(fakeNode: FakeNode, {path = '', code, module}: {path?: string, code: string, module?: false | string}) {
+    constructor(fakeNode: FakeNode, {path = '<anonymous>', code, module = false}: {path?: string, code?: string, module?: false | string}) {
         this.fakeNode = fakeNode;
         this.pid = fakeNode.nextPid;
         fakeNode.nextPid++;
         fakeNode.processes.set(this.pid, this);
-        this.code = code;
         this.path = path;
         this.cwd = path.split('/').slice(0, -1).join('/');
-        this.module = module ?? false;
+        this.module = module;
+        this.code = code;
     }
 
     get env(): {[key: string]: string} {
@@ -69,49 +95,69 @@ export class Process {
     }
 
     run(): void {
-        let code: string;
+        let code = this.code;
+        if (code === undefined) {
+            code = this.fakeNode.fs.readFrom(this.path);
+        }
+        let injectCode: string;
         if (this.module) {
-            code = `with(${this.fakeNode.globalName}.getGlobals(${this.pid})){__fakeNode__.modules.set('${this.module},(function(){${this.code};return module.exports;})());}`;
+            injectCode = `with(${this.fakeNode.globalName}.getGlobals(${this.pid})){__fakeNode__.modules.set('${this.module},(function(){${code};return module.exports;})());}`;
         } else {
-            code = `with(${this.fakeNode.globalName}.getGlobals(${this.pid})){(function(){${this.code}})();}`;
+            injectCode = `with(${this.fakeNode.globalName}.getGlobals(${this.pid})){(function(){${code}})();}`;
         }
         let elt = document.createElement('script');
-        elt.textContent = code;
+        elt.textContent = injectCode;
         document.body.appendChild(elt);
     }
 
 }
 
 
+if (!('__fakeNode_next_instance_id__' in globalThis)) {
+    // @ts-ignore
+    globalThis.__fakeNode_next_instance_id__ = 0;
+}
+
+
 export class FakeNode {
 
     version: string = '0.3.0';
+    versions: {[key: string]: string} = {
+        'fake-node': '0.3.0',
+        'punycode': '2.3.1',
+    };
 
-    static nextId: number = 0;
     id: number;
     globalName: string;
 
-    globalenv: {[key: string]: string} = DEFAULT_ENV;
-    
-    modules: Map<string, unknown> = new Map();
-    
-    globals: {[key: string]: unknown};
+    fs: FileSystem;
 
     processes: Map<number, Process> = new Map();
     nextPid: number = 3;
 
-    window: Window = window;
+    globalenv: {[key: string]: string} = DEFAULT_ENV;
+    
+    modules: Map<string, unknown> = new Map();
+
+    // @ts-ignore
+    window: Window;
 
     errorCallbacks: (Function | undefined)[] = [];
 
     constructor() {
-        this.id = FakeNode.nextId;
-        FakeNode.nextId++;
+        // @ts-ignore
+        this.id = globalThis.__fakeNode_next_instance_id;
+        // @ts-ignore
+        globalThis.__fakeNode_next_instance_id++;
         this.globalName = '__fakeNode_' + this.id + '__';
         // @ts-ignore
         globalThis[this.globalName] = this;
-        this.globals = {__fakeNode__: this};
-        Object.assign(this.globals, DEFAULT_GLOBALS);
+        if (IS_BROWSER) {
+            this.window = window;
+        } else {
+            Object.defineProperty(this, 'window', {get() {throw new ReferenceError('fake-node is not running in a browser')}});
+        }
+        this.fs = new FileSystem();
         window.addEventListener('error', ({error}) => this.onError(error));
         window.addEventListener('unhandledrejection', ({reason}) => reason instanceof Error ? this.onError(reason) : this.onError(new Error(String(reason))));
         for (const [name, module] of BUILTIN_MODULES) {
@@ -121,25 +167,70 @@ export class FakeNode {
         }
     }
 
-    require(module: string): unknown {
+    require(module: string, pid: number): unknown {
+        if (module.startsWith('/') || module.startsWith('./') || module.startsWith('../')) {
+            const process = this.processes.get(pid);
+            if (process === undefined) {
+                throw new TypeError(`nonexistent PID in FakeNode.getProcessObject call: ${pid}. If you do not know why this occured, it is probably a bug in fake-node.`);
+            }
+            module = module_path.resolve(process.cwd, module);
+        }
         if (this.modules.has(module)) {
             return this.modules.get(module);
+        } else if (module === 'process' || module === 'node:process' || module === 'fake-node:process') {
+            return this.getProcessObject(pid);
         } else {
             throw new Error(`cannot find module '${module}'`);
         }
     }
 
+    addModuleFromValue(name: string, module: unknown): void {
+        this.modules.set(name, module);
+    }
+
+    eval(code: string): void {
+        (new Process(this, {code, path: '/'})).run();
+    }
+
+    evalModule(name: string, code: string): void {
+        (new Process(this, {code, path: '/', module: name})).run();
+    }
+
+    addModule(path: string, data: string): void {
+        this.fs.writeTo(path, data);
+        (new Process(this, {path, module: path}))
+    }
+
+    getProcessObject(pid: number): ProcessObject {
+        let out = Object.create(baseProcessObject);
+        const process = this.processes.get(pid);
+        if (process === undefined) {
+            throw new TypeError(`nonexistent PID in FakeNode.getProcessObject call: ${pid}. If you do not know why this occured, it is probably a bug in fake-node.`);
+        }
+        out.argv = process.argv;
+        out.argv0 = process.argv0;
+        out.env = process.env;
+        out.execArgv = process.execArgv;
+        out.execPath = process.execPath;
+        out.mainModule = '';
+        out.platform = this.getPlatform();
+        out.version = this.version;
+        out.versions = this.versions;
+        return out;
+    }
+
     getGlobals(pid: number): object {
         const process = this.processes.get(pid);
         if (process === undefined) {
-            throw new TypeError(`nonexistent PID in FakeNode.getGlobals call: ${pid}. If you do not know why this occured, it is probably a bug in fake-node. Please report it at https://github.com/speedydelete/fake-node/issues.`);
+            throw new TypeError(`nonexistent PID in FakeNode.getGlobals call: ${pid}. If you do not know why this occured, it is probably a bug in fake-node.`);
         }
-        let scope: {[key: string]: unknown} = {};
-        Object.assign(scope, this.globals);
+        let scope = Object.assign({
+            __fakeNode__: this,
+            __fakeNode_process__: process,
+            require: ((module: string) => this.require(module, pid)).bind(this)
+        }, Object.defineProperties({}, Object.fromEntries(WEB_ONLY_GLOBALS.map((name: string) => [name, {get(): void {throw new ReferenceError(`${name} is not defined`);}}]))));
         scope.global = scope;
         scope.globalThis = scope;
-        scope.__fakeNode_process__ = process;
-        scope.require = this.require.bind(this);
         if (process.path !== '') {
             const pathParts = process.path.split('/');
             scope.__dirname = pathParts.slice(0, -1).join('/');
@@ -165,18 +256,6 @@ export class FakeNode {
         return env;
     }
 
-    run(code: string): void {
-        (new Process(this, {code, path: '/'})).run();
-    }
-
-    addModule(name: string, code: string): void {
-        (new Process(this, {code, path: '/', module: name})).run();
-    }
-
-    addModuleFromValue(name: string, module: unknown): void {
-        this.modules.set(name, module);
-    }
-
     getUserFromUID(uid: number | string): string {
         if (typeof uid === 'string') {
             return uid;
@@ -226,4 +305,17 @@ export class FakeNode {
         this.errorCallbacks[callbackID] = undefined;
     }
 
+    getPlatform(): string {
+        const data = navigator.userAgent.slice('Mozilla/5.0 ('.length, navigator.userAgent.indexOf(')'));
+        if (data.includes('Windows')) {
+            return 'win32';
+        } else if (data.includes('Linux')) {
+            return 'linux';
+        } else if (data.includes('Mac')) {
+            return 'darwin';
+        } else {
+            return 'unknown';
+        }
+    }
+
 }

package/src/os.ts

@@ -1,4 +1,6 @@
 
+/// <reference path="./in_fake_node.d.ts" />
+
 export const EOL = '\n';
 
 export function availableParallelism(): number {
@@ -196,16 +198,7 @@ export function networkInterfaces(): {[key: string]: {address: string, netmask:
 }
 
 export function platform(): string {
-    const data = __fakeNode__.window.navigator.userAgent.slice('Mozilla/5.0 ('.length, navigator.userAgent.indexOf(')'));
-    if (data.includes('Windows')) {
-        return 'win32';
-    } else if (data.includes('Linux')) {
-        return 'linux';
-    } else if (data.includes('Mac')) {
-        return 'darwin';
-    } else {
-        return 'unknown';
-    }
+    return __fakeNode__.getPlatform();
 }
 
 export function release(): string {

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

@@ -1,18 +1,14 @@
 
-import {platform as _platform} from './os';
+/// <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 argv = __fakeNode_process__.argv;
-
-// export const argv0 = __fakeNode_process__.argv0;
-
 export const channel = undefined;
 
 export function chdir(path: string): void {
@@ -51,12 +47,6 @@ export function emitWarning(warning: string | Error, type_or_options: string | {
     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();
@@ -152,8 +142,6 @@ 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');
 }
@@ -182,8 +170,6 @@ export function ref(maybeRefable: any): void {
 
 export const pid = 1;
 
-// export const platform = _platform();
-
 export const ppid = 1;
 
 export const release = {
@@ -257,7 +243,3 @@ export function unref(maybeRefable: any): void {
 export function uptime(): number {
     return __fakeNode_process__.fakeNode.window.performance.now() / 1000;
 }
-
-// export const version = __fakeNode__.version;
-
-// export const versions = [version];