@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/perf_hooks.d.ts

@@ -0,0 +1,36 @@
+/**
+ * perf_hooks 模块（部分）。
+ *
+ * 宿主提供 `performance.now()`，但只有这一个方法；mark / measure / getEntries 这些
+ * 由本模块自己维护一张表实现，与 Node 的语义对齐（含 measure 的两种调用形式）。
+ *
+ * 未实现：PerformanceObserver、PerformanceEntry 等类、monitorEventLoopDelay、
+ * createHistogram。这些要么依赖 V8/Node 的观测能力，要么在沙箱里没有意义；
+ * 保持 undefined 而不是给空壳。
+ */
+import type { MeasureOptions, PerformanceEntryLike } from './lib/perf-hooks-types';
+declare function now(): number;
+declare function mark(name: unknown, options?: {
+    detail?: unknown;
+}): PerformanceEntryLike;
+declare function measure(name: unknown, startOrOptions?: string | number | MeasureOptions, endMark?: string | number): PerformanceEntryLike;
+declare function getEntries(): PerformanceEntryLike[];
+declare function getEntriesByName(name: unknown, type?: unknown): PerformanceEntryLike[];
+declare function getEntriesByType(type: unknown): PerformanceEntryLike[];
+declare function clearMarks(name?: unknown): void;
+declare function clearMeasures(name?: unknown): void;
+declare const api: {
+    performance: {
+        now: typeof now;
+        timeOrigin: number;
+        mark: typeof mark;
+        measure: typeof measure;
+        getEntries: typeof getEntries;
+        getEntriesByName: typeof getEntriesByName;
+        getEntriesByType: typeof getEntriesByType;
+        clearMarks: typeof clearMarks;
+        clearMeasures: typeof clearMeasures;
+    };
+    constants: Record<string, number>;
+};
+export = api;

package/dist/perf_hooks.js

@@ -0,0 +1,144 @@
+'use strict';
+const entries = [];
+const markTimes = new Map();
+const timeOrigin = Date.now() - performance.now();
+function now() {
+    return performance.now();
+}
+function makeEntry(name, entryType, startTime, duration, detail) {
+    const entry = {
+        name: name,
+        entryType: entryType,
+        startTime: startTime,
+        duration: duration
+    };
+    if (detail !== undefined) {
+        entry.detail = detail;
+    }
+    return entry;
+}
+/** options 形式：start/end 既可以是 mark 名字，也可以是时间戳。 */
+function resolveOptionTime(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    const marked = markTimes.get(value);
+    return marked === undefined ? fallback : marked;
+}
+/**
+ * 位置参数形式：startMark / endMark **只当 mark 名字**，不认数字。
+ * 这是实测 Node 的行为 —— measure('x', 10, 30) 在 Node 里是"找名叫 10 和 30 的 mark"，
+ * 找不到就是 start=0、end=now()，而不是把 10/30 当时间戳。
+ */
+function resolveMarkName(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const marked = markTimes.get(String(value));
+    return marked === undefined ? fallback : marked;
+}
+function mark(name, options) {
+    const label = String(name);
+    const startTime = now();
+    markTimes.set(label, startTime);
+    const entry = makeEntry(label, 'mark', startTime, 0, options === undefined ? undefined : options.detail);
+    entries.push(entry);
+    return entry;
+}
+function measure(name, startOrOptions, endMark) {
+    const label = String(name);
+    let start = 0;
+    let end = now();
+    let detail;
+    if (startOrOptions !== undefined && typeof startOrOptions === 'object') {
+        start = resolveOptionTime(startOrOptions.start, 0);
+        end = resolveOptionTime(startOrOptions.end, now());
+        detail = startOrOptions.detail;
+    }
+    else {
+        start = resolveMarkName(startOrOptions, 0);
+        end = resolveMarkName(endMark, now());
+    }
+    const entry = makeEntry(label, 'measure', start, end - start, detail);
+    entries.push(entry);
+    return entry;
+}
+function getEntries() {
+    return entries.slice();
+}
+function getEntriesByName(name, type) {
+    const label = String(name);
+    return entries.filter(function (entry) {
+        if (entry.name !== label) {
+            return false;
+        }
+        return type === undefined || entry.entryType === String(type);
+    });
+}
+function getEntriesByType(type) {
+    const wanted = String(type);
+    return entries.filter(function (entry) {
+        return entry.entryType === wanted;
+    });
+}
+function clearMarks(name) {
+    const label = name === undefined ? undefined : String(name);
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+        if (entries[i].entryType !== 'mark') {
+            continue;
+        }
+        if (label === undefined || entries[i].name === label) {
+            entries.splice(i, 1);
+        }
+    }
+    if (label === undefined) {
+        markTimes.clear();
+    }
+    else {
+        markTimes.delete(label);
+    }
+}
+function clearMeasures(name) {
+    const label = name === undefined ? undefined : String(name);
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+        if (entries[i].entryType !== 'measure') {
+            continue;
+        }
+        if (label === undefined || entries[i].name === label) {
+            entries.splice(i, 1);
+        }
+    }
+}
+const performanceApi = {
+    now: now,
+    timeOrigin: timeOrigin,
+    mark: mark,
+    measure: measure,
+    getEntries: getEntries,
+    getEntriesByName: getEntriesByName,
+    getEntriesByType: getEntriesByType,
+    clearMarks: clearMarks,
+    clearMeasures: clearMeasures
+};
+/** 与 Node 的 perf_hooks.constants 一致。 */
+const constants = {
+    NODE_PERFORMANCE_GC_MAJOR: 4,
+    NODE_PERFORMANCE_GC_MINOR: 1,
+    NODE_PERFORMANCE_GC_INCREMENTAL: 8,
+    NODE_PERFORMANCE_GC_WEAKCB: 16,
+    NODE_PERFORMANCE_GC_FLAGS_NO: 0,
+    NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED: 2,
+    NODE_PERFORMANCE_GC_FLAGS_FORCED: 4,
+    NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING: 8,
+    NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE: 16,
+    NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY: 32,
+    NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE: 64
+};
+const api = {
+    performance: performanceApi,
+    constants: constants
+};
+module.exports = api;

package/dist/process.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Node process 模块的移植。
+ *
+ * 这是 `require('process')` 返回的对象。注意 Operit 运行时**没有** `process` 全局，
+ * 所以直接引用裸 `process` 的代码需要由 OperitPackageManager 在重写时注入（见 README）。
+ *
+ * 已知差异：
+ *   - process.env 是 Proxy，读走 Operit 的 getEnv；getEnv 对不存在的变量返回空串，
+ *     因此空串与未设置都表现为 undefined；且无法枚举（Object.keys(env) 恒为 []）
+ *   - process.exit() 会终止整个 Operit 运行时，这里显式抛错而不是静默继续
+ *   - versions.node 是"声明的兼容目标"，不是真实运行时版本
+ */
+import EventEmitter = require('./events');
+declare function nextTick(fn: (...args: unknown[]) => void, ...args: unknown[]): void;
+declare class Process extends EventEmitter {
+    exitCode: number | undefined;
+    title: string;
+    get platform(): string;
+    get arch(): string;
+    get version(): string;
+    readonly versions: {
+        node: string;
+        operit: string;
+        quickjs: string;
+    };
+    readonly argv: string[];
+    readonly execArgv: string[];
+    readonly execPath = "operit";
+    readonly env: Record<string, string | undefined>;
+    readonly stdout: {
+        isTTY: boolean;
+        columns: number;
+        rows: number;
+        write(chunk: string | Uint8Array): boolean;
+    };
+    readonly stderr: {
+        isTTY: boolean;
+        columns: number;
+        rows: number;
+        write(chunk: string | Uint8Array): boolean;
+    };
+    readonly stdin: {
+        isTTY: boolean;
+        read: () => null;
+        on: () => unknown;
+        resume: () => void;
+    };
+    readonly nextTick: typeof nextTick;
+    readonly hrtime: ((previous?: number[]) => number[]) & {
+        bigint(): bigint;
+    };
+    get pid(): number;
+    cwd(): string;
+    chdir(directory: string): void;
+    uptime(): number;
+    memoryUsage(): {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        arrayBuffers: number;
+    };
+    emitWarning(warning: unknown): void;
+    exit(code?: number): never;
+    abort(): never;
+    umask(): number;
+}
+declare const processObject: Process;
+export = processObject;

package/dist/process.js

@@ -0,0 +1,230 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+/**
+ * Node process 模块的移植。
+ *
+ * 这是 `require('process')` 返回的对象。注意 Operit 运行时**没有** `process` 全局，
+ * 所以直接引用裸 `process` 的代码需要由 OperitPackageManager 在重写时注入（见 README）。
+ *
+ * 已知差异：
+ *   - process.env 是 Proxy，读走 Operit 的 getEnv；getEnv 对不存在的变量返回空串，
+ *     因此空串与未设置都表现为 undefined；且无法枚举（Object.keys(env) 恒为 []）
+ *   - process.exit() 会终止整个 Operit 运行时，这里显式抛错而不是静默继续
+ *   - versions.node 是"声明的兼容目标"，不是真实运行时版本
+ */
+const EventEmitter = require("./events");
+const fsModule = require("./fs");
+const pathModule = require("./path");
+const os = __importStar(require("./os"));
+const cwd = __importStar(require("./lib/cwd"));
+const bridge = __importStar(require("./lib/bridge"));
+const bytesCodec = __importStar(require("./lib/bytes"));
+const errors_1 = require("./lib/errors");
+const pending = [];
+let drainScheduled = false;
+function drainQueue() {
+    drainScheduled = false;
+    const batch = pending.splice(0, pending.length);
+    for (let i = 0; i < batch.length; i += 1) {
+        batch[i].fn.apply(null, batch[i].args);
+    }
+}
+function nextTick(fn, ...args) {
+    if (typeof fn !== 'function') {
+        throw new TypeError('The "callback" argument must be of type function.');
+    }
+    pending.push({ fn: fn, args: args });
+    if (!drainScheduled) {
+        drainScheduled = true;
+        queueMicrotask(drainQueue);
+    }
+}
+function hrtime(previous) {
+    const nowMs = performance.now();
+    let seconds = Math.floor(nowMs / 1000);
+    let nanoseconds = Math.floor((nowMs % 1000) * 1e6);
+    if (previous !== undefined) {
+        seconds -= previous[0];
+        nanoseconds -= previous[1];
+        if (nanoseconds < 0) {
+            seconds -= 1;
+            nanoseconds += 1e9;
+        }
+    }
+    return [seconds, nanoseconds];
+}
+const hrtimeFunction = hrtime;
+hrtimeFunction.bigint = function () {
+    return BigInt(Math.floor(performance.now() * 1e6));
+};
+function readEnvVariable(key) {
+    if (typeof getEnv !== 'function') {
+        return undefined;
+    }
+    const value = getEnv(key);
+    // Operit 的 getEnv 对不存在的变量返回空串，无法与"设为空串"区分
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+const env = new Proxy({}, {
+    get: function (_target, key) {
+        return typeof key === 'string' ? readEnvVariable(key) : undefined;
+    },
+    set: function (_target, key, value) {
+        bridge.setEnv(String(key), value === undefined || value === null ? null : String(value));
+        return true;
+    },
+    has: function (_target, key) {
+        return typeof key === 'string' && readEnvVariable(key) !== undefined;
+    },
+    deleteProperty: function (_target, key) {
+        bridge.setEnv(String(key), null);
+        return true;
+    },
+    ownKeys: function () {
+        // Operit 没有枚举环境变量的接口，因此这里只能为空
+        return [];
+    }
+});
+function createWritable(level) {
+    return {
+        isTTY: false,
+        columns: 0,
+        rows: 0,
+        write: function (chunk) {
+            const text = typeof chunk === 'string' ? chunk : bytesCodec.utf8Decode(chunk);
+            const line = text.charAt(text.length - 1) === '\n' ? text.slice(0, text.length - 1) : text;
+            if (level === 'log') {
+                console.log(line);
+            }
+            else {
+                console.warn(line);
+            }
+            return true;
+        }
+    };
+}
+class Process extends EventEmitter {
+    constructor() {
+        // 注意：Process 只以实例形式导出（export =），所以所有成员必须是 public，
+        // 否则 declaration 生成会报 TS4094。
+        super(...arguments);
+        this.exitCode = undefined;
+        this.title = 'operit';
+        this.versions = {
+            // 声明的兼容目标，不是真实运行时版本；见 README「已知偏差」
+            node: '18.0.0',
+            operit: 'node.operit/0.1.0',
+            quickjs: 'unknown'
+        };
+        this.argv = ['operit'];
+        this.execArgv = [];
+        this.execPath = 'operit';
+        this.env = env;
+        this.stdout = createWritable('log');
+        this.stderr = createWritable('warn');
+        this.stdin = {
+            isTTY: false,
+            read: function () {
+                return null;
+            },
+            on: function () {
+                return this;
+            },
+            resume: function () {
+                // 沙箱里没有真实 stdin
+            }
+        };
+        this.nextTick = nextTick;
+        this.hrtime = hrtimeFunction;
+    }
+    // 这三个改成 getter：读的时候才碰宿主，模块加载本身不调用 bridge
+    get platform() {
+        return os.platform();
+    }
+    get arch() {
+        return os.arch();
+    }
+    get version() {
+        return os.version();
+    }
+    get pid() {
+        return Number(bridge.callStatic('android.os.Process', 'myPid', [])) || 0;
+    }
+    cwd() {
+        return cwd.get();
+    }
+    chdir(directory) {
+        if (typeof directory !== 'string') {
+            throw new TypeError('The "directory" argument must be of type string.');
+        }
+        const stats = fsModule.statSync(directory);
+        if (stats === undefined || !stats.isDirectory()) {
+            throw (0, errors_1.createError)('ENOTDIR', 'chdir', directory);
+        }
+        // Node 把 cwd 存成解析后的绝对路径，不是原始参数
+        cwd.set(pathModule.resolve(directory));
+    }
+    uptime() {
+        return os.uptime();
+    }
+    memoryUsage() {
+        const heapTotal = os.totalmem();
+        const free = os.freemem();
+        return {
+            rss: heapTotal,
+            heapTotal: heapTotal,
+            heapUsed: heapTotal - free,
+            external: 0,
+            arrayBuffers: 0
+        };
+    }
+    emitWarning(warning) {
+        const value = warning instanceof Error ? warning : new Error(String(warning));
+        this.emit('warning', value);
+        console.warn('Warning: ' + value.message);
+    }
+    exit(code) {
+        void code;
+        throw (0, errors_1.onjError)('ONJ_UNSUPPORTED', 'process.exit() 会终止整个 Operit 运行时，node.operit 不提供。');
+    }
+    abort() {
+        throw (0, errors_1.onjError)('ONJ_UNSUPPORTED', 'process.abort() 会终止整个 Operit 运行时，node.operit 不提供。');
+    }
+    umask() {
+        return 0o022;
+    }
+}
+const processObject = new Process();
+module.exports = processObject;

package/dist/querystring.d.ts

@@ -0,0 +1,15 @@
+/** 与 Node 一致：querystring.escape 就是 encodeURIComponent（不额外转义 ! ' ( ) *）。 */
+export declare function escape(value: unknown): string;
+export declare function unescape(value: unknown): string;
+interface StringifyOptions {
+    encodeURIComponent?: (value: string) => string;
+}
+export declare function stringify(value: unknown, separator?: string, equals?: string, options?: StringifyOptions): string;
+interface ParseOptions {
+    maxKeys?: number;
+    decodeURIComponent?: (value: string) => string;
+}
+export declare function parse(text: unknown, separator?: string, equals?: string, options?: ParseOptions): Record<string, string | string[]>;
+export declare const encode: typeof stringify;
+export declare const decode: typeof parse;
+export {};