ru.Bee 1.3.2 → 1.4.0

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

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unflatten = void 0;
+const utils_js_1 = require("./utils.js");
+const globalObj = (typeof window !== "undefined"
+    ? window
+    : typeof globalThis !== "undefined"
+        ? globalThis
+        : undefined);
+function unflatten(parsed) {
+    const { hydrated, values } = this;
+    if (typeof parsed === "number")
+        return hydrate.call(this, parsed);
+    if (!Array.isArray(parsed) || !parsed.length)
+        throw new SyntaxError();
+    const startIndex = values.length;
+    for (const value of parsed) {
+        values.push(value);
+    }
+    hydrated.length = values.length;
+    return hydrate.call(this, startIndex);
+}
+exports.unflatten = unflatten;
+function hydrate(index) {
+    const { hydrated, values, deferred, plugins } = this;
+    let result;
+    const stack = [
+        [
+            index,
+            (v) => {
+                result = v;
+            },
+        ],
+    ];
+    let postRun = [];
+    while (stack.length > 0) {
+        const [index, set] = stack.pop();
+        switch (index) {
+            case utils_js_1.UNDEFINED:
+                set(undefined);
+                continue;
+            case utils_js_1.NULL:
+                set(null);
+                continue;
+            case utils_js_1.NAN:
+                set(NaN);
+                continue;
+            case utils_js_1.POSITIVE_INFINITY:
+                set(Infinity);
+                continue;
+            case utils_js_1.NEGATIVE_INFINITY:
+                set(-Infinity);
+                continue;
+            case utils_js_1.NEGATIVE_ZERO:
+                set(-0);
+                continue;
+        }
+        if (hydrated[index]) {
+            set(hydrated[index]);
+            continue;
+        }
+        const value = values[index];
+        if (!value || typeof value !== "object") {
+            hydrated[index] = value;
+            set(value);
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (typeof value[0] === "string") {
+                const [type, b, c] = value;
+                switch (type) {
+                    case utils_js_1.TYPE_DATE:
+                        set((hydrated[index] = new Date(b)));
+                        continue;
+                    case utils_js_1.TYPE_URL:
+                        set((hydrated[index] = new URL(b)));
+                        continue;
+                    case utils_js_1.TYPE_BIGINT:
+                        set((hydrated[index] = BigInt(b)));
+                        continue;
+                    case utils_js_1.TYPE_REGEXP:
+                        set((hydrated[index] = new RegExp(b, c)));
+                        continue;
+                    case utils_js_1.TYPE_SYMBOL:
+                        set((hydrated[index] = Symbol.for(b)));
+                        continue;
+                    case utils_js_1.TYPE_SET:
+                        const newSet = new Set();
+                        hydrated[index] = newSet;
+                        for (let i = 1; i < value.length; i++)
+                            stack.push([
+                                value[i],
+                                (v) => {
+                                    newSet.add(v);
+                                },
+                            ]);
+                        set(newSet);
+                        continue;
+                    case utils_js_1.TYPE_MAP:
+                        const map = new Map();
+                        hydrated[index] = map;
+                        for (let i = 1; i < value.length; i += 2) {
+                            const r = [];
+                            stack.push([
+                                value[i + 1],
+                                (v) => {
+                                    r[1] = v;
+                                },
+                            ]);
+                            stack.push([
+                                value[i],
+                                (k) => {
+                                    r[0] = k;
+                                },
+                            ]);
+                            postRun.push(() => {
+                                map.set(r[0], r[1]);
+                            });
+                        }
+                        set(map);
+                        continue;
+                    case utils_js_1.TYPE_NULL_OBJECT:
+                        const obj = Object.create(null);
+                        hydrated[index] = obj;
+                        for (const key of Object.keys(b).reverse()) {
+                            const r = [];
+                            stack.push([
+                                b[key],
+                                (v) => {
+                                    r[1] = v;
+                                },
+                            ]);
+                            stack.push([
+                                Number(key.slice(1)),
+                                (k) => {
+                                    r[0] = k;
+                                },
+                            ]);
+                            postRun.push(() => {
+                                obj[r[0]] = r[1];
+                            });
+                        }
+                        set(obj);
+                        continue;
+                    case utils_js_1.TYPE_PROMISE:
+                        if (hydrated[b]) {
+                            set((hydrated[index] = hydrated[b]));
+                        }
+                        else {
+                            const d = new utils_js_1.Deferred();
+                            deferred[b] = d;
+                            set((hydrated[index] = d.promise));
+                        }
+                        continue;
+                    case utils_js_1.TYPE_ERROR:
+                        const [, message, errorType] = value;
+                        let error = errorType && globalObj && globalObj[errorType]
+                            ? new globalObj[errorType](message)
+                            : new Error(message);
+                        hydrated[index] = error;
+                        set(error);
+                        continue;
+                    case utils_js_1.TYPE_PREVIOUS_RESOLVED:
+                        set((hydrated[index] = hydrated[b]));
+                        continue;
+                    default:
+                        // Run plugins at the end so we have a chance to resolve primitives
+                        // without running into a loop
+                        if (Array.isArray(plugins)) {
+                            const r = [];
+                            const vals = value.slice(1);
+                            for (let i = 0; i < vals.length; i++) {
+                                const v = vals[i];
+                                stack.push([
+                                    v,
+                                    (v) => {
+                                        r[i] = v;
+                                    },
+                                ]);
+                            }
+                            postRun.push(() => {
+                                for (const plugin of plugins) {
+                                    const result = plugin(value[0], ...r);
+                                    if (result) {
+                                        set((hydrated[index] = result.value));
+                                        return;
+                                    }
+                                }
+                                throw new SyntaxError();
+                            });
+                            continue;
+                        }
+                        throw new SyntaxError();
+                }
+            }
+            else {
+                const array = [];
+                hydrated[index] = array;
+                for (let i = 0; i < value.length; i++) {
+                    const n = value[i];
+                    if (n !== utils_js_1.HOLE) {
+                        stack.push([
+                            n,
+                            (v) => {
+                                array[i] = v;
+                            },
+                        ]);
+                    }
+                }
+                set(array);
+                continue;
+            }
+        }
+        else {
+            const object = {};
+            hydrated[index] = object;
+            for (const key of Object.keys(value).reverse()) {
+                const r = [];
+                stack.push([
+                    value[key],
+                    (v) => {
+                        r[1] = v;
+                    },
+                ]);
+                stack.push([
+                    Number(key.slice(1)),
+                    (k) => {
+                        r[0] = k;
+                    },
+                ]);
+                postRun.push(() => {
+                    object[r[0]] = r[1];
+                });
+            }
+            set(object);
+            continue;
+        }
+    }
+    while (postRun.length > 0) {
+        postRun.pop()();
+    }
+    return result;
+}

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

