@highstate/designer 0.19.1 → 0.21.1

package/.output/server/node_modules/trpc-bun-adapter/dist/index.js

@@ -0,0 +1,406 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createBunHttpHandler: () => createBunHttpHandler,
+  createBunServeHandler: () => createBunServeHandler,
+  createBunWSHandler: () => createBunWSHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/createBunHttpHandler.ts
+var import_fetch = require("@trpc/server/adapters/fetch");
+function createBunHttpHandler(opts) {
+  return (request, server) => {
+    const url = new URL(request.url);
+    if (opts.endpoint && !url.pathname.startsWith(opts.endpoint)) {
+      return;
+    }
+    if (opts.emitWsUpgrades && server.upgrade(request, { data: { req: request } })) {
+      return new Response(null, { status: 101 });
+    }
+    return (0, import_fetch.fetchRequestHandler)({
+      createContext: () => ({}),
+      ...opts,
+      req: request,
+      endpoint: opts.endpoint ?? ""
+    });
+  };
+}
+
+// src/createBunWSHandler.ts
+var import_server = require("@trpc/server");
+var import_http = require("@trpc/server/http");
+var import_observable = require("@trpc/server/observable");
+var import_rpc = require("@trpc/server/rpc");
+function createBunWSHandler(opts) {
+  const { router, createContext } = opts;
+  const respond = (client, untransformedJSON) => {
+    client.send(
+      JSON.stringify(
+        (0, import_server.transformTRPCResponse)(
+          opts.router._def._config,
+          untransformedJSON
+        )
+      )
+    );
+  };
+  async function createClientCtx(client, url, connectionParams) {
+    const ctxPromise = createContext?.({
+      req: client.data.req,
+      res: client,
+      info: {
+        url,
+        connectionParams,
+        calls: [],
+        isBatchCall: false,
+        accept: null,
+        type: "unknown",
+        signal: client.data.abortController.signal
+      }
+    });
+    try {
+      return await ctxPromise;
+    } catch (cause) {
+      const error = (0, import_server.getTRPCErrorFromUnknown)(cause);
+      opts.onError?.({
+        error,
+        path: void 0,
+        type: "unknown",
+        ctx: void 0,
+        req: client.data.req,
+        input: void 0
+      });
+      respond(client, {
+        id: null,
+        error: (0, import_server.getErrorShape)({
+          config: router._def._config,
+          error,
+          type: "unknown",
+          path: void 0,
+          input: void 0,
+          ctx: void 0
+        })
+      });
+    }
+  }
+  async function handleRequest(client, msg) {
+    if (!msg.id) {
+      throw new import_server.TRPCError({
+        code: "BAD_REQUEST",
+        message: "`id` is required"
+      });
+    }
+    if (msg.method === "subscription.stop") {
+      client.data.abortControllers.get(msg.id)?.abort();
+      client.data.abortControllers.delete(msg.id);
+      return;
+    }
+    const { id, method, jsonrpc } = msg;
+    const type = method;
+    const { path, lastEventId } = msg.params;
+    const req = client.data.req;
+    const clientAbortControllers = client.data.abortControllers;
+    let { input } = msg.params;
+    const ctx = await client.data.ctx;
+    try {
+      if (lastEventId !== void 0) {
+        if (isObject(input)) {
+          input = {
+            ...input,
+            lastEventId
+          };
+        } else {
+          input ??= {
+            lastEventId
+          };
+        }
+      }
+      if (clientAbortControllers.has(id)) {
+        throw new import_server.TRPCError({
+          message: `Duplicate id ${id}`,
+          code: "BAD_REQUEST"
+        });
+      }
+      const abortController = new AbortController();
+      const result = await (0, import_server.callTRPCProcedure)({
+        router,
+        path,
+        getRawInput: () => Promise.resolve(input),
+        ctx,
+        type,
+        signal: abortController.signal
+      });
+      const isIterableResult = isAsyncIterable(result) || (0, import_observable.isObservable)(result);
+      if (type !== "subscription") {
+        if (isIterableResult) {
+          throw new import_server.TRPCError({
+            code: "UNSUPPORTED_MEDIA_TYPE",
+            message: `Cannot return an async iterable or observable from a ${type} procedure with WebSockets`
+          });
+        }
+        respond(client, {
+          id,
+          jsonrpc,
+          result: {
+            type: "data",
+            data: result
+          }
+        });
+        return;
+      }
+      if (!isIterableResult) {
+        throw new import_server.TRPCError({
+          message: `Subscription ${path} did not return an observable or a AsyncGenerator`,
+          code: "INTERNAL_SERVER_ERROR"
+        });
+      }
+      if (client.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      const iterable = (0, import_observable.isObservable)(result) ? (0, import_observable.observableToAsyncIterable)(result, abortController.signal) : result;
+      const iterator = iterable[Symbol.asyncIterator]();
+      const abortPromise = new Promise((resolve) => {
+        abortController.signal.onabort = () => resolve("abort");
+      });
+      clientAbortControllers.set(id, abortController);
+      run(async () => {
+        while (true) {
+          const next = await Promise.race([
+            iterator.next().catch(import_server.getTRPCErrorFromUnknown),
+            abortPromise
+          ]);
+          if (next === "abort") {
+            await iterator.return?.();
+            break;
+          }
+          if (next instanceof Error) {
+            const error = (0, import_server.getTRPCErrorFromUnknown)(next);
+            opts.onError?.({
+              error,
+              path,
+              type,
+              ctx,
+              req,
+              input
+            });
+            respond(client, {
+              id,
+              jsonrpc,
+              error: (0, import_server.getErrorShape)({
+                config: router._def._config,
+                error,
+                type,
+                path,
+                input,
+                ctx
+              })
+            });
+            break;
+          }
+          if (next.done) {
+            break;
+          }
+          const result2 = {
+            type: "data",
+            data: next.value
+          };
+          if ((0, import_server.isTrackedEnvelope)(next.value)) {
+            const [id2, data] = next.value;
+            result2.id = id2;
+            result2.data = {
+              id: id2,
+              data
+            };
+          }
+          respond(client, {
+            id,
+            jsonrpc,
+            result: result2
+          });
+        }
+        await iterator.return?.();
+        respond(client, {
+          id,
+          jsonrpc,
+          result: {
+            type: "stopped"
+          }
+        });
+      }).catch((cause) => {
+        const error = (0, import_server.getTRPCErrorFromUnknown)(cause);
+        opts.onError?.({ error, path, type, ctx, req, input });
+        respond(client, {
+          id,
+          jsonrpc,
+          error: (0, import_server.getErrorShape)({
+            config: router._def._config,
+            error,
+            type,
+            path,
+            input,
+            ctx
+          })
+        });
+        abortController.abort();
+      }).finally(() => {
+        clientAbortControllers.delete(id);
+      });
+      respond(client, {
+        id,
+        jsonrpc,
+        result: {
+          type: "started"
+        }
+      });
+    } catch (cause) {
+      const error = (0, import_server.getTRPCErrorFromUnknown)(cause);
+      opts.onError?.({ error, path, type, ctx, req, input });
+      respond(client, {
+        id,
+        jsonrpc,
+        error: (0, import_server.getErrorShape)({
+          config: router._def._config,
+          error,
+          type,
+          path,
+          input,
+          ctx
+        })
+      });
+    }
+  }
+  return {
+    open(client) {
+      client.data.abortController = new AbortController();
+      client.data.abortControllers = /* @__PURE__ */ new Map();
+      const url = createURL(client);
+      client.data.ctx = createClientCtx.bind(null, client, url);
+      const connectionParams = url.searchParams.get("connectionParams") === "1";
+      if (!connectionParams) {
+        client.data.ctx = client.data.ctx(null);
+      }
+    },
+    async close(client) {
+      client.data.abortController.abort();
+      await Promise.all(
+        Array.from(
+          client.data.abortControllers.values(),
+          (ctrl) => ctrl.abort()
+        )
+      );
+    },
+    async message(client, message) {
+      const msgStr = message.toString();
+      if (msgStr === "PONG") {
+        return;
+      }
+      if (msgStr === "PING") {
+        client.send("PONG");
+        return;
+      }
+      try {
+        const msgJSON = JSON.parse(msgStr);
+        const msgs = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
+        if (client.data.ctx instanceof Function) {
+          const msg = msgs.shift();
+          client.data.ctx = client.data.ctx(
+            (0, import_http.parseConnectionParamsFromUnknown)(msg.data)
+          );
+        }
+        const promises = [];
+        for (const raw of msgs) {
+          const msg = (0, import_rpc.parseTRPCMessage)(
+            raw,
+            router._def._config.transformer
+          );
+          promises.push(handleRequest(client, msg));
+        }
+        await Promise.all(promises);
+      } catch (cause) {
+        const error = new import_server.TRPCError({
+          code: "PARSE_ERROR",
+          cause
+        });
+        respond(client, {
+          id: null,
+          error: (0, import_server.getErrorShape)({
+            config: router._def._config,
+            error,
+            type: "unknown",
+            path: void 0,
+            input: void 0,
+            ctx: void 0
+          })
+        });
+      }
+    }
+  };
+}
+function isAsyncIterable(value) {
+  return isObject(value) && Symbol.asyncIterator in value;
+}
+function run(fn) {
+  return fn();
+}
+function isObject(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
+}
+function createURL(client) {
+  try {
+    const req = client.data.req;
+    const protocol = client && "encrypted" in client && client.encrypted ? "https:" : "http:";
+    const host = req.headers.get("host") ?? "localhost";
+    return new URL(req.url, `${protocol}//${host}`);
+  } catch (cause) {
+    throw new import_server.TRPCError({
+      code: "BAD_REQUEST",
+      message: "Invalid URL",
+      cause
+    });
+  }
+}
+
+// src/createBunServeHandler.ts
+function createBunServeHandler(opts, serveOptions) {
+  const trpcHandler = createBunHttpHandler({
+    ...opts,
+    emitWsUpgrades: true
+  });
+  return {
+    ...serveOptions,
+    async fetch(req, server) {
+      const trpcResponse = trpcHandler(req, server);
+      if (trpcResponse) {
+        return trpcResponse;
+      }
+      return serveOptions?.fetch?.call(server, req, server);
+    },
+    websocket: createBunWSHandler(opts)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBunHttpHandler,
+  createBunServeHandler,
+  createBunWSHandler
+});
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/trpc-bun-adapter/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "trpc-bun-adapter",
+  "version": "1.3.0",
+  "description": "TRPC adapter for bun js runtime",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "package.json",
+    "LICENSE.txt",
+    "README.md",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "lint": "biome check",
+    "lint:fix": "biome check --write .",
+    "bundle": "npx tsup src/index.ts --format cjs,esm --dts --clean --sourcemap"
+  },
+  "keywords": [
+    "bun",
+    "trpc",
+    "adapter",
+    "websocket"
+  ],
+  "repository": {
+    "url": "git+https://github.com/cah4a/trpc-bun-adapter.git"
+  },
+  "bugs": "https://github.com/cah4a/trpc-bun-adapter/issues",
+  "author": "Sancha <cah4o3@gmail.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@trpc/server": "11.0.0",
+    "bun-types": "^1.1.17",
+    "tsup": "^8.0.1",
+    "typescript": "^5.5.4",
+    "@biomejs/biome": "^1.9.4"
+  },
+  "peerDependencies": {
+    "@trpc/server": "^11.0.0"
+  }
+}

