@highstate/designer 0.9.5 → 0.9.6

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/middleware.mjs

@@ -0,0 +1,90 @@
+import { TRPCError } from './error/TRPCError.mjs';
+import { isObject } from './utils.mjs';
+
+/** @internal */ const middlewareMarker = 'middlewareMarker';
+/**
+ * @internal
+ */ function createMiddlewareFactory() {
+    function createMiddlewareInner(middlewares) {
+        return {
+            _middlewares: middlewares,
+            unstable_pipe (middlewareBuilderOrFn) {
+                const pipedMiddleware = '_middlewares' in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [
+                    middlewareBuilderOrFn
+                ];
+                return createMiddlewareInner([
+                    ...middlewares,
+                    ...pipedMiddleware
+                ]);
+            }
+        };
+    }
+    function createMiddleware(fn) {
+        return createMiddlewareInner([
+            fn
+        ]);
+    }
+    return createMiddleware;
+}
+/**
+ * Create a standalone middleware
+ * @see https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
+ * @deprecated use `.concat()` instead
+ */ const experimental_standaloneMiddleware = ()=>({
+        create: createMiddlewareFactory()
+    });
+/**
+ * @internal
+ * Please note, `trpc-openapi` uses this function.
+ */ function createInputMiddleware(parse) {
+    const inputMiddleware = async function inputValidatorMiddleware(opts) {
+        let parsedInput;
+        const rawInput = await opts.getRawInput();
+        try {
+            parsedInput = await parse(rawInput);
+        } catch (cause) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                cause
+            });
+        }
+        // Multiple input parsers
+        const combinedInput = isObject(opts.input) && isObject(parsedInput) ? {
+            ...opts.input,
+            ...parsedInput
+        } : parsedInput;
+        return opts.next({
+            input: combinedInput
+        });
+    };
+    inputMiddleware._type = 'input';
+    return inputMiddleware;
+}
+/**
+ * @internal
+ */ function createOutputMiddleware(parse) {
+    const outputMiddleware = async function outputValidatorMiddleware({ next }) {
+        const result = await next();
+        if (!result.ok) {
+            // pass through failures without validating
+            return result;
+        }
+        try {
+            const data = await parse(result.data);
+            return {
+                ...result,
+                data
+            };
+        } catch (cause) {
+            throw new TRPCError({
+                message: 'Output validation failed',
+                code: 'INTERNAL_SERVER_ERROR',
+                cause
+            });
+        }
+    };
+    outputMiddleware._type = 'output';
+    return outputMiddleware;
+}
+
+export { createInputMiddleware, createMiddlewareFactory, createOutputMiddleware, experimental_standaloneMiddleware, middlewareMarker };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/parser.mjs

@@ -0,0 +1,52 @@
+import { StandardSchemaV1Error } from '../vendor/standard-schema-v1/error.mjs';
+
+function getParseFn(procedureParser) {
+    const parser = procedureParser;
+    const isStandardSchema = '~standard' in parser;
+    if (typeof parser === 'function' && typeof parser.assert === 'function') {
+        // ParserArkTypeEsque - arktype schemas shouldn't be called as a function because they return a union type instead of throwing
+        return parser.assert.bind(parser);
+    }
+    if (typeof parser === 'function' && !isStandardSchema) {
+        // ParserValibotEsque (>= v0.31.0)
+        // ParserCustomValidatorEsque - note the check for standard-schema conformance - some libraries like `effect` use function schemas which are *not* a "parse" function.
+        return parser;
+    }
+    if (typeof parser.parseAsync === 'function') {
+        // ParserZodEsque
+        return parser.parseAsync.bind(parser);
+    }
+    if (typeof parser.parse === 'function') {
+        // ParserZodEsque
+        // ParserValibotEsque (< v0.13.0)
+        return parser.parse.bind(parser);
+    }
+    if (typeof parser.validateSync === 'function') {
+        // ParserYupEsque
+        return parser.validateSync.bind(parser);
+    }
+    if (typeof parser.create === 'function') {
+        // ParserSuperstructEsque
+        return parser.create.bind(parser);
+    }
+    if (typeof parser.assert === 'function') {
+        // ParserScaleEsque
+        return (value)=>{
+            parser.assert(value);
+            return value;
+        };
+    }
+    if (isStandardSchema) {
+        // StandardSchemaEsque
+        return async (value)=>{
+            const result = await parser['~standard'].validate(value);
+            if (result.issues) {
+                throw new StandardSchemaV1Error(result.issues);
+            }
+            return result.value;
+        };
+    }
+    throw new Error('Could not find a validator fn');
+}
+
+export { getParseFn };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/procedure.mjs

