@trpc/client 11.1.2 → 11.1.3-alpha-tmp-tsdown.23

package/dist/internals/TRPCUntypedClient.mjs

@@ -1,113 +1,96 @@
-import { share, observableToPromise } from '@trpc/server/observable';
-import { createChain } from '../links/internals/createChain.mjs';
-import { TRPCClientError } from '../TRPCClientError.mjs';
+import { createChain } from "../links/internals/createChain.mjs";
+import { TRPCClientError } from "../TRPCClientError.mjs";
+import { observableToPromise, share } from "@trpc/server/observable";
 
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-class TRPCUntypedClient {
-    $request(opts) {
-        const chain$ = createChain({
-            links: this.links,
-            op: {
-                ...opts,
-                context: opts.context ?? {},
-                id: ++this.requestId
-            }
-        });
-        return chain$.pipe(share());
-    }
-    async requestAsPromise(opts) {
-        try {
-            const req$ = this.$request(opts);
-            const envelope = await observableToPromise(req$);
-            const data = envelope.result.data;
-            return data;
-        } catch (err) {
-            throw TRPCClientError.from(err);
-        }
-    }
-    query(path, input, opts) {
-        return this.requestAsPromise({
-            type: 'query',
-            path,
-            input,
-            context: opts?.context,
-            signal: opts?.signal
-        });
-    }
-    mutation(path, input, opts) {
-        return this.requestAsPromise({
-            type: 'mutation',
-            path,
-            input,
-            context: opts?.context,
-            signal: opts?.signal
-        });
-    }
-    subscription(path, input, opts) {
-        const observable$ = this.$request({
-            type: 'subscription',
-            path,
-            input,
-            context: opts.context,
-            signal: opts.signal
-        });
-        return observable$.subscribe({
-            next (envelope) {
-                switch(envelope.result.type){
-                    case 'state':
-                        {
-                            opts.onConnectionStateChange?.(envelope.result);
-                            break;
-                        }
-                    case 'started':
-                        {
-                            opts.onStarted?.({
-                                context: envelope.context
-                            });
-                            break;
-                        }
-                    case 'stopped':
-                        {
-                            opts.onStopped?.();
-                            break;
-                        }
-                    case 'data':
-                    case undefined:
-                        {
-                            opts.onData?.(envelope.result.data);
-                            break;
-                        }
-                }
-            },
-            error (err) {
-                opts.onError?.(err);
-            },
-            complete () {
-                opts.onComplete?.();
-            }
-        });
-    }
-    constructor(opts){
-        _define_property(this, "links", void 0);
-        _define_property(this, "runtime", void 0);
-        _define_property(this, "requestId", void 0);
-        this.requestId = 0;
-        this.runtime = {};
-        // Initialize the links
-        this.links = opts.links.map((link)=>link(this.runtime));
-    }
-}
+//#region src/internals/TRPCUntypedClient.ts
+var TRPCUntypedClient = class {
+	links;
+	runtime;
+	requestId;
+	constructor(opts) {
+		this.requestId = 0;
+		this.runtime = {};
+		this.links = opts.links.map((link) => link(this.runtime));
+	}
+	$request(opts) {
+		const chain$ = createChain({
+			links: this.links,
+			op: {
+				...opts,
+				context: opts.context ?? {},
+				id: ++this.requestId
+			}
+		});
+		return chain$.pipe(share());
+	}
+	async requestAsPromise(opts) {
+		try {
+			const req$ = this.$request(opts);
+			const envelope = await observableToPromise(req$);
+			const data = envelope.result.data;
+			return data;
+		} catch (err) {
+			throw TRPCClientError.from(err);
+		}
+	}
+	query(path, input, opts) {
+		return this.requestAsPromise({
+			type: "query",
+			path,
+			input,
+			context: opts?.context,
+			signal: opts?.signal
+		});
+	}
+	mutation(path, input, opts) {
+		return this.requestAsPromise({
+			type: "mutation",
+			path,
+			input,
+			context: opts?.context,
+			signal: opts?.signal
+		});
+	}
+	subscription(path, input, opts) {
+		const observable$ = this.$request({
+			type: "subscription",
+			path,
+			input,
+			context: opts.context,
+			signal: opts.signal
+		});
+		return observable$.subscribe({
+			next(envelope) {
+				switch (envelope.result.type) {
+					case "state": {
+						opts.onConnectionStateChange?.(envelope.result);
+						break;
+					}
+					case "started": {
+						opts.onStarted?.({ context: envelope.context });
+						break;
+					}
+					case "stopped": {
+						opts.onStopped?.();
+						break;
+					}
+					case "data":
+					case void 0: {
+						opts.onData?.(envelope.result.data);
+						break;
+					}
+				}
+			},
+			error(err) {
+				opts.onError?.(err);
+			},
+			complete() {
+				opts.onComplete?.();
+			}
+		});
+	}
+};
 