package/.output/server/node_modules/ufo/dist/index.mjs

@@ -21,23 +21,23 @@ const u = function(n2, t2, o2) {
   return e(r2 + 36 * n2 / (n2 + 38));
 };
 function toASCII(o2) {
-  return function(n2, o3) {
+  return (function(n2, o3) {
     const e2 = n2.split("@");
     let r2 = "";
     e2.length > 1 && (r2 = e2[0] + "@", n2 = e2[1]);
-    const s2 = function(n3, t2) {
+    const s2 = (function(n3, t2) {
       const o4 = [];
       let e3 = n3.length;
       for (; e3--; ) {
         o4[e3] = t2(n3[e3]);
       }
       return o4;
-    }((n2 = n2.replace(t, ".")).split("."), o3).join(".");
+    })((n2 = n2.replace(t, ".")).split("."), o3).join(".");
     return r2 + s2;
-  }(o2, function(t2) {
-    return n.test(t2) ? "xn--" + function(n2) {
+  })(o2, function(t2) {
+    return n.test(t2) ? "xn--" + (function(n2) {
       const t3 = [];
-      const o3 = (n2 = function(n3) {
+      const o3 = (n2 = (function(n3) {
         const t4 = [];
         let o4 = 0;
         const e2 = n3.length;
@@ -51,7 +51,7 @@ function toASCII(o2) {
           }
         }
         return t4;
-      }(n2)).length;
+      })(n2)).length;
       let f = 128;
       let i = 0;
       let l = 72;
@@ -85,7 +85,7 @@ function toASCII(o2) {
         ++i, ++f;
       }
       return t3.join("");
-    }(t2) : t2;
+    })(t2) : t2;
   });
 }
 
@@ -267,7 +267,10 @@ function withBase(input, base) {
   }
   const _base = withoutTrailingSlash(base);
   if (input.startsWith(_base)) {
-    return input;
+    const nextChar = input[_base.length];
+    if (!nextChar || nextChar === "/" || nextChar === "?") {
+      return input;
+    }
   }
   return joinURL(_base, input);
 }