@@ -0,0 +1,44 @@
+export declare const HOLE = -1;
+export declare const NAN = -2;
+export declare const NEGATIVE_INFINITY = -3;
+export declare const NEGATIVE_ZERO = -4;
+export declare const NULL = -5;
+export declare const POSITIVE_INFINITY = -6;
+export declare const UNDEFINED = -7;
+export declare const TYPE_BIGINT = "B";
+export declare const TYPE_DATE = "D";
+export declare const TYPE_ERROR = "E";
+export declare const TYPE_MAP = "M";
+export declare const TYPE_NULL_OBJECT = "N";
+export declare const TYPE_PROMISE = "P";
+export declare const TYPE_REGEXP = "R";
+export declare const TYPE_SET = "S";
+export declare const TYPE_SYMBOL = "Y";
+export declare const TYPE_URL = "U";
+export declare const TYPE_PREVIOUS_RESOLVED = "Z";
+export type DecodePlugin = (type: string, ...data: unknown[]) => {
+    value: unknown;
+} | false | null | undefined;
+export type EncodePlugin = (value: unknown) => [string, ...unknown[]] | false | null | undefined;
+export interface ThisDecode {
+    values: unknown[];
+    hydrated: unknown[];
+    deferred: Record<number, Deferred<unknown>>;
+    plugins?: DecodePlugin[];
+}
+export interface ThisEncode {
+    index: number;
+    indices: Map<unknown, number>;
+    stringified: string[];
+    deferred: Record<number, Promise<unknown>>;
+    plugins?: EncodePlugin[];
+    postPlugins?: EncodePlugin[];
+    signal?: AbortSignal;
+}
+export declare class Deferred<T = unknown> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+    constructor();
+}
+export declare function createLineSplittingTransform(): TransformStream<any, any>;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLineSplittingTransform = exports.Deferred = exports.TYPE_PREVIOUS_RESOLVED = exports.TYPE_URL = exports.TYPE_SYMBOL = exports.TYPE_SET = exports.TYPE_REGEXP = exports.TYPE_PROMISE = exports.TYPE_NULL_OBJECT = exports.TYPE_MAP = exports.TYPE_ERROR = exports.TYPE_DATE = exports.TYPE_BIGINT = exports.UNDEFINED = exports.POSITIVE_INFINITY = exports.NULL = exports.NEGATIVE_ZERO = exports.NEGATIVE_INFINITY = exports.NAN = exports.HOLE = void 0;
+exports.HOLE = -1;
+exports.NAN = -2;
+exports.NEGATIVE_INFINITY = -3;
+exports.NEGATIVE_ZERO = -4;
+exports.NULL = -5;
+exports.POSITIVE_INFINITY = -6;
+exports.UNDEFINED = -7;
+exports.TYPE_BIGINT = "B";
+exports.TYPE_DATE = "D";
+exports.TYPE_ERROR = "E";
+exports.TYPE_MAP = "M";
+exports.TYPE_NULL_OBJECT = "N";
+exports.TYPE_PROMISE = "P";
+exports.TYPE_REGEXP = "R";
+exports.TYPE_SET = "S";
+exports.TYPE_SYMBOL = "Y";
+exports.TYPE_URL = "U";
+exports.TYPE_PREVIOUS_RESOLVED = "Z";
+class Deferred {
+    promise;
+    resolve;
+    reject;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+exports.Deferred = Deferred;
+function createLineSplittingTransform() {
+    const decoder = new TextDecoder();
+    let leftover = "";
+    return new TransformStream({
+        transform(chunk, controller) {
+            const str = decoder.decode(chunk, { stream: true });
+            const parts = (leftover + str).split("\n");
+            // The last part might be a partial line, so keep it for the next chunk.
+            leftover = parts.pop() || "";
+            for (const part of parts) {
+                controller.enqueue(part);
+            }
+        },
+        flush(controller) {
+            // If there's any leftover data, enqueue it before closing.
+            if (leftover) {
+                controller.enqueue(leftover);
+            }
+        },
+    });
+}
+exports.createLineSplittingTransform = createLineSplittingTransform;

data/lib/node_modules/turbo-stream/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "turbo-stream",
+  "version": "2.4.0",
+  "description": "A streaming data transport format that aims to support built-in features such as Promises, Dates, RegExps, Maps, Sets and more.",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "dist/turbo-stream.js",
+  "types": "dist/turbo-stream.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/turbo-stream.d.ts",
+      "import": "./dist/turbo-stream.mjs",
+      "require": "./dist/turbo-stream.js",
+      "default": "./dist/turbo-stream.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "pnpm build:esm && pnpm build:cjs && cp ./dist/turbo-stream.mjs ./viewer/scripts/turbo-stream.js",
+    "build:cjs": "tsc --outDir dist --project tsconfig.lib.json",
+    "build:esm": "esbuild --bundle --platform=node --target=node16 --format=esm --outfile=dist/turbo-stream.mjs src/turbo-stream.ts",
+    "test": "node --no-warnings --loader tsm --enable-source-maps --test-reporter tap --test src/*.spec.ts",
+    "test-typecheck": "tsc --noEmit --project tsconfig.spec.json",
+    "prepublish": "attw $(npm pack) --ignore-rules false-cjs"
+  },
+  "keywords": [
+    "devalue",
+    "turbo",
+    "stream",
+    "enhanced",
+    "json"
+  ],
+  "author": "Jacob Ebey <jacob.ebey@live.com>",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jacob-ebey/turbo-stream.git"
+  },
+  "sideEffects": false,
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.12.2",
+    "@types/node": "^20.8.7",
+    "esbuild": "^0.19.5",
+    "expect": "^29.7.0",
+    "tsm": "^2.3.0",
+    "typescript": "^5.2.2"
+  }
+}

