@highstate/designer 0.1.0

package/.output/server/node_modules/@trpc/server/dist/config-d5fdbd39.mjs

@@ -0,0 +1,196 @@
+import { T as TRPCError } from './TRPCError-98d44758.mjs';
+import { a as createRecursiveProxy, g as getHTTPStatusCodeFromError } from './index-f91d720c.mjs';
+import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-c924c3db.mjs';
+
+/**
+ * @public
+ */ /**
+ * @internal
+ */ function getDataTransformer(transformer) {
+    if ('input' in transformer) {
+        return transformer;
+    }
+    return {
+        input: transformer,
+        output: transformer
+    };
+}
+/**
+ * @internal
+ */ const defaultTransformer = {
+    _default: true,
+    input: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    },
+    output: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    }
+};
+
+const defaultFormatter = ({ shape  })=>{
+    return shape;
+};
+
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */ function omitPrototype(obj) {
+    return Object.assign(Object.create(null), obj);
+}
+
+const procedureTypes = [
+    'query',
+    'mutation',
+    'subscription'
+];
+
+function isRouter(procedureOrRouter) {
+    return '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'
+];
+/**
+ * @internal
+ */ function createRouterFactory(config) {
+    return function createRouterInner(procedures) {
+        const reservedWordsUsed = new Set(Object.keys(procedures).filter((v)=>reservedWords.includes(v)));
+        if (reservedWordsUsed.size > 0) {
+            throw new Error('Reserved words used in `router({})` call: ' + Array.from(reservedWordsUsed).join(', '));
+        }
+        const routerProcedures = omitPrototype({});
+        function recursiveGetPaths(procedures, path = '') {
+            for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
+                const newPath = `${path}${key}`;
+                if (isRouter(procedureOrRouter)) {
+                    recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
+                    continue;
+                }
+                if (routerProcedures[newPath]) {
+                    throw new Error(`Duplicate key: ${newPath}`);
+                }
+                routerProcedures[newPath] = procedureOrRouter;
+            }
+        }
+        recursiveGetPaths(procedures);
+        const _def = {
+            _config: config,
+            router: true,
+            procedures: routerProcedures,
+            ...emptyRouter,
+            record: procedures,
+            queries: Object.entries(routerProcedures).filter((pair)=>pair[1]._def.query).reduce((acc, [key, val])=>({
+                    ...acc,
+                    [key]: val
+                }), {}),
+            mutations: Object.entries(routerProcedures).filter((pair)=>pair[1]._def.mutation).reduce((acc, [key, val])=>({
+                    ...acc,
+                    [key]: val
+                }), {}),
+            subscriptions: Object.entries(routerProcedures).filter((pair)=>pair[1]._def.subscription).reduce((acc, [key, val])=>({
+                    ...acc,
+                    [key]: val
+                }), {})
+        };
+        const router = {
+            ...procedures,
+            _def,
+            createCaller (ctx) {
+                return createCallerFactory()(router)(ctx);
+            },
+            getErrorShape (opts) {
+                const { path , error  } = 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 this._def._config.errorFormatter({
+                    ...opts,
+                    shape
+                });
+            }
+        };
+        return router;
+    };
+}
+/**
+ * @internal
+ */ function callProcedure(opts) {
+    const { type , path  } = opts;
+    if (!(path in opts.procedures) || !opts.procedures[path]?._def[type]) {
+        throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: `No "${type}"-procedure on path "${path}"`
+        });
+    }
+    const procedure = opts.procedures[path];
+    return procedure(opts);
+}
+function createCallerFactory() {
+    return function createCallerInner(router) {
+        const def = router._def;
+        return function createCaller(ctx) {
+            const proxy = createRecursiveProxy(({ path , args  })=>{
+                // interop mode
+                if (path.length === 1 && procedureTypes.includes(path[0])) {
+                    return callProcedure({
+                        procedures: def.procedures,
+                        path: args[0],
+                        rawInput: args[1],
+                        ctx,
+                        type: path[0]
+                    });
+                }
+                const fullPath = path.join('.');
+                const procedure = def.procedures[fullPath];
+                let type = 'query';
+                if (procedure._def.mutation) {
+                    type = 'mutation';
+                } else if (procedure._def.subscription) {
+                    type = 'subscription';
+                }
+                return procedure({
+                    path: fullPath,
+                    rawInput: args[0],
+                    ctx,
+                    type
+                });
+            });
+            return proxy;
+        };
+    };
+}
+
+/**
+ * The default check to see if we're in a server
+ */ const isServerDefault = typeof window === 'undefined' || 'Deno' in window || globalThis.process?.env?.NODE_ENV === 'test' || !!globalThis.process?.env?.JEST_WORKER_ID || !!globalThis.process?.env?.VITEST_WORKER_ID;
+
+export { defaultTransformer as a, createCallerFactory as b, createRouterFactory as c, defaultFormatter as d, callProcedure as e, getDataTransformer as g, isServerDefault as i, procedureTypes as p };

