fake-node 0.2.0 → 0.4.0

package/src/buffer.ts

@@ -0,0 +1,13 @@
+
+const Blob_ = Blob;
+export {Blob_ as Blob};
+
+export type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";
+
+export class Buffer extends Uint8Array {
+
+    toString(encoding: BufferEncoding = 'utf-8'): string {
+        return (new TextDecoder(encoding)).decode(this);
+    }
+
+}

package/src/fs.ts

@@ -0,0 +1,230 @@
+
+/// <reference path="./in_fake_node.d.ts" />
+import {type TypedArray} from './util';
+import {dirname, basename, resolve} from './path';
+import {Buffer, type BufferEncoding} from './buffer';
+import {constants, parsePathArg, Directory, FileSystem} from './_fs';
+import type {PathArg, ModeArg, DataArg, TimeArg, Flag, Stats, BigIntStats, StatFs, BigIntStatFs} from './_fs';
+
+export {constants} from './_fs';
+
+export {Stats, BigIntStats, StatFs, BigIntStatFs} from './_fs';
+
+export function accessSync(path: PathArg, mode: number = constants.F_OK) {
+    __fakeNode__.fs.get(path).access(mode);
+}
+
+export function appendFileSync(path: PathArg, data: DataArg, {encoding = 'utf8', mode = 0o666, flag = 'a'}: {encoding?: BufferEncoding, mode: number, flag: string}) {
+    __fakeNode__.fs.getRegular(path).append(data, encoding);
+}
+
+export function chmodSync(path: PathArg, mode: ModeArg): void {
+    __fakeNode__.fs.get(path).chmod(mode);
+}
+
+export function chownSync(path: PathArg, uid: number, gid: number): void {
+    __fakeNode__.fs.get(path).chown(uid, gid);
+}
+
+export function closeSync(fd: number): void {
+    __fakeNode__.fs.fileDescriptors[fd] = null;
+}
+
+export function copyFileSync(src: PathArg, dest: PathArg, mode: number = 0): void {
+    if ((mode & constants.COPYFILE_EXCL) === constants.COPYFILE_EXCL && __fakeNode__.fs.exists(dest)) {
+        throw new TypeError(`${dest} exists`);
+    }
+    if ((mode & constants.COPYFILE_FICLONE_FORCE) === constants.COPYFILE_FICLONE_FORCE) {
+        throw new TypeError('fake-node does not support copy-on-write');
+    }
+    __fakeNode__.fs.getRegular(dest).write(__fakeNode__.fs.getRegular(src).read());
+}
+
+export function existsSync(path: PathArg): boolean {
+    return __fakeNode__.fs.exists(path);
+}
+
+export function fchmodSync(fd: number, mode: ModeArg): void {
+    __fakeNode__.fs.getfd(fd).chmod(mode);
+}
+
+export function fchownsync(fd: number, uid: number, gid: number): void {
+    __fakeNode__.fs.getfd(fd).chown(uid, gid);
+}
+
+export function fdatasyncSync(fd: number): void {
+    return;
+}
+
+export function fstatSync(fd: number): Stats {
+    return __fakeNode__.fs.getfd(fd).stat();
+}
+
+export function fsyncSync(fd: number): void {
+    return;
+}
+
+export function ftruncateSync(fd: number, len: number): void {
+    let file = __fakeNode__.fs.getfdRegular(fd);
+    file.data = file.data.slice(0, len);
+}
+
+export function futimesSync(fd: number, atime: TimeArg, ctime: TimeArg): void {
+    __fakeNode__.fs.getfd(fd).utimes(atime, ctime);
+}
+
+export function globSync(pattern: string | string[]): string[] {
+    throw new TypeError('globs are not supported in fake-node');
+}
+
+export function lchmodSync(path: PathArg, mode: number): void {
+    __fakeNode__.fs.lget(path).chmod(mode);
+}
+
+export function lchownSync(path: PathArg, uid: number, gid: number): void {
+    __fakeNode__.fs.lget(path).chown(uid, gid);
+}
+
+export function lutimesSync(path: PathArg, atime: TimeArg, mtime: TimeArg): void {
+    __fakeNode__.fs.lget(path).utimes(atime, mtime);
+}
+
+export function linkSync(existingPath: PathArg, newPath: PathArg): void {
+    __fakeNode__.fs.getDir(dirname(parsePathArg(existingPath))).link(basename(parsePathArg(newPath)), __fakeNode__.fs.get(existingPath));
+}
+
+export function lstatSync(path: PathArg, {bigint, throwIfNoEntry}: {bigint?: false, throwIfNoEntry: false}): Stats;
+export function lstatSync(path: PathArg, {bigint, throwIfNoEntry}: {bigint?: false, throwIfNoEntry: true}): Stats | undefined;
+export function lstatSync(path: PathArg, {bigint, throwIfNoEntry}: {bigint?: true, throwIfNoEntry: false}): BigIntStats;
+export function lstatSync(path: PathArg, {bigint, throwIfNoEntry}: {bigint?: true, throwIfNoEntry: true}): BigIntStats | undefined;
+export function lstatSync(path: PathArg, {bigint = false, throwIfNoEntry = false}: {bigint?: boolean, throwIfNoEntry?: boolean} = {}): Stats | BigIntStats | undefined {
+    if (!throwIfNoEntry && !__fakeNode__.fs.exists(path)) {
+        return undefined;
+    }
+    // @ts-ignore // why is it doing this
+    return __fakeNode__.fs.lget(path).stat(bigint);
+}
+
+export function mkdirSync(path: PathArg, options: {recursive?: boolean, mode?: ModeArg} | ModeArg = 0o777): void {
+    let recursive: boolean;
+    let mode: ModeArg;
+    if (typeof options === 'number' || typeof options === 'string') {
+        recursive = false;
+        mode = options;
+    } else {
+        recursive = options.recursive ?? false;
+        mode = options.mode ?? 0o777;
+    }
+    __fakeNode__.fs.mkdir(path, recursive, mode);
+}
+
+export function mkdtempSync(prefix: PathArg, options: {encoding?: string} | string = 'utf8'): void {
+    throw new TypeError('fs.mkdtemp is not supported in fake-node');
+}
+
+export function opendirSync(path: PathArg, {encoding = 'utf8', bufferSize = 32, recursive = false}: {encoding?: string, bufferSize?: number, recursive?: boolean} = {}): void {
+    throw new TypeError('fs.opendir is not supported in fake-node');
+}
+
+export function openSync(path: PathArg, flags: Flag, mode: ModeArg = 'r'): number {
+    return __fakeNode__.fs.open(path, flags, mode);
+}
+
+export function readdirSync(path: PathArg, options: {encoding?: string, withFileTypes?: boolean, recursive?: boolean} | string = 'utf8') {
+    throw new TypeError('fs.readdir is not supported in fake-node');
+}
+
+export function readFileSync(path: PathArg, options: {encoding?: null | 'buffer', flag?: string} | 'buffer'): Buffer;
+export function readFileSync(path: PathArg, options: {encoding: BufferEncoding, flag?: string} | BufferEncoding): string;
+export function readFileSync(path: PathArg, options: {encoding?: BufferEncoding | null | 'buffer', flag?: string} | BufferEncoding | 'buffer' = {encoding: null, flag: 'r'}): string | Buffer {
+    // @ts-ignore // why is it doing this
+    return __fakeNode__.fs.getRegular(path).read(typeof options === 'string' ? options : options.encoding ?? 'buffer');
+}
+
+export function readlinkSync(path: PathArg, options: {encoding?: string} | string = 'utf8'): string | Buffer {
+    throw new TypeError('fs.readlink is not supported in fake-node');
+}
+
+export function readSync(fd: number, buffer: Buffer | TypedArray | DataView, offset: number, length: number, position: number | bigint | null = null): number {
+    position = Number(position ?? 0);
+    const data = __fakeNode__.fs.getfdRegular(fd).read('uint8array', offset, length);
+    if (buffer instanceof DataView) {
+        for (let i = position; i < data.length; i++) {
+            buffer.setUint8(i, data[i]);
+        }
+    } else {
+        // @ts-ignore // why is it doing this
+        buffer.set(data, position);
+    }
+    return length;
+}
+
+export function readvSync(fd: number, buffers: ArrayBufferView[], position: number | null = null): number {
+    throw new TypeError('fs.readv is not supported in fake-node');
+}
+
+export function realpathSync(path: PathArg, {encoding}: {encoding: string} = {encoding: 'utf8'}): string {
+    return resolve(parsePathArg(path));
+}
+realpathSync.native = realpathSync;
+
+export function renameSync(oldPath: PathArg, newPath: PathArg): void {
+    const parsedOldPath = parsePathArg(oldPath);
+    const parsedNewPath = parsePathArg(newPath);
+    const file = __fakeNode__.fs.getDir(dirname(parsedOldPath)).unlink(basename(parsedOldPath));
+    __fakeNode__.fs.getDir(dirname(parsedNewPath)).link(basename(parsedNewPath), file);
+}
+
+export function rmdirSync(path: PathArg): void {
+    const file = __fakeNode__.fs.get(path);
+    if (!(file instanceof Directory)) {
+        throw new TypeError(`cannot remove directory ${path}: is not a directory`);
+    } else if (!(file.size === 0)) {
+        throw new TypeError(`cannot remove directory ${path}: is not empty`);
+    }
+    __fakeNode__.fs.unlink(path);
+}
+
+export function rmSync(path: PathArg): void {
+    __fakeNode__.fs.unlink(path);
+}
+
+export function statSync(path: PathArg, {bigint, throwIfNoEntry}: {bigint?: false, throwIfNoEntry: false}): Stats;
+export function statSync(path: PathArg, {bigint, throwIfNoEntry}: {bigint?: false, throwIfNoEntry: true}): Stats | undefined;
+export function statSync(path: PathArg, {bigint, throwIfNoEntry}: {bigint?: true, throwIfNoEntry: false}): BigIntStats;
+export function statSync(path: PathArg, {bigint, throwIfNoEntry}: {bigint?: true, throwIfNoEntry: true}): BigIntStats | undefined;
+export function statSync(path: PathArg, {bigint = false, throwIfNoEntry = false}: {bigint?: boolean, throwIfNoEntry?: boolean} = {}): Stats | BigIntStats | undefined {
+    if (!throwIfNoEntry && !__fakeNode__.fs.exists(path)) {
+        return undefined;
+    }
+    // @ts-ignore // why is it doing this
+    return __fakeNode__.fs.get(path).stat(bigint);
+}
+
+export function statfsSync(path: PathArg, {bigint}: {bigint?: false}): StatFs;
+export function statfsSync(path: PathArg, {bigint}: {bigint?: true}): BigIntStatFs;
+export function statfsSync(path: PathArg, {bigint = false}: {bigint?: boolean} = {}): StatFs | BigIntStatFs {
+    let file = __fakeNode__.fs.get(path);
+    if (!(file instanceof FileSystem)) {
+        throw new TypeError(`cannot get fs stat for ${path}: is not a file system`);
+    }
+    // @ts-ignore // why is it doing this
+    return file.statfs(bigint);
+}
+
+export function symlinkSync(target: PathArg, path: PathArg): void {
+    __fakeNode__.fs.symlink(target, path);
+}
+
+export function truncateSync(path: PathArg, len: number = 0): void {
+    let file = __fakeNode__.fs.getRegular(path);
+    file.data = file.data.slice(0, len);
+}
+
+export function unlinkSync(path: PathArg): void {
+    __fakeNode__.fs.unlink(path);
+}
+
+export function utimesSync(path: PathArg, atime: TimeArg, mtime: TimeArg) {
+    __fakeNode__.fs.get(path).utimes(atime, mtime);
+}

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

