@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/querystring.js

@@ -0,0 +1,209 @@
+'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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+exports.escape = escape;
+exports.unescape = unescape;
+exports.stringify = stringify;
+exports.parse = parse;
+/**
+ * Node querystring 模块的移植。
+ *
+ * 与 URI 编码有关的两处 Node 特性必须照搬，否则三方库看到的串会不一样：
+ *   - escape() 在 encodeURIComponent 之上额外转义 ! ' ( ) *
+ *   - unescape()/parse() 是**宽松**解码：非法 % 序列原样保留，不抛 URIError
+ * 另外 parse() 会把 '+' 当空格，而 unescape() 不会 —— 这是 Node 的既有不对称。
+ */
+const bytesCodec = __importStar(require("./lib/bytes"));
+const CHAR_PERCENT = 37;
+const CHAR_PLUS = 43;
+const CHAR_SPACE = 32;
+/** 与 Node 一致：querystring.escape 就是 encodeURIComponent（不额外转义 ! ' ( ) *）。 */
+function escape(value) {
+    return encodeURIComponent(String(value));
+}
+function unescape(value) {
+    return decodeComponent(String(value), false);
+}
+function charCodeHex(code) {
+    const digits = '0123456789ABCDEF';
+    return digits.charAt((code >> 4) & 15) + digits.charAt(code & 15);
+}
+function hexValue(code) {
+    if (code >= 48 && code <= 57) {
+        return code - 48;
+    }
+    if (code >= 97 && code <= 102) {
+        return code - 87;
+    }
+    if (code >= 65 && code <= 70) {
+        return code - 55;
+    }
+    return -1;
+}
+/** 宽松百分号解码：连续的 %XX 汇总成字节后按 UTF-8 解释，非法序列原样保留。 */
+function decodeComponent(text, decodeSpaces) {
+    let result = '';
+    let i = 0;
+    const length = text.length;
+    while (i < length) {
+        const code = text.charCodeAt(i);
+        if (code === CHAR_PERCENT && i + 3 <= length) {
+            const bytes = [];
+            while (i + 3 <= length && text.charCodeAt(i) === CHAR_PERCENT) {
+                const high = hexValue(text.charCodeAt(i + 1));
+                const low = hexValue(text.charCodeAt(i + 2));
+                if (high < 0 || low < 0) {
+                    break;
+                }
+                bytes.push((high << 4) | low);
+                i += 3;
+            }
+            if (bytes.length === 0) {
+                result += '%';
+                i += 1;
+                continue;
+            }
+            result += bytesCodec.utf8Decode(new Uint8Array(bytes));
+            continue;
+        }
+        if (code === CHAR_PLUS && decodeSpaces) {
+            result += ' ';
+            i += 1;
+            continue;
+        }
+        result += text.charAt(i);
+        i += 1;
+    }
+    return result;
+}
+function stringifyPrimitive(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' && isFinite(value)) {
+        return String(value);
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    return '';
+}
+function stringify(value, separator, equals, options) {
+    const sep = separator === undefined || separator === '' ? '&' : separator;
+    const eq = equals === undefined || equals === '' ? '=' : equals;
+    const encode = options !== undefined && typeof options.encodeURIComponent === 'function'
+        ? options.encodeURIComponent
+        : escape;
+    if (value === null || typeof value !== 'object') {
+        return '';
+    }
+    const source = value;
+    const keys = Object.keys(source);
+    let fields = '';
+    for (let i = 0; i < keys.length; i += 1) {
+        const key = keys[i];
+        const raw = source[key];
+        const prefix = encode(stringifyPrimitive(key)) + eq;
+        if (Array.isArray(raw)) {
+            for (let j = 0; j < raw.length; j += 1) {
+                if (fields.length > 0) {
+                    fields += sep;
+                }
+                fields += prefix + encode(stringifyPrimitive(raw[j]));
+            }
+        }
+        else {
+            if (fields.length > 0) {
+                fields += sep;
+            }
+            fields += prefix + encode(stringifyPrimitive(raw));
+        }
+    }
+    return fields;
+}
+function parse(text, separator, equals, options) {
+    const result = Object.create(null);
+    if (typeof text !== 'string' || text.length === 0) {
+        return result;
+    }
+    const sep = separator === undefined || separator === '' ? '&' : separator;
+    const eq = equals === undefined || equals === '' ? '=' : equals;
+    const decode = options !== undefined && typeof options.decodeURIComponent === 'function'
+        ? options.decodeURIComponent
+        : function (value) {
+            return decodeComponent(value, true);
+        };
+    const maxKeys = options !== undefined && typeof options.maxKeys === 'number' && options.maxKeys >= 0
+        ? options.maxKeys
+        : 1000;
+    const pairs = text.split(sep);
+    let count = 0;
+    for (let i = 0; i < pairs.length; i += 1) {
+        if (maxKeys > 0 && count >= maxKeys) {
+            break;
+        }
+        // 空分段也占用 maxKeys 预算（Node: parse('&a=1', '&', '=', {maxKeys:1}) === {}）
+        count += 1;
+        const pair = pairs[i];
+        if (pair.length === 0) {
+            continue;
+        }
+        const index = pair.indexOf(eq);
+        let key;
+        let value;
+        if (index >= 0) {
+            key = decode(pair.slice(0, index));
+            value = decode(pair.slice(index + eq.length));
+        }
+        else {
+            key = decode(pair);
+            value = '';
+        }
+        const existing = result[key];
+        if (existing === undefined) {
+            result[key] = value;
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            result[key] = [existing, value];
+        }
+    }
+    return result;
+}
+exports.encode = stringify;
+exports.decode = parse;

package/dist/stream/promises.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    pipeline: (...streams: unknown[]) => Promise<void>;
+    finished: (stream: unknown) => Promise<void>;
+};
+export = _default;

package/dist/stream/promises.js

@@ -0,0 +1,10 @@
+'use strict';
+/**
+ * `stream/promises` 子路径入口。
+ *
+ * pipeline / finished 的 Promise 版实现放在 stream.ts 里（避免与它循环依赖），
+ * 这里只是把 `stream.promises` 暴露成子路径 —— 与 Node 的
+ * `require('stream').promises` / `require('stream/promises')` 两条路径一致。
+ */
+const streamModule = require("../stream");
+module.exports = streamModule.promises;

package/dist/stream.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Node stream 模块的移植：Readable / Writable / Duplex / Transform / PassThrough，
+ * 以及 pipeline / finished（回调与 Promise 两种）。
+ *
+ * 实现取舍：
+ *   - 调度用 queueMicrotask（QuickJS 不一定有 process.nextTick），语义上贴近 Node 的 nextTick；
+ *     因此事件时序与 Node 是"同类但不必逐拍相同"，测试验证的是**语义**（数据、顺序、事件、
+ *     背压返回值、错误传播），不是逐拍时序。
+ *   - 不实现 objectMode 的完整语义差异（只影响 highWaterMark 的计数单位），
+ *     也不实现 cork 的深度合并优化。
+ *   - 未实现：stream.Duplex 的 allowHalfOpen 完整语义、compose、addAbortSignal。
+ */
+import EventEmitter = require('./events');
+import type { StreamOptions, WritableLike } from './lib/stream-types';
+declare class Readable extends EventEmitter {
+    readable: boolean;
+    constructor(options?: StreamOptions);
+    _read(size: number): void;
+    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+    push(chunk: unknown, encoding?: string): boolean;
+    unshift(chunk: unknown): void;
+    read(size?: number): unknown;
+    setEncoding(encoding: string): this;
+    pause(): this;
+    resume(): this;
+    isPaused(): boolean;
+    pipe<T extends WritableLike>(destination: T, options?: {
+        end?: boolean;
+    }): T;
+    unpipe(destination?: WritableLike): this;
+    destroy(error?: Error | null): this;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    [Symbol.asyncIterator](): {
+        next(): Promise<{
+            value: unknown;
+            done: boolean;
+        }>;
+    };
+    static from(iterable: unknown): Readable;
+}
+declare class Writable extends EventEmitter {
+    writable: boolean;
+    constructor(options?: StreamOptions);
+}
+declare class Duplex extends Readable {
+    writable: boolean;
+    constructor(options?: StreamOptions);
+}
+declare class Transform extends Duplex {
+    constructor(options?: StreamOptions);
+    _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+    /** Transform 的可读侧由 _write 推入，不去主动拉数据，因此这里是空的。 */
+    _read(size: number): void;
+    _flush(callback: (error?: Error | null) => void): void;
+    _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+}
+declare class PassThrough extends Transform {
+    _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+}
+declare function finished(stream: WritableLike | Readable, callback: (error?: Error | null) => void): () => void;
+declare function isReadableStream(value: unknown): boolean;
+declare function isWritableStream(value: unknown): boolean;
+declare function pipeline(...args: unknown[]): unknown;
+/** stream/promises 用的 Promise 版：不走 pipeline 的回调校验。 */
+declare function pipelinePromise(...streams: unknown[]): Promise<void>;
+declare function finishedPromise(stream: unknown): Promise<void>;
+declare class Stream extends EventEmitter {
+    static Readable: typeof Readable;
+    static Writable: typeof Writable;
+    static Duplex: typeof Duplex;
+    static Transform: typeof Transform;
+    static PassThrough: typeof PassThrough;
+    static Stream: typeof Stream;
+    static pipeline: typeof pipeline;
+    static finished: typeof finished;
+    static promises: {
+        pipeline: typeof pipelinePromise;
+        finished: typeof finishedPromise;
+    };
+    static isReadable: typeof isReadableStream;
+    static isWritable: typeof isWritableStream;
+}
+export = Stream;