package/.output/server/node_modules/@trpc/server/dist/contentType-9fd995d3.mjs

@@ -0,0 +1,52 @@
+import { T as TRPCError } from './TRPCError-98d44758.mjs';
+
+function getRawProcedureInputOrThrow(opts) {
+    const { req  } = opts;
+    try {
+        if (req.method === 'GET') {
+            if (!req.query.has('input')) {
+                return undefined;
+            }
+            const raw = req.query.get('input');
+            return JSON.parse(raw);
+        }
+        if (!opts.preprocessedBody && typeof req.body === 'string') {
+            // A mutation with no inputs will have req.body === ''
+            return req.body.length === 0 ? undefined : JSON.parse(req.body);
+        }
+        return req.body;
+    } catch (cause) {
+        throw new TRPCError({
+            code: 'PARSE_ERROR',
+            cause
+        });
+    }
+}
+const deserializeInputValue = (rawValue, transformer)=>{
+    return typeof rawValue !== 'undefined' ? transformer.input.deserialize(rawValue) : rawValue;
+};
+const getJsonContentTypeInputs = (opts)=>{
+    const rawInput = getRawProcedureInputOrThrow(opts);
+    const transformer = opts.router._def._config.transformer;
+    if (!opts.isBatchCall) {
+        return {
+            0: deserializeInputValue(rawInput, transformer)
+        };
+    }
+    /* istanbul ignore if  */ if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
+        throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: '"input" needs to be an object when doing a batch call'
+        });
+    }
+    const input = {};
+    for(const key in rawInput){
+        const k = key;
+        const rawValue = rawInput[k];
+        const value = deserializeInputValue(rawValue, transformer);
+        input[k] = value;
+    }
+    return input;
+};
+
+export { getJsonContentTypeInputs as g };

package/.output/server/node_modules/@trpc/server/dist/getCauseFromUnknown-2d66414a.mjs

@@ -0,0 +1,33 @@
+/**
+ * @internal
+ */ function isObject(value) {
+    // check that value is object
+    return !!value && !Array.isArray(value) && typeof value === 'object';
+}
+
+class UnknownCauseError extends Error {
+}
+function getCauseFromUnknown(cause) {
+    if (cause instanceof Error) {
+        return cause;
+    }
+    const type = typeof cause;
+    if (type === 'undefined' || type === 'function' || cause === null) {
+        return undefined;
+    }
+    // Primitive types just get wrapped in an error
+    if (type !== 'object') {
+        return new Error(String(cause));
+    }
+    // If it's an object, we'll create a synthetic error
+    if (isObject(cause)) {
+        const err = new UnknownCauseError();
+        for(const key in cause){
+            err[key] = cause[key];
+        }
+        return err;
+    }
+    return undefined;
+}
+
+export { getCauseFromUnknown as g };

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