@@ -0,0 +1,321 @@
+
+import * as baseProcessObject from './process';
+import {FileSystem} from './_fs';
+import * as module_os from './os';
+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';
+
+
+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],
+    ['util', module_util],
+    ['querystring', module_querystring],
+    ['punycode', module_punycode],
+    ['path', module_path],
+    ['buffer', module_buffer],
+    ['fs', module_fs],
+];
+
+const DEFAULT_ENV = {
+    PATH: '/usr/local/bin:/usr/bin:/bin',
+    SHLVL: '1',
+    SHELL: '/bin/bash',
+    TERM: 'none',
+    PS1: '',
+    PS2: '> ',
+    HISTFILE: '~/.bash_history',
+    EDITOR: 'vim',
+    VISUAL: 'vim',
+    LANG: 'en_US.utf8',
+    HOSTNAME: 'fake-node',
+    TMPDIR: '/tmp',
+};
+
+
+export class Process {
+
+    fakeNode: FakeNode;
+
+    pid: number;
+    priority: number = 0;
+
+    uid: number = 0;
+    gid: number = 0;
+    groups: number[] = [];
+    cwd: string;
+    umask: number = 0o6440;
+
+    argv: string[] = [];
+    argv0: string = '';
+    execArgv: string[] = [];
+    execPath: string = '/usr/bin/local/node';
+
+    path: string;
+    module: false | string;
+    code?: 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.path = path;
+        this.cwd = path.split('/').slice(0, -1).join('/');
+        this.module = module;
+        this.code = code;
+    }
+
+    get env(): {[key: string]: string} {
+        return this.fakeNode.getenv(this.pid);
+    }
+
+    run(): void {
+        let code = this.code;
+        if (code === undefined) {
+            code = this.fakeNode.fs.readFrom(this.path);
+        }
+        let injectCode: string;
+        if (this.module) {
+            injectCode = `with(${this.fakeNode.globalName}.getGlobals(${this.pid})){__fakeNode__.modules.set('${this.module},(function(){${code};return module.exports;})());}`;
+        } else {
+            injectCode = `with(${this.fakeNode.globalName}.getGlobals(${this.pid})){(function(){${code}})();}`;
+        }
+        let elt = document.createElement('script');
+        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',
+    };
+
+    id: number;
+    globalName: string;
+
+    fs: FileSystem;
+
+    processes: Map<number, Process> = new Map();
+    nextPid: number = 3;
+
+    globalenv: {[key: string]: string} = DEFAULT_ENV;
+    
+    modules: Map<string, unknown> = new Map();
+
+    // @ts-ignore
+    window: Window;
+
+    errorCallbacks: (Function | undefined)[] = [];
+
+    constructor() {
+        // @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;
+        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) {
+            this.addModuleFromValue(name, module);
+            this.addModuleFromValue('node:' + name, module);
+            this.addModuleFromValue('fake-node:' + name, module);
+        }
+    }
+
+    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.`);
+        }
+        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;
+        if (process.path !== '') {
+            const pathParts = process.path.split('/');
+            scope.__dirname = pathParts.slice(0, -1).join('/');
+            scope.__filename = pathParts[pathParts.length - 1];
+        }
+        if (process.module !== false) {
+            scope.module = {
+                exports: {},
+            };
+            // @ts-ignore
+            scope.exports = scope.module.exports;
+        }
+        return scope;
+    }
+
+    getenv(pid: number): {[key: string]: string} {
+        let env = Object.create(this.globalenv);
+        const process = this.processes.get(pid);
+        if (process === undefined) {
+            throw new TypeError(`invalid PID: ${pid}`);
+        }
+        env.USER = this.getUserFromUID(process.uid);
+        return env;
+    }
+
+    getUserFromUID(uid: number | string): string {
+        if (typeof uid === 'string') {
+            return uid;
+        } else {
+            return 'root';
+        }
+    }
+
+    getUserFromGID(gid: number | string): string {
+        if (typeof gid === 'string') {
+            return gid;
+        } else {
+            return 'root';
+        }
+    }
+
+    getUIDFromUser(user: string | number): number {
+        if (typeof user === 'number') {
+            return user;
+        } else {
+            return 0;
+        }
+    }
+
+    getGIDFromGroup(group: string | number): number {
+        if (typeof group === 'number') {
+            return group;
+        } else {
+            return 0;
+        }
+    }
+
+    onError(error: Error): void {
+        for (const callback of this.errorCallbacks) {
+            if (callback !== undefined) {
+                callback(error);
+            }
+        }
+    }
+
+    addErrorCallback(callback: Function): number {
+        this.errorCallbacks.push(callback);
+        return this.errorCallbacks.length - 1;
+    }
+
+    removeErrorCallback(callbackID: number): void {
+        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';
+        }
+    }
+
+}