@@ -0,0 +1,7 @@
+const procedureTypes = [
+    'query',
+    'mutation',
+    'subscription'
+];
+
+export { procedureTypes };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/procedureBuilder.mjs

@@ -0,0 +1,198 @@
+import { TRPCError, getTRPCErrorFromUnknown } from './error/TRPCError.mjs';
+import { createOutputMiddleware, createInputMiddleware, middlewareMarker } from './middleware.mjs';
+import { getParseFn } from './parser.mjs';
+import { mergeWithoutOverrides } from './utils.mjs';
+
+function createNewBuilder(def1, def2) {
+    const { middlewares = [], inputs, meta, ...rest } = def2;
+    // TODO: maybe have a fn here to warn about calls
+    return createBuilder({
+        ...mergeWithoutOverrides(def1, rest),
+        inputs: [
+            ...def1.inputs,
+            ...inputs ?? []
+        ],
+        middlewares: [
+            ...def1.middlewares,
+            ...middlewares
+        ],
+        meta: def1.meta && meta ? {
+            ...def1.meta,
+            ...meta
+        } : meta ?? def1.meta
+    });
+}
+function createBuilder(initDef = {}) {
+    const _def = {
+        procedure: true,
+        inputs: [],
+        middlewares: [],
+        ...initDef
+    };
+    const builder = {
+        _def,
+        input (input) {
+            const parser = getParseFn(input);
+            return createNewBuilder(_def, {
+                inputs: [
+                    input
+                ],
+                middlewares: [
+                    createInputMiddleware(parser)
+                ]
+            });
+        },
+        output (output) {
+            const parser = getParseFn(output);
+            return createNewBuilder(_def, {
+                output,
+                middlewares: [
+                    createOutputMiddleware(parser)
+                ]
+            });
+        },
+        meta (meta) {
+            return createNewBuilder(_def, {
+                meta
+            });
+        },
+        use (middlewareBuilderOrFn) {
+            // Distinguish between a middleware builder and a middleware function
+            const middlewares = '_middlewares' in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [
+                middlewareBuilderOrFn
+            ];
+            return createNewBuilder(_def, {
+                middlewares: middlewares
+            });
+        },
+        unstable_concat (builder) {
+            return createNewBuilder(_def, builder._def);
+        },
+        concat (builder) {
+            return createNewBuilder(_def, builder._def);
+        },
+        query (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'query'
+            }, resolver);
+        },
+        mutation (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'mutation'
+            }, resolver);
+        },
+        subscription (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'subscription'
+            }, resolver);
+        },
+        experimental_caller (caller) {
+            return createNewBuilder(_def, {
+                caller
+            });
+        }
+    };
+    return builder;
+}
+function createResolver(_defIn, resolver) {
+    const finalBuilder = createNewBuilder(_defIn, {
+        resolver,
+        middlewares: [
+            async function resolveMiddleware(opts) {
+                const data = await resolver(opts);
+                return {
+                    marker: middlewareMarker,
+                    ok: true,
+                    data,
+                    ctx: opts.ctx
+                };
+            }
+        ]
+    });
+    const _def = {
+        ...finalBuilder._def,
+        type: _defIn.type,
+        experimental_caller: Boolean(finalBuilder._def.caller),
+        meta: finalBuilder._def.meta,
+        $types: null
+    };
+    const invoke = createProcedureCaller(finalBuilder._def);
+    const callerOverride = finalBuilder._def.caller;
+    if (!callerOverride) {
+        return invoke;
+    }
+    const callerWrapper = async (...args)=>{
+        return await callerOverride({
+            args,
+            invoke,
+            _def: _def
+        });
+    };
+    callerWrapper._def = _def;
+    return callerWrapper;
+}
+const codeblock = `
+This is a client-only function.
+If you want to call this function on the server, see https://trpc.io/docs/v11/server/server-side-calls
+`.trim();
+// run the middlewares recursively with the resolver as the last one
+async function callRecursive(index, _def, opts) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const middleware = _def.middlewares[index];
+        const result = await middleware({
+            ...opts,
+            meta: _def.meta,
+            input: opts.input,
+            next (_nextOpts) {
+                const nextOpts = _nextOpts;
+                return callRecursive(index + 1, _def, {
+                    ...opts,
+                    ctx: nextOpts?.ctx ? {
+                        ...opts.ctx,
+                        ...nextOpts.ctx
+                    } : opts.ctx,
+                    input: nextOpts && 'input' in nextOpts ? nextOpts.input : opts.input,
+                    getRawInput: nextOpts?.getRawInput ?? opts.getRawInput
+                });
+            }
+        });
+        return result;
+    } catch (cause) {
+        return {
+            ok: false,
+            error: getTRPCErrorFromUnknown(cause),
+            marker: middlewareMarker
+        };
+    }
+}
+function createProcedureCaller(_def) {
+    async function procedure(opts) {
+        // is direct server-side call
+        if (!opts || !('getRawInput' in opts)) {
+            throw new Error(codeblock);
+        }
+        // there's always at least one "next" since we wrap this.resolver in a middleware
+        const result = await callRecursive(0, _def, opts);
+        if (!result) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'No result from middlewares - did you forget to `return next()`?'
+            });
+        }
+        if (!result.ok) {
+            // re-throw original error
+            throw result.error;
+        }
+        return result.data;
+    }
+    procedure._def = _def;
+    procedure.procedure = true;
+    // FIXME typecast shouldn't be needed - fixittt
+    return procedure;
+}
+
+export { createBuilder };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/rootConfig.mjs