@@ -279,6 +282,10 @@ function withoutBase(input, base) {
   if (!input.startsWith(_base)) {
     return input;
   }
+  const nextChar = input[_base.length];
+  if (nextChar && nextChar !== "/" && nextChar !== "?") {
+    return input;
+  }
   const trimmed = input.slice(_base.length);
   return trimmed[0] === "/" ? trimmed : "/" + trimmed;
 }

package/.output/server/node_modules/ufo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ufo",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "URL utils for humans",
   "repository": "unjs/ufo",
   "license": "MIT",
@@ -8,8 +8,9 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
-      "import": "./dist/index.mjs"
+      "default": "./dist/index.mjs"
     },
     "./*": "./*"
   },
@@ -30,18 +31,18 @@
     "test": "pnpm lint && vitest run --typecheck"
   },
   "devDependencies": {
-    "@types/node": "^22.14.0",
-    "@vitest/coverage-v8": "^3.1.1",
-    "automd": "^0.4.0",
-    "changelogen": "^0.6.1",
-    "eslint": "^9.24.0",
-    "eslint-config-unjs": "^0.4.2",
-    "jiti": "^2.4.2",
-    "prettier": "^3.5.3",
-    "typescript": "^5.8.3",
-    "unbuild": "^3.5.0",
+    "@types/node": "^25.0.8",
+    "@vitest/coverage-v8": "^4.0.17",
+    "automd": "^0.4.2",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.2",
+    "eslint-config-unjs": "^0.6.2",
+    "jiti": "^2.6.1",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "unbuild": "^3.6.1",
     "untyped": "^2.0.0",
-    "vitest": "^3.1.1"
+    "vitest": "^4.0.17"
   },
