@highstate/designer 0.1.0

package/.output/server/node_modules/@trpc/client/dist/index.mjs

@@ -0,0 +1,365 @@
+import { share, observableToPromise } from '@trpc/server/observable';
+import { c as createChain } from './splitLink-4c75f7be.mjs';
+export { s as splitLink } from './splitLink-4c75f7be.mjs';
+import { T as TRPCClientError } from './TRPCClientError-38f9a32a.mjs';
+export { T as TRPCClientError } from './TRPCClientError-38f9a32a.mjs';
+import { createFlatProxy, createRecursiveProxy } from '@trpc/server/shared';
+import { f as fetchHTTPResponse, g as getUrl, a as getBody$1, h as httpRequest } from './httpUtils-b9d0cb48.mjs';
+export { b as getFetch } from './httpUtils-b9d0cb48.mjs';
+import { c as createHTTPBatchLink } from './httpBatchLink-d0f9eac9.mjs';
+export { h as httpBatchLink } from './httpBatchLink-d0f9eac9.mjs';
+import { httpLinkFactory } from './links/httpLink.mjs';
+export { httpLink, httpLinkFactory } from './links/httpLink.mjs';
+export { loggerLink } from './links/loggerLink.mjs';
+export { createWSClient, wsLink } from './links/wsLink.mjs';
+import './transformResult-ace864b8.mjs';
+
+class TRPCUntypedClient {
+    $request({ type , input , path , context ={}  }) {
+        const chain$ = createChain({
+            links: this.links,
+            op: {
+                id: ++this.requestId,
+                type,
+                path,
+                input,
+                context
+            }
+        });
+        return chain$.pipe(share());
+    }
+    requestAsPromise(opts) {
+        const req$ = this.$request(opts);
+        const { promise , abort  } = observableToPromise(req$);
+        const abortablePromise = new Promise((resolve, reject)=>{
+            opts.signal?.addEventListener('abort', abort);
+            promise.then((envelope)=>{
+                resolve(envelope.result.data);
+            }).catch((err)=>{
+                reject(TRPCClientError.from(err));
+            });
+        });
+        return abortablePromise;
+    }
+    query(path, input, opts) {
+        return this.requestAsPromise({
+            type: 'query',
+            path,
+            input,
+            context: opts?.context,
+            signal: opts?.signal
+        });
+    }
+    mutation(path, input, opts) {
+        return this.requestAsPromise({
+            type: 'mutation',
+            path,
+            input,
+            context: opts?.context,
+            signal: opts?.signal
+        });
+    }
+    subscription(path, input, opts) {
+        const observable$ = this.$request({
+            type: 'subscription',
+            path,
+            input,
+            context: opts?.context
+        });
+        return observable$.subscribe({
+            next (envelope) {
+                if (envelope.result.type === 'started') {
+                    opts.onStarted?.();
+                } else if (envelope.result.type === 'stopped') {
+                    opts.onStopped?.();
+                } else {
+                    opts.onData?.(envelope.result.data);
+                }
+            },
+            error (err) {
+                opts.onError?.(err);
+            },
+            complete () {
+                opts.onComplete?.();
+            }
+        });
+    }
+    constructor(opts){
+        this.requestId = 0;
+        const combinedTransformer = (()=>{
+            const transformer = opts.transformer;
+            if (!transformer) {
+                return {
+                    input: {
+                        serialize: (data)=>data,
+                        deserialize: (data)=>data
+                    },
+                    output: {
+                        serialize: (data)=>data,
+                        deserialize: (data)=>data
+                    }
+                };
+            }
+            if ('input' in transformer) {
+                return opts.transformer;
+            }
+            return {
+                input: transformer,
+                output: transformer
+            };
+        })();
+        this.runtime = {
+            transformer: {
+                serialize: (data)=>combinedTransformer.input.serialize(data),
+                deserialize: (data)=>combinedTransformer.output.deserialize(data)
+            },
+            combinedTransformer
+        };
+        // Initialize the links
+        this.links = opts.links.map((link)=>link(this.runtime));
+    }
+}
+
+function createTRPCUntypedClient(opts) {
+    return new TRPCUntypedClient(opts);
+}
+
+/**
+ * @deprecated use `createTRPCProxyClient` instead
+ */ function createTRPCClient(opts) {
+    const client = new TRPCUntypedClient(opts);
+    return client;
+}
+
+const clientCallTypeMap = {
+    query: 'query',
+    mutate: 'mutation',
+    subscribe: 'subscription'
+};
+/** @internal */ const clientCallTypeToProcedureType = (clientCallType)=>{
+    return clientCallTypeMap[clientCallType];
+};
+/**
+ * @deprecated use `createTRPCProxyClient` instead
+ * @internal
+ */ function createTRPCClientProxy(client) {
+    return createFlatProxy((key)=>{
+        if (client.hasOwnProperty(key)) {
+            return client[key];
+        }
+        if (key === '__untypedClient') {
+            return client;
+        }
+        return createRecursiveProxy(({ path , args  })=>{
+            const pathCopy = [
+                key,
+                ...path
+            ];
+            const procedureType = clientCallTypeToProcedureType(pathCopy.pop());
+            const fullPath = pathCopy.join('.');
+            return client[procedureType](fullPath, ...args);
+        });
+    });
+}
+function createTRPCProxyClient(opts) {
+    const client = new TRPCUntypedClient(opts);
+    const proxy = createTRPCClientProxy(client);
+    return proxy;
+}
+/**
+ * Get an untyped client from a proxy client
+ * @internal
+ */ function getUntypedClient(client) {
+    return client.__untypedClient;
+}
+
+function getTextDecoder(customTextDecoder) {
+    if (customTextDecoder) {
+        return customTextDecoder;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (typeof window !== 'undefined' && window.TextDecoder) {
+        return new window.TextDecoder();
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (typeof globalThis !== 'undefined' && globalThis.TextDecoder) {
+        return new globalThis.TextDecoder();
+    }
+    throw new Error('No TextDecoder implementation found');
+}
+
+// Stream parsing adapted from https://www.loginradius.com/blog/engineering/guest-post/http-streaming-with-nodejs-and-fetch-api/
+/**
+ * @internal
+ * @description Take a stream of bytes and call `onLine` with
+ * a JSON object for each line in the stream. Expected stream
+ * format is:
+ * ```json
+ * {"1": {...}
+ * ,"0": {...}
+ * }
+ * ```
+ */ async function parseJSONStream(opts) {
+    const parse = opts.parse ?? JSON.parse;
+    const onLine = (line)=>{
+        if (opts.signal?.aborted) return;
+        if (!line || line === '}') {
+            return;
+        }
+        /**
+     * At this point, `line` can be one of two things:
+     * - The first line of the stream `{"2":{...}`
+     * - A line in the middle of the stream `,"2":{...}`
+     */ const indexOfColon = line.indexOf(':');
+        const indexAsStr = line.substring(2, indexOfColon - 1);
+        const text = line.substring(indexOfColon + 1);
+        opts.onSingle(Number(indexAsStr), parse(text));
+    };
+    await readLines(opts.readableStream, onLine, opts.textDecoder);
+}
+/**
+ * Handle transforming a stream of bytes into lines of text.
+ * To avoid using AsyncIterators / AsyncGenerators,
+ * we use a callback for each line.
+ *
+ * @param readableStream can be a NodeJS stream or a WebAPI stream
+ * @param onLine will be called for every line ('\n' delimited) in the stream
+ */ async function readLines(readableStream, onLine, textDecoder) {
+    let partOfLine = '';
+    const onChunk = (chunk)=>{
+        const chunkText = textDecoder.decode(chunk);
+        const chunkLines = chunkText.split('\n');
+        if (chunkLines.length === 1) {
+            partOfLine += chunkLines[0];
+        } else if (chunkLines.length > 1) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length checked on line above
+            onLine(partOfLine + chunkLines[0]);
+            for(let i = 1; i < chunkLines.length - 1; i++){
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length checked on line above
+                onLine(chunkLines[i]);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length doesn't change, so is necessarily > 1
+            partOfLine = chunkLines[chunkLines.length - 1];
+        }
+    };
+    // we handle 2 different types of streams, this if where we figure out which one we have
+    if ('getReader' in readableStream) {
+        await readStandardChunks(readableStream, onChunk);
+    } else {
+        await readNodeChunks(readableStream, onChunk);
+    }
+    onLine(partOfLine);
+}
+/**
+ * Handle NodeJS stream
+ */ function readNodeChunks(stream, onChunk) {
+    return new Promise((resolve)=>{
+        stream.on('data', onChunk);
+        stream.on('end', resolve);
+    });
+}
+/**
+ * Handle WebAPI stream
+ */ async function readStandardChunks(stream, onChunk) {
+    const reader = stream.getReader();
+    let readResult = await reader.read();
+    while(!readResult.done){
+        onChunk(readResult.value);
+        readResult = await reader.read();
+    }
+}
+const streamingJsonHttpRequester = (opts, onSingle)=>{
+    const ac = opts.AbortController ? new opts.AbortController() : null;
+    const responsePromise = fetchHTTPResponse({
+        ...opts,
+        contentTypeHeader: 'application/json',
+        batchModeHeader: 'stream',
+        getUrl,
+        getBody: getBody$1
+    }, ac);
+    const cancel = ()=>ac?.abort();
+    const promise = responsePromise.then(async (res)=>{
+        if (!res.body) throw new Error('Received response without body');
+        const meta = {
+            response: res
+        };
+        return parseJSONStream({
+            readableStream: res.body,
+            onSingle,
+            parse: (string)=>({
+                    json: JSON.parse(string),
+                    meta
+                }),
+            signal: ac?.signal,
+            textDecoder: opts.textDecoder
+        });
+    });
+    return {
+        cancel,
+        promise
+    };
+};
+
+const streamRequester = (requesterOpts)=>{
+    const textDecoder = getTextDecoder(requesterOpts.opts.textDecoder);
+    return (batchOps, unitResolver)=>{
+        const path = batchOps.map((op)=>op.path).join(',');
+        const inputs = batchOps.map((op)=>op.input);
+        const { cancel , promise  } = streamingJsonHttpRequester({
+            ...requesterOpts,
+            textDecoder,
+            path,
+            inputs,
+            headers () {
+                if (!requesterOpts.opts.headers) {
+                    return {};
+                }
+                if (typeof requesterOpts.opts.headers === 'function') {
+                    return requesterOpts.opts.headers({
+                        opList: batchOps
+                    });
+                }
+                return requesterOpts.opts.headers;
+            }
+        }, (index, res)=>{
+            unitResolver(index, res);
+        });
+        return {
+            /**
+       * return an empty array because the batchLoader expects an array of results
+       * but we've already called the `unitResolver` for each of them, there's
+       * nothing left to do here.
+       */ promise: promise.then(()=>[]),
+            cancel
+        };
+    };
+};
+const unstable_httpBatchStreamLink = createHTTPBatchLink(streamRequester);
+
+const getBody = (opts)=>{
+    if (!('input' in opts)) {
+        return undefined;
+    }
+    if (!(opts.input instanceof FormData)) {
+        throw new Error('Input is not FormData');
+    }
+    return opts.input;
+};
+const formDataRequester = (opts)=>{
+    if (opts.type !== 'mutation') {
+        // TODO(?) handle formdata queries
+        throw new Error('We only handle mutations with formdata');
+    }
+    return httpRequest({
+        ...opts,
+        getUrl () {
+            return `${opts.url}/${opts.path}`;
+        },
+        getBody
+    });
+};
+const experimental_formDataLink = httpLinkFactory({
+    requester: formDataRequester
+});
+
+export { TRPCUntypedClient, clientCallTypeToProcedureType, createTRPCClient, createTRPCClientProxy, createTRPCProxyClient, createTRPCUntypedClient, experimental_formDataLink, getUntypedClient, unstable_httpBatchStreamLink };

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

@@ -0,0 +1,62 @@
+import { observable } from '@trpc/server/observable';
+import { t as transformResult } from '../transformResult-ace864b8.mjs';
+import { T as TRPCClientError } from '../TRPCClientError-38f9a32a.mjs';
+import { r as resolveHTTPLinkOptions, j as jsonHttpRequester } from '../httpUtils-b9d0cb48.mjs';
+import '@trpc/server/shared';
+
+function httpLinkFactory(factoryOpts) {
+    return (opts)=>{
+        const resolvedOpts = resolveHTTPLinkOptions(opts);
+        return (runtime)=>({ op  })=>observable((observer)=>{
+                    const { path , input , type  } = op;
+                    const { promise , cancel  } = factoryOpts.requester({
+                        ...resolvedOpts,
+                        runtime,
+                        type,
+                        path,
+                        input,
+                        headers () {
+                            if (!opts.headers) {
+                                return {};
+                            }
+                            if (typeof opts.headers === 'function') {
+                                return opts.headers({
+                                    op
+                                });
+                            }
+                            return opts.headers;
+                        }
+                    });
+                    let meta = undefined;
+                    promise.then((res)=>{
+                        meta = res.meta;
+                        const transformed = transformResult(res.json, runtime);
+                        if (!transformed.ok) {
+                            observer.error(TRPCClientError.from(transformed.error, {
+                                meta
+                            }));
+                            return;
+                        }
+                        observer.next({
+                            context: res.meta,
+                            result: transformed.result
+                        });
+                        observer.complete();
+                    }).catch((cause)=>{
+                        observer.error(TRPCClientError.from(cause, {
+                            meta
+                        }));
+                    });
+                    return ()=>{
+                        cancel();
+                    };
+                });
+    };
+}
+/**
+ * @see https://trpc.io/docs/client/links/httpLink
+ */ const httpLink = httpLinkFactory({
+    requester: jsonHttpRequester
+});
+
+export { httpLink, httpLinkFactory };

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

@@ -0,0 +1,173 @@
+import { observable, tap } from '@trpc/server/observable';
+
+/// <reference lib="dom.iterable" />
+function isFormData(value) {
+    if (typeof FormData === 'undefined') {
+        // FormData is not supported
+        return false;
+    }
+    return value instanceof FormData;
+}
+const palettes = {
+    css: {
+        query: [
+            '72e3ff',
+            '3fb0d8'
+        ],
+        mutation: [
+            'c5a3fc',
+            '904dfc'
+        ],
+        subscription: [
+            'ff49e1',
+            'd83fbe'
+        ]
+    },
+    ansi: {
+        regular: {
+            // Cyan background, black and white text respectively
+            query: [
+                '\x1b[30;46m',
+                '\x1b[97;46m'
+            ],
+            // Magenta background, black and white text respectively
+            mutation: [
+                '\x1b[30;45m',
+                '\x1b[97;45m'
+            ],
+            // Green background, black and white text respectively
+            subscription: [
+                '\x1b[30;42m',
+                '\x1b[97;42m'
+            ]
+        },
+        bold: {
+            query: [
+                '\x1b[1;30;46m',
+                '\x1b[1;97;46m'
+            ],
+            mutation: [
+                '\x1b[1;30;45m',
+                '\x1b[1;97;45m'
+            ],
+            subscription: [
+                '\x1b[1;30;42m',
+                '\x1b[1;97;42m'
+            ]
+        }
+    }
+};
+function constructPartsAndArgs(opts) {
+    const { direction , type , path , id , input  } = opts;
+    const parts = [];
+    const args = [];
+    if (opts.colorMode === 'ansi') {
+        const [lightRegular, darkRegular] = palettes.ansi.regular[type];
+        const [lightBold, darkBold] = palettes.ansi.bold[type];
+        const reset = '\x1b[0m';
+        parts.push(direction === 'up' ? lightRegular : darkRegular, direction === 'up' ? '>>' : '<<', type, direction === 'up' ? lightBold : darkBold, `#${id}`, path, reset);
+        if (direction === 'up') {
+            args.push({
+                input: opts.input
+            });
+        } else {
+            args.push({
+                input: opts.input,
+                // strip context from result cause it's too noisy in terminal wihtout collapse mode
+                result: 'result' in opts.result ? opts.result.result : opts.result,
+                elapsedMs: opts.elapsedMs
+            });
+        }
+        return {
+            parts,
+            args
+        };
+    }
+    const [light, dark] = palettes.css[type];
+    const css = `
+    background-color: #${direction === 'up' ? light : dark}; 
+    color: ${direction === 'up' ? 'black' : 'white'};
+    padding: 2px;
+  `;
+    parts.push('%c', direction === 'up' ? '>>' : '<<', type, `#${id}`, `%c${path}%c`, '%O');
+    args.push(css, `${css}; font-weight: bold;`, `${css}; font-weight: normal;`);
+    if (direction === 'up') {
+        args.push({
+            input,
+            context: opts.context
+        });
+    } else {
+        args.push({
+            input,
+            result: opts.result,
+            elapsedMs: opts.elapsedMs,
+            context: opts.context
+        });
+    }
+    return {
+        parts,
+        args
+    };
+}
+// maybe this should be moved to it's own package
+const defaultLogger = ({ c =console , colorMode ='css'  })=>(props)=>{
+        const rawInput = props.input;
+        const input = isFormData(rawInput) ? Object.fromEntries(rawInput) : rawInput;
+        const { parts , args  } = constructPartsAndArgs({
+            ...props,
+            colorMode,
+            input
+        });
+        const fn = props.direction === 'down' && props.result && (props.result instanceof Error || 'error' in props.result.result) ? 'error' : 'log';
+        c[fn].apply(null, [
+            parts.join(' ')
+        ].concat(args));
+    };
+/**
+ * @see https://trpc.io/docs/client/links/loggerLink
+ */ function loggerLink(opts = {}) {
+    const { enabled =()=>true  } = opts;
+    const colorMode = opts.colorMode ?? (typeof window === 'undefined' ? 'ansi' : 'css');
+    const { logger =defaultLogger({
+        c: opts.console,
+        colorMode
+    })  } = opts;
+    return ()=>{
+        return ({ op , next  })=>{
+            return observable((observer)=>{
+                // ->
+                enabled({
+                    ...op,
+                    direction: 'up'
+                }) && logger({
+                    ...op,
+                    direction: 'up'
+                });
+                const requestStartTime = Date.now();
+                function logResult(result) {
+                    const elapsedMs = Date.now() - requestStartTime;
+                    enabled({
+                        ...op,
+                        direction: 'down',
+                        result
+                    }) && logger({
+                        ...op,
+                        direction: 'down',
+                        elapsedMs,
+                        result
+                    });
+                }
+                return next(op).pipe(tap({
+                    next (result) {
+                        logResult(result);
+                    },
+                    error (result) {
+                        logResult(result);
+                    }
+                })).subscribe(observer);
+            });
+        };
+    };
+}
+
+export { loggerLink };