@@ -0,0 +1,6 @@
+/**
+ * The default check to see if we're in a server
+ */ const isServerDefault = typeof window === 'undefined' || 'Deno' in window || // eslint-disable-next-line @typescript-eslint/dot-notation
+globalThis.process?.env?.['NODE_ENV'] === 'test' || !!globalThis.process?.env?.['JEST_WORKER_ID'] || !!globalThis.process?.env?.['VITEST_WORKER_ID'];
+
+export { isServerDefault };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/router.mjs

@@ -0,0 +1,278 @@
+import { createRecursiveProxy } from './createProxy.mjs';
+import { defaultFormatter } from './error/formatter.mjs';
+import { TRPCError, getTRPCErrorFromUnknown } from './error/TRPCError.mjs';
+import { defaultTransformer } from './transformer.mjs';
+import { mergeWithoutOverrides, omitPrototype, isObject, isFunction } from './utils.mjs';
+
+const lazySymbol = Symbol('lazy');
+function once(fn) {
+    const uncalled = Symbol();
+    let result = uncalled;
+    return ()=>{
+        if (result === uncalled) {
+            result = fn();
+        }
+        return result;
+    };
+}
+/**
+ * Lazy load a router
+ * @see https://trpc.io/docs/server/merging-routers#lazy-load
+ */ function lazy(importRouter) {
+    async function resolve() {
+        const mod = await importRouter();
+        // if the module is a router, return it
+        if (isRouter(mod)) {
+            return mod;
+        }
+        const routers = Object.values(mod);
+        if (routers.length !== 1 || !isRouter(routers[0])) {
+            throw new Error("Invalid router module - either define exactly 1 export or return the router directly.\nExample: `lazy(() => import('./slow.js').then((m) => m.slowRouter))`");
+        }
+        return routers[0];
+    }
+    resolve[lazySymbol] = true;
+    return resolve;
+}
+function isLazy(input) {
+    return typeof input === 'function' && lazySymbol in input;
+}
+function isRouter(value) {
+    return isObject(value) && isObject(value['_def']) && 'router' in value['_def'];
+}
+const emptyRouter = {
+    _ctx: null,
+    _errorShape: null,
+    _meta: null,
+    queries: {},
+    mutations: {},
+    subscriptions: {},
+    errorFormatter: defaultFormatter,
+    transformer: defaultTransformer
+};
+/**
+ * Reserved words that can't be used as router or procedure names
+ */ const reservedWords = [
+    /**
+   * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
+   * since JS will think that `.then` is something that exists
+   */ 'then',
+    /**
+   * `fn.call()` and `fn.apply()` are reserved words because otherwise we can't call a function using `.call` or `.apply`
+   */ 'call',
+    'apply'
+];
+/**
+ * @internal
+ */ function createRouterFactory(config) {
+    function createRouterInner(input) {
+        const reservedWordsUsed = new Set(Object.keys(input).filter((v)=>reservedWords.includes(v)));
+        if (reservedWordsUsed.size > 0) {
+            throw new Error('Reserved words used in `router({})` call: ' + Array.from(reservedWordsUsed).join(', '));
+        }
+        const procedures = omitPrototype({});
+        const lazy = omitPrototype({});
+        function createLazyLoader(opts) {
+            return {
+                ref: opts.ref,
+                load: once(async ()=>{
+                    const router = await opts.ref();
+                    const lazyPath = [
+                        ...opts.path,
+                        opts.key
+                    ];
+                    const lazyKey = lazyPath.join('.');
+                    opts.aggregate[opts.key] = step(router._def.record, lazyPath);
+                    delete lazy[lazyKey];
+                    // add lazy loaders for nested routers
+                    for (const [nestedKey, nestedItem] of Object.entries(router._def.lazy)){
+                        const nestedRouterKey = [
+                            ...lazyPath,
+                            nestedKey
+                        ].join('.');
+                        // console.log('adding lazy', nestedRouterKey);
+                        lazy[nestedRouterKey] = createLazyLoader({
+                            ref: nestedItem.ref,
+                            path: lazyPath,
+                            key: nestedKey,
+                            aggregate: opts.aggregate[opts.key]
+                        });
+                    }
+                })
+            };
+        }
+        function step(from, path = []) {
+            const aggregate = omitPrototype({});
+            for (const [key, item] of Object.entries(from ?? {})){
+                if (isLazy(item)) {
+                    lazy[[
+                        ...path,
+                        key
+                    ].join('.')] = createLazyLoader({
+                        path,
+                        ref: item,
+                        key,
+                        aggregate
+                    });
+                    continue;
+                }
+                if (isRouter(item)) {
+                    aggregate[key] = step(item._def.record, [
+                        ...path,
+                        key
+                    ]);
+                    continue;
+                }
+                if (!isProcedure(item)) {
+                    // RouterRecord
+                    aggregate[key] = step(item, [
+                        ...path,
+                        key
+                    ]);
+                    continue;
+                }
+                const newPath = [
+                    ...path,
+                    key
+                ].join('.');
+                if (procedures[newPath]) {
+                    throw new Error(`Duplicate key: ${newPath}`);
+                }
+                procedures[newPath] = item;
+                aggregate[key] = item;
+            }
+            return aggregate;
+        }
+        const record = step(input);
+        const _def = {
+            _config: config,
+            router: true,
+            procedures,
+            lazy,
+            ...emptyRouter,
+            record
+        };
+        const router = {
+            ...record,
+            _def,
+            createCaller: createCallerFactory()({
+                _def
+            })
+        };
+        return router;
+    }
+    return createRouterInner;
+}
+function isProcedure(procedureOrRouter) {
+    return typeof procedureOrRouter === 'function';
+}
+/**
+ * @internal
+ */ async function getProcedureAtPath(router, path) {
+    const { _def } = router;
+    let procedure = _def.procedures[path];
+    while(!procedure){
+        const key = Object.keys(_def.lazy).find((key)=>path.startsWith(key));
+        // console.log(`found lazy: ${key ?? 'NOPE'} (fullPath: ${fullPath})`);
+        if (!key) {
+            return null;
+        }
+        // console.log('loading', key, '.......');
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const lazyRouter = _def.lazy[key];
+        await lazyRouter.load();
+        procedure = _def.procedures[path];
+    }
+    return procedure;
+}
+/**
+ * @internal
+ */ async function callProcedure(opts) {
+    const { type, path } = opts;
+    const proc = await getProcedureAtPath(opts.router, path);
+    if (!proc || !isProcedure(proc) || proc._def.type !== type && !opts.allowMethodOverride) {
+        throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: `No "${type}"-procedure on path "${path}"`
+        });
+    }
+    /* istanbul ignore if -- @preserve */ if (proc._def.type !== type && opts.allowMethodOverride && proc._def.type === 'subscription') {
+        throw new TRPCError({
+            code: 'METHOD_NOT_SUPPORTED',
+            message: `Method override is not supported for subscriptions`
+        });
+    }
+    return proc(opts);
+}
+function createCallerFactory() {
+    return function createCallerInner(router) {
+        const { _def } = router;
+        return function createCaller(ctxOrCallback, opts) {
+            return createRecursiveProxy(async ({ path, args })=>{
+                const fullPath = path.join('.');
+                if (path.length === 1 && path[0] === '_def') {
+                    return _def;
+                }
+                const procedure = await getProcedureAtPath(router, fullPath);
+                let ctx = undefined;
+                try {
+                    if (!procedure) {
+                        throw new TRPCError({
+                            code: 'NOT_FOUND',
+                            message: `No procedure found on path "${path}"`
+                        });
+                    }
+                    ctx = isFunction(ctxOrCallback) ? await Promise.resolve(ctxOrCallback()) : ctxOrCallback;
+                    return await procedure({
+                        path: fullPath,
+                        getRawInput: async ()=>args[0],
+                        ctx,
+                        type: procedure._def.type,
+                        signal: opts?.signal
+                    });
+                } catch (cause) {
+                    opts?.onError?.({
+                        ctx,
+                        error: getTRPCErrorFromUnknown(cause),
+                        input: args[0],
+                        path: fullPath,
+                        type: procedure?._def.type ?? 'unknown'
+                    });
+                    throw cause;
+                }
+            });
+        };
+    };
+}
+function mergeRouters(...routerList) {
+    const record = mergeWithoutOverrides({}, ...routerList.map((r)=>r._def.record));
+    const errorFormatter = routerList.reduce((currentErrorFormatter, nextRouter)=>{
+        if (nextRouter._def._config.errorFormatter && nextRouter._def._config.errorFormatter !== defaultFormatter) {
+            if (currentErrorFormatter !== defaultFormatter && currentErrorFormatter !== nextRouter._def._config.errorFormatter) {
+                throw new Error('You seem to have several error formatters');
+            }
+            return nextRouter._def._config.errorFormatter;
+        }
+        return currentErrorFormatter;
+    }, defaultFormatter);
+    const transformer = routerList.reduce((prev, current)=>{
+        if (current._def._config.transformer && current._def._config.transformer !== defaultTransformer) {
+            if (prev !== defaultTransformer && prev !== current._def._config.transformer) {
+                throw new Error('You seem to have several transformers');
+            }
+            return current._def._config.transformer;
+        }
+        return prev;
+    }, defaultTransformer);
+    const router = createRouterFactory({
+        errorFormatter,
+        transformer,
+        isDev: routerList.every((r)=>r._def._config.isDev),
+        allowOutsideOfServer: routerList.every((r)=>r._def._config.allowOutsideOfServer),
+        isServer: routerList.every((r)=>r._def._config.isServer),
+        $types: routerList[0]?._def._config.$types
+    })(record);
+    return router;
+}
+
+export { callProcedure, createCallerFactory, createRouterFactory, getProcedureAtPath, lazy, mergeRouters };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/rpc/codes.mjs

