@highstate/designer 0.1.0

package/.output/server/node_modules/@trpc/client/dist/links/wsLink.mjs

@@ -0,0 +1,278 @@
+import { observable } from '@trpc/server/observable';
+import { t as transformResult } from '../transformResult-ace864b8.mjs';
+import { T as TRPCClientError } from '../TRPCClientError-38f9a32a.mjs';
+import '@trpc/server/shared';
+
+/* istanbul ignore next -- @preserve */ const retryDelay = (attemptIndex)=>attemptIndex === 0 ? 0 : Math.min(1000 * 2 ** attemptIndex, 30000);
+
+function createWSClient(opts) {
+    const { url , WebSocket: WebSocketImpl = WebSocket , retryDelayMs: retryDelayFn = retryDelay , onOpen , onClose ,  } = opts;
+    /* istanbul ignore next -- @preserve */ if (!WebSocketImpl) {
+        throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
+    }
+    /**
+   * outgoing messages buffer whilst not open
+   */ let outgoing = [];
+    const pendingRequests = Object.create(null);
+    let connectAttempt = 0;
+    let dispatchTimer = null;
+    let connectTimer = null;
+    let activeConnection = createWS();
+    let state = 'connecting';
+    /**
+   * tries to send the list of messages
+   */ function dispatch() {
+        if (state !== 'open' || dispatchTimer) {
+            return;
+        }
+        dispatchTimer = setTimeout(()=>{
+            dispatchTimer = null;
+            if (outgoing.length === 1) {
+                // single send
+                activeConnection.send(JSON.stringify(outgoing.pop()));
+            } else {
+                // batch send
+                activeConnection.send(JSON.stringify(outgoing));
+            }
+            // clear
+            outgoing = [];
+        });
+    }
+    function tryReconnect() {
+        if (connectTimer !== null || state === 'closed') {
+            return;
+        }
+        const timeout = retryDelayFn(connectAttempt++);
+        reconnectInMs(timeout);
+    }
+    function reconnect() {
+        state = 'connecting';
+        const oldConnection = activeConnection;
+        activeConnection = createWS();
+        closeIfNoPending(oldConnection);
+    }
+    function reconnectInMs(ms) {
+        if (connectTimer) {
+            return;
+        }
+        state = 'connecting';
+        connectTimer = setTimeout(reconnect, ms);
+    }
+    function closeIfNoPending(conn) {
+        // disconnect as soon as there are are no pending result
+        const hasPendingRequests = Object.values(pendingRequests).some((p)=>p.ws === conn);
+        if (!hasPendingRequests) {
+            conn.close();
+        }
+    }
+    function closeActiveSubscriptions() {
+        Object.values(pendingRequests).forEach((req)=>{
+            if (req.type === 'subscription') {
+                req.callbacks.complete();
+            }
+        });
+    }
+    function resumeSubscriptionOnReconnect(req) {
+        if (outgoing.some((r)=>r.id === req.op.id)) {
+            return;
+        }
+        request(req.op, req.callbacks);
+    }
+    function createWS() {
+        const urlString = typeof url === 'function' ? url() : url;
+        const conn = new WebSocketImpl(urlString);
+        clearTimeout(connectTimer);
+        connectTimer = null;
+        conn.addEventListener('open', ()=>{
+            /* istanbul ignore next -- @preserve */ if (conn !== activeConnection) {
+                return;
+            }
+            connectAttempt = 0;
+            state = 'open';
+            onOpen?.();
+            dispatch();
+        });
+        conn.addEventListener('error', ()=>{
+            if (conn === activeConnection) {
+                tryReconnect();
+            }
+        });
+        const handleIncomingRequest = (req)=>{
+            if (req.method === 'reconnect' && conn === activeConnection) {
+                if (state === 'open') {
+                    onClose?.();
+                }
+                reconnect();
+                // notify subscribers
+                for (const pendingReq of Object.values(pendingRequests)){
+                    if (pendingReq.type === 'subscription') {
+                        resumeSubscriptionOnReconnect(pendingReq);
+                    }
+                }
+            }
+        };
+        const handleIncomingResponse = (data)=>{
+            const req = data.id !== null && pendingRequests[data.id];
+            if (!req) {
+                // do something?
+                return;
+            }
+            req.callbacks.next?.(data);
+            if (req.ws !== activeConnection && conn === activeConnection) {
+                const oldWs = req.ws;
+                // gracefully replace old connection with this
+                req.ws = activeConnection;
+                closeIfNoPending(oldWs);
+            }
+            if ('result' in data && data.result.type === 'stopped' && conn === activeConnection) {
+                req.callbacks.complete();
+            }
+        };
+        conn.addEventListener('message', ({ data  })=>{
+            const msg = JSON.parse(data);
+            if ('method' in msg) {
+                handleIncomingRequest(msg);
+            } else {
+                handleIncomingResponse(msg);
+            }
+            if (conn !== activeConnection || state === 'closed') {
+                // when receiving a message, we close old connection that has no pending requests
+                closeIfNoPending(conn);
+            }
+        });
+        conn.addEventListener('close', ({ code  })=>{
+            if (state === 'open') {
+                onClose?.({
+                    code
+                });
+            }
+            if (activeConnection === conn) {
+                // connection might have been replaced already
+                tryReconnect();
+            }
+            for (const [key, req] of Object.entries(pendingRequests)){
+                if (req.ws !== conn) {
+                    continue;
+                }
+                if (state === 'closed') {
+                    // If the connection was closed, we just call `complete()` on the request
+                    delete pendingRequests[key];
+                    req.callbacks.complete?.();
+                    continue;
+                }
+                // The connection was closed either unexpectedly or because of a reconnect
+                if (req.type === 'subscription') {
+                    // Subscriptions will resume after we've reconnected
+                    resumeSubscriptionOnReconnect(req);
+                } else {
+                    // Queries and mutations will error if interrupted
+                    delete pendingRequests[key];
+                    req.callbacks.error?.(TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+                }
+            }
+        });
+        return conn;
+    }
+    function request(op, callbacks) {
+        const { type , input , path , id  } = op;
+        const envelope = {
+            id,
+            method: type,
+            params: {
+                input,
+                path
+            }
+        };
+        pendingRequests[id] = {
+            ws: activeConnection,
+            type,
+            callbacks,
+            op
+        };
+        // enqueue message
+        outgoing.push(envelope);
+        dispatch();
+        return ()=>{
+            const callbacks = pendingRequests[id]?.callbacks;
+            delete pendingRequests[id];
+            outgoing = outgoing.filter((msg)=>msg.id !== id);
+            callbacks?.complete?.();
+            if (activeConnection.readyState === WebSocketImpl.OPEN && op.type === 'subscription') {
+                outgoing.push({
+                    id,
+                    method: 'subscription.stop'
+                });
+                dispatch();
+            }
+        };
+    }
+    return {
+        close: ()=>{
+            state = 'closed';
+            onClose?.();
+            closeActiveSubscriptions();
+            closeIfNoPending(activeConnection);
+            clearTimeout(connectTimer);
+            connectTimer = null;
+        },
+        request,
+        getConnection () {
+            return activeConnection;
+        }
+    };
+}
+class TRPCWebSocketClosedError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'TRPCWebSocketClosedError';
+        Object.setPrototypeOf(this, TRPCWebSocketClosedError.prototype);
+    }
+}
+/**
+ * @see https://trpc.io/docs/client/links/wsLink
+ */ function wsLink(opts) {
+    return (runtime)=>{
+        const { client  } = opts;
+        return ({ op  })=>{
+            return observable((observer)=>{
+                const { type , path , id , context  } = op;
+                const input = runtime.transformer.serialize(op.input);
+                const unsub = client.request({
+                    type,
+                    path,
+                    input,
+                    id,
+                    context
+                }, {
+                    error (err) {
+                        observer.error(err);
+                        unsub();
+                    },
+                    complete () {
+                        observer.complete();
+                    },
+                    next (message) {
+                        const transformed = transformResult(message, runtime);
+                        if (!transformed.ok) {
+                            observer.error(TRPCClientError.from(transformed.error));
+                            return;
+                        }
+                        observer.next({
+                            result: transformed.result
+                        });
+                        if (op.type !== 'subscription') {
+                            // if it isn't a subscription we don't care about next response
+                            unsub();
+                            observer.complete();
+                        }
+                    }
+                });
+                return ()=>{
+                    unsub();
+                };
+            });
+        };
+    };
+}
+
+export { createWSClient, wsLink };

