@highstate/designer 0.1.0

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

@@ -0,0 +1,147 @@
+export { i as isObservable, o as observable } from '../observable-ade1bad8.mjs';
+
+function share(_opts) {
+    return (originalObserver)=>{
+        let refCount = 0;
+        let subscription = null;
+        const observers = [];
+        function startIfNeeded() {
+            if (subscription) {
+                return;
+            }
+            subscription = originalObserver.subscribe({
+                next (value) {
+                    for (const observer of observers){
+                        observer.next?.(value);
+                    }
+                },
+                error (error) {
+                    for (const observer of observers){
+                        observer.error?.(error);
+                    }
+                },
+                complete () {
+                    for (const observer of observers){
+                        observer.complete?.();
+                    }
+                }
+            });
+        }
+        function resetIfNeeded() {
+            // "resetOnRefCountZero"
+            if (refCount === 0 && subscription) {
+                const _sub = subscription;
+                subscription = null;
+                _sub.unsubscribe();
+            }
+        }
+        return {
+            subscribe (observer) {
+                refCount++;
+                observers.push(observer);
+                startIfNeeded();
+                return {
+                    unsubscribe () {
+                        refCount--;
+                        resetIfNeeded();
+                        const index = observers.findIndex((v)=>v === observer);
+                        if (index > -1) {
+                            observers.splice(index, 1);
+                        }
+                    }
+                };
+            }
+        };
+    };
+}
+
+function map(project) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer) {
+                let index = 0;
+                const subscription = originalObserver.subscribe({
+                    next (value) {
+                        observer.next?.(project(value, index++));
+                    },
+                    error (error) {
+                        observer.error?.(error);
+                    },
+                    complete () {
+                        observer.complete?.();
+                    }
+                });
+                return subscription;
+            }
+        };
+    };
+}
+
+function tap(observer) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer2) {
+                return originalObserver.subscribe({
+                    next (v) {
+                        observer.next?.(v);
+                        observer2.next?.(v);
+                    },
+                    error (v) {
+                        observer.error?.(v);
+                        observer2.error?.(v);
+                    },
+                    complete () {
+                        observer.complete?.();
+                        observer2.complete?.();
+                    }
+                });
+            }
+        };
+    };
+}
+
+class ObservableAbortError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'ObservableAbortError';
+        Object.setPrototypeOf(this, ObservableAbortError.prototype);
+    }
+}
+/** @internal */ function observableToPromise(observable) {
+    let abort;
+    const promise = new Promise((resolve, reject)=>{
+        let isDone = false;
+        function onDone() {
+            if (isDone) {
+                return;
+            }
+            isDone = true;
+            reject(new ObservableAbortError('This operation was aborted.'));
+            obs$.unsubscribe();
+        }
+        const obs$ = observable.subscribe({
+            next (data) {
+                isDone = true;
+                resolve(data);
+                onDone();
+            },
+            error (data) {
+                isDone = true;
+                reject(data);
+                onDone();
+            },
+            complete () {
+                isDone = true;
+                onDone();
+            }
+        });
+        abort = onDone;
+    });
+    return {
+        promise,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        abort: abort
+    };
+}
+
+export { map, observableToPromise, share, tap };

package/.output/server/node_modules/@trpc/server/dist/observable-ade1bad8.mjs

