@highstate/designer 0.20.0 → 0.26.0

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/unhead/dist/plugins.mjs

@@ -1,6 +1,6 @@
-export { A as AliasSortingPlugin, D as DeprecationsPlugin, P as PromisesPlugin, T as TemplateParamsPlugin } from './shared/unhead.ckV6dpEQ.mjs';
-import { d as defineHeadPlugin } from './shared/unhead.CApf5sj3.mjs';
-export { F as FlatMetaPlugin, S as SafeInputPlugin } from './shared/unhead.CApf5sj3.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';

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

@@ -1,8 +1,8 @@
-import { a as createUnhead } from './shared/unhead.BFfcxOoW.mjs';
+import { a as createUnhead } from './shared/unhead.Ct24BOby.mjs';
 import { T as TagsWithInnerContent, S as SelfClosingTags } from './shared/unhead.yem5I2v_.mjs';
 import { parseHtmlForUnheadExtraction, applyHeadToHtml, parseHtmlForIndexes } from './parser.mjs';
 import 'hookable';
-import './shared/unhead.eK9_7LaY.mjs';
+import './shared/unhead.B5FWS6X0.mjs';
 import './shared/unhead.CbpEuj3y.mjs';
 
 // @__NO_SIDE_EFFECTS__

package/.output/server/node_modules/unhead/dist/shared/{unhead.eK9_7LaY.mjs → unhead.B5FWS6X0.mjs}

@@ -1,4 +1,4 @@
-import { U as UniqueTags, T as TagsWithInnerContent, M as MetaTagsArrayable, a as TagConfigKeys, D as DupeableTags } from './unhead.yem5I2v_.mjs';
+import { U as UniqueTags, T as TagsWithInnerContent, M as MetaTagsArrayable, H as HasElementTags, a as TagConfigKeys, D as DupeableTags } from './unhead.yem5I2v_.mjs';
 
 const allowedMetaProperties = ["name", "property", "http-equiv"];
 const StandardSingleMetaTags = /* @__PURE__ */ new Set([
@@ -19,9 +19,11 @@ function dedupeKey(tag) {
     return name;
   if (name === "link" && props.rel === "canonical")
     return "canonical";
-  const altKey = props.hreflang || props.type;
-  if (name === "link" && props.rel === "alternate" && altKey) {
-    return `alternate:${altKey}`;
+  if (name === "link" && props.rel === "alternate") {
+    const altKey = props.hreflang || props.type;
+    if (altKey) {
+      return `alternate:${altKey}`;
+    }
   }
   if (props.charset)
     return "charset";
@@ -43,6 +45,9 @@ function dedupeKey(tag) {
   if (props.id) {
     return `${name}:id:${props.id}`;
   }
+  if (name === "link" && props.rel === "alternate") {
+    return `alternate:${props.href || ""}`;
+  }
   if (TagsWithInnerContent.has(name)) {
     const v = tag.textContent || tag.innerHTML;
     if (v) {
@@ -119,17 +124,20 @@ function normalizeProps(tag, input) {
     tag.props = input;
     return tag;
   }
-  Object.entries(input).forEach(([key, value]) => {
+  const isHtmlTag = HasElementTags.has(tag.tag) || tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs";
+  Object.entries(input).forEach(([prop, value]) => {
+    if (prop === "__proto__" || prop === "constructor" || prop === "prototype")
+      return;
     if (value === null) {
-      tag.props[key] = null;
+      tag.props[prop] = null;
       return;
     }
-    if (key === "class" || key === "style") {
-      tag.props[key] = normalizeStyleClassProps(key, value);
+    if (prop === "class" || prop === "style") {
+      tag.props[prop] = normalizeStyleClassProps(prop, value);
       return;
     }
-    if (TagConfigKeys.has(key)) {
-      if (["textContent", "innerHTML"].includes(key) && typeof value === "object") {
+    if (TagConfigKeys.has(prop)) {
+      if ((prop === "textContent" || prop === "innerHTML") && typeof value === "object") {
         let type = input.type;
         if (!input.type) {
           type = "application/json";
@@ -139,14 +147,15 @@ function normalizeProps(tag, input) {
         }
         input.type = type;
         tag.props.type = type;
-        tag[key] = JSON.stringify(value);
+        tag[prop] = JSON.stringify(value);
       } else {
-        tag[key] = value;
+        tag[prop] = value;
       }
       return;
     }
+    const isDataKey = prop.startsWith("data-");
+    const key = isHtmlTag && !isDataKey ? prop.toLowerCase() : prop;
     const strValue = String(value);
-    const isDataKey = key.startsWith("data-");
     const isMetaContentKey = tag.tag === "meta" && key === "content";
     if (strValue === "true" || strValue === "") {
       tag.props[key] = isDataKey || isMetaContentKey ? strValue : true;

package/.output/server/node_modules/unhead/dist/shared/{unhead.BFfcxOoW.mjs → unhead.Ct24BOby.mjs}

@@ -1,5 +1,5 @@
 import { createHooks } from 'hookable';
-import { n as normalizeEntryToTags, d as dedupeKey, i as isMetaArrayDupeKey } from './unhead.eK9_7LaY.mjs';
+import { n as normalizeEntryToTags, d as dedupeKey, h as hashTag, i as isMetaArrayDupeKey } from './unhead.B5FWS6X0.mjs';
 import { t as tagWeight, s as sortTags } from './unhead.CbpEuj3y.mjs';
 import { c as UsesMergeStrategy, V as ValidHeadTags } from './unhead.yem5I2v_.mjs';
 
@@ -86,13 +86,15 @@ function createUnhead(resolvedOptions = {}) {
             t._w = tagWeight(head, t);
             t._p = (e._i << 10) + i2;
             t._d = dedupeKey(t);
+            if (!t._d)
+              t._h = hashTag(t);
             return t;
           });
         }
       }
       let hasFlatMeta = false;
       ctx.entries.flatMap((e) => (e._tags || []).map((t) => ({ ...t, props: { ...t.props } }))).sort(sortTags).reduce((acc, next) => {
-        const k = String(next._d || next._p);
+        const k = next._d || next._h;
         if (!acc.has(k))
           return acc.set(k, next);
         const prev = acc.get(k);