package/.output/server/node_modules/@trpc/client/dist/splitLink-4c75f7be.mjs

@@ -0,0 +1,45 @@
+import { observable } from '@trpc/server/observable';
+
+/** @internal */ function createChain(opts) {
+    return observable((observer)=>{
+        function execute(index = 0, op = opts.op) {
+            const next = opts.links[index];
+            if (!next) {
+                throw new Error('No more links to execute - did you forget to add an ending link?');
+            }
+            const subscription = next({
+                op,
+                next (nextOp) {
+                    const nextObserver = execute(index + 1, nextOp);
+                    return nextObserver;
+                }
+            });
+            return subscription;
+        }
+        const obs$ = execute();
+        return obs$.subscribe(observer);
+    });
+}
+
+function asArray(value) {
+    return Array.isArray(value) ? value : [
+        value
+    ];
+}
+function splitLink(opts) {
+    return (runtime)=>{
+        const yes = asArray(opts.true).map((link)=>link(runtime));
+        const no = asArray(opts.false).map((link)=>link(runtime));
+        return (props)=>{
+            return observable((observer)=>{
+                const links = opts.condition(props.op) ? yes : no;
+                return createChain({
+                    op: props.op,
+                    links
+                }).subscribe(observer);
+            });
+        };
+    };
+}
+
+export { createChain as c, splitLink as s };

