@highstate/designer 0.1.0 → 0.2.0

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

@@ -1,278 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,101 +0,0 @@
-{
-  "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

@@ -1,39 +0,0 @@
-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

@@ -1,30 +0,0 @@
-/**
- * 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

@@ -1,44 +0,0 @@
-/**
- * @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 };