+//#endregion
 export { TRPCUntypedClient };
+//# sourceMappingURL=TRPCUntypedClient.mjs.map

package/dist/internals/TRPCUntypedClient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRPCUntypedClient.mjs","names":["opts: CreateTRPCClientOptions<TInferrable>","opts: {\n    type: TRPCType;\n    input: TInput;\n    path: string;\n    context?: OperationContext;\n    signal: Maybe<AbortSignal>;\n  }","path: string","input?: unknown","opts?: TRPCRequestOptions","input: unknown","opts: Partial<\n      TRPCSubscriptionObserver<unknown, TRPCClientError<AnyRouter>>\n    > &\n      TRPCRequestOptions"],"sources":["../../src/internals/TRPCUntypedClient.ts"],"sourcesContent":["import type {\n  inferObservableValue,\n  Unsubscribable,\n} from '@trpc/server/observable';\nimport { observableToPromise, share } from '@trpc/server/observable';\nimport type {\n  AnyRouter,\n  inferAsyncIterableYield,\n  InferrableClientTypes,\n  Maybe,\n  TypeError,\n} from '@trpc/server/unstable-core-do-not-import';\nimport { createChain } from '../links/internals/createChain';\nimport type { TRPCConnectionState } from '../links/internals/subscriptions';\nimport type {\n  OperationContext,\n  OperationLink,\n  TRPCClientRuntime,\n  TRPCLink,\n} from '../links/types';\nimport { TRPCClientError } from '../TRPCClientError';\n\ntype TRPCType = 'mutation' | 'query' | 'subscription';\nexport interface TRPCRequestOptions {\n  /**\n   * Pass additional context to links\n   */\n  context?: OperationContext;\n  signal?: AbortSignal;\n}\n\nexport interface TRPCSubscriptionObserver<TValue, TError> {\n  onStarted: (opts: { context: OperationContext | undefined }) => void;\n  onData: (value: inferAsyncIterableYield<TValue>) => void;\n  onError: (err: TError) => void;\n  onStopped: () => void;\n  onComplete: () => void;\n  onConnectionStateChange: (state: TRPCConnectionState<TError>) => void;\n}\n\n/** @internal */\nexport type CreateTRPCClientOptions<TRouter extends InferrableClientTypes> = {\n  links: TRPCLink<TRouter>[];\n  transformer?: TypeError<'The transformer property has moved to httpLink/httpBatchLink/wsLink'>;\n};\n\nexport class TRPCUntypedClient<TInferrable extends InferrableClientTypes> {\n  private readonly links: OperationLink<TInferrable>[];\n  public readonly runtime: TRPCClientRuntime;\n  private requestId: number;\n\n  constructor(opts: CreateTRPCClientOptions<TInferrable>) {\n    this.requestId = 0;\n\n    this.runtime = {};\n\n    // Initialize the links\n    this.links = opts.links.map((link) => link(this.runtime));\n  }\n\n  private $request<TInput = unknown, TOutput = unknown>(opts: {\n    type: TRPCType;\n    input: TInput;\n    path: string;\n    context?: OperationContext;\n    signal: Maybe<AbortSignal>;\n  }) {\n    const chain$ = createChain<AnyRouter, TInput, TOutput>({\n      links: this.links as OperationLink<any, any, any>[],\n      op: {\n        ...opts,\n        context: opts.context ?? {},\n        id: ++this.requestId,\n      },\n    });\n    return chain$.pipe(share());\n  }\n\n  private async requestAsPromise<TInput = unknown, TOutput = unknown>(opts: {\n    type: TRPCType;\n    input: TInput;\n    path: string;\n    context?: OperationContext;\n    signal: Maybe<AbortSignal>;\n  }): Promise<TOutput> {\n    try {\n      const req$ = this.$request<TInput, TOutput>(opts);\n      type TValue = inferObservableValue<typeof req$>;\n\n      const envelope = await observableToPromise<TValue>(req$);\n      const data = (envelope.result as any).data;\n      return data;\n    } catch (err) {\n      throw TRPCClientError.from(err as Error);\n    }\n  }\n  public query(path: string, input?: unknown, opts?: TRPCRequestOptions) {\n    return this.requestAsPromise<unknown, unknown>({\n      type: 'query',\n      path,\n      input,\n      context: opts?.context,\n      signal: opts?.signal,\n    });\n  }\n  public mutation(path: string, input?: unknown, opts?: TRPCRequestOptions) {\n    return this.requestAsPromise<unknown, unknown>({\n      type: 'mutation',\n      path,\n      input,\n      context: opts?.context,\n      signal: opts?.signal,\n    });\n  }\n  public subscription(\n    path: string,\n    input: unknown,\n    opts: Partial<\n      TRPCSubscriptionObserver<unknown, TRPCClientError<AnyRouter>>\n    > &\n      TRPCRequestOptions,\n  ): Unsubscribable {\n    const observable$ = this.$request({\n      type: 'subscription',\n      path,\n      input,\n      context: opts.context,\n      signal: opts.signal,\n    });\n    return observable$.subscribe({\n      next(envelope) {\n        switch (envelope.result.type) {\n          case 'state': {\n            opts.onConnectionStateChange?.(envelope.result);\n            break;\n          }\n          case 'started': {\n            opts.onStarted?.({\n              context: envelope.context,\n            });\n            break;\n          }\n          case 'stopped': {\n            opts.onStopped?.();\n            break;\n          }\n          case 'data':\n          case undefined: {\n            opts.onData?.(envelope.result.data);\n            break;\n          }\n        }\n      },\n      error(err) {\n        opts.onError?.(err);\n      },\n      complete() {\n        opts.onComplete?.();\n      },\n    });\n  }\n}\n"],"mappings":";;;;;AA8CA,IAAa,oBAAb,MAA0E;CACxE,AAAiB;CACjB,AAAgB;CAChB,AAAQ;CAER,YAAYA,MAA4C;AACtD,OAAK,YAAY;AAEjB,OAAK,UAAU,CAAE;AAGjB,OAAK,QAAQ,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,KAAK,QAAQ,CAAC;CAC1D;CAED,AAAQ,SAA8CC,MAMnD;EACD,MAAM,SAAS,YAAwC;GACrD,OAAO,KAAK;GACZ,IAAI;IACF,GAAG;IACH,SAAS,KAAK,WAAW,CAAE;IAC3B,IAAI,EAAE,KAAK;GACZ;EACF,EAAC;AACF,SAAO,OAAO,KAAK,OAAO,CAAC;CAC5B;CAED,MAAc,iBAAsDA,MAM/C;AACnB,MAAI;GACF,MAAM,OAAO,KAAK,SAA0B,KAAK;GAGjD,MAAM,WAAW,MAAM,oBAA4B,KAAK;GACxD,MAAM,OAAQ,SAAS,OAAe;AACtC,UAAO;EACR,SAAQ,KAAK;AACZ,SAAM,gBAAgB,KAAK,IAAa;EACzC;CACF;CACD,AAAO,MAAMC,MAAcC,OAAiBC,MAA2B;AACrE,SAAO,KAAK,iBAAmC;GAC7C,MAAM;GACN;GACA;GACA,SAAS,MAAM;GACf,QAAQ,MAAM;EACf,EAAC;CACH;CACD,AAAO,SAASF,MAAcC,OAAiBC,MAA2B;AACxE,SAAO,KAAK,iBAAmC;GAC7C,MAAM;GACN;GACA;GACA,SAAS,MAAM;GACf,QAAQ,MAAM;EACf,EAAC;CACH;CACD,AAAO,aACLF,MACAG,OACAC,MAIgB;EAChB,MAAM,cAAc,KAAK,SAAS;GAChC,MAAM;GACN;GACA;GACA,SAAS,KAAK;GACd,QAAQ,KAAK;EACd,EAAC;AACF,SAAO,YAAY,UAAU;GAC3B,KAAK,UAAU;AACb,YAAQ,SAAS,OAAO,MAAxB;KACE,KAAK,SAAS;AACZ,WAAK,0BAA0B,SAAS,OAAO;AAC/C;KACD;KACD,KAAK,WAAW;AACd,WAAK,YAAY,EACf,SAAS,SAAS,QACnB,EAAC;AACF;KACD;KACD,KAAK,WAAW;AACd,WAAK,aAAa;AAClB;KACD;KACD,KAAK;KACL,aAAgB;AACd,WAAK,SAAS,SAAS,OAAO,KAAK;AACnC;KACD;IACF;GACF;GACD,MAAM,KAAK;AACT,SAAK,UAAU,IAAI;GACpB;GACD,WAAW;AACT,SAAK,cAAc;GACpB;EACF,EAAC;CACH;AACF"}

package/dist/internals/dataLoader.js

@@ -1,121 +1,106 @@
-'use strict';
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ /**
- * A function that should never be called unless we messed something up.
- */ const throwFatalError = ()=>{
-    throw new Error('Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new');
+//#region src/internals/dataLoader.ts
+/**
+* A function that should never be called unless we messed something up.
+*/
+const throwFatalError = () => {
+	throw new Error("Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new");
 };
 /**
- * Dataloader that's very inspired by https://github.com/graphql/dataloader
- * Less configuration, no caching, and allows you to cancel requests
- * When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
- */ function dataLoader(batchLoader) {
-    let pendingItems = null;
-    let dispatchTimer = null;
-    const destroyTimerAndPendingItems = ()=>{
-        clearTimeout(dispatchTimer);
-        dispatchTimer = null;
-        pendingItems = null;
-    };
-    /**
-   * Iterate through the items and split them into groups based on the `batchLoader`'s validate function
-   */ function groupItems(items) {
-        const groupedItems = [
-            []
-        ];
-        let index = 0;
-        while(true){
-            const item = items[index];
-            if (!item) {
-                break;
-            }
-            const lastGroup = groupedItems[groupedItems.length - 1];
-            if (item.aborted) {
-                // Item was aborted before it was dispatched
-                item.reject?.(new Error('Aborted'));
-                index++;
-                continue;
-            }
-            const isValid = batchLoader.validate(lastGroup.concat(item).map((it)=>it.key));
-            if (isValid) {
-                lastGroup.push(item);
-                index++;
-                continue;
-            }
-            if (lastGroup.length === 0) {
-                item.reject?.(new Error('Input is too big for a single dispatch'));
-                index++;
-                continue;
-            }
-            // Create new group, next iteration will try to add the item to that
-            groupedItems.push([]);
-        }
-        return groupedItems;
-    }
-    function dispatch() {
-        const groupedItems = groupItems(pendingItems);
-        destroyTimerAndPendingItems();
-        // Create batches for each group of items
-        for (const items of groupedItems){
-            if (!items.length) {
-                continue;
-            }
-            const batch = {
-                items
-            };
-            for (const item of items){
-                item.batch = batch;
-            }
-            const promise = batchLoader.fetch(batch.items.map((_item)=>_item.key));
-            promise.then(async (result)=>{
-                await Promise.all(result.map(async (valueOrPromise, index)=>{
-                    const item = batch.items[index];
-                    try {
-                        const value = await Promise.resolve(valueOrPromise);
-                        item.resolve?.(value);
-                    } catch (cause) {
-                        item.reject?.(cause);
-                    }
-                    item.batch = null;
-                    item.reject = null;
-                    item.resolve = null;
-                }));
-                for (const item of batch.items){
-                    item.reject?.(new Error('Missing result'));
-                    item.batch = null;
-                }
-            }).catch((cause)=>{
-                for (const item of batch.items){
-                    item.reject?.(cause);
-                    item.batch = null;
-                }
-            });
-        }
-    }
-    function load(key) {
-        const item = {
-            aborted: false,
-            key,
-            batch: null,
-            resolve: throwFatalError,
-            reject: throwFatalError
-        };
-        const promise = new Promise((resolve, reject)=>{
-            item.reject = reject;
-            item.resolve = resolve;
-            if (!pendingItems) {
-                pendingItems = [];
-            }
-            pendingItems.push(item);
-        });
-        if (!dispatchTimer) {
-            dispatchTimer = setTimeout(dispatch);
-        }
-        return promise;
-    }
-    return {
-        load
-    };
+* Dataloader that's very inspired by https://github.com/graphql/dataloader
+* Less configuration, no caching, and allows you to cancel requests
+* When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
+*/
+function dataLoader(batchLoader) {
+	let pendingItems = null;
+	let dispatchTimer = null;
+	const destroyTimerAndPendingItems = () => {
+		clearTimeout(dispatchTimer);
+		dispatchTimer = null;
+		pendingItems = null;
+	};
+	/**
+	* Iterate through the items and split them into groups based on the `batchLoader`'s validate function
+	*/
+	function groupItems(items) {
+		const groupedItems = [[]];
+		let index = 0;
+		while (true) {
+			const item = items[index];
+			if (!item) break;
+			const lastGroup = groupedItems[groupedItems.length - 1];
+			if (item.aborted) {
+				item.reject?.(new Error("Aborted"));
+				index++;
+				continue;
+			}
+			const isValid = batchLoader.validate(lastGroup.concat(item).map((it) => it.key));
+			if (isValid) {
+				lastGroup.push(item);
+				index++;
+				continue;
+			}
+			if (lastGroup.length === 0) {
+				item.reject?.(new Error("Input is too big for a single dispatch"));
+				index++;
+				continue;
+			}
+			groupedItems.push([]);
+		}
+		return groupedItems;
+	}
+	function dispatch() {
+		const groupedItems = groupItems(pendingItems);
+		destroyTimerAndPendingItems();
+		for (const items of groupedItems) {
+			if (!items.length) continue;
+			const batch = { items };
+			for (const item of items) item.batch = batch;
+			const promise = batchLoader.fetch(batch.items.map((_item) => _item.key));
+			promise.then(async (result) => {
+				await Promise.all(result.map(async (valueOrPromise, index) => {
+					const item = batch.items[index];
+					try {
+						const value = await Promise.resolve(valueOrPromise);
+						item.resolve?.(value);
+					} catch (cause) {
+						item.reject?.(cause);
+					}
+					item.batch = null;
+					item.reject = null;
+					item.resolve = null;
+				}));
+				for (const item of batch.items) {
+					item.reject?.(new Error("Missing result"));
+					item.batch = null;
+				}
+			}).catch((cause) => {
+				for (const item of batch.items) {
+					item.reject?.(cause);
+					item.batch = null;
+				}
+			});
+		}
+	}
+	function load(key) {
+		const item = {
+			aborted: false,
+			key,
+			batch: null,
+			resolve: throwFatalError,
+			reject: throwFatalError
+		};
+		const promise = new Promise((resolve, reject) => {
+			item.reject = reject;
+			item.resolve = resolve;
+			pendingItems ??= [];
+			pendingItems.push(item);
+		});
+		dispatchTimer ??= setTimeout(dispatch);
+		return promise;
+	}
+	return { load };
 }
 
-exports.dataLoader = dataLoader;
+//#endregion
+exports.dataLoader = dataLoader;