package/.output/server/node_modules/@trpc/client/dist/transformResult-ace864b8.mjs

@@ -0,0 +1,58 @@
+function isObject(value) {
+    // check that value is object
+    return !!value && !Array.isArray(value) && typeof value === 'object';
+}
+
+// FIXME:
+// - the generics here are probably unnecessary
+// - the RPC-spec could probably be simplified to combine HTTP + WS
+/** @internal */ function transformResultInner(response, runtime) {
+    if ('error' in response) {
+        const error = runtime.transformer.deserialize(response.error);
+        return {
+            ok: false,
+            error: {
+                ...response,
+                error
+            }
+        };
+    }
+    const result = {
+        ...response.result,
+        ...(!response.result.type || response.result.type === 'data') && {
+            type: 'data',
+            data: runtime.transformer.deserialize(response.result.data)
+        }
+    };
+    return {
+        ok: true,
+        result
+    };
+}
+class TransformResultError extends Error {
+    constructor(){
+        super('Unable to transform response from server');
+    }
+}
+/**
+ * Transforms and validates that the result is a valid TRPCResponse
+ * @internal
+ */ function transformResult(response, runtime) {
+    let result;
+    try {
+        // Use the data transformers on the JSON-response
+        result = transformResultInner(response, runtime);
+    } catch (err) {
+        throw new TransformResultError();
+    }
+    // check that output of the transformers is a valid TRPCResponse
+    if (!result.ok && (!isObject(result.error.error) || typeof result.error.error.code !== 'number')) {
+        throw new TransformResultError();
+    }
+    if (result.ok && !isObject(result.result)) {
+        throw new TransformResultError();
+    }
+    return result;
+}
+
+export { isObject as i, transformResult as t };

package/.output/server/node_modules/@trpc/client/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@trpc/client",
+  "version": "10.45.2",
+  "description": "The tRPC client library",
+  "author": "KATT",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "homepage": "https://trpc.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/trpc/trpc.git",
+    "directory": "packages/client"
+  },
+  "eslintConfig": {
+    "rules": {
+      "no-restricted-imports": [
+        "error",
+        "@trpc/client"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "rollup --config rollup.config.ts --configPlugin rollup-plugin-swc3",
+    "dev": "pnpm build --watch",
+    "codegen-entrypoints": "tsx entrypoints.script.ts",
+    "lint": "eslint --cache --ext \".js,.ts,.tsx\" --ignore-path ../../.gitignore --report-unused-disable-directives src",
+    "ts-watch": "tsc --watch"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./links/httpLink": {
+      "import": "./dist/links/httpLink.mjs",
+      "require": "./dist/links/httpLink.js",
+      "default": "./dist/links/httpLink.js"
+    },
+    "./links/httpBatchLink": {
+      "import": "./dist/links/httpBatchLink.mjs",
+      "require": "./dist/links/httpBatchLink.js",
+      "default": "./dist/links/httpBatchLink.js"
+    },
+    "./links/splitLink": {
+      "import": "./dist/links/splitLink.mjs",
+      "require": "./dist/links/splitLink.js",
+      "default": "./dist/links/splitLink.js"
+    },
+    "./links/loggerLink": {
+      "import": "./dist/links/loggerLink.mjs",
+      "require": "./dist/links/loggerLink.js",
+      "default": "./dist/links/loggerLink.js"
+    },
+    "./links/wsLink": {
+      "import": "./dist/links/wsLink.mjs",
+      "require": "./dist/links/wsLink.js",
+      "default": "./dist/links/wsLink.js"
+    },
+    "./shared": {
+      "import": "./dist/shared/index.mjs",
+      "require": "./dist/shared/index.js",
+      "default": "./dist/shared/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "package.json",
+    "links",
+    "shared",
+    "!**/*.test.*"
+  ],
+  "peerDependencies": {
+    "@trpc/server": "10.45.2"
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^9.0.0",
+    "@trpc/server": "10.45.2",
+    "@types/isomorphic-fetch": "^0.0.39",
+    "@types/node": "^20.10.0",
+    "eslint": "^8.40.0",
+    "isomorphic-fetch": "^3.0.0",
+    "node-fetch": "^3.3.0",
+    "rollup": "^2.79.1",
+    "tsx": "^4.0.0",
+    "undici": "^6.0.1",
+    "vitest": "^0.32.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": [
+    "https://trpc.io/sponsor"
+  ],
+  "gitHead": "936db6dd2598337758e29c843ff66984ed54faaf"
+}

package/.output/server/node_modules/@trpc/server/dist/TRPCError-98d44758.mjs

@@ -0,0 +1,39 @@
+import { g as getCauseFromUnknown } from './getCauseFromUnknown-2d66414a.mjs';
+
+function getTRPCErrorFromUnknown(cause) {
+    if (cause instanceof TRPCError) {
+        return cause;
+    }
+    if (cause instanceof Error && cause.name === 'TRPCError') {
+        // https://github.com/trpc/trpc/pull/4848
+        return cause;
+    }
+    const trpcError = new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        cause
+    });
+    // Inherit stack from error
+    if (cause instanceof Error && cause.stack) {
+        trpcError.stack = cause.stack;
+    }
+    return trpcError;
+}
+class TRPCError extends Error {
+    constructor(opts){
+        const cause = getCauseFromUnknown(opts.cause);
+        const message = opts.message ?? cause?.message ?? opts.code;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore https://github.com/tc39/proposal-error-cause
+        super(message, {
+            cause
+        });
+        this.code = opts.code;
+        this.name = 'TRPCError';
+        if (!this.cause) {
+            // < ES2022 / < Node 16.9.0 compatability
+            this.cause = cause;
+        }
+    }
+}
+
+export { TRPCError as T, getTRPCErrorFromUnknown as g };