@@ -0,0 +1,54 @@
+// 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,
+    BAD_GATEWAY: -32603,
+    SERVICE_UNAVAILABLE: -32603,
+    GATEWAY_TIMEOUT: -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,
+    UNSUPPORTED_MEDIA_TYPE: -32015,
+    UNPROCESSABLE_CONTENT: -32022,
+    TOO_MANY_REQUESTS: -32029,
+    CLIENT_CLOSED_REQUEST: -32099
+};
+// pure
+const TRPC_ERROR_CODES_BY_NUMBER = {
+    [-32700]: 'PARSE_ERROR',
+    [-32600]: 'BAD_REQUEST',
+    [-32603]: 'INTERNAL_SERVER_ERROR',
+    [-32001]: 'UNAUTHORIZED',
+    [-32003]: 'FORBIDDEN',
+    [-32004]: 'NOT_FOUND',
+    [-32005]: 'METHOD_NOT_SUPPORTED',
+    [-32008]: 'TIMEOUT',
+    [-32009]: 'CONFLICT',
+    [-32012]: 'PRECONDITION_FAILED',
+    [-32013]: 'PAYLOAD_TOO_LARGE',
+    [-32015]: 'UNSUPPORTED_MEDIA_TYPE',
+    [-32022]: 'UNPROCESSABLE_CONTENT',
+    [-32029]: 'TOO_MANY_REQUESTS',
+    [-32099]: 'CLIENT_CLOSED_REQUEST'
+};
+
+export { TRPC_ERROR_CODES_BY_KEY, TRPC_ERROR_CODES_BY_NUMBER };