@@ -0,0 +1,9 @@
+export { T as TRPC_ERROR_CODES_BY_NUMBER, b as getHTTPStatusCode, g as getHTTPStatusCodeFromError } from '../index-f91d720c.mjs';
+export { r as resolveHTTPResponse } from '../resolveHTTPResponse-2fc435bb.mjs';
+export { g as getBatchStreamFormatter } from '../batchStreamFormatter-fc1ffb26.mjs';
+import '../codes-c924c3db.mjs';
+import '../config-d5fdbd39.mjs';
+import '../TRPCError-98d44758.mjs';
+import '../getCauseFromUnknown-2d66414a.mjs';
+import '../transformTRPCResponse-1153b421.mjs';
+import '../contentType-9fd995d3.mjs';

package/.output/server/node_modules/@trpc/server/dist/index-f91d720c.mjs

@@ -0,0 +1,97 @@
+import { i as invert, T as TRPC_ERROR_CODES_BY_KEY } from './codes-c924c3db.mjs';
+
+const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
+const JSONRPC2_TO_HTTP_CODE = {
+    PARSE_ERROR: 400,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    NOT_FOUND: 404,
+    FORBIDDEN: 403,
+    METHOD_NOT_SUPPORTED: 405,
+    TIMEOUT: 408,
+    CONFLICT: 409,
+    PRECONDITION_FAILED: 412,
+    PAYLOAD_TOO_LARGE: 413,
+    UNPROCESSABLE_CONTENT: 422,
+    TOO_MANY_REQUESTS: 429,
+    CLIENT_CLOSED_REQUEST: 499,
+    INTERNAL_SERVER_ERROR: 500,
+    NOT_IMPLEMENTED: 501
+};
+function getStatusCodeFromKey(code) {
+    return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
+}
+function getHTTPStatusCode(json) {
+    const arr = Array.isArray(json) ? json : [
+        json
+    ];
+    const httpStatuses = new Set(arr.map((res)=>{
+        if ('error' in res) {
+            const data = res.error.data;
+            if (typeof data.httpStatus === 'number') {
+                return data.httpStatus;
+            }
+            const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
+            return getStatusCodeFromKey(code);
+        }
+        return 200;
+    }));
+    if (httpStatuses.size !== 1) {
+        return 207;
+    }
+    const httpStatus = httpStatuses.values().next().value;
+    return httpStatus;
+}
+function getHTTPStatusCodeFromError(error) {
+    return getStatusCodeFromKey(error.code);
+}
+
+const noop = ()=>{
+// noop
+};
+function createInnerProxy(callback, path) {
+    const proxy = new Proxy(noop, {
+        get (_obj, key) {
+            if (typeof key !== 'string' || key === 'then') {
+                // special case for if the proxy is accidentally treated
+                // like a PromiseLike (like in `Promise.resolve(proxy)`)
+                return undefined;
+            }
+            return createInnerProxy(callback, [
+                ...path,
+                key
+            ]);
+        },
+        apply (_1, _2, args) {
+            const isApply = path[path.length - 1] === 'apply';
+            return callback({
+                args: isApply ? args.length >= 2 ? args[1] : [] : args,
+                path: isApply ? path.slice(0, -1) : path
+            });
+        }
+    });
+    return proxy;
+}
+/**
+ * Creates a proxy that calls the callback with the path and arguments
+ *
+ * @internal
+ */ const createRecursiveProxy = (callback)=>createInnerProxy(callback, []);
+/**
+ * Used in place of `new Proxy` where each handler will map 1 level deep to another value.
+ *
+ * @internal
+ */ const createFlatProxy = (callback)=>{
+    return new Proxy(noop, {
+        get (_obj, name) {
+            if (typeof name !== 'string' || name === 'then') {
+                // special case for if the proxy is accidentally treated
+                // like a PromiseLike (like in `Promise.resolve(proxy)`)
+                return undefined;
+            }
+            return callback(name);
+        }
+    });
+};
+
+export { TRPC_ERROR_CODES_BY_NUMBER as T, createRecursiveProxy as a, getHTTPStatusCode as b, createFlatProxy as c, getHTTPStatusCodeFromError as g };