@highstate/designer 0.2.1 → 0.2.2

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

@@ -1,80 +0,0 @@
-import { defaultFormatter } from './error/formatter.mjs';
-import { createMiddlewareFactory } from './middleware.mjs';
-import { createBuilder } from './procedureBuilder.mjs';
-import { isServerDefault } from './rootConfig.mjs';
-import { createRouterFactory, mergeRouters, createCallerFactory } from './router.mjs';
-import { getDataTransformer, defaultTransformer } from './transformer.mjs';
-
-class TRPCBuilder {
-    /**
-   * Add a context shape as a generic to the root object
-   * @see https://trpc.io/docs/v11/server/context
-   */ context() {
-        return new TRPCBuilder();
-    }
-    /**
-   * Add a meta shape as a generic to the root object
-   * @see https://trpc.io/docs/v11/quickstart
-   */ meta() {
-        return new TRPCBuilder();
-    }
-    /**
-   * Create the root object
-   * @see https://trpc.io/docs/v11/server/routers#initialize-trpc
-   */ create(opts) {
-        const config = {
-            ...opts,
-            transformer: getDataTransformer(opts?.transformer ?? defaultTransformer),
-            isDev: opts?.isDev ?? // eslint-disable-next-line @typescript-eslint/dot-notation
-            globalThis.process?.env['NODE_ENV'] !== 'production',
-            allowOutsideOfServer: opts?.allowOutsideOfServer ?? false,
-            errorFormatter: opts?.errorFormatter ?? defaultFormatter,
-            isServer: opts?.isServer ?? isServerDefault,
-            /**
-       * These are just types, they can't be used at runtime
-       * @internal
-       */ $types: null
-        };
-        {
-            // Server check
-            const isServer = opts?.isServer ?? isServerDefault;
-            if (!isServer && opts?.allowOutsideOfServer !== true) {
-                throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
-            }
-        }
-        return {
-            /**
-       * Your router config
-       * @internal
-       */ _config: config,
-            /**
-       * Builder object for creating procedures
-       * @see https://trpc.io/docs/v11/server/procedures
-       */ procedure: createBuilder({
-                meta: opts?.defaultMeta
-            }),
-            /**
-       * Create reusable middlewares
-       * @see https://trpc.io/docs/v11/server/middlewares
-       */ middleware: createMiddlewareFactory(),
-            /**
-       * Create a router
-       * @see https://trpc.io/docs/v11/server/routers
-       */ router: createRouterFactory(config),
-            /**
-       * Merge Routers
-       * @see https://trpc.io/docs/v11/server/merging-routers
-       */ mergeRouters,
-            /**
-       * Create a server-side caller for a router
-       * @see https://trpc.io/docs/v11/server/server-side-calls
-       */ createCallerFactory: createCallerFactory()
-        };
-    }
-}
-/**
- * Builder to initialize the tRPC root object - use this exactly once per backend
- * @see https://trpc.io/docs/v11/quickstart
- */ const initTRPC = new TRPCBuilder();
-
-export { initTRPC };

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

@@ -1,90 +0,0 @@
-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 `.unstable_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

@@ -1,40 +0,0 @@
-// zod / typeschema
-function getParseFn(procedureParser) {
-    const parser = procedureParser;
-    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') {
-        // ParserValibotEsque (>= v0.31.0)
-        // ParserCustomValidatorEsque
-        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;
-        };
-    }
-    throw new Error('Could not find a validator fn');
-}
-
-export { getParseFn };

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

@@ -1,194 +0,0 @@
-import { TRPCError, getTRPCErrorFromUnknown } from './error/TRPCError.mjs';
-import { createInputMiddleware, createOutputMiddleware, 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);
-        },
-        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;
-    // 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

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

@@ -1,176 +0,0 @@
-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, isFunction } from './utils.mjs';
-
-function isRouter(procedureOrRouter) {
-    return procedureOrRouter._def && 'router' in procedureOrRouter._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({});
-        function step(from, path = []) {
-            const aggregate = omitPrototype({});
-            for (const [key, item] of Object.entries(from ?? {})){
-                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,
-            ...emptyRouter,
-            record
-        };
-        return {
-            ...record,
-            _def,
-            createCaller: createCallerFactory()({
-                _def
-            })
-        };
-    }
-    return createRouterInner;
-}
-function isProcedure(procedureOrRouter) {
-    return typeof procedureOrRouter === 'function';
-}
-/**
- * @internal
- */ function callProcedure(opts) {
-    const { type, path } = opts;
-    const proc = opts.procedures[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._def;
-        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 = _def.procedures[fullPath];
-                let ctx = undefined;
-                try {
-                    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
-                    });
-                    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, mergeRouters };

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

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