@@ -0,0 +1,81 @@
+function identity(x) {
+    return x;
+}
+
+/** @internal */ function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce((prev, fn)=>fn(prev), input);
+    };
+}
+
+function isObservable(x) {
+    return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+function observable(subscribe) {
+    const self = {
+        subscribe (observer) {
+            let teardownRef = null;
+            let isDone = false;
+            let unsubscribed = false;
+            let teardownImmediately = false;
+            function unsubscribe() {
+                if (teardownRef === null) {
+                    teardownImmediately = true;
+                    return;
+                }
+                if (unsubscribed) {
+                    return;
+                }
+                unsubscribed = true;
+                if (typeof teardownRef === 'function') {
+                    teardownRef();
+                } else if (teardownRef) {
+                    teardownRef.unsubscribe();
+                }
+            }
+            teardownRef = subscribe({
+                next (value) {
+                    if (isDone) {
+                        return;
+                    }
+                    observer.next?.(value);
+                },
+                error (err) {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.error?.(err);
+                    unsubscribe();
+                },
+                complete () {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.complete?.();
+                    unsubscribe();
+                }
+            });
+            if (teardownImmediately) {
+                unsubscribe();
+            }
+            return {
+                unsubscribe
+            };
+        },
+        pipe (...operations) {
+            return pipeFromArray(operations)(self);
+        }
+    };
+    return self;
+}
+
+export { isObservable as i, observable as o };

package/.output/server/node_modules/@trpc/server/dist/resolveHTTPResponse-2fc435bb.mjs

@@ -0,0 +1,291 @@
+import { e as callProcedure } from './config-d5fdbd39.mjs';
+import { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-98d44758.mjs';
+import { t as transformTRPCResponse, g as getErrorShape } from './transformTRPCResponse-1153b421.mjs';
+import { g as getJsonContentTypeInputs } from './contentType-9fd995d3.mjs';
+import { b as getHTTPStatusCode } from './index-f91d720c.mjs';
+
+const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
+    GET: 'query',
+    POST: 'mutation'
+};
+const fallbackContentTypeHandler = {
+    getInputs: getJsonContentTypeInputs
+};
+function initResponse(initOpts) {
+    const { ctx , paths , type , responseMeta , untransformedJSON , errors =[] ,  } = initOpts;
+    let status = untransformedJSON ? getHTTPStatusCode(untransformedJSON) : 200;
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    const eagerGeneration = !untransformedJSON;
+    const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
+        untransformedJSON
+    ];
+    const meta = responseMeta?.({
+        ctx,
+        paths,
+        type,
+        data,
+        errors,
+        eagerGeneration
+    }) ?? {};
+    for (const [key, value] of Object.entries(meta.headers ?? {})){
+        headers[key] = value;
+    }
+    if (meta.status) {
+        status = meta.status;
+    }
+    return {
+        status,
+        headers
+    };
+}
+async function inputToProcedureCall(procedureOpts) {
+    const { opts , ctx , type , input , path  } = procedureOpts;
+    try {
+        const data = await callProcedure({
+            procedures: opts.router._def.procedures,
+            path,
+            rawInput: input,
+            ctx,
+            type
+        });
+        return {
+            result: {
+                data
+            }
+        };
+    } catch (cause) {
+        const error = getTRPCErrorFromUnknown(cause);
+        opts.onError?.({
+            error,
+            path,
+            input,
+            ctx,
+            type: type,
+            req: opts.req
+        });
+        return {
+            error: getErrorShape({
+                config: opts.router._def._config,
+                error,
+                type,
+                path,
+                input,
+                ctx
+            })
+        };
+    }
+}
+function caughtErrorToData(cause, errorOpts) {
+    const { router , req , onError  } = errorOpts.opts;
+    const error = getTRPCErrorFromUnknown(cause);
+    onError?.({
+        error,
+        path: errorOpts.path,
+        input: errorOpts.input,
+        ctx: errorOpts.ctx,
+        type: errorOpts.type,
+        req
+    });
+    const untransformedJSON = {
+        error: getErrorShape({
+            config: router._def._config,
+            error,
+            type: errorOpts.type,
+            path: errorOpts.path,
+            input: errorOpts.input,
+            ctx: errorOpts.ctx
+        })
+    };
+    const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
+    const body = JSON.stringify(transformedJSON);
+    return {
+        error,
+        untransformedJSON,
+        body
+    };
+}
+// implementation
+async function resolveHTTPResponse(opts) {
+    const { router , req , unstable_onHead , unstable_onChunk  } = opts;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        const headResponse = {
+            status: 204
+        };
+        unstable_onHead?.(headResponse, false);
+        unstable_onChunk?.([
+            -1,
+            ''
+        ]);
+        return headResponse;
+    }
+    const contentTypeHandler = opts.contentTypeHandler ?? fallbackContentTypeHandler;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
+    let ctx = undefined;
+    let paths;
+    const isBatchCall = !!req.query.get('batch');
+    const isStreamCall = isBatchCall && unstable_onHead && unstable_onChunk && req.headers['trpc-batch-mode'] === 'stream';
+    try {
+        // we create context first so that (unless `createContext()` throws)
+        // error handler may access context information
+        //
+        // this way even if the client sends malformed input that might cause an exception:
+        //  - `opts.error` has value,
+        //  - batching is not enabled,
+        //  - `type` is unknown,
+        //  - `getInputs` throws because of malformed JSON,
+        // context value is still available to the error handler
+        ctx = await opts.createContext();
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (isBatchCall && !batchingEnabled) {
+            throw new Error(`Batching is not enabled on the server`);
+        }
+        /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
+            throw new TRPCError({
+                message: 'Subscriptions should use wsLink',
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        if (type === 'unknown') {
+            throw new TRPCError({
+                message: `Unexpected request method ${req.method}`,
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        const inputs = await contentTypeHandler.getInputs({
+            isBatchCall,
+            req,
+            router,
+            preprocessedBody: opts.preprocessedBody ?? false
+        });
+        paths = isBatchCall ? decodeURIComponent(opts.path).split(',') : [
+            opts.path
+        ];
+        const promises = paths.map((path, index)=>inputToProcedureCall({
+                opts,
+                ctx,
+                type,
+                input: inputs[index],
+                path
+            }));
+        if (!isStreamCall) {
+            /**
+       * Non-streaming response:
+       * - await all responses in parallel, blocking on the slowest one
+       * - create headers with known response body
+       * - return a complete HTTPResponse
+       */ const untransformedJSON = await Promise.all(promises);
+            const errors = untransformedJSON.flatMap((response)=>'error' in response ? [
+                    response.error
+                ] : []);
+            const headResponse1 = initResponse({
+                ctx,
+                paths,
+                type,
+                responseMeta: opts.responseMeta,
+                untransformedJSON,
+                errors
+            });
+            unstable_onHead?.(headResponse1, false);
+            // return body stuff
+            const result = isBatchCall ? untransformedJSON : untransformedJSON[0]; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- `untransformedJSON` should be the length of `paths` which should be at least 1 otherwise there wouldn't be a request at all
+            const transformedJSON = transformTRPCResponse(router._def._config, result);
+            const body = JSON.stringify(transformedJSON);
+            unstable_onChunk?.([
+                -1,
+                body
+            ]);
+            return {
+                status: headResponse1.status,
+                headers: headResponse1.headers,
+                body
+            };
+        }
+        /**
+     * Streaming response:
+     * - block on none, call `onChunk` as soon as each response is ready
+     * - create headers with minimal data (cannot know the response body in advance)
+     * - return void
+     */ const headResponse2 = initResponse({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta
+        });
+        unstable_onHead(headResponse2, true);
+        const indexedPromises = new Map(promises.map((promise, index)=>[
+                index,
+                promise.then((r)=>[
+                        index,
+                        r
+                    ])
+            ]));
+        for (const _ of paths){
+            const [index, untransformedJSON1] = await Promise.race(indexedPromises.values());
+            indexedPromises.delete(index);
+            try {
+                const transformedJSON1 = transformTRPCResponse(router._def._config, untransformedJSON1);
+                const body1 = JSON.stringify(transformedJSON1);
+                unstable_onChunk([
+                    index,
+                    body1
+                ]);
+            } catch (cause) {
+                const path = paths[index];
+                const input = inputs[index];
+                const { body: body2  } = caughtErrorToData(cause, {
+                    opts,
+                    ctx,
+                    type,
+                    path,
+                    input
+                });
+                unstable_onChunk([
+                    index,
+                    body2
+                ]);
+            }
+        }
+        return;
+    } catch (cause1) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - `router._def._config.transformer.output.serialize()` throws
+        // - post body is too large
+        // - input deserialization fails
+        // - `errorFormatter` return value is malformed
+        const { error , untransformedJSON: untransformedJSON2 , body: body3  } = caughtErrorToData(cause1, {
+            opts,
+            ctx,
+            type
+        });
+        const headResponse3 = initResponse({
+            ctx,
+            paths,
+            type,
+            responseMeta: opts.responseMeta,
+            untransformedJSON: untransformedJSON2,
+            errors: [
+                error
+            ]
+        });
+        unstable_onHead?.(headResponse3, false);
+        unstable_onChunk?.([
+            -1,
+            body3
+        ]);
+        return {
+            status: headResponse3.status,
+            headers: headResponse3.headers,
+            body: body3
+        };
+    }
+}
+
+export { resolveHTTPResponse as r };

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

@@ -0,0 +1,4 @@
+export { c as createFlatProxy, a as createRecursiveProxy } from '../index-f91d720c.mjs';
+export { g as getErrorShape, t as transformTRPCResponse } from '../transformTRPCResponse-1153b421.mjs';
+export { g as getCauseFromUnknown } from '../getCauseFromUnknown-2d66414a.mjs';
+import '../codes-c924c3db.mjs';

package/.output/server/node_modules/@trpc/server/dist/transformTRPCResponse-1153b421.mjs

@@ -0,0 +1,53 @@
+import { g as getHTTPStatusCodeFromError } from './index-f91d720c.mjs';
+import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-c924c3db.mjs';
+
+/**
+ * @internal
+ */ function getErrorShape(opts) {
+    const { path , error , config  } = opts;
+    const { code  } = opts.error;
+    const shape = {
+        message: error.message,
+        code: TRPC_ERROR_CODES_BY_KEY[code],
+        data: {
+            code,
+            httpStatus: getHTTPStatusCodeFromError(error)
+        }
+    };
+    if (config.isDev && typeof opts.error.stack === 'string') {
+        shape.data.stack = opts.error.stack;
+    }
+    if (typeof path === 'string') {
+        shape.data.path = path;
+    }
+    return config.errorFormatter({
+        ...opts,
+        shape
+    });
+}
+
+function transformTRPCResponseItem(config, item) {
+    if ('error' in item) {
+        return {
+            ...item,
+            error: config.transformer.output.serialize(item.error)
+        };
+    }
+    if ('data' in item.result) {
+        return {
+            ...item,
+            result: {
+                ...item.result,
+                data: config.transformer.output.serialize(item.result.data)
+            }
+        };
+    }
+    return item;
+}
+/**
+ * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+ **/ function transformTRPCResponse(config, itemOrItems) {
+    return Array.isArray(itemOrItems) ? itemOrItems.map((item)=>transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
+}
+
+export { getErrorShape as g, transformTRPCResponse as t };