data/lib/package-lock.json

@@ -0,0 +1,133 @@
+{
+  "name": "lib",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        "react-router-dom": "^7.5.0"
+      }
+    },
+    "node_modules/@types/cookie": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@types/cookie/-/cookie-0.6.0.tgz",
+      "integrity": "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==",
+      "license": "MIT"
+    },
+    "node_modules/cookie": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.0.2.tgz",
+      "integrity": "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
+    "node_modules/react-router": {
+      "version": "7.5.0",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.5.0.tgz",
+      "integrity": "sha512-estOHrRlDMKdlQa6Mj32gIks4J+AxNsYoE0DbTTxiMy2mPzZuWSDU+N85/r1IlNR7kGfznF3VCUlvc5IUO+B9g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/cookie": "^0.6.0",
+        "cookie": "^1.0.1",
+        "set-cookie-parser": "^2.6.0",
+        "turbo-stream": "2.4.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/react-router-dom": {
+      "version": "7.5.0",
+      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.5.0.tgz",
+      "integrity": "sha512-fFhGFCULy4vIseTtH5PNcY/VvDJK5gvOWcwJVHQp8JQcWVr85ENhJ3UpuF/zP1tQOIFYNRJHzXtyhU1Bdgw0RA==",
+      "license": "MIT",
+      "dependencies": {
+        "react-router": "7.5.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/set-cookie-parser": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.1.tgz",
+      "integrity": "sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ==",
+      "license": "MIT"
+    },
+    "node_modules/turbo-stream": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/turbo-stream/-/turbo-stream-2.4.0.tgz",
+      "integrity": "sha512-FHncC10WpBd2eOmGwpmQsWLDoK4cqsA/UT/GqNoaKOQnT8uzhtCbg3EoUDMvqpOSAI0S26mr0rkjzbOO6S3v1g==",
+      "license": "ISC"
+    }
+  }
+}

