@trpc/server 11.0.0-next.91 → 11.0.0-rc.329

package/dist/unstable-core-do-not-import/rpc/parseTRPCMessage.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var procedure = require('../procedure.js');
+var utils = require('../utils.js');
+
+/* istanbul ignore next -- @preserve */ function assertIsObject(obj) {
+    if (!utils.isObject(obj)) {
+        throw new Error('Not an object');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsProcedureType(obj) {
+    if (!procedure.procedureTypes.includes(obj)) {
+        throw new Error('Invalid procedure type');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsRequestId(obj) {
+    if (obj !== null && typeof obj === 'number' && isNaN(obj) && typeof obj !== 'string') {
+        throw new Error('Invalid request id');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsString(obj) {
+    if (typeof obj !== 'string') {
+        throw new Error('Invalid string');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsJSONRPC2OrUndefined(obj) {
+    if (typeof obj !== 'undefined' && obj !== '2.0') {
+        throw new Error('Must be JSONRPC 2.0');
+    }
+}
+/** @public */ function parseTRPCMessage(obj, transformer) {
+    assertIsObject(obj);
+    const { id , jsonrpc , method , params  } = obj;
+    assertIsRequestId(id);
+    assertIsJSONRPC2OrUndefined(jsonrpc);
+    if (method === 'subscription.stop') {
+        return {
+            id,
+            jsonrpc,
+            method
+        };
+    }
+    assertIsProcedureType(method);
+    assertIsObject(params);
+    const { input: rawInput , path  } = params;
+    assertIsString(path);
+    const input = transformer.input.deserialize(rawInput);
+    return {
+        id,
+        jsonrpc,
+        method,
+        params: {
+            input,
+            path
+        }
+    };
+}
+
+exports.parseTRPCMessage = parseTRPCMessage;

package/dist/unstable-core-do-not-import/rpc/parseTRPCMessage.mjs

@@ -0,0 +1,57 @@
+import { procedureTypes } from '../procedure.mjs';
+import { isObject } from '../utils.mjs';
+
+/* istanbul ignore next -- @preserve */ function assertIsObject(obj) {
+    if (!isObject(obj)) {
+        throw new Error('Not an object');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsProcedureType(obj) {
+    if (!procedureTypes.includes(obj)) {
+        throw new Error('Invalid procedure type');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsRequestId(obj) {
+    if (obj !== null && typeof obj === 'number' && isNaN(obj) && typeof obj !== 'string') {
+        throw new Error('Invalid request id');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsString(obj) {
+    if (typeof obj !== 'string') {
+        throw new Error('Invalid string');
+    }
+}
+/* istanbul ignore next -- @preserve */ function assertIsJSONRPC2OrUndefined(obj) {
+    if (typeof obj !== 'undefined' && obj !== '2.0') {
+        throw new Error('Must be JSONRPC 2.0');
+    }
+}
+/** @public */ function parseTRPCMessage(obj, transformer) {
+    assertIsObject(obj);
+    const { id , jsonrpc , method , params  } = obj;
+    assertIsRequestId(id);
+    assertIsJSONRPC2OrUndefined(jsonrpc);
+    if (method === 'subscription.stop') {
+        return {
+            id,
+            jsonrpc,
+            method
+        };
+    }
+    assertIsProcedureType(method);
+    assertIsObject(params);
+    const { input: rawInput , path  } = params;
+    assertIsString(path);
+    const input = transformer.input.deserialize(rawInput);
+    return {
+        id,
+        jsonrpc,
+        method,
+        params: {
+            input,
+            path
+        }
+    };
+}
+
+export { parseTRPCMessage };

package/dist/unstable-core-do-not-import/transformer.d.ts

@@ -0,0 +1,101 @@
+import type { AnyRootTypes, RootConfig } from './rootConfig';
+import type { AnyRouter, inferRouterError } from './router';
+import type { TRPCResponse, TRPCResponseMessage, TRPCResultMessage } from './rpc';
+/**
+ * @public
+ */
+export interface DataTransformer {
+    serialize: (object: any) => any;
+    deserialize: (object: any) => any;
+}
+interface InputDataTransformer extends DataTransformer {
+    /**
+     * This function runs **on the client** before sending the data to the server.
+     */
+    serialize: (object: any) => any;
+    /**
+     * This function runs **on the server** to transform the data before it is passed to the resolver
+     */
+    deserialize: (object: any) => any;
+}
+interface OutputDataTransformer extends DataTransformer {
+    /**
+     * This function runs **on the server** before sending the data to the client.
+     */
+    serialize: (object: any) => any;
+    /**
+     * This function runs **only on the client** to transform the data sent from the server.
+     */
+    deserialize: (object: any) => any;
+}
+/**
+ * @public
+ */
+export interface CombinedDataTransformer {
+    /**
+     * Specify how the data sent from the client to the server should be transformed.
+     */
+    input: InputDataTransformer;
+    /**
+     * Specify how the data sent from the server to the client should be transformed.
+     */
+    output: OutputDataTransformer;
+}
+/**
+ * @public
+ */
+export type CombinedDataTransformerClient = {
+    input: Pick<CombinedDataTransformer['input'], 'serialize'>;
+    output: Pick<CombinedDataTransformer['output'], 'deserialize'>;
+};
+/**
+ * @public
+ */
+export type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
+/**
+ * @internal
+ */
+export declare function getDataTransformer(transformer: DataTransformerOptions): CombinedDataTransformer;
+/**
+ * @internal
+ */
+export declare const defaultTransformer: CombinedDataTransformer;
+/**
+ * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+ **/
+export declare function transformTRPCResponse<TResponse extends TRPCResponse | TRPCResponse[] | TRPCResponseMessage | TRPCResponseMessage[]>(config: RootConfig<AnyRootTypes>, itemOrItems: TResponse): import("./rpc").TRPCErrorResponse<import("./rpc").TRPCErrorShape<object>> | import("./rpc").TRPCSuccessResponse<unknown> | ({
+    id: import("./rpc").JSONRPC2.RequestId;
+} & TRPCResultMessage<unknown>) | (TRPCResponse | TRPCResponseMessage)[];
+/** @internal */
+declare function transformResultInner<TRouter extends AnyRouter, TOutput>(response: TRPCResponse<TOutput, inferRouterError<TRouter>> | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>, transformer: DataTransformer): {
+    readonly ok: false;
+    readonly error: {
+        readonly error: inferRouterError<TRouter>;
+        readonly id?: import("./rpc").JSONRPC2.RequestId | undefined;
+        readonly jsonrpc?: "2.0" | undefined;
+    } | {
+        readonly error: inferRouterError<TRouter>;
+        readonly id: string | number | null;
+        readonly jsonrpc?: "2.0" | undefined;
+    };
+    readonly result?: undefined;
+} | {
+    readonly ok: true;
+    readonly result: {
+        type: "started";
+        data?: undefined;
+    } | {
+        type: "stopped";
+        data?: undefined;
+    } | (import("./rpc").TRPCResult<TOutput> & {
+        type: "data";
+    });
+    readonly error?: undefined;
+};
+/**
+ * Transforms and validates that the result is a valid TRPCResponse
+ * @internal
+ */
+export declare function transformResult<TRouter extends AnyRouter, TOutput>(response: TRPCResponse<TOutput, inferRouterError<TRouter>> | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>, transformer: DataTransformer): ReturnType<typeof transformResultInner>;
+export {};
+//# sourceMappingURL=transformer.d.ts.map

package/dist/unstable-core-do-not-import/transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../src/unstable-core-do-not-import/transformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,OAAO,CAAC;AAGf;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC;IAChC,WAAW,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC;CACnC;AAED,UAAU,oBAAqB,SAAQ,eAAe;IACpD;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC;IAChC;;OAEG;IACH,WAAW,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC;CACnC;AAED,UAAU,qBAAsB,SAAQ,eAAe;IACrD;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC;IAChC;;OAEG;IACH,WAAW,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,KAAK,EAAE,oBAAoB,CAAC;IAC5B;;OAEG;IACH,MAAM,EAAE,qBAAqB,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG;IAC1C,KAAK,EAAE,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC;IAC3D,MAAM,EAAE,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,CAAC;CAChE,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,uBAAuB,GAAG,eAAe,CAAC;AAE/E;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,sBAAsB,GAClC,uBAAuB,CAKzB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,uBAGhC,CAAC;AAyBF;;IAEI;AACJ,wBAAgB,qBAAqB,CACnC,SAAS,SACL,YAAY,GACZ,YAAY,EAAE,GACd,mBAAmB,GACnB,mBAAmB,EAAE,EACzB,MAAM,EAAE,UAAU,CAAC,YAAY,CAAC,EAAE,WAAW,EAAE,SAAS;;yEAIzD;AAKD,gBAAgB;AAChB,iBAAS,oBAAoB,CAAC,OAAO,SAAS,SAAS,EAAE,OAAO,EAC9D,QAAQ,EACJ,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC,GAChD,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAC3D,WAAW,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;EAuB7B;AAQD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,SAAS,SAAS,EAAE,OAAO,EAChE,QAAQ,EACJ,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC,GAChD,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAC3D,WAAW,EAAE,eAAe,GAC3B,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAqBzC"}

package/dist/unstable-core-do-not-import/transformer.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var utils = require('./utils.js');
+
+/**
+ * @internal
+ */ function getDataTransformer(transformer) {
+    if ('input' in transformer) {
+        return transformer;
+    }
+    return {
+        input: transformer,
+        output: transformer
+    };
+}
+/**
+ * @internal
+ */ const defaultTransformer = {
+    input: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    },
+    output: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    }
+};
+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);
+}
+// FIXME:
+// - the generics here are probably unnecessary
+// - the RPC-spec could probably be simplified to combine HTTP + WS
+/** @internal */ function transformResultInner(response, transformer) {
+    if ('error' in response) {
+        const error = transformer.deserialize(response.error);
+        return {
+            ok: false,
+            error: {
+                ...response,
+                error
+            }
+        };
+    }
+    const result = {
+        ...response.result,
+        ...(!response.result.type || response.result.type === 'data') && {
+            type: 'data',
+            data: transformer.deserialize(response.result.data)
+        }
+    };
+    return {
+        ok: true,
+        result
+    };
+}
+class TransformResultError extends Error {
+    constructor(){
+        super('Unable to transform response from server');
+    }
+}
+/**
+ * Transforms and validates that the result is a valid TRPCResponse
+ * @internal
+ */ function transformResult(response, transformer) {
+    let result;
+    try {
+        // Use the data transformers on the JSON-response
+        result = transformResultInner(response, transformer);
+    } catch (err) {
+        throw new TransformResultError();
+    }
+    // check that output of the transformers is a valid TRPCResponse
+    if (!result.ok && (!utils.isObject(result.error.error) || typeof result.error.error['code'] !== 'number')) {
+        throw new TransformResultError();
+    }
+    if (result.ok && !utils.isObject(result.result)) {
+        throw new TransformResultError();
+    }
+    return result;
+}
+
+exports.defaultTransformer = defaultTransformer;
+exports.getDataTransformer = getDataTransformer;
+exports.transformResult = transformResult;
+exports.transformTRPCResponse = transformTRPCResponse;

package/dist/unstable-core-do-not-import/transformer.mjs

@@ -0,0 +1,101 @@
+import { isObject } from './utils.mjs';
+
+/**
+ * @internal
+ */ function getDataTransformer(transformer) {
+    if ('input' in transformer) {
+        return transformer;
+    }
+    return {
+        input: transformer,
+        output: transformer
+    };
+}
+/**
+ * @internal
+ */ const defaultTransformer = {
+    input: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    },
+    output: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    }
+};
+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);
+}
+// FIXME:
+// - the generics here are probably unnecessary
+// - the RPC-spec could probably be simplified to combine HTTP + WS
+/** @internal */ function transformResultInner(response, transformer) {
+    if ('error' in response) {
+        const error = transformer.deserialize(response.error);
+        return {
+            ok: false,
+            error: {
+                ...response,
+                error
+            }
+        };
+    }
+    const result = {
+        ...response.result,
+        ...(!response.result.type || response.result.type === 'data') && {
+            type: 'data',
+            data: transformer.deserialize(response.result.data)
+        }
+    };
+    return {
+        ok: true,
+        result
+    };
+}
+class TransformResultError extends Error {
+    constructor(){
+        super('Unable to transform response from server');
+    }
+}
+/**
+ * Transforms and validates that the result is a valid TRPCResponse
+ * @internal
+ */ function transformResult(response, transformer) {
+    let result;
+    try {
+        // Use the data transformers on the JSON-response
+        result = transformResultInner(response, transformer);
+    } catch (err) {
+        throw new TransformResultError();
+    }
+    // check that output of the transformers is a valid TRPCResponse
+    if (!result.ok && (!isObject(result.error.error) || typeof result.error.error['code'] !== 'number')) {
+        throw new TransformResultError();
+    }
+    if (result.ok && !isObject(result.result)) {
+        throw new TransformResultError();
+    }
+    return result;
+}
+
+export { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse };

package/dist/unstable-core-do-not-import/types.d.ts

@@ -0,0 +1,103 @@
+/**
+ * ================================
+ * Useful utility types that doesn't have anything to do with tRPC in particular
+ * ================================
+ */
+/**
+ * @public
+ */
+export type Maybe<TType> = TType | null | undefined;
+/**
+ * @internal
+ * @link https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ */
+export type Simplify<TType> = TType extends any[] | Date ? TType : {
+    [K in keyof TType]: TType[K];
+};
+/**
+ * @public
+ */
+export type Dict<TType> = Record<string, TType | undefined>;
+/**
+ * @public
+ */
+export type MaybePromise<TType> = Promise<TType> | TType;
+export type FilterKeys<TObj extends object, TFilter> = {
+    [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never;
+}[keyof TObj];
+/**
+ * @internal
+ */
+export type Filter<TObj extends object, TFilter> = Pick<TObj, FilterKeys<TObj, TFilter>>;
+/**
+ * Unwrap return type if the type is a function (sync or async), else use the type as is
+ * @internal
+ */
+export type Unwrap<TType> = TType extends (...args: any[]) => infer R ? Awaited<R> : TType;
+/**
+ * Makes the object recursively optional
+ * @internal
+ */
+export type DeepPartial<TObject> = TObject extends object ? {
+    [P in keyof TObject]?: DeepPartial<TObject[P]>;
+} : TObject;
+/**
+ * Omits the key without removing a potential union
+ * @internal
+ */
+export type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any ? Omit<TObj, TKey> : never;
+/**
+ * See https://github.com/microsoft/TypeScript/issues/41966#issuecomment-758187996
+ * Fixes issues with iterating over keys of objects with index signatures.
+ * Without this, iterations over keys of objects with index signatures will lose
+ * type information about the keys and only the index signature will remain.
+ * @internal
+ */
+export type WithoutIndexSignature<TObj> = {
+    [K in keyof TObj as string extends K ? never : number extends K ? never : K]: TObj[K];
+};
+/**
+ * @internal
+ * Overwrite properties in `TType` with properties in `TWith`
+ * Only overwrites properties when the type to be overwritten
+ * is an object. Otherwise it will just use the type from `TWith`.
+ */
+export type Overwrite<TType, TWith> = TWith extends any ? TType extends object ? {
+    [K in keyof WithoutIndexSignature<TType> | keyof WithoutIndexSignature<TWith>]: K extends keyof TWith ? TWith[K] : K extends keyof TType ? TType[K] : never;
+} & (string extends keyof TWith ? {
+    [key: string]: TWith[string];
+} : number extends keyof TWith ? {
+    [key: number]: TWith[number];
+} : {}) : TWith : never;
+/**
+ * @internal
+ */
+export type ValidateShape<TActualShape, TExpectedShape> = TActualShape extends TExpectedShape ? Exclude<keyof TActualShape, keyof TExpectedShape> extends never ? TActualShape : TExpectedShape : never;
+/**
+ * @internal
+ */
+export type PickFirstDefined<TType, TPick> = undefined extends TType ? undefined extends TPick ? never : TPick : TType;
+/**
+ * ================================
+ * tRPC specific types
+ * ================================
+ */
+/**
+ * @internal
+ */
+export type IntersectionError<TKey extends string> = `The property '${TKey}' in your router collides with a built-in method, rename this router or procedure on your backend.`;
+/**
+ * @internal
+ */
+export type ProtectedIntersection<TType, TWith> = keyof TType & keyof TWith extends never ? TType & TWith : IntersectionError<string & keyof TType & keyof TWith>;
+/**
+ * @internal
+ * Returns the raw input type of a procedure
+ */
+export type GetRawInputFn = () => Promise<unknown>;
+export declare const ERROR_SYMBOL: unique symbol;
+export type TypeError<TMessage extends string> = TMessage & {
+    _: typeof ERROR_SYMBOL;
+};
+export type ValueOf<TObj> = TObj[keyof TObj];
+//# sourceMappingURL=types.d.ts.map

package/dist/unstable-core-do-not-import/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/unstable-core-do-not-import/types.ts"],"names":[],"mappings":"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"}

package/dist/unstable-core-do-not-import/types.js

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * ================================
+ * Useful utility types that doesn't have anything to do with tRPC in particular
+ * ================================
+ */ /**
+ * @public
+ */ const ERROR_SYMBOL = Symbol('TypeError');
+
+exports.ERROR_SYMBOL = ERROR_SYMBOL;

package/dist/unstable-core-do-not-import/types.mjs

@@ -0,0 +1,9 @@
+/**
+ * ================================
+ * Useful utility types that doesn't have anything to do with tRPC in particular
+ * ================================
+ */ /**
+ * @public
+ */ const ERROR_SYMBOL = Symbol('TypeError');
+
+export { ERROR_SYMBOL };

package/dist/unstable-core-do-not-import/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ * @internal
+ */
+export declare function mergeWithoutOverrides<TType extends Record<string, unknown>>(obj1: TType, ...objs: Partial<TType>[]): TType;
+/**
+ * Check that value is object
+ * @internal
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+type AnyFn = (...args: any[]) => unknown;
+export declare function isFunction(fn: unknown): fn is AnyFn;
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */
+export declare function omitPrototype<TObj extends Record<string, unknown>>(obj: TObj): TObj;
+/**
+ * Prevents access to `$types` at runtime
+ * @internal
+ */
+export declare const $typesProxy: any;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/unstable-core-do-not-import/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/unstable-core-do-not-import/utils.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzE,IAAI,EAAE,KAAK,EACX,GAAG,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,GACxB,KAAK,CAYP;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,KAAK,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC;AACzC,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,KAAK,CAEnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,GAAG,EAAE,IAAI,GACR,IAAI,CAEN;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,KAItB,CAAC"}

package/dist/unstable-core-do-not-import/utils.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var createProxy = require('./createProxy.js');
+
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ * @internal
+ */ function mergeWithoutOverrides(obj1, ...objs) {
+    const newObj = Object.assign(Object.create(null), obj1);
+    for (const overrides of objs){
+        for(const key in overrides){
+            if (key in newObj && newObj[key] !== overrides[key]) {
+                throw new Error(`Duplicate key ${key}`);
+            }
+            newObj[key] = overrides[key];
+        }
+    }
+    return newObj;
+}
+/**
+ * Check that value is object
+ * @internal
+ */ function isObject(value) {
+    return !!value && !Array.isArray(value) && typeof value === 'object';
+}
+function isFunction(fn) {
+    return typeof fn === 'function';
+}
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */ function omitPrototype(obj) {
+    return Object.assign(Object.create(null), obj);
+}
+/**
+ * Prevents access to `$types` at runtime
+ * @internal
+ */ const $typesProxy = createProxy.createFlatProxy((key)=>{
+    throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
+});
+
+exports.$typesProxy = $typesProxy;
+exports.isFunction = isFunction;
+exports.isObject = isObject;
+exports.mergeWithoutOverrides = mergeWithoutOverrides;
+exports.omitPrototype = omitPrototype;

package/dist/unstable-core-do-not-import/utils.mjs

@@ -0,0 +1,40 @@
+import { createFlatProxy } from './createProxy.mjs';
+
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ * @internal
+ */ function mergeWithoutOverrides(obj1, ...objs) {
+    const newObj = Object.assign(Object.create(null), obj1);
+    for (const overrides of objs){
+        for(const key in overrides){
+            if (key in newObj && newObj[key] !== overrides[key]) {
+                throw new Error(`Duplicate key ${key}`);
+            }
+            newObj[key] = overrides[key];
+        }
+    }
+    return newObj;
+}
+/**
+ * Check that value is object
+ * @internal
+ */ function isObject(value) {
+    return !!value && !Array.isArray(value) && typeof value === 'object';
+}
+function isFunction(fn) {
+    return typeof fn === 'function';
+}
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */ function omitPrototype(obj) {
+    return Object.assign(Object.create(null), obj);
+}
+/**
+ * Prevents access to `$types` at runtime
+ * @internal
+ */ const $typesProxy = createFlatProxy((key)=>{
+    throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
+});
+
+export { $typesProxy, isFunction, isObject, mergeWithoutOverrides, omitPrototype };