package/.output/server/node_modules/@trpc/server/dist/batchStreamFormatter-fc1ffb26.mjs

@@ -0,0 +1,30 @@
+/**
+ * Format a batch response as a line-delimited JSON stream
+ * that the `unstable_httpBatchStreamLink` can parse:
+ *
+ * @example
+ * ```ts
+ * const formatter = getBatchStreamFormatter();
+ * res.send(formatter(1, 'response #2'));
+ * res.send(formatter(0, 'response #1'));
+ * res.send(formatter.end());
+ * ```
+ *
+ * Expected format:
+ * ```json
+ * {"1":"response #2"
+ * ,"0":"response #1"
+ * }
+ * ```
+ */ function getBatchStreamFormatter() {
+    let first = true;
+    function format(index, string) {
+        const prefix = first ? '{' : ',';
+        first = false;
+        return `${prefix}"${index}":${string}\n`;
+    }
+    format.end = ()=>'}';
+    return format;
+}
+
+export { getBatchStreamFormatter as g };

package/.output/server/node_modules/@trpc/server/dist/codes-c924c3db.mjs

@@ -0,0 +1,44 @@
+/**
+ * @internal
+ */ function invert(obj) {
+    const newObj = Object.create(null);
+    for(const key in obj){
+        const v = obj[key];
+        newObj[v] = key;
+    }
+    return newObj;
+}
+
+// reference: https://www.jsonrpc.org/specification
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */ const TRPC_ERROR_CODES_BY_KEY = {
+    /**
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */ PARSE_ERROR: -32700,
+    /**
+   * The JSON sent is not a valid Request object.
+   */ BAD_REQUEST: -32600,
+    // Internal JSON-RPC error
+    INTERNAL_SERVER_ERROR: -32603,
+    NOT_IMPLEMENTED: -32603,
+    // Implementation specific errors
+    UNAUTHORIZED: -32001,
+    FORBIDDEN: -32003,
+    NOT_FOUND: -32004,
+    METHOD_NOT_SUPPORTED: -32005,
+    TIMEOUT: -32008,
+    CONFLICT: -32009,
+    PRECONDITION_FAILED: -32012,
+    PAYLOAD_TOO_LARGE: -32013,
+    UNPROCESSABLE_CONTENT: -32022,
+    TOO_MANY_REQUESTS: -32029,
+    CLIENT_CLOSED_REQUEST: -32099
+};
+const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
+
+export { TRPC_ERROR_CODES_BY_KEY as T, TRPC_ERROR_CODES_BY_NUMBER as a, invert as i };