data/lib/package.json

@@ -0,0 +1,12 @@
+{
+  "scripts": {
+    "build": "node esbuild.config.js",
+    "watch": "node esbuild.config.js --watch",
+    "prepare": "npm install react react-dom react-router-dom"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^7.5.0"
+  }
+}

data/lib/rubee/async/asyncable.rb

@@ -1,5 +1,5 @@
 unless defined?(Rubee)
-  require_relative '../../../../rubee.rb'
+  require_relative '../../../../rubee'
   Rubee::Autoload.call
 end
 
@@ -11,7 +11,7 @@ module Rubee
     end
 
     def adapter
-      @adapter ||= (Rubee::Configuration.get_async_adapter || ThreadAsync)
+      @adapter ||= Rubee::Configuration.get_async_adapter || ThreadAsync
     end
   end
 end

data/lib/rubee/async/sidekiq_async.rb

@@ -1,15 +1,15 @@
 module Rubee
-class SidekiqAsync
-  def perform_async(**args)
-    options = if args[:options].is_a? Hash
-      [JSON.generate(args[:options])]
-    elsif args[:options].is_a? Array
-      args[:options]
-    else
-      [args[:options]]
-    end
+  class SidekiqAsync
+    def perform_async(**args)
+      options = if args[:options].is_a?(Hash)
+        [JSON.generate(args[:options])]
+      elsif args[:options].is_a?(Array)
+        args[:options]
+      else
+        [args[:options]]
+      end
 
-    args[:_class].perform_async(*options)
+      args[:_class].perform_async(*options)
+    end
   end
 end
-end

data/lib/rubee/async/thread_async.rb

@@ -1,7 +1,7 @@
 module Rubee
   class ThreadAsync
     def perform_async(**args)
-      color_puts "WARN: ThreadAsync engine is not yet recommended for production", color: :yellow
+      color_puts('WARN: ThreadAsync engine is not yet recommended for production', color: :yellow)
       ThreadPool.instance.enqueue(args[:_class], args[:options])
     end
   end

data/lib/rubee/async/thread_pool.rb

@@ -23,7 +23,7 @@ module Rubee
 
     def shutdown
       @running = false
-      THREADS_LIMIT.times { @queue << { task:  :stop, args: nil } }
+      THREADS_LIMIT.times { @queue << { task: :stop, args: nil } }
       @workers.each(&:join)
     end
 
@@ -39,6 +39,7 @@ module Rubee
               args = task_hash[:args]
             end
             break if task == :stop
+
             begin
               task.new.perform(**args)
             rescue StandardError => e
@@ -50,4 +51,3 @@ module Rubee
     end
   end
 end
-