-  "packageManager": "pnpm@10.7.1"
+  "packageManager": "pnpm@10.28.0"
 }

package/.output/server/node_modules/unhead/dist/plugins.mjs

@@ -1,7 +1,7 @@
-export { A as AliasSortingPlugin, D as DeprecationsPlugin, P as PromisesPlugin, T as TemplateParamsPlugin } from './shared/unhead.Djo8ep_Y.mjs';
-import { d as defineHeadPlugin } from './shared/unhead.CApf5sj3.mjs';
-export { F as FlatMetaPlugin, S as SafeInputPlugin } from './shared/unhead.CApf5sj3.mjs';
-import './shared/unhead.DZbvapt-.mjs';
+export { A as AliasSortingPlugin, D as DeprecationsPlugin, P as PromisesPlugin, T as TemplateParamsPlugin } from './shared/unhead.TxTMM7cM.mjs';
+import { d as defineHeadPlugin } from './shared/unhead.D4vSFytZ.mjs';
+export { F as FlatMetaPlugin, S as SafeInputPlugin } from './shared/unhead.D4vSFytZ.mjs';
+import './shared/unhead.CbpEuj3y.mjs';
 import './shared/unhead.BYvz9V1x.mjs';
 import './shared/unhead.DQc16pHI.mjs';
 import './shared/unhead.yem5I2v_.mjs';

package/.output/server/node_modules/unhead/dist/server.mjs

@@ -1,9 +1,9 @@
-import { a as createUnhead } from './shared/unhead.DH45uomy.mjs';
+import { a as createUnhead } from './shared/unhead.Ct24BOby.mjs';
 import { T as TagsWithInnerContent, S as SelfClosingTags } from './shared/unhead.yem5I2v_.mjs';
-import { parseHtmlForUnheadExtraction } from './parser.mjs';
+import { parseHtmlForUnheadExtraction, applyHeadToHtml, parseHtmlForIndexes } from './parser.mjs';
 import 'hookable';
-import './shared/unhead.BpRRHAhY.mjs';
-import './shared/unhead.DZbvapt-.mjs';
+import './shared/unhead.B5FWS6X0.mjs';
+import './shared/unhead.CbpEuj3y.mjs';
 
 // @__NO_SIDE_EFFECTS__
 function createHead(options = {}) {
@@ -165,7 +165,6 @@ async function renderSSRHead(head, options) {
 
 // @__NO_SIDE_EFFECTS__
 async function transformHtmlTemplate(head, html, options) {
-  const { parseHtmlForUnheadExtraction, applyHeadToHtml } = await import('./parser.mjs');
   const template = parseHtmlForUnheadExtraction(html);
   head.push(template.input, { _index: 0 });
   const headHtml = await renderSSRHead(head, options);
@@ -173,7 +172,6 @@ async function transformHtmlTemplate(head, html, options) {
 }
 // @__NO_SIDE_EFFECTS__
 async function transformHtmlTemplateRaw(head, html, options) {
-  const { parseHtmlForIndexes, applyHeadToHtml } = await import('./parser.mjs');
   const headHtml = await renderSSRHead(head, options);
   const template = parseHtmlForIndexes(html);
   return applyHeadToHtml(template, headHtml);