@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.215 → 11.0.0-alpha-tmp-export-from-main.211

package/dist/initTRPC-fa1b3d57.mjs

@@ -1,376 +0,0 @@
-import { d as createFlatProxy } from './createProxy-0306dcaa.mjs';
-import { d as defaultFormatter, g as getDataTransformer, a as defaultTransformer, b as createRouterFactory, m as mergeRouters, e as createCallerFactory } from './router-d6789e4b.mjs';
-import { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-14edcf88.mjs';
-import { i as isObject, m as mergeWithoutOverrides, c as isServerDefault } from './rootConfig-6b04a6b8.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
- * @link https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
- */ 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;
-}
-
-// zod / @decs/typeschema
-function getParseFn(procedureParser) {
-    const parser = procedureParser;
-    if (typeof parser === 'function') {
-        // ParserCustomValidatorEsque
-        return parser;
-    }
-    if (typeof parser.parseAsync === 'function') {
-        // ParserZodEsque
-        return parser.parseAsync.bind(parser);
-    }
-    if (typeof parser.parse === 'function') {
-        // ParserZodEsque
-        // ParserValibotEsque (<= v0.12.X)
-        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');
-}
-
-/** @internal */ const unsetMarker = Symbol('unsetMarker');
-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
-            });
-        },
-        query (resolver) {
-            return createResolver({
-                ..._def,
-                type: 'query'
-            }, resolver);
-        },
-        mutation (resolver) {
-            return createResolver({
-                ..._def,
-                type: 'mutation'
-            }, resolver);
-        },
-        subscription (resolver) {
-            return createResolver({
-                ..._def,
-                type: 'subscription'
-            }, resolver);
-        }
-    };
-    return builder;
-}
-function createResolver(_def, resolver) {
-    const finalBuilder = createNewBuilder(_def, {
-        resolver,
-        middlewares: [
-            async function resolveMiddleware(opts) {
-                const data = await resolver(opts);
-                return {
-                    marker: middlewareMarker,
-                    ok: true,
-                    data,
-                    ctx: opts.ctx
-                };
-            }
-        ]
-    });
-    return createProcedureCaller(finalBuilder._def);
-}
-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();
-function createProcedureCaller(_def) {
-    async function procedure(opts) {
-        // is direct server-side call
-        if (!opts || !('getRawInput' in opts)) {
-            throw new Error(codeblock);
-        }
-        // run the middlewares recursively with the resolver as the last one
-        async function callRecursive(callOpts = {
-            index: 0,
-            ctx: opts.ctx
-        }) {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const middleware = _def.middlewares[callOpts.index];
-                const result = await middleware({
-                    ctx: callOpts.ctx,
-                    type: opts.type,
-                    path: opts.path,
-                    getRawInput: callOpts.getRawInput ?? opts.getRawInput,
-                    meta: _def.meta,
-                    input: callOpts.input,
-                    next (_nextOpts) {
-                        const nextOpts = _nextOpts;
-                        return callRecursive({
-                            index: callOpts.index + 1,
-                            ctx: nextOpts && 'ctx' in nextOpts ? {
-                                ...callOpts.ctx,
-                                ...nextOpts.ctx
-                            } : callOpts.ctx,
-                            input: nextOpts && 'input' in nextOpts ? nextOpts.input : callOpts.input,
-                            getRawInput: nextOpts && 'getRawInput' in nextOpts ? nextOpts.getRawInput : callOpts.getRawInput
-                        });
-                    }
-                });
-                return result;
-            } catch (cause) {
-                return {
-                    ok: false,
-                    error: getTRPCErrorFromUnknown(cause),
-                    marker: middlewareMarker
-                };
-            }
-        }
-        // there's always at least one "next" since we wrap this.resolver in a middleware
-        const result = await callRecursive();
-        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;
-}
-
-/**
- * TODO: This can be improved:
- * - We should be able to chain `.meta()`/`.context()` only once
- * - Simplify typings
- * - Doesn't need to be a class but it doesn't really hurt either
- */ class TRPCBuilder {
-    /**
-   * Add a context shape as a generic to the root object
-   * @link https://trpc.io/docs/v11/server/context
-   */ context() {
-        return new TRPCBuilder();
-    }
-    /**
-   * Add a meta shape as a generic to the root object
-   * @link https://trpc.io/docs/v11/quickstart
-   */ meta() {
-        return new TRPCBuilder();
-    }
-    /**
-   * Create the root object
-   * @link https://trpc.io/docs/v11/server/routers#initialize-trpc
-   */ create(options) {
-        return createTRPCInner()(options);
-    }
-}
-/**
- * Builder to initialize the tRPC root object - use this exactly once per backend
- * @link https://trpc.io/docs/v11/quickstart
- */ const initTRPC = new TRPCBuilder();
-function createTRPCInner() {
-    return function initTRPCInner(runtime) {
-        const errorFormatter = runtime?.errorFormatter ?? defaultFormatter;
-        const transformer = getDataTransformer(runtime?.transformer ?? defaultTransformer);
-        const config = {
-            transformer,
-            isDev: runtime?.isDev ?? // eslint-disable-next-line @typescript-eslint/dot-notation
-            globalThis.process?.env?.['NODE_ENV'] !== 'production',
-            allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
-            errorFormatter,
-            isServer: runtime?.isServer ?? isServerDefault,
-            /**
-       * @internal
-       */ $types: createFlatProxy((key)=>{
-                throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
-            })
-        };
-        {
-            // Server check
-            const isServer = runtime?.isServer ?? isServerDefault;
-            if (!isServer && runtime?.allowOutsideOfServer !== true) {
-                throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
-            }
-        }
-        return {
-            /**
-       * These are just types, they can't be used
-       * @internal
-       */ _config: config,
-            /**
-       * Builder object for creating procedures
-       * @link https://trpc.io/docs/v11/server/procedures
-       */ procedure: createBuilder({
-                meta: runtime?.defaultMeta
-            }),
-            /**
-       * Create reusable middlewares
-       * @link https://trpc.io/docs/v11/server/middlewares
-       */ middleware: createMiddlewareFactory(),
-            /**
-       * Create a router
-       * @link https://trpc.io/docs/v11/server/routers
-       */ router: createRouterFactory(config),
-            /**
-       * Merge Routers
-       * @link https://trpc.io/docs/v11/server/merging-routers
-       */ mergeRouters,
-            /**
-       * Create a server-side caller for a router
-       * @link https://trpc.io/docs/v11/server/server-side-calls
-       */ createCallerFactory: createCallerFactory()
-        };
-    };
-}
-
-export { createOutputMiddleware as a, createBuilder as b, createInputMiddleware as c, experimental_standaloneMiddleware as e, initTRPC as i, middlewareMarker as m, unsetMarker as u };

package/dist/observable-2a5a96d5.js

@@ -1,125 +0,0 @@
-'use strict';
-
-var rootConfig = require('./rootConfig-3371c473.js');
-
-/** @public */ function isObservable(x) {
-    return typeof x === 'object' && x !== null && 'subscribe' in x;
-}
-/** @public */ 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;
-}
-function pipeFromArray(fns) {
-    if (fns.length === 0) {
-        return rootConfig.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);
-    };
-}
-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
-    };
-}
-
-exports.isObservable = isObservable;
-exports.observable = observable;
-exports.observableToPromise = observableToPromise;

package/dist/observable-62674916.js

@@ -1,125 +0,0 @@
-import { b as identity } from './rootConfig-571c9267.js';
-
-/** @public */
-function isObservable(x) {
-    return typeof x === 'object' && x !== null && 'subscribe' in x;
-}
-/** @public */
-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;
-}
-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);
-    };
-}
-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 { observableToPromise as a, isObservable as i, observable as o };