@serveryyswys/node.operit 0.1.5 → 0.1.7

package/dist/index.js

@@ -51,7 +51,7 @@ const diagnosticsChannelModule = require("./diagnostics_channel");
 const streamConsumersModule = require("./stream/consumers");
 const v8Module = require("./v8");
 const api = {
-    version: '0.1.5',
+    version: '0.1.7',
     path: pathModule,
     'path/posix': pathPosixModule,
     'path/win32': pathWin32Module,

package/dist/lib/legacy-callable.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 让 class 写法的构造器**兼容老式"直接调用父类"用法**。
+ *
+ * 背景（真实故障）：
+ *   很多老包写
+ *       function PNG(options) { Stream.call(this, options); }
+ *       util.inherits(PNG, Stream);
+ *   这在 Node 上完全合法 —— Node 的 Stream / EventEmitter / Readable 都是**普通函数**，
+ *   不用 new 也能调用。而本库这些类是用 class 写的，class 必须 new 才会执行构造体，
+ *   在 QuickJS 上抛的正是 "class constructors must be invoked with 'new'"。
+ *
+ * 做法：
+ *   - 有 this（即 X.call(this)）：把"构造器对实例做的初始化"作用到调用者的 this 上，
+ *     然后返回这个 this。**不碰原型链** —— 调用方自己的 util.inherits 已经接好了，
+ *     我们改反而会破坏它。
+ *   - 没有 this（严格模式下裸调）：按 Node 的宽松语义，等价于 new 一个。
+ *
+ * 之所以能这样"重放初始化"：本库这些类的状态都是按对象惰性创建的
+ * （stateOf(this)），初始化就是一次纯函数式调用，不依赖 class 的 this 绑定。
+ *
+ * **适用范围**：只给"初始化就等于整个构造函数体"的类用。
+ * 目前用了两处 —— events.EventEmitter（构造体就是 stateOf(this)）与
+ * stream.Stream（自己没有构造函数，直接继承 EventEmitter）。
+ *
+ * 构造函数还做别的事的类**不能**套这个包装：Readable/Writable 要在构造时搬运
+ * options.read / options.destroy 等，走包装会漏掉那一步。那些类目前仍然
+ * 只能 new —— 这是已知缺口，不是遗漏。
+ */
+export declare function makeLegacyCallable<T extends object>(Class: new (...args: never[]) => T, name: string, initialize: (self: object, args: unknown[]) => void): new (...args: never[]) => T;

package/dist/lib/legacy-callable.js

@@ -0,0 +1,61 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLegacyCallable = makeLegacyCallable;
+/**
+ * 让 class 写法的构造器**兼容老式"直接调用父类"用法**。
+ *
+ * 背景（真实故障）：
+ *   很多老包写
+ *       function PNG(options) { Stream.call(this, options); }
+ *       util.inherits(PNG, Stream);
+ *   这在 Node 上完全合法 —— Node 的 Stream / EventEmitter / Readable 都是**普通函数**，
+ *   不用 new 也能调用。而本库这些类是用 class 写的，class 必须 new 才会执行构造体，
+ *   在 QuickJS 上抛的正是 "class constructors must be invoked with 'new'"。
+ *
+ * 做法：
+ *   - 有 this（即 X.call(this)）：把"构造器对实例做的初始化"作用到调用者的 this 上，
+ *     然后返回这个 this。**不碰原型链** —— 调用方自己的 util.inherits 已经接好了，
+ *     我们改反而会破坏它。
+ *   - 没有 this（严格模式下裸调）：按 Node 的宽松语义，等价于 new 一个。
+ *
+ * 之所以能这样"重放初始化"：本库这些类的状态都是按对象惰性创建的
+ * （stateOf(this)），初始化就是一次纯函数式调用，不依赖 class 的 this 绑定。
+ *
+ * **适用范围**：只给"初始化就等于整个构造函数体"的类用。
+ * 目前用了两处 —— events.EventEmitter（构造体就是 stateOf(this)）与
+ * stream.Stream（自己没有构造函数，直接继承 EventEmitter）。
+ *
+ * 构造函数还做别的事的类**不能**套这个包装：Readable/Writable 要在构造时搬运
+ * options.read / options.destroy 等，走包装会漏掉那一步。那些类目前仍然
+ * 只能 new —— 这是已知缺口，不是遗漏。
+ */
+function makeLegacyCallable(Class, name, initialize) {
+    const legacy = function legacyConstructor(...args) {
+        if (this === undefined || this === null) {
+            // 严格模式下的裸调：按 Node 的宽松语义等价于 new 一个
+            return Reflect.construct(Class, args, Class);
+        }
+        // X.call(this)：把初始化重放到调用者给的 this 上。
+        //
+        // 这里**刻意**不区分 new 与 .call —— 本包装只用于"初始化就等于构造函数体"
+        // 的类（EventEmitter 是 stateOf(this)，Stream 直接继承 EventEmitter）。
+        // 对构造函数还做别的事的类（Readable/Writable 要搬运 options），
+        // 这样写会漏掉那部分，所以那些类不套这个包装 —— 见文件末尾的说明。
+        initialize(this, args);
+        return this;
+    };
+    // 原型指向 class：instanceof 与 util.inherits(X, 这个) 都能成立
+    legacy.prototype = Class.prototype;
+    Object.defineProperty(legacy, 'name', { value: name, configurable: true });
+    // 静态成员搬过去（defaultMaxListeners / once / on 之类）
+    for (const key of Object.getOwnPropertyNames(Class)) {
+        if (key === 'length' || key === 'name' || key === 'prototype') {
+            continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(Class, key);
+        if (descriptor !== undefined) {
+            Object.defineProperty(legacy, key, descriptor);
+        }
+    }
+    return legacy;
+}

package/dist/stream.d.ts

@@ -81,4 +81,14 @@ declare class Stream extends EventEmitter {
     static isReadable: typeof isReadableStream;
     static isWritable: typeof isWritableStream;
 }
-export = Stream;
+/**
+ * 运行期导出**可调用包装**。
+ *
+ * 老包（pngjs 等）写 `function PNG() { Stream.call(this); } util.inherits(PNG, Stream);` ——
+ * Node 的 Stream 是普通函数所以合法，class 不行（QuickJS 会抛
+ * "class constructors must be invoked with 'new'"）。Stream 自己没有构造函数，
+ * 初始化就是 EventEmitter 那一份，所以直接转调。
+ * 类型仍标注为 class，静态成员（Readable/Writable/…）由包装层原样拷贝。
+ */
+declare const StreamExport: typeof Stream;
+export = StreamExport;

package/dist/stream.js

@@ -1,4 +1,5 @@
 'use strict';
+const legacy_callable_1 = require("./lib/legacy-callable");
 /**
  * Node stream 模块的移植：Readable / Writable / Duplex / Transform / PassThrough，
  * 以及 pipeline / finished（回调与 Promise 两种）。
@@ -82,19 +83,68 @@ function decodeChunk(chunk, encoding) {
     return encoding === null ? '' : buffer_1.Buffer.from(chunk).toString(encoding);
 }
 // ------------------------------------------------------------------ Readable
+/**
+ * 各流类的"初始化" —— 与构造函数体**逐字等价**。
+ *
+ * 抽出来的唯一原因：老包写 `Readable.call(this, opts)` 这种继承方式
+ * （Node 的 Readable 是普通函数，class 不是）。把构造体独立成函数后，
+ * 老式调用路径可以把它重放到调用者给的 this 上，效果与 new 完全一致。
+ * 见 lib/legacy-callable.ts。
+ */
+function initReadable(self, options) {
+    EventEmitter.call(self);
+    // 类字段声明（readable = true）也是构造的一部分 —— 抽初始化时最容易漏掉的就是它
+    self.readable = true;
+    readableStateOf(self, options);
+    if (options !== undefined) {
+        if (typeof options.read === 'function') {
+            self._read = options.read;
+        }
+        if (typeof options.destroy === 'function') {
+            self._destroy = options.destroy;
+        }
+    }
+}
+function initWritable(self, options) {
+    EventEmitter.call(self);
+    // 同上：Writable / Duplex 里都有 writable = true 的类字段声明
+    self.writable = true;
+    writableStateOf(self, options);
+    if (options !== undefined) {
+        if (typeof options.write === 'function') {
+            self._write = options.write;
+        }
+        if (typeof options.final === 'function') {
+            self._final = options.final;
+        }
+        if (typeof options.destroy === 'function') {
+            self._destroy = options.destroy;
+        }
+    }
+}
+function initDuplex(self, options) {
+    initReadable(self, options);
+    initWritable(self, options);
+}
+function initTransform(self, options) {
+    initDuplex(self, options);
+    if (options !== undefined) {
+        if (typeof options.transform === 'function') {
+            self._transform = options.transform;
+        }
+        if (typeof options.flush === 'function') {
+            self._flush = options.flush;
+        }
+    }
+}
+function initPassThrough(self, options) {
+    initTransform(self, options);
+}
 class Readable extends EventEmitter {
     constructor(options) {
         super();
         this.readable = true;
-        readableStateOf(this, options);
-        if (options !== undefined) {
-            if (typeof options.read === 'function') {
-                this._read = options.read;
-            }
-            if (typeof options.destroy === 'function') {
-                this._destroy = options.destroy;
-            }
-        }
+        initReadable(this, options);
     }
     // 子类覆写
     _read(size) {
@@ -601,18 +651,7 @@ class Writable extends EventEmitter {
     constructor(options) {
         super();
         this.writable = true;
-        writableStateOf(this, options);
-        if (options !== undefined) {
-            if (typeof options.write === 'function') {
-                this._write = options.write;
-            }
-            if (typeof options.final === 'function') {
-                this._final = options.final;
-            }
-            if (typeof options.destroy === 'function') {
-                this._destroy = options.destroy;
-            }
-        }
+        initWritable(this, options);
     }
 }
 function applyWritable(target) {
@@ -627,15 +666,7 @@ class Duplex extends Readable {
     constructor(options) {
         super(options);
         this.writable = true;
-        writableStateOf(this, options);
-        if (options !== undefined) {
-            if (typeof options.write === 'function') {
-                this._write = options.write;
-            }
-            if (typeof options.final === 'function') {
-                this._final = options.final;
-            }
-        }
+        initWritable(this, options);
     }
 }
 applyWritable(Duplex.prototype);
@@ -643,14 +674,7 @@ applyWritable(Duplex.prototype);
 class Transform extends Duplex {
     constructor(options) {
         super(options);
-        if (options !== undefined) {
-            if (typeof options.transform === 'function') {
-                this._transform = options.transform;
-            }
-            if (typeof options.flush === 'function') {
-                this._flush = options.flush;
-            }
-        }
+        initTransform(this, options);
     }
     _transform(chunk, encoding, callback) {
         void chunk;
@@ -872,4 +896,27 @@ Stream.finished = finished;
 Stream.promises = { pipeline: pipelinePromise, finished: finishedPromise };
 Stream.isReadable = isReadableStream;
 Stream.isWritable = isWritableStream;
-module.exports = Stream;
+/**
+ * 运行期导出**可调用包装**。
+ *
+ * 老包（pngjs 等）写 `function PNG() { Stream.call(this); } util.inherits(PNG, Stream);` ——
+ * Node 的 Stream 是普通函数所以合法，class 不行（QuickJS 会抛
+ * "class constructors must be invoked with 'new'"）。Stream 自己没有构造函数，
+ * 初始化就是 EventEmitter 那一份，所以直接转调。
+ * 类型仍标注为 class，静态成员（Readable/Writable/…）由包装层原样拷贝。
+ */
+const StreamExport = (0, legacy_callable_1.makeLegacyCallable)(Stream, 'Stream', (self) => { EventEmitter.call(self); });
+const ReadableExport = (0, legacy_callable_1.makeLegacyCallable)(Readable, 'Readable', (self, args) => { initReadable(self, args[0]); });
+const WritableExport = (0, legacy_callable_1.makeLegacyCallable)(Writable, 'Writable', (self, args) => { initWritable(self, args[0]); });
+const DuplexExport = (0, legacy_callable_1.makeLegacyCallable)(Duplex, 'Duplex', (self, args) => { initDuplex(self, args[0]); });
+const TransformExport = (0, legacy_callable_1.makeLegacyCallable)(Transform, 'Transform', (self, args) => { initTransform(self, args[0]); });
+const PassThroughExport = (0, legacy_callable_1.makeLegacyCallable)(PassThrough, 'PassThrough', (self, args) => { initPassThrough(self, args[0]); });
+// 静态槽统一指向包装：包装层会从 class 拷贝静态成员，那些槽会指回 class，
+// 于是"模块上是包装、类上是 class"两套并存 —— 这里全部改成包装，保持一致。
+StreamExport.Readable = ReadableExport;
+StreamExport.Writable = WritableExport;
+StreamExport.Duplex = DuplexExport;
+StreamExport.Transform = TransformExport;
+StreamExport.PassThrough = PassThroughExport;
+StreamExport.Stream = StreamExport;
+module.exports = StreamExport;

package/dist/string_decoder.d.ts

@@ -1,5 +1,5 @@
-export declare class StringDecoder {
-    static StringDecoder: typeof StringDecoder;
+declare class StringDecoderImpl {
+    static StringDecoder: typeof StringDecoderImpl;
     readonly encoding: string;
     private pending;
     constructor(encoding?: string);
@@ -13,3 +13,5 @@ export declare class StringDecoder {
     private writeUtf16;
     private writeBase64;
 }
+declare const StringDecoderExport: typeof StringDecoderImpl;
+export { StringDecoderExport as StringDecoder };

package/dist/string_decoder.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StringDecoder = void 0;
+const legacy_callable_1 = require("./lib/legacy-callable");
 /**
  * Node string_decoder 模块的移植。
  *
@@ -93,10 +94,17 @@ function completePrefixLength(bytes) {
     }
     return bytes.length;
 }
-class StringDecoder {
+/**
+ * 各字段的初始化 —— 与构造函数体逐字等价，供老式 `StringDecoder.call(this)` 重放。
+ * 见 lib/legacy-callable.ts。
+ */
+function initStringDecoder(self, encoding) {
+    self.encoding = normalizeEncoding(encoding);
+    self.pending = new Uint8Array(0);
+}
+class StringDecoderImpl {
     constructor(encoding) {
-        this.encoding = normalizeEncoding(encoding);
-        this.pending = new Uint8Array(0);
+        initStringDecoder(this, encoding);
     }
     get lastNeed() {
         if (this.pending.length === 0) {
@@ -211,8 +219,9 @@ class StringDecoder {
         return bytesCodec.encodeBase64(merged.subarray(0, usable));
     }
 }
-exports.StringDecoder = StringDecoder;
-StringDecoder.StringDecoder = StringDecoder;
+// 自引用静态（Node 的 string_decoder.StringDecoder 指向自己）；
+// 包装层会把它拷过去，随后改指包装本身。
+StringDecoderImpl.StringDecoder = StringDecoderImpl;
 function hexOf(buffer) {
     const digits = '0123456789abcdef';
     let out = '';
@@ -235,3 +244,7 @@ function asciiOf(buffer) {
     }
     return out;
 }
+const StringDecoderExport = (0, legacy_callable_1.makeLegacyCallable)(StringDecoderImpl, 'StringDecoder', (self, args) => { initStringDecoder(self, args[0]); });
+exports.StringDecoder = StringDecoderExport;
+// 同 events：包装层拷贝静态成员会把自引用指回 class，改指包装
+StringDecoderExport.StringDecoder = StringDecoderExport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serveryyswys/node.operit",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "为 Operit 的 CommonJS 运行时补齐 Node 核心能力（fs / path / os / buffer / ...）",
   "license": "Apache-2.0",
   "author": "serveryyswys",