@serveryyswys/node.operit 0.1.2 → 0.1.3

package/dist/lib/v8-types.d.ts

@@ -0,0 +1,30 @@
+/** v8 的堆统计类型（与 Node 的字段名一致）。 */
+export interface HeapStatistics {
+    total_heap_size: number;
+    total_heap_size_executable: number;
+    total_physical_size: number;
+    total_available_size: number;
+    used_heap_size: number;
+    heap_size_limit: number;
+    malloced_memory: number;
+    peak_malloced_memory: number;
+    does_zap_garbage: boolean;
+    number_of_native_contexts: number;
+    number_of_detached_contexts: number;
+    total_global_handles_size: number;
+    used_global_handles_size: number;
+    external_memory: number;
+}
+export interface HeapSpaceStatistics {
+    space_name: string;
+    space_size: number;
+    space_used_size: number;
+    space_available_size: number;
+    physical_space_size: number;
+}
+export interface HeapCodeStatistics {
+    code_and_metadata_size: number;
+    bytecode_and_metadata_size: number;
+    external_script_source_size: number;
+    cpu_profiler_metadata_size: number;
+}

package/dist/lib/v8-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/module.js

@@ -17,21 +17,42 @@
  */
 const errors_1 = require("./lib/errors");
 const builtinModules = [
+    '_http_agent',
+    '_http_client',
+    '_http_common',
+    '_http_incoming',
+    '_http_outgoing',
+    '_http_server',
+    '_stream_duplex',
+    '_stream_passthrough',
+    '_stream_readable',
+    '_stream_transform',
+    '_stream_wrap',
+    '_stream_writable',
+    '_tls_common',
+    '_tls_wrap',
     'assert',
     'assert/strict',
     'async_hooks',
     'buffer',
     'child_process',
     'cluster',
+    'console',
     'constants',
     'crypto',
+    'dgram',
+    'diagnostics_channel',
     'dns',
+    'dns/promises',
+    'domain',
     'events',
     'fs',
     'fs/promises',
     'http',
+    'http2',
     'https',
     'inspector',
+    'inspector/promises',
     'module',
     'net',
     'os',
@@ -40,18 +61,27 @@ const builtinModules = [
     'path/win32',
     'perf_hooks',
     'process',
+    'punycode',
     'querystring',
     'readline',
     'repl',
     'stream',
+    'stream/consumers',
     'stream/promises',
+    'stream/web',
     'string_decoder',
+    'sys',
     'timers',
     'timers/promises',
+    'tls',
+    'trace_events',
     'tty',
     'url',
     'util',
+    'util/types',
+    'v8',
     'vm',
+    'wasi',
     'worker_threads',
     'zlib'
 ];

package/dist/punycode.d.ts

@@ -0,0 +1,22 @@
+/**
+ * punycode（已废弃，但仍被不少包直接 require）。
+ *
+ * 实现复用 lib/punycode.ts —— url 模块内部也在用它，所以这里不重复一份。
+ * 与 Node 的差异：`version` 报 '2.1.1'（Node 内置的是同一个算法实现的 2.x）。
+ */
+import punycodeCore = require('./lib/punycode');
+/** UTF-16 码元序列（Node 的 punycode.ucs2.decode 返回的是码元，不是码点）。 */
+declare function ucs2decode(value: string): number[];
+declare function ucs2encode(codePoints: readonly number[]): string;
+declare const punycode: {
+    version: string;
+    ucs2: {
+        decode: typeof ucs2decode;
+        encode: typeof ucs2encode;
+    };
+    decode: typeof punycodeCore.decode;
+    encode: typeof punycodeCore.encode;
+    toASCII: typeof punycodeCore.toASCII;
+    toUnicode: typeof punycodeCore.toUnicode;
+};
+export = punycode;

package/dist/punycode.js

@@ -0,0 +1,53 @@
+'use strict';
+/**
+ * punycode（已废弃，但仍被不少包直接 require）。
+ *
+ * 实现复用 lib/punycode.ts —— url 模块内部也在用它，所以这里不重复一份。
+ * 与 Node 的差异：`version` 报 '2.1.1'（Node 内置的是同一个算法实现的 2.x）。
+ */
+const punycodeCore = require("./lib/punycode");
+/** UTF-16 码元序列（Node 的 punycode.ucs2.decode 返回的是码元，不是码点）。 */
+function ucs2decode(value) {
+    const output = [];
+    let counter = 0;
+    while (counter < value.length) {
+        const first = value.charCodeAt(counter);
+        counter += 1;
+        if (first >= 0xd800 && first <= 0xdbff && counter < value.length) {
+            const second = value.charCodeAt(counter);
+            if ((second & 0xfc00) === 0xdc00) {
+                counter += 1;
+                output.push(((first & 0x3ff) << 10) + (second & 0x3ff) + 0x10000);
+                continue;
+            }
+        }
+        output.push(first);
+    }
+    return output;
+}
+function ucs2encode(codePoints) {
+    let output = '';
+    for (let index = 0; index < codePoints.length; index += 1) {
+        const value = codePoints[index];
+        if (value > 0xffff) {
+            const adjusted = value - 0x10000;
+            output += String.fromCharCode((adjusted >>> 10) + 0xd800, (adjusted % 0x400) + 0xdc00);
+        }
+        else {
+            output += String.fromCharCode(value);
+        }
+    }
+    return output;
+}
+const punycode = {
+    version: '2.1.1',
+    ucs2: {
+        decode: ucs2decode,
+        encode: ucs2encode
+    },
+    decode: punycodeCore.decode,
+    encode: punycodeCore.encode,
+    toASCII: punycodeCore.toASCII,
+    toUnicode: punycodeCore.toUnicode
+};
+module.exports = punycode;

package/dist/stream/consumers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * stream/consumers：把一个可读流整体读成各种表示。
+ *
+ * 与 Node 的差异（都写进 BUILTINS.json）：
+ *   - `blob` 显式抛 ONJ_UNSUPPORTED：运行时不提供 Blob（Node 的 blob() 返回一个 Blob 实例），
+ *     与其返回一个形状相似但不是 Blob 的对象，不如明确拒绝；
+ *   - 不做 Node 内部的 `stream.Readable` 品牌校验，只要求对象有 on()。
+ */
+import bufferModule = require('../buffer');
+import { ReadableLike } from '../lib/stream-consumers-types';
+type BufferInstance = InstanceType<typeof bufferModule.Buffer>;
+declare function buffer(stream: ReadableLike): Promise<BufferInstance>;
+declare function text(stream: ReadableLike): Promise<string>;
+declare function json(stream: ReadableLike): Promise<unknown>;
+declare function arrayBuffer(stream: ReadableLike): Promise<ArrayBuffer>;
+declare function blob(_stream: ReadableLike): Promise<never>;
+declare const consumers: {
+    buffer: typeof buffer;
+    text: typeof text;
+    json: typeof json;
+    arrayBuffer: typeof arrayBuffer;
+    blob: typeof blob;
+};
+export = consumers;

package/dist/stream/consumers.js

@@ -0,0 +1,75 @@
+'use strict';
+/**
+ * stream/consumers：把一个可读流整体读成各种表示。
+ *
+ * 与 Node 的差异（都写进 BUILTINS.json）：
+ *   - `blob` 显式抛 ONJ_UNSUPPORTED：运行时不提供 Blob（Node 的 blob() 返回一个 Blob 实例），
+ *     与其返回一个形状相似但不是 Blob 的对象，不如明确拒绝；
+ *   - 不做 Node 内部的 `stream.Readable` 品牌校验，只要求对象有 on()。
+ */
+const bufferModule = require("../buffer");
+function onjUnsupported(feature) {
+    const failure = new Error(feature + ' 需要运行时的 Blob 实现，Android 的 QuickJS 运行时不提供。');
+    failure.code = 'ONJ_UNSUPPORTED';
+    return failure;
+}
+function toBytes(chunk) {
+    if (typeof chunk === 'string') {
+        return bufferModule.Buffer.from(chunk);
+    }
+    if (chunk instanceof Uint8Array) {
+        return chunk;
+    }
+    throw new TypeError('流给出的数据块既不是字符串也不是 Uint8Array。');
+}
+function consume(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let finished = false;
+        stream.on('data', (chunk) => {
+            chunks.push(toBytes(chunk));
+        });
+        stream.on('end', () => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            resolve(bufferModule.Buffer.concat(chunks));
+        });
+        stream.on('error', (error) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            reject(error);
+        });
+    });
+}
+async function buffer(stream) {
+    return consume(stream);
+}
+async function text(stream) {
+    const bytes = await consume(stream);
+    return bytes.toString('utf8');
+}
+async function json(stream) {
+    const content = await text(stream);
+    return JSON.parse(content);
+}
+async function arrayBuffer(stream) {
+    const bytes = await consume(stream);
+    const copy = new Uint8Array(bytes.length);
+    copy.set(bytes);
+    return copy.buffer;
+}
+function blob(_stream) {
+    return Promise.reject(onjUnsupported('stream/consumers.blob()'));
+}
+const consumers = {
+    buffer: buffer,
+    text: text,
+    json: json,
+    arrayBuffer: arrayBuffer,
+    blob: blob
+};
+module.exports = consumers;

package/dist/sys.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 已废弃的 `sys` 模块。
+ *
+ * Node 里它就是 `util` 的**同一个对象**（`require('sys') === require('util')`），
+ * 历史上是 util 的前身。仍有老包 require 它，所以保持这个别名。
+ */
+import utilModule = require('./util');
+export = utilModule;

package/dist/sys.js

@@ -0,0 +1,9 @@
+'use strict';
+/**
+ * 已废弃的 `sys` 模块。
+ *
+ * Node 里它就是 `util` 的**同一个对象**（`require('sys') === require('util')`），
+ * 历史上是 util 的前身。仍有老包 require 它，所以保持这个别名。
+ */
+const utilModule = require("./util");
+module.exports = utilModule;

package/dist/util/types.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    isDate: (value: unknown) => boolean;
+    isRegExp: (value: unknown) => boolean;
+    isArray: (value: unknown) => boolean;
+    isTypedArray: (value: unknown) => boolean;
+    isUint8Array: (value: unknown) => boolean;
+    isArrayBuffer: (value: unknown) => boolean;
+    isPromise: (value: unknown) => boolean;
+    isNativeError: (value: unknown) => boolean;
+    isMap: (value: unknown) => boolean;
+    isSet: (value: unknown) => boolean;
+    isBigInt64Array: (value: unknown) => boolean;
+    isAsyncFunction: (value: unknown) => boolean;
+    isGeneratorFunction: (value: unknown) => boolean;
+};
+export = _default;

package/dist/util/types.js

@@ -0,0 +1,9 @@
+'use strict';
+/**
+ * `util/types` 子路径入口：与 `require('util').types` 是同一个对象。
+ *
+ * 它是很多包的高频依赖（比如 `is-* 系列、`has-symbols` 这类能力探测），
+ * 而且写法通常是 `require('util/types')` 而不是从 `util` 上取。
+ */
+const utilModule = require("../util");
+module.exports = utilModule.types;

package/dist/util.d.ts

@@ -1,15 +1,4 @@
-interface InspectOptions {
-    depth?: number | null;
-    colors?: boolean;
-    showHidden?: boolean;
-    compact?: boolean | number;
-    breakLength?: number;
-    sorted?: boolean;
-    maxArrayLength?: number;
-    maxStringLength?: number | null;
-    getters?: boolean;
-    showProxy?: boolean;
-}
+import { InspectOptions } from './lib/util-types';
 declare function inspect(value: unknown, options?: InspectOptions | boolean | number): string;
 declare function formatWithOptions(options: InspectOptions, template?: unknown, ...rest: unknown[]): string;
 declare function format(template?: unknown, ...rest: unknown[]): string;

package/dist/util.js

@@ -245,6 +245,12 @@ function jsonOf(value) {
     }
 }
 function formatWithOptions(options, template, ...rest) {
+    // Node 的 util.format() / util.formatWithOptions({}) 在**没有要格式化的值**时返回空串，
+    // 而不是字符串 'undefined'。两者必须区分开 —— 否则 console.log() 会多打印一个 "undefined"
+    // （console 与 Node 的逐字节对拍抓到了这一条）。
+    if (arguments.length <= 1) {
+        return '';
+    }
     const args = [template].concat(rest);
     const first = args[0];
     const inspectOptions = options === undefined || options === null ? {} : options;
@@ -323,6 +329,12 @@ function formatWithOptions(options, template, ...rest) {
     return out;
 }
 function format(template, ...rest) {
+    // 必须在**这一层**判断参数个数：下面那次调用永远会给 formatWithOptions 传两个实参
+    // （options 和显式的 template），所以那边无法区分"没传值"和"传了 undefined"。
+    // Node：util.format() === ''，util.format(undefined) === 'undefined'。
+    if (arguments.length === 0) {
+        return '';
+    }
     return formatWithOptions({}, template, ...rest);
 }
 function inherits(constructor, superConstructor) {

package/dist/v8.d.ts

@@ -0,0 +1,25 @@
+import { HeapStatistics, HeapSpaceStatistics, HeapCodeStatistics } from './lib/v8-types';
+declare function getHeapStatistics(): HeapStatistics;
+/** QuickJS 不暴露分空间统计，返回空数组（Node 在 V8 下会给出各 space）。 */
+declare function getHeapSpaceStatistics(): HeapSpaceStatistics[];
+declare function getHeapCodeStatistics(): HeapCodeStatistics;
+declare function serialize(): never;
+declare function deserialize(): never;
+declare function setFlagsFromString(): never;
+declare function cachedDataVersionTag(): never;
+declare function writeHeapSnapshot(): never;
+declare function takeCoverage(): never;
+declare function stopCoverage(): never;
+declare const v8Module: {
+    getHeapStatistics: typeof getHeapStatistics;
+    getHeapSpaceStatistics: typeof getHeapSpaceStatistics;
+    getHeapCodeStatistics: typeof getHeapCodeStatistics;
+    serialize: typeof serialize;
+    deserialize: typeof deserialize;
+    setFlagsFromString: typeof setFlagsFromString;
+    cachedDataVersionTag: typeof cachedDataVersionTag;
+    writeHeapSnapshot: typeof writeHeapSnapshot;
+    takeCoverage: typeof takeCoverage;
+    stopCoverage: typeof stopCoverage;
+};
+export = v8Module;

package/dist/v8.js

@@ -0,0 +1,127 @@
+'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;
+    };
+})();
+/**
+ * v8 —— **partial**。
+ *
+ * 只实现"能从 JVM 如实取到"的堆统计；V8 专有的东西（序列化格式、V8 标志、覆盖率、
+ * 堆快照）在 QuickJS + Android 上没有对应物，一律显式抛 ONJ_UNSUPPORTED，
+ * 不给形状相似但语义不同的假实现。
+ *
+ * 注意：这里的堆统计是 **JVM 堆**，不是 V8 堆（Node 里是 V8 堆）。
+ * 这一点与 os.totalmem / os.freemem 的近似同类，已在 BUILTINS.json 里记明。
+ */
+const bridge = __importStar(require("./lib/bridge"));
+function onjUnsupported(feature, reason) {
+    const failure = new Error(feature + '：' + reason);
+    failure.code = 'ONJ_UNSUPPORTED';
+    return failure;
+}
+function runtime() {
+    return bridge.callStatic('java.lang.Runtime', 'getRuntime', []);
+}
+function heapNumbers() {
+    const handle = runtime();
+    return {
+        total: Number(bridge.callInstance(handle, 'totalMemory', [])) || 0,
+        free: Number(bridge.callInstance(handle, 'freeMemory', [])) || 0,
+        max: Number(bridge.callInstance(handle, 'maxMemory', [])) || 0
+    };
+}
+function getHeapStatistics() {
+    const heap = heapNumbers();
+    const used = heap.total - heap.free;
+    return {
+        total_heap_size: heap.total,
+        total_heap_size_executable: 0,
+        total_physical_size: heap.total,
+        total_available_size: heap.max - used,
+        used_heap_size: used,
+        heap_size_limit: heap.max,
+        malloced_memory: 0,
+        peak_malloced_memory: 0,
+        does_zap_garbage: false,
+        number_of_native_contexts: 1,
+        number_of_detached_contexts: 0,
+        total_global_handles_size: 0,
+        used_global_handles_size: 0,
+        external_memory: 0
+    };
+}
+/** QuickJS 不暴露分空间统计，返回空数组（Node 在 V8 下会给出各 space）。 */
+function getHeapSpaceStatistics() {
+    return [];
+}
+function getHeapCodeStatistics() {
+    return {
+        code_and_metadata_size: 0,
+        bytecode_and_metadata_size: 0,
+        external_script_source_size: 0,
+        cpu_profiler_metadata_size: 0
+    };
+}
+function serialize() {
+    throw onjUnsupported('v8.serialize()', 'V8 的二进制序列化格式依赖 V8 本身，QuickJS 无法产出兼容字节流');
+}
+function deserialize() {
+    throw onjUnsupported('v8.deserialize()', '同上：无法解析 V8 的序列化格式');
+}
+function setFlagsFromString() {
+    throw onjUnsupported('v8.setFlagsFromString()', '这是 V8 专有的标志开关，运行时不是 V8');
+}
+function cachedDataVersionTag() {
+    throw onjUnsupported('v8.cachedDataVersionTag()', '该值标识 V8 版本，用于判断编译缓存是否可用；运行时不用 V8 缓存');
+}
+function writeHeapSnapshot() {
+    throw onjUnsupported('v8.writeHeapSnapshot()', '堆快照是 V8 专有格式');
+}
+function takeCoverage() {
+    throw onjUnsupported('v8.takeCoverage()', '覆盖率采集是 V8 专有能力');
+}
+function stopCoverage() {
+    throw onjUnsupported('v8.stopCoverage()', '覆盖率采集是 V8 专有能力');
+}
+const v8Module = {
+    getHeapStatistics: getHeapStatistics,
+    getHeapSpaceStatistics: getHeapSpaceStatistics,
+    getHeapCodeStatistics: getHeapCodeStatistics,
+    serialize: serialize,
+    deserialize: deserialize,
+    setFlagsFromString: setFlagsFromString,
+    cachedDataVersionTag: cachedDataVersionTag,
+    writeHeapSnapshot: writeHeapSnapshot,
+    takeCoverage: takeCoverage,
+    stopCoverage: stopCoverage
+};
+module.exports = v8Module;

package/package.json

@@ -1,17 +1,9 @@
 {
   "name": "@serveryyswys/node.operit",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "为 Operit 的 CommonJS 运行时补齐 Node 核心能力（fs / path / os / buffer / ...）",
-  "license": "GPL-3.0-or-later",
-  "keywords": [
-    "operit",
-    "quickjs",
-    "node-compat",
-    "commonjs",
-    "polyfill",
-    "android",
-    "shim"
-  ],
+  "license": "Apache-2.0",
+  "author": "serveryyswys",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -26,6 +18,16 @@
     "BUILTINS.json",
     "README.md",
     "DESIGN.md",
-    "LICENSE*"
+    "LICENSE*",
+    "NOTICE"
+  ],
+  "keywords": [
+    "operit",
+    "quickjs",
+    "node-compat",
+    "commonjs",
+    "polyfill",
+    "android",
+    "shim"
   ]
 }