ru.Bee 1.3.2 → 1.4.0

data/lib/node_modules/turbo-stream/dist/flatten.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = void 0;
+const utils_js_1 = require("./utils.js");
+function flatten(input) {
+    const { indices } = this;
+    const existing = indices.get(input);
+    if (existing)
+        return [existing];
+    if (input === undefined)
+        return utils_js_1.UNDEFINED;
+    if (input === null)
+        return utils_js_1.NULL;
+    if (Number.isNaN(input))
+        return utils_js_1.NAN;
+    if (input === Number.POSITIVE_INFINITY)
+        return utils_js_1.POSITIVE_INFINITY;
+    if (input === Number.NEGATIVE_INFINITY)
+        return utils_js_1.NEGATIVE_INFINITY;
+    if (input === 0 && 1 / input < 0)
+        return utils_js_1.NEGATIVE_ZERO;
+    const index = this.index++;
+    indices.set(input, index);
+    stringify.call(this, input, index);
+    return index;
+}
+exports.flatten = flatten;
+function stringify(input, index) {
+    const { deferred, plugins, postPlugins } = this;
+    const str = this.stringified;
+    const stack = [[input, index]];
+    while (stack.length > 0) {
+        const [input, index] = stack.pop();
+        const partsForObj = (obj) => Object.keys(obj)
+            .map((k) => `"_${flatten.call(this, k)}":${flatten.call(this, obj[k])}`)
+            .join(",");
+        let error = null;
+        switch (typeof input) {
+            case "boolean":
+            case "number":
+            case "string":
+                str[index] = JSON.stringify(input);
+                break;
+            case "bigint":
+                str[index] = `["${utils_js_1.TYPE_BIGINT}","${input}"]`;
+                break;
+            case "symbol": {
+                const keyFor = Symbol.keyFor(input);
+                if (!keyFor) {
+                    error = new Error("Cannot encode symbol unless created with Symbol.for()");
+                }
+                else {
+                    str[index] = `["${utils_js_1.TYPE_SYMBOL}",${JSON.stringify(keyFor)}]`;
+                }
+                break;
+            }
+            case "object": {
+                if (!input) {
+                    str[index] = `${utils_js_1.NULL}`;
+                    break;
+                }
+                const isArray = Array.isArray(input);
+                let pluginHandled = false;
+                if (!isArray && plugins) {
+                    for (const plugin of plugins) {
+                        const pluginResult = plugin(input);
+                        if (Array.isArray(pluginResult)) {
+                            pluginHandled = true;
+                            const [pluginIdentifier, ...rest] = pluginResult;
+                            str[index] = `[${JSON.stringify(pluginIdentifier)}`;
+                            if (rest.length > 0) {
+                                str[index] += `,${rest
+                                    .map((v) => flatten.call(this, v))
+                                    .join(",")}`;
+                            }
+                            str[index] += "]";
+                            break;
+                        }
+                    }
+                }
+                if (!pluginHandled) {
+                    let result = isArray ? "[" : "{";
+                    if (isArray) {
+                        for (let i = 0; i < input.length; i++)
+                            result +=
+                                (i ? "," : "") +
+                                    (i in input ? flatten.call(this, input[i]) : utils_js_1.HOLE);
+                        str[index] = `${result}]`;
+                    }
+                    else if (input instanceof Date) {
+                        str[index] = `["${utils_js_1.TYPE_DATE}",${input.getTime()}]`;
+                    }
+                    else if (input instanceof URL) {
+                        str[index] = `["${utils_js_1.TYPE_URL}",${JSON.stringify(input.href)}]`;
+                    }
+                    else if (input instanceof RegExp) {
+                        str[index] = `["${utils_js_1.TYPE_REGEXP}",${JSON.stringify(input.source)},${JSON.stringify(input.flags)}]`;
+                    }
+                    else if (input instanceof Set) {
+                        if (input.size > 0) {
+                            str[index] = `["${utils_js_1.TYPE_SET}",${[...input]
+                                .map((val) => flatten.call(this, val))
+                                .join(",")}]`;
+                        }
+                        else {
+                            str[index] = `["${utils_js_1.TYPE_SET}"]`;
+                        }
+                    }
+                    else if (input instanceof Map) {
+                        if (input.size > 0) {
+                            str[index] = `["${utils_js_1.TYPE_MAP}",${[...input]
+                                .flatMap(([k, v]) => [
+                                flatten.call(this, k),
+                                flatten.call(this, v),
+                            ])
+                                .join(",")}]`;
+                        }
+                        else {
+                            str[index] = `["${utils_js_1.TYPE_MAP}"]`;
+                        }
+                    }
+                    else if (input instanceof Promise) {
+                        str[index] = `["${utils_js_1.TYPE_PROMISE}",${index}]`;
+                        deferred[index] = input;
+                    }
+                    else if (input instanceof Error) {
+                        str[index] = `["${utils_js_1.TYPE_ERROR}",${JSON.stringify(input.message)}`;
+                        if (input.name !== "Error") {
+                            str[index] += `,${JSON.stringify(input.name)}`;
+                        }
+                        str[index] += "]";
+                    }
+                    else if (Object.getPrototypeOf(input) === null) {
+                        str[index] = `["${utils_js_1.TYPE_NULL_OBJECT}",{${partsForObj(input)}}]`;
+                    }
+                    else if (isPlainObject(input)) {
+                        str[index] = `{${partsForObj(input)}}`;
+                    }
+                    else {
+                        error = new Error("Cannot encode object with prototype");
+                    }
+                }
+                break;
+            }
+            default: {
+                const isArray = Array.isArray(input);
+                let pluginHandled = false;
+                if (!isArray && plugins) {
+                    for (const plugin of plugins) {
+                        const pluginResult = plugin(input);
+                        if (Array.isArray(pluginResult)) {
+                            pluginHandled = true;
+                            const [pluginIdentifier, ...rest] = pluginResult;
+                            str[index] = `[${JSON.stringify(pluginIdentifier)}`;
+                            if (rest.length > 0) {
+                                str[index] += `,${rest
+                                    .map((v) => flatten.call(this, v))
+                                    .join(",")}`;
+                            }
+                            str[index] += "]";
+                            break;
+                        }
+                    }
+                }
+                if (!pluginHandled) {
+                    error = new Error("Cannot encode function or unexpected type");
+                }
+            }
+        }
+        if (error) {
+            let pluginHandled = false;
+            if (postPlugins) {
+                for (const plugin of postPlugins) {
+                    const pluginResult = plugin(input);
+                    if (Array.isArray(pluginResult)) {
+                        pluginHandled = true;
+                        const [pluginIdentifier, ...rest] = pluginResult;
+                        str[index] = `[${JSON.stringify(pluginIdentifier)}`;
+                        if (rest.length > 0) {
+                            str[index] += `,${rest
+                                .map((v) => flatten.call(this, v))
+                                .join(",")}`;
+                        }
+                        str[index] += "]";
+                        break;
+                    }
+                }
+            }
+            if (!pluginHandled) {
+                throw error;
+            }
+        }
+    }
+}
+const objectProtoNames = Object.getOwnPropertyNames(Object.prototype)
+    .sort()
+    .join("\0");
+function isPlainObject(thing) {
+    const proto = Object.getPrototypeOf(thing);
+    return (proto === Object.prototype ||
+        proto === null ||
+        Object.getOwnPropertyNames(proto).sort().join("\0") === objectProtoNames);
+}

data/lib/node_modules/turbo-stream/dist/turbo-stream.d.ts

@@ -0,0 +1,13 @@
+import { type DecodePlugin, type EncodePlugin } from "./utils.js";
+export type { DecodePlugin, EncodePlugin };
+export declare function decode(readable: ReadableStream<Uint8Array>, options?: {
+    plugins?: DecodePlugin[];
+}): Promise<{
+    done: Promise<undefined>;
+    value: unknown;
+}>;
+export declare function encode(input: unknown, options?: {
+    plugins?: EncodePlugin[];
+    postPlugins?: EncodePlugin[];
+    signal?: AbortSignal;
+}): ReadableStream<Uint8Array>;

data/lib/node_modules/turbo-stream/dist/turbo-stream.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = exports.decode = void 0;
+const flatten_js_1 = require("./flatten.js");
+const unflatten_js_1 = require("./unflatten.js");
+const utils_js_1 = require("./utils.js");
+async function decode(readable, options) {
+    const { plugins } = options ?? {};
+    const done = new utils_js_1.Deferred();
+    const reader = readable
+        .pipeThrough((0, utils_js_1.createLineSplittingTransform)())
+        .getReader();
+    const decoder = {
+        values: [],
+        hydrated: [],
+        deferred: {},
+        plugins,
+    };
+    const decoded = await decodeInitial.call(decoder, reader);
+    let donePromise = done.promise;
+    if (decoded.done) {
+        done.resolve();
+    }
+    else {
+        donePromise = decodeDeferred
+            .call(decoder, reader)
+            .then(done.resolve)
+            .catch((reason) => {
+            for (const deferred of Object.values(decoder.deferred)) {
+                deferred.reject(reason);
+            }
+            done.reject(reason);
+        });
+    }
+    return {
+        done: donePromise.then(() => reader.closed),
+        value: decoded.value,
+    };
+}
+exports.decode = decode;
+async function decodeInitial(reader) {
+    const read = await reader.read();
+    if (!read.value) {
+        throw new SyntaxError();
+    }
+    let line;
+    try {
+        line = JSON.parse(read.value);
+    }
+    catch (reason) {
+        throw new SyntaxError();
+    }
+    return {
+        done: read.done,
+        value: unflatten_js_1.unflatten.call(this, line),
+    };
+}
+async function decodeDeferred(reader) {
+    let read = await reader.read();
+    while (!read.done) {
+        if (!read.value)
+            continue;
+        const line = read.value;
+        switch (line[0]) {
+            case utils_js_1.TYPE_PROMISE: {
+                const colonIndex = line.indexOf(":");
+                const deferredId = Number(line.slice(1, colonIndex));
+                const deferred = this.deferred[deferredId];
+                if (!deferred) {
+                    throw new Error(`Deferred ID ${deferredId} not found in stream`);
+                }
+                const lineData = line.slice(colonIndex + 1);
+                let jsonLine;
+                try {
+                    jsonLine = JSON.parse(lineData);
+                }
+                catch (reason) {
+                    throw new SyntaxError();
+                }
+                const value = unflatten_js_1.unflatten.call(this, jsonLine);
+                deferred.resolve(value);
+                break;
+            }
+            case utils_js_1.TYPE_ERROR: {
+                const colonIndex = line.indexOf(":");
+                const deferredId = Number(line.slice(1, colonIndex));
+                const deferred = this.deferred[deferredId];
+                if (!deferred) {
+                    throw new Error(`Deferred ID ${deferredId} not found in stream`);
+                }
+                const lineData = line.slice(colonIndex + 1);
+                let jsonLine;
+                try {
+                    jsonLine = JSON.parse(lineData);
+                }
+                catch (reason) {
+                    throw new SyntaxError();
+                }
+                const value = unflatten_js_1.unflatten.call(this, jsonLine);
+                deferred.reject(value);
+                break;
+            }
+            default:
+                throw new SyntaxError();
+        }
+        read = await reader.read();
+    }
+}
+function encode(input, options) {
+    const { plugins, postPlugins, signal } = options ?? {};
+    const encoder = {
+        deferred: {},
+        index: 0,
+        indices: new Map(),
+        stringified: [],
+        plugins,
+        postPlugins,
+        signal,
+    };
+    const textEncoder = new TextEncoder();
+    let lastSentIndex = 0;
+    const readable = new ReadableStream({
+        async start(controller) {
+            const id = flatten_js_1.flatten.call(encoder, input);
+            if (Array.isArray(id)) {
+                throw new Error("This should never happen");
+            }
+            if (id < 0) {
+                controller.enqueue(textEncoder.encode(`${id}\n`));
+            }
+            else {
+                controller.enqueue(textEncoder.encode(`[${encoder.stringified.join(",")}]\n`));
+                lastSentIndex = encoder.stringified.length - 1;
+            }
+            const seenPromises = new WeakSet();
+            while (Object.keys(encoder.deferred).length > 0) {
+                for (const [deferredId, deferred] of Object.entries(encoder.deferred)) {
+                    if (seenPromises.has(deferred))
+                        continue;
+                    seenPromises.add((encoder.deferred[Number(deferredId)] = raceSignal(deferred, encoder.signal)
+                        .then((resolved) => {
+                        const id = flatten_js_1.flatten.call(encoder, resolved);
+                        if (Array.isArray(id)) {
+                            controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:[["${utils_js_1.TYPE_PREVIOUS_RESOLVED}",${id[0]}]]\n`));
+                            encoder.index++;
+                            lastSentIndex++;
+                        }
+                        else if (id < 0) {
+                            controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:${id}\n`));
+                        }
+                        else {
+                            const values = encoder.stringified
+                                .slice(lastSentIndex + 1)
+                                .join(",");
+                            controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:[${values}]\n`));
+                            lastSentIndex = encoder.stringified.length - 1;
+                        }
+                    }, (reason) => {
+                        if (!reason ||
+                            typeof reason !== "object" ||
+                            !(reason instanceof Error)) {
+                            reason = new Error("An unknown error occurred");
+                        }
+                        const id = flatten_js_1.flatten.call(encoder, reason);
+                        if (Array.isArray(id)) {
+                            controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:[["${utils_js_1.TYPE_PREVIOUS_RESOLVED}",${id[0]}]]\n`));
+                            encoder.index++;
+                            lastSentIndex++;
+                        }
+                        else if (id < 0) {
+                            controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:${id}\n`));
+                        }
+                        else {
+                            const values = encoder.stringified
+                                .slice(lastSentIndex + 1)
+                                .join(",");
+                            controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:[${values}]\n`));
+                            lastSentIndex = encoder.stringified.length - 1;
+                        }
+                    })
+                        .finally(() => {
+                        delete encoder.deferred[Number(deferredId)];
+                    })));
+                }
+                await Promise.race(Object.values(encoder.deferred));
+            }
+            await Promise.all(Object.values(encoder.deferred));
+            controller.close();
+        },
+    });
+    return readable;
+}
+exports.encode = encode;
+function raceSignal(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(signal.reason || new Error("Signal was aborted."));
+    const abort = new Promise((resolve, reject) => {
+        signal.addEventListener("abort", (event) => {
+            reject(signal.reason || new Error("Signal was aborted."));
+        });
+        promise.then(resolve).catch(reject);
+    });
+    abort.catch(() => { });
+    return Promise.race([abort, promise]);
+}