@serveryyswys/node.operit 0.0.0-stage → 0.1.3

package/dist/events.js

@@ -0,0 +1,237 @@
+'use strict';
+const registry = new WeakMap();
+/** Node 用它旁听 error 事件而不消费它。 */
+const errorMonitor = Symbol.for('nodejs.errorMonitor');
+function stateOf(emitter) {
+    let current = registry.get(emitter);
+    if (current === undefined) {
+        current = { events: new Map(), maxListeners: 0 };
+        registry.set(emitter, current);
+    }
+    return current;
+}
+function listenersOf(emitter, name, create) {
+    const state = stateOf(emitter);
+    let list = state.events.get(name);
+    if (list === undefined && create) {
+        list = [];
+        state.events.set(name, list);
+    }
+    return list;
+}
+function unwrap(entry) {
+    const fn = entry.fn;
+    return entry.once && typeof fn.listener === 'function' ? fn.listener : entry.fn;
+}
+function indexFromEnd(list, fn) {
+    for (let i = list.length - 1; i >= 0; i -= 1) {
+        if (unwrap(list[i]) === fn || list[i].fn === fn) {
+            return i;
+        }
+    }
+    return -1;
+}
+class EventEmitter {
+    static listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+    }
+    static getEventListeners(emitter, name) {
+        return emitter.listeners(name);
+    }
+    static once(emitter, name) {
+        return new Promise(function (resolve, reject) {
+            function onEvent(...args) {
+                emitter.removeListener(name, onError);
+                resolve(args);
+            }
+            function onError(error) {
+                emitter.removeListener(name, onEvent);
+                reject(error);
+            }
+            emitter.once(name, onEvent);
+            if (name !== 'error') {
+                emitter.once('error', onError);
+            }
+        });
+    }
+    static on(emitter, name) {
+        void emitter;
+        void name;
+        throw new Error('node.operit 尚未实现 events.on()（异步迭代器）。');
+    }
+    constructor() {
+        stateOf(this);
+    }
+    get maxListeners() {
+        const current = stateOf(this).maxListeners;
+        return current === 0 ? EventEmitter.defaultMaxListeners : current;
+    }
+    set maxListeners(value) {
+        this.setMaxListeners(value);
+    }
+    setMaxListeners(count) {
+        const normalized = Number(count);
+        if (normalized < 0 || !isFinite(normalized)) {
+            throw new RangeError('The value of "n" is out of range. It must be a non-negative number.');
+        }
+        stateOf(this).maxListeners = Math.floor(normalized);
+        return this;
+    }
+    getMaxListeners() {
+        return this.maxListeners;
+    }
+    on(name, listener) {
+        return this.addEntry(name, listener, false);
+    }
+    addListener(name, listener) {
+        return this.addEntry(name, listener, false);
+    }
+    prependListener(name, listener) {
+        return this.addEntry(name, listener, false, true);
+    }
+    once(name, listener) {
+        return this.addEntry(name, listener, true);
+    }
+    prependOnceListener(name, listener) {
+        return this.addEntry(name, listener, true, true);
+    }
+    /** 内部注册入口。Node 的 EventEmitter 没有它，但 Process 只以实例导出，成员必须是 public。 */
+    addEntry(name, listener, once, prepend = false) {
+        if (typeof listener !== 'function') {
+            throw new TypeError('The "listener" argument must be of type function.');
+        }
+        const list = listenersOf(this, name, true);
+        if (list === undefined) {
+            return this;
+        }
+        const emitter = this;
+        let stored;
+        if (once) {
+            // once 的包装器自己摘除自己（与 Node 一致：emit 不做预先移除），
+            // 并在 .listener 上保留原函数，供 listeners() / rawListeners() 区分。
+            const wrapped = function (...args) {
+                removeEntry(emitter, name, wrapped);
+                listener.apply(emitter, args);
+            };
+            wrapped.listener = listener;
+            stored = { fn: wrapped, once: true };
+        }
+        else {
+            stored = { fn: listener, once: false };
+        }
+        if (prepend) {
+            list.unshift(stored);
+        }
+        else {
+            list.push(stored);
+        }
+        return this;
+    }
+    emit(name, ...args) {
+        const list = listenersOf(this, name, false);
+        const monitor = name === 'error' ? listenersOf(this, errorMonitor, false) : undefined;
+        if ((list === undefined || list.length === 0) && (monitor === undefined || monitor.length === 0)) {
+            if (name === 'error') {
+                const first = args[0];
+                if (first instanceof Error) {
+                    throw first;
+                }
+                const error = new Error('Unhandled error.' + (first === undefined ? '' : ' (' + String(first) + ')'));
+                error.context = first;
+                throw error;
+            }
+            return false;
+        }
+        if (monitor !== undefined) {
+            for (let i = 0; i < monitor.length; i += 1) {
+                monitor[i].fn.apply(this, args);
+            }
+        }
+        if (list === undefined || list.length === 0) {
+            return false;
+        }
+        const snapshot = list.slice();
+        for (let i = 0; i < snapshot.length; i += 1) {
+            const entry = snapshot[i];
+            if (entry.once && indexOfEntry(list, entry.fn) < 0) {
+                continue;
+            }
+            entry.fn.apply(this, args);
+        }
+        return true;
+    }
+    removeListener(name, listener) {
+        return this.off(name, listener);
+    }
+    off(name, listener) {
+        const list = listenersOf(this, name, false);
+        if (list === undefined) {
+            return this;
+        }
+        const index = indexFromEnd(list, listener);
+        if (index >= 0) {
+            list.splice(index, 1);
+            if (list.length === 0) {
+                stateOf(this).events.delete(name);
+            }
+        }
+        return this;
+    }
+    removeAllListeners(name) {
+        const state = stateOf(this);
+        if (name === undefined) {
+            state.events.clear();
+            return this;
+        }
+        state.events.delete(name);
+        return this;
+    }
+    listeners(name) {
+        const list = listenersOf(this, name, false);
+        if (list === undefined) {
+            return [];
+        }
+        return list.map(unwrap);
+    }
+    rawListeners(name) {
+        const list = listenersOf(this, name, false);
+        if (list === undefined) {
+            return [];
+        }
+        return list.map(function (entry) {
+            return entry.fn;
+        });
+    }
+    listenerCount(name) {
+        const list = listenersOf(this, name, false);
+        return list === undefined ? 0 : list.length;
+    }
+    eventNames() {
+        return Array.from(stateOf(this).events.keys());
+    }
+}
+EventEmitter.defaultMaxListeners = 10;
+EventEmitter.errorMonitor = errorMonitor;
+EventEmitter.EventEmitter = EventEmitter;
+function indexOfEntry(list, fn) {
+    for (let i = 0; i < list.length; i += 1) {
+        if (list[i].fn === fn) {
+            return i;
+        }
+    }
+    return -1;
+}
+function removeEntry(emitter, name, fn) {
+    const list = listenersOf(emitter, name, false);
+    if (list === undefined) {
+        return;
+    }
+    const index = indexOfEntry(list, fn);
+    if (index >= 0) {
+        list.splice(index, 1);
+        if (list.length === 0) {
+            stateOf(emitter).events.delete(name);
+        }
+    }
+}
+module.exports = EventEmitter;

package/dist/fs/promises.d.ts

@@ -0,0 +1,160 @@
+import { Buffer } from '../buffer';
+declare class FileHandle {
+    readonly fd: number;
+    closed: boolean;
+    constructor(fd: number);
+    /** 公开而非 private：FileHandle 会随 fs/promises 一起被聚合导出，TS 不允许导出型别含私有成员（TS4094）。 */
+    ensureOpen(): void;
+    /** Node 的 FileHandle.read 返回 { bytesRead, buffer }，不是裸数字。 */
+    read(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): Promise<{
+        bytesRead: number;
+        buffer: Uint8Array;
+    }>;
+    /** 同理，write 返回 { bytesWritten, buffer }，buffer 是调用方传入的原始数据。 */
+    write(data: unknown, ...rest: unknown[]): Promise<{
+        bytesWritten: number;
+        buffer: unknown;
+    }>;
+    readFile(options?: unknown): Promise<string | Uint8Array>;
+    writeFile(data: unknown, options?: unknown): Promise<void>;
+    appendFile(data: unknown, options?: unknown): Promise<void>;
+    stat(): Promise<unknown>;
+    truncate(length?: number): Promise<void>;
+    sync(): Promise<void>;
+    datasync(): Promise<void>;
+    close(): Promise<void>;
+}
+declare function open(path: unknown, flags?: unknown, mode?: unknown): Promise<FileHandle>;
+declare const api: {
+    open: typeof open;
+    readFile: (target: unknown, options?: unknown) => Promise<string | Buffer>;
+    writeFile: (target: unknown, data: unknown, options?: unknown) => Promise<void>;
+    appendFile: (target: unknown, data: unknown, options?: unknown) => Promise<void>;
+    stat: (target: unknown, options?: unknown) => Promise<{
+        readonly sizeValue: number;
+        readonly modeValue: number;
+        readonly atimeMsValue: number;
+        readonly mtimeMsValue: number;
+        readonly ctimeMsValue: number;
+        readonly birthtimeMsValue: number;
+        readonly fileLike: boolean;
+        readonly directoryLike: boolean;
+        readonly linkLike: boolean;
+        get size(): number;
+        get mode(): number;
+        get atimeMs(): number;
+        get mtimeMs(): number;
+        get ctimeMs(): number;
+        get birthtimeMs(): number;
+        get atime(): Date;
+        get mtime(): Date;
+        get ctime(): Date;
+        get birthtime(): Date;
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+    } | undefined>;
+    lstat: (target: unknown, options?: unknown) => Promise<{
+        readonly sizeValue: number;
+        readonly modeValue: number;
+        readonly atimeMsValue: number;
+        readonly mtimeMsValue: number;
+        readonly ctimeMsValue: number;
+        readonly birthtimeMsValue: number;
+        readonly fileLike: boolean;
+        readonly directoryLike: boolean;
+        readonly linkLike: boolean;
+        get size(): number;
+        get mode(): number;
+        get atimeMs(): number;
+        get mtimeMs(): number;
+        get ctimeMs(): number;
+        get birthtimeMs(): number;
+        get atime(): Date;
+        get mtime(): Date;
+        get ctime(): Date;
+        get birthtime(): Date;
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+    } | undefined>;
+    readdir: (target: unknown, options?: unknown) => Promise<string[] | {
+        readonly name: string;
+        readonly kind: number;
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+    }[]>;
+    mkdir: (target: unknown, options?: unknown) => Promise<string | undefined>;
+    rm: (target: unknown, options?: unknown) => Promise<void>;
+    unlink: (target: unknown) => Promise<void>;
+    rmdir: (target: unknown, options?: unknown) => Promise<void>;
+    rename: (from: unknown, to: unknown) => Promise<void>;
+    copyFile: (from: unknown, to: unknown) => Promise<void>;
+    realpath: (target: unknown) => Promise<string>;
+    readlink: (target: unknown) => Promise<string>;
+    symlink: (target: unknown, linkPath: unknown) => Promise<void>;
+    chmod: (target: unknown, mode: unknown) => Promise<void>;
+    truncate: (target: unknown, length?: unknown) => Promise<void>;
+    utimes: (target: unknown, atime: unknown, mtime: unknown) => Promise<void>;
+    access: (target: unknown) => Promise<void>;
+    mkdtemp: (prefix: unknown) => Promise<string>;
+    constants: {
+        F_OK: number;
+        R_OK: number;
+        W_OK: number;
+        X_OK: number;
+        COPYFILE_EXCL: number;
+        COPYFILE_FICLONE: number;
+        COPYFILE_FICLONE_FORCE: number;
+        UV_FS_COPYFILE_EXCL: number;
+        UV_FS_COPYFILE_FICLONE: number;
+        UV_FS_COPYFILE_FICLONE_FORCE: number;
+        O_RDONLY: number;
+        O_WRONLY: number;
+        O_RDWR: number;
+        O_CREAT: number;
+        O_EXCL: number;
+        O_TRUNC: number;
+        O_APPEND: number;
+        UV_FS_O_FILEMAP: number;
+        UV_FS_SYMLINK_DIR: number;
+        UV_FS_SYMLINK_JUNCTION: number;
+        UV_DIRENT_UNKNOWN: number;
+        UV_DIRENT_FILE: number;
+        UV_DIRENT_DIR: number;
+        UV_DIRENT_LINK: number;
+        UV_DIRENT_FIFO: number;
+        UV_DIRENT_SOCKET: number;
+        UV_DIRENT_CHAR: number;
+        UV_DIRENT_BLOCK: number;
+        S_IFMT: number;
+        S_IFREG: number;
+        S_IFDIR: number;
+        S_IFCHR: number;
+        S_IFIFO: number;
+        S_IFLNK: number;
+        S_IRUSR: number;
+        S_IWUSR: number;
+        S_IXUSR: number;
+        S_IRGRP: number;
+        S_IWGRP: number;
+        S_IXGRP: number;
+        S_IROTH: number;
+        S_IWOTH: number;
+        S_IXOTH: number;
+    };
+};
+export = api;

package/dist/fs/promises.js

@@ -0,0 +1,130 @@
+'use strict';
+/**
+ * fs/promises 子路径入口。
+ *
+ * 实现方式：把同步面逐个包进 Promise。
+ * 原因很直接 —— 宿主只有 Java bridge 这一条同步通道（DESIGN.md §6.3），
+ * 没有真异步可用；所以这里给的是"接口是异步、执行是同步"。
+ * 调用方若在 UI 线程上使用，需要自己评估阻塞成本。
+ *
+ * `open()` 按 Node 语义返回 **FileHandle**（不是裸 fd）。
+ * Node 的 fs.promises 并没有 fd 形式的 read/write/close/fstat/ftruncate/fsync，
+ * 所以这里也不提供 —— 那些能力在 FileHandle 上。
+ */
+const fs = require("../fs");
+const buffer_1 = require("../buffer");
+function promisify(fn) {
+    return function (...args) {
+        try {
+            return Promise.resolve(fn.apply(null, args));
+        }
+        catch (failure) {
+            return Promise.reject(failure);
+        }
+    };
+}
+function toBytes(data, encoding) {
+    if (typeof data === 'string') {
+        const resolved = typeof encoding === 'string'
+            ? encoding
+            : (encoding !== undefined && encoding !== null && typeof encoding.encoding === 'string' ? encoding.encoding : 'utf8');
+        return buffer_1.Buffer.from(data, resolved);
+    }
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    throw new TypeError('The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView.');
+}
+class FileHandle {
+    constructor(fd) {
+        this.closed = false;
+        this.fd = fd;
+    }
+    /** 公开而非 private：FileHandle 会随 fs/promises 一起被聚合导出，TS 不允许导出型别含私有成员（TS4094）。 */
+    ensureOpen() {
+        if (this.closed) {
+            const error = new Error('file descriptor was closed');
+            error.code = 'EBADF';
+            throw error;
+        }
+    }
+    /** Node 的 FileHandle.read 返回 { bytesRead, buffer }，不是裸数字。 */
+    async read(buffer, offset, length, position) {
+        this.ensureOpen();
+        const bytesRead = fs.readSync(this.fd, buffer, offset, length, position);
+        return { bytesRead: bytesRead, buffer: buffer };
+    }
+    /** 同理，write 返回 { bytesWritten, buffer }，buffer 是调用方传入的原始数据。 */
+    async write(data, ...rest) {
+        this.ensureOpen();
+        const bytesWritten = fs.writeSync(this.fd, data, rest[0], rest[1], rest[2]);
+        return { bytesWritten: bytesWritten, buffer: data };
+    }
+    async readFile(options) {
+        this.ensureOpen();
+        return fs.readFileSync(this.fd, options);
+    }
+    async writeFile(data, options) {
+        this.ensureOpen();
+        fs.writeFileSync(this.fd, data, options);
+    }
+    async appendFile(data, options) {
+        this.ensureOpen();
+        const bytes = toBytes(data, options);
+        const size = fs.fstatSync(this.fd).size;
+        fs.writeSync(this.fd, bytes, 0, bytes.length, size);
+    }
+    async stat() {
+        this.ensureOpen();
+        return fs.fstatSync(this.fd);
+    }
+    async truncate(length) {
+        this.ensureOpen();
+        fs.ftruncateSync(this.fd, length);
+    }
+    async sync() {
+        this.ensureOpen();
+        fs.fsyncSync(this.fd);
+    }
+    async datasync() {
+        this.ensureOpen();
+        fs.fdatasyncSync(this.fd);
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        fs.closeSync(this.fd);
+    }
+}
+function open(path, flags, mode) {
+    return Promise.resolve().then(function () {
+        return new FileHandle(fs.openSync(path, flags, mode));
+    });
+}
+const api = {
+    open: open,
+    readFile: promisify(fs.readFileSync),
+    writeFile: promisify(fs.writeFileSync),
+    appendFile: promisify(fs.appendFileSync),
+    stat: promisify(fs.statSync),
+    lstat: promisify(fs.lstatSync),
+    readdir: promisify(fs.readdirSync),
+    mkdir: promisify(fs.mkdirSync),
+    rm: promisify(fs.rmSync),
+    unlink: promisify(fs.unlinkSync),
+    rmdir: promisify(fs.rmdirSync),
+    rename: promisify(fs.renameSync),
+    copyFile: promisify(fs.copyFileSync),
+    realpath: promisify(fs.realpathSync),
+    readlink: promisify(fs.readlinkSync),
+    symlink: promisify(fs.symlinkSync),
+    chmod: promisify(fs.chmodSync),
+    truncate: promisify(fs.truncateSync),
+    utimes: promisify(fs.utimesSync),
+    access: promisify(fs.accessSync),
+    mkdtemp: promisify(fs.mkdtempSync),
+    constants: fs.constants
+};
+module.exports = api;