@trpc/server 11.3.1-canary.1 → 11.3.2-canary.2

package/dist/observable-B1orLHHI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable-B1orLHHI.mjs","names":["x: unknown","subscribe: (observer: Observer<TValue, TError>) => TeardownLogic","self: Observable<TValue, TError>","teardownRef: TeardownLogic | null","prev: any","fn: UnaryFunction<any, any>","observable: Observable<TValue, unknown>","signal: AbortSignal","unsub: Unsubscribable | null","observable","iterator: AsyncIterator<TValue>"],"sources":["../src/observable/observable.ts"],"sourcesContent":["import type { Result } from '../unstable-core-do-not-import';\nimport type {\n  Observable,\n  Observer,\n  OperatorFunction,\n  TeardownLogic,\n  UnaryFunction,\n  Unsubscribable,\n} from './types';\n\n/** @public */\nexport type inferObservableValue<TObservable> =\n  TObservable extends Observable<infer TValue, unknown> ? TValue : never;\n\n/** @public */\nexport function isObservable(x: unknown): x is Observable<unknown, unknown> {\n  return typeof x === 'object' && x !== null && 'subscribe' in x;\n}\n\n/** @public */\nexport function observable<TValue, TError = unknown>(\n  subscribe: (observer: Observer<TValue, TError>) => TeardownLogic,\n): Observable<TValue, TError> {\n  const self: Observable<TValue, TError> = {\n    subscribe(observer) {\n      let teardownRef: TeardownLogic | null = null;\n      let isDone = false;\n      let unsubscribed = false;\n      let teardownImmediately = false;\n      function unsubscribe() {\n        if (teardownRef === null) {\n          teardownImmediately = true;\n          return;\n        }\n        if (unsubscribed) {\n          return;\n        }\n        unsubscribed = true;\n\n        if (typeof teardownRef === 'function') {\n          teardownRef();\n        } else if (teardownRef) {\n          teardownRef.unsubscribe();\n        }\n      }\n      teardownRef = subscribe({\n        next(value) {\n          if (isDone) {\n            return;\n          }\n          observer.next?.(value);\n        },\n        error(err) {\n          if (isDone) {\n            return;\n          }\n          isDone = true;\n          observer.error?.(err);\n          unsubscribe();\n        },\n        complete() {\n          if (isDone) {\n            return;\n          }\n          isDone = true;\n          observer.complete?.();\n          unsubscribe();\n        },\n      });\n      if (teardownImmediately) {\n        unsubscribe();\n      }\n      return {\n        unsubscribe,\n      };\n    },\n    pipe(\n      ...operations: OperatorFunction<any, any, any, any>[]\n    ): Observable<any, any> {\n      return operations.reduce(pipeReducer, self);\n    },\n  };\n  return self;\n}\n\nfunction pipeReducer(prev: any, fn: UnaryFunction<any, any>) {\n  return fn(prev);\n}\n\n/** @internal */\nexport function observableToPromise<TValue>(\n  observable: Observable<TValue, unknown>,\n) {\n  const ac = new AbortController();\n  const promise = new Promise<TValue>((resolve, reject) => {\n    let isDone = false;\n    function onDone() {\n      if (isDone) {\n        return;\n      }\n      isDone = true;\n      obs$.unsubscribe();\n    }\n    ac.signal.addEventListener('abort', () => {\n      reject(ac.signal.reason);\n    });\n    const obs$ = observable.subscribe({\n      next(data) {\n        isDone = true;\n        resolve(data);\n        onDone();\n      },\n      error(data) {\n        reject(data);\n      },\n      complete() {\n        ac.abort();\n        onDone();\n      },\n    });\n  });\n  return promise;\n}\n\n/**\n * @internal\n */\nfunction observableToReadableStream<TValue>(\n  observable: Observable<TValue, unknown>,\n  signal: AbortSignal,\n): ReadableStream<Result<TValue>> {\n  let unsub: Unsubscribable | null = null;\n\n  const onAbort = () => {\n    unsub?.unsubscribe();\n    unsub = null;\n    signal.removeEventListener('abort', onAbort);\n  };\n\n  return new ReadableStream<Result<TValue>>({\n    start(controller) {\n      unsub = observable.subscribe({\n        next(data) {\n          controller.enqueue({ ok: true, value: data });\n        },\n        error(error) {\n          controller.enqueue({ ok: false, error });\n          controller.close();\n        },\n        complete() {\n          controller.close();\n        },\n      });\n\n      if (signal.aborted) {\n        onAbort();\n      } else {\n        signal.addEventListener('abort', onAbort, { once: true });\n      }\n    },\n    cancel() {\n      onAbort();\n    },\n  });\n}\n\n/** @internal */\nexport function observableToAsyncIterable<TValue>(\n  observable: Observable<TValue, unknown>,\n  signal: AbortSignal,\n): AsyncIterable<TValue> {\n  const stream = observableToReadableStream(observable, signal);\n\n  const reader = stream.getReader();\n  const iterator: AsyncIterator<TValue> = {\n    async next() {\n      const value = await reader.read();\n      if (value.done) {\n        return {\n          value: undefined,\n          done: true,\n        };\n      }\n      const { value: result } = value;\n      if (!result.ok) {\n        throw result.error;\n      }\n      return {\n        value: result.value,\n        done: false,\n      };\n    },\n    async return() {\n      await reader.cancel();\n      return {\n        value: undefined,\n        done: true,\n      };\n    },\n  };\n  return {\n    [Symbol.asyncIterator]() {\n      return iterator;\n    },\n  };\n}\n"],"mappings":";;AAeA,SAAgB,aAAaA,GAA+C;AAC1E,eAAc,MAAM,YAAY,MAAM,QAAQ,eAAe;AAC9D;;AAGD,SAAgB,WACdC,WAC4B;CAC5B,MAAMC,OAAmC;EACvC,UAAU,UAAU;GAClB,IAAIC,cAAoC;GACxC,IAAI,SAAS;GACb,IAAI,eAAe;GACnB,IAAI,sBAAsB;GAC1B,SAAS,cAAc;AACrB,QAAI,gBAAgB,MAAM;AACxB,2BAAsB;AACtB;IACD;AACD,QAAI,aACF;AAEF,mBAAe;AAEf,eAAW,gBAAgB,WACzB,cAAa;aACJ,YACT,aAAY,aAAa;GAE5B;AACD,iBAAc,UAAU;IACtB,KAAK,OAAO;AACV,SAAI,OACF;AAEF,cAAS,OAAO,MAAM;IACvB;IACD,MAAM,KAAK;AACT,SAAI,OACF;AAEF,cAAS;AACT,cAAS,QAAQ,IAAI;AACrB,kBAAa;IACd;IACD,WAAW;AACT,SAAI,OACF;AAEF,cAAS;AACT,cAAS,YAAY;AACrB,kBAAa;IACd;GACF,EAAC;AACF,OAAI,oBACF,cAAa;AAEf,UAAO,EACL,YACD;EACF;EACD,KACE,GAAG,YACmB;AACtB,UAAO,WAAW,OAAO,aAAa,KAAK;EAC5C;CACF;AACD,QAAO;AACR;AAED,SAAS,YAAYC,MAAWC,IAA6B;AAC3D,QAAO,GAAG,KAAK;AAChB;;AAGD,SAAgB,oBACdC,cACA;CACA,MAAM,KAAK,IAAI;CACf,MAAM,UAAU,IAAI,QAAgB,CAAC,SAAS,WAAW;EACvD,IAAI,SAAS;EACb,SAAS,SAAS;AAChB,OAAI,OACF;AAEF,YAAS;AACT,QAAK,aAAa;EACnB;AACD,KAAG,OAAO,iBAAiB,SAAS,MAAM;AACxC,UAAO,GAAG,OAAO,OAAO;EACzB,EAAC;EACF,MAAM,OAAO,aAAW,UAAU;GAChC,KAAK,MAAM;AACT,aAAS;AACT,YAAQ,KAAK;AACb,YAAQ;GACT;GACD,MAAM,MAAM;AACV,WAAO,KAAK;GACb;GACD,WAAW;AACT,OAAG,OAAO;AACV,YAAQ;GACT;EACF,EAAC;CACH;AACD,QAAO;AACR;;;;AAKD,SAAS,2BACPA,cACAC,QACgC;CAChC,IAAIC,QAA+B;CAEnC,MAAM,UAAU,MAAM;AACpB,SAAO,aAAa;AACpB,UAAQ;AACR,SAAO,oBAAoB,SAAS,QAAQ;CAC7C;AAED,QAAO,IAAI,eAA+B;EACxC,MAAM,YAAY;AAChB,WAAQ,aAAW,UAAU;IAC3B,KAAK,MAAM;AACT,gBAAW,QAAQ;MAAE,IAAI;MAAM,OAAO;KAAM,EAAC;IAC9C;IACD,MAAM,OAAO;AACX,gBAAW,QAAQ;MAAE,IAAI;MAAO;KAAO,EAAC;AACxC,gBAAW,OAAO;IACnB;IACD,WAAW;AACT,gBAAW,OAAO;IACnB;GACF,EAAC;AAEF,OAAI,OAAO,QACT,UAAS;OAET,QAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAM,EAAC;EAE5D;EACD,SAAS;AACP,YAAS;EACV;CACF;AACF;;AAGD,SAAgB,0BACdF,cACAC,QACuB;CACvB,MAAM,SAAS,2BAA2BE,cAAY,OAAO;CAE7D,MAAM,SAAS,OAAO,WAAW;CACjC,MAAMC,WAAkC;EACtC,MAAM,OAAO;GACX,MAAM,QAAQ,MAAM,OAAO,MAAM;AACjC,OAAI,MAAM,KACR,QAAO;IACL;IACA,MAAM;GACP;GAEH,MAAM,EAAE,OAAO,QAAQ,GAAG;AAC1B,QAAK,OAAO,GACV,OAAM,OAAO;AAEf,UAAO;IACL,OAAO,OAAO;IACd,MAAM;GACP;EACF;EACD,MAAM,SAAS;AACb,SAAM,OAAO,QAAQ;AACrB,UAAO;IACL;IACA,MAAM;GACP;EACF;CACF;AACD,QAAO,EACL,CAAC,OAAO,iBAAiB;AACvB,SAAO;CACR,EACF;AACF"}

package/dist/observable-BwdrSFZU.cjs

@@ -0,0 +1,178 @@
+
+//#region src/observable/observable.ts
+/** @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 operations.reduce(pipeReducer, self);
+		}
+	};
+	return self;
+}
+function pipeReducer(prev, fn) {
+	return fn(prev);
+}
+/** @internal */
+function observableToPromise(observable$1) {
+	const ac = new AbortController();
+	const promise = new Promise((resolve, reject) => {
+		let isDone = false;
+		function onDone() {
+			if (isDone) return;
+			isDone = true;
+			obs$.unsubscribe();
+		}
+		ac.signal.addEventListener("abort", () => {
+			reject(ac.signal.reason);
+		});
+		const obs$ = observable$1.subscribe({
+			next(data) {
+				isDone = true;
+				resolve(data);
+				onDone();
+			},
+			error(data) {
+				reject(data);
+			},
+			complete() {
+				ac.abort();
+				onDone();
+			}
+		});
+	});
+	return promise;
+}
+/**
+* @internal
+*/
+function observableToReadableStream(observable$1, signal) {
+	let unsub = null;
+	const onAbort = () => {
+		unsub?.unsubscribe();
+		unsub = null;
+		signal.removeEventListener("abort", onAbort);
+	};
+	return new ReadableStream({
+		start(controller) {
+			unsub = observable$1.subscribe({
+				next(data) {
+					controller.enqueue({
+						ok: true,
+						value: data
+					});
+				},
+				error(error) {
+					controller.enqueue({
+						ok: false,
+						error
+					});
+					controller.close();
+				},
+				complete() {
+					controller.close();
+				}
+			});
+			if (signal.aborted) onAbort();
+			else signal.addEventListener("abort", onAbort, { once: true });
+		},
+		cancel() {
+			onAbort();
+		}
+	});
+}
+/** @internal */
+function observableToAsyncIterable(observable$1, signal) {
+	const stream = observableToReadableStream(observable$1, signal);
+	const reader = stream.getReader();
+	const iterator = {
+		async next() {
+			const value = await reader.read();
+			if (value.done) return {
+				value: void 0,
+				done: true
+			};
+			const { value: result } = value;
+			if (!result.ok) throw result.error;
+			return {
+				value: result.value,
+				done: false
+			};
+		},
+		async return() {
+			await reader.cancel();
+			return {
+				value: void 0,
+				done: true
+			};
+		}
+	};
+	return { [Symbol.asyncIterator]() {
+		return iterator;
+	} };
+}
+
+//#endregion
+Object.defineProperty(exports, 'isObservable', {
+  enumerable: true,
+  get: function () {
+    return isObservable;
+  }
+});
+Object.defineProperty(exports, 'observable', {
+  enumerable: true,
+  get: function () {
+    return observable;
+  }
+});
+Object.defineProperty(exports, 'observableToAsyncIterable', {
+  enumerable: true,
+  get: function () {
+    return observableToAsyncIterable;
+  }
+});
+Object.defineProperty(exports, 'observableToPromise', {
+  enumerable: true,
+  get: function () {
+    return observableToPromise;
+  }
+});

package/dist/observable-C6qq2Ydk.cjs

@@ -0,0 +1,180 @@
+const require_observable = require('./observable-BwdrSFZU.cjs');
+
+//#region src/observable/operators.ts
+function map(project) {
+	return (source) => {
+		return require_observable.observable((destination) => {
+			let index = 0;
+			const subscription = source.subscribe({
+				next(value) {
+					destination.next(project(value, index++));
+				},
+				error(error) {
+					destination.error(error);
+				},
+				complete() {
+					destination.complete();
+				}
+			});
+			return subscription;
+		});
+	};
+}
+function share(_opts) {
+	return (source) => {
+		let refCount = 0;
+		let subscription = null;
+		const observers = [];
+		function startIfNeeded() {
+			if (subscription) return;
+			subscription = source.subscribe({
+				next(value) {
+					for (const observer of observers) observer.next?.(value);
+				},
+				error(error) {
+					for (const observer of observers) observer.error?.(error);
+				},
+				complete() {
+					for (const observer of observers) observer.complete?.();
+				}
+			});
+		}
+		function resetIfNeeded() {
+			if (refCount === 0 && subscription) {
+				const _sub = subscription;
+				subscription = null;
+				_sub.unsubscribe();
+			}
+		}
+		return require_observable.observable((subscriber) => {
+			refCount++;
+			observers.push(subscriber);
+			startIfNeeded();
+			return { unsubscribe() {
+				refCount--;
+				resetIfNeeded();
+				const index = observers.findIndex((v) => v === subscriber);
+				if (index > -1) observers.splice(index, 1);
+			} };
+		});
+	};
+}
+function tap(observer) {
+	return (source) => {
+		return require_observable.observable((destination) => {
+			return source.subscribe({
+				next(value) {
+					observer.next?.(value);
+					destination.next(value);
+				},
+				error(error) {
+					observer.error?.(error);
+					destination.error(error);
+				},
+				complete() {
+					observer.complete?.();
+					destination.complete();
+				}
+			});
+		});
+	};
+}
+const distinctUnsetMarker = Symbol();
+function distinctUntilChanged(compare = (a, b) => a === b) {
+	return (source) => {
+		return require_observable.observable((destination) => {
+			let lastValue = distinctUnsetMarker;
+			return source.subscribe({
+				next(value) {
+					if (lastValue !== distinctUnsetMarker && compare(lastValue, value)) return;
+					lastValue = value;
+					destination.next(value);
+				},
+				error(error) {
+					destination.error(error);
+				},
+				complete() {
+					destination.complete();
+				}
+			});
+		});
+	};
+}
+const isDeepEqual = (a, b) => {
+	if (a === b) return true;
+	const bothAreObjects = a && b && typeof a === "object" && typeof b === "object";
+	return !!bothAreObjects && Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([k, v]) => isDeepEqual(v, b[k]));
+};
+function distinctUntilDeepChanged() {
+	return distinctUntilChanged(isDeepEqual);
+}
+
+//#endregion
+//#region src/observable/behaviorSubject.ts
+/**
+* @internal
+* An observable that maintains and provides a "current value" to subscribers
+* @see https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject
+*/
+function behaviorSubject(initialValue) {
+	let value = initialValue;
+	const observerList = [];
+	const addObserver = (observer) => {
+		if (value !== void 0) observer.next(value);
+		observerList.push(observer);
+	};
+	const removeObserver = (observer) => {
+		observerList.splice(observerList.indexOf(observer), 1);
+	};
+	const obs = require_observable.observable((observer) => {
+		addObserver(observer);
+		return () => {
+			removeObserver(observer);
+		};
+	});
+	obs.next = (nextValue) => {
+		if (value === nextValue) return;
+		value = nextValue;
+		for (const observer of observerList) observer.next(nextValue);
+	};
+	obs.get = () => value;
+	return obs;
+}
+
+//#endregion
+Object.defineProperty(exports, 'behaviorSubject', {
+  enumerable: true,
+  get: function () {
+    return behaviorSubject;
+  }
+});
+Object.defineProperty(exports, 'distinctUntilChanged', {
+  enumerable: true,
+  get: function () {
+    return distinctUntilChanged;
+  }
+});
+Object.defineProperty(exports, 'distinctUntilDeepChanged', {
+  enumerable: true,
+  get: function () {
+    return distinctUntilDeepChanged;
+  }
+});
+Object.defineProperty(exports, 'map', {
+  enumerable: true,
+  get: function () {
+    return map;
+  }
+});
+Object.defineProperty(exports, 'share', {
+  enumerable: true,
+  get: function () {
+    return share;
+  }
+});
+Object.defineProperty(exports, 'tap', {
+  enumerable: true,
+  get: function () {
+    return tap;
+  }
+});

package/dist/observable-CFXA_tyK.mjs

@@ -0,0 +1,146 @@
+import { observable } from "./observable-B1orLHHI.mjs";
+
+//#region src/observable/operators.ts
+function map(project) {
+	return (source) => {
+		return observable((destination) => {
+			let index = 0;
+			const subscription = source.subscribe({
+				next(value) {
+					destination.next(project(value, index++));
+				},
+				error(error) {
+					destination.error(error);
+				},
+				complete() {
+					destination.complete();
+				}
+			});
+			return subscription;
+		});
+	};
+}
+function share(_opts) {
+	return (source) => {
+		let refCount = 0;
+		let subscription = null;
+		const observers = [];
+		function startIfNeeded() {
+			if (subscription) return;
+			subscription = source.subscribe({
+				next(value) {
+					for (const observer of observers) observer.next?.(value);
+				},
+				error(error) {
+					for (const observer of observers) observer.error?.(error);
+				},
+				complete() {
+					for (const observer of observers) observer.complete?.();
+				}
+			});
+		}
+		function resetIfNeeded() {
+			if (refCount === 0 && subscription) {
+				const _sub = subscription;
+				subscription = null;
+				_sub.unsubscribe();
+			}
+		}
+		return observable((subscriber) => {
+			refCount++;
+			observers.push(subscriber);
+			startIfNeeded();
+			return { unsubscribe() {
+				refCount--;
+				resetIfNeeded();
+				const index = observers.findIndex((v) => v === subscriber);
+				if (index > -1) observers.splice(index, 1);
+			} };
+		});
+	};
+}
+function tap(observer) {
+	return (source) => {
+		return observable((destination) => {
+			return source.subscribe({
+				next(value) {
+					observer.next?.(value);
+					destination.next(value);
+				},
+				error(error) {
+					observer.error?.(error);
+					destination.error(error);
+				},
+				complete() {
+					observer.complete?.();
+					destination.complete();
+				}
+			});
+		});
+	};
+}
+const distinctUnsetMarker = Symbol();
+function distinctUntilChanged(compare = (a, b) => a === b) {
+	return (source) => {
+		return observable((destination) => {
+			let lastValue = distinctUnsetMarker;
+			return source.subscribe({
+				next(value) {
+					if (lastValue !== distinctUnsetMarker && compare(lastValue, value)) return;
+					lastValue = value;
+					destination.next(value);
+				},
+				error(error) {
+					destination.error(error);
+				},
+				complete() {
+					destination.complete();
+				}
+			});
+		});
+	};
+}
+const isDeepEqual = (a, b) => {
+	if (a === b) return true;
+	const bothAreObjects = a && b && typeof a === "object" && typeof b === "object";
+	return !!bothAreObjects && Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([k, v]) => isDeepEqual(v, b[k]));
+};
+function distinctUntilDeepChanged() {
+	return distinctUntilChanged(isDeepEqual);
+}
+
+//#endregion
+//#region src/observable/behaviorSubject.ts
+/**
+* @internal
+* An observable that maintains and provides a "current value" to subscribers
+* @see https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject
+*/
+function behaviorSubject(initialValue) {
+	let value = initialValue;
+	const observerList = [];
+	const addObserver = (observer) => {
+		if (value !== void 0) observer.next(value);
+		observerList.push(observer);
+	};
+	const removeObserver = (observer) => {
+		observerList.splice(observerList.indexOf(observer), 1);
+	};
+	const obs = observable((observer) => {
+		addObserver(observer);
+		return () => {
+			removeObserver(observer);
+		};
+	});
+	obs.next = (nextValue) => {
+		if (value === nextValue) return;
+		value = nextValue;
+		for (const observer of observerList) observer.next(nextValue);
+	};
+	obs.get = () => value;
+	return obs;
+}
+
+//#endregion
+export { behaviorSubject, distinctUntilChanged, distinctUntilDeepChanged, map, share, tap };
+//# sourceMappingURL=observable-CFXA_tyK.mjs.map

package/dist/observable-CFXA_tyK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable-CFXA_tyK.mjs","names":["project: (value: TValueBefore, index: number) => TValueAfter","_opts?: ShareConfig","subscription: Unsubscribable | null","observers: Partial<Observer<TValue, TError>>[]","observer: Partial<Observer<TValue, TError>>","compare: (a: TValue, b: TValue) => boolean","lastValue: TValue | typeof distinctUnsetMarker","a: T","b: T","initialValue: TValue","value: TValue","observerList: Observer<TValue, never>[]","observer: Observer<TValue, never>","nextValue: TValue"],"sources":["../src/observable/operators.ts","../src/observable/behaviorSubject.ts"],"sourcesContent":["import { observable } from './observable';\nimport type {\n  MonoTypeOperatorFunction,\n  Observer,\n  OperatorFunction,\n  Unsubscribable,\n} from './types';\n\nexport function map<TValueBefore, TError, TValueAfter>(\n  project: (value: TValueBefore, index: number) => TValueAfter,\n): OperatorFunction<TValueBefore, TError, TValueAfter, TError> {\n  return (source) => {\n    return observable((destination) => {\n      let index = 0;\n      const subscription = source.subscribe({\n        next(value) {\n          destination.next(project(value, index++));\n        },\n        error(error) {\n          destination.error(error);\n        },\n        complete() {\n          destination.complete();\n        },\n      });\n      return subscription;\n    });\n  };\n}\n\ninterface ShareConfig {}\nexport function share<TValue, TError>(\n  _opts?: ShareConfig,\n): MonoTypeOperatorFunction<TValue, TError> {\n  return (source) => {\n    let refCount = 0;\n\n    let subscription: Unsubscribable | null = null;\n    const observers: Partial<Observer<TValue, TError>>[] = [];\n\n    function startIfNeeded() {\n      if (subscription) {\n        return;\n      }\n      subscription = source.subscribe({\n        next(value) {\n          for (const observer of observers) {\n            observer.next?.(value);\n          }\n        },\n        error(error) {\n          for (const observer of observers) {\n            observer.error?.(error);\n          }\n        },\n        complete() {\n          for (const observer of observers) {\n            observer.complete?.();\n          }\n        },\n      });\n    }\n    function resetIfNeeded() {\n      // \"resetOnRefCountZero\"\n      if (refCount === 0 && subscription) {\n        const _sub = subscription;\n        subscription = null;\n        _sub.unsubscribe();\n      }\n    }\n\n    return observable((subscriber) => {\n      refCount++;\n\n      observers.push(subscriber);\n      startIfNeeded();\n      return {\n        unsubscribe() {\n          refCount--;\n          resetIfNeeded();\n\n          const index = observers.findIndex((v) => v === subscriber);\n\n          if (index > -1) {\n            observers.splice(index, 1);\n          }\n        },\n      };\n    });\n  };\n}\n\nexport function tap<TValue, TError>(\n  observer: Partial<Observer<TValue, TError>>,\n): MonoTypeOperatorFunction<TValue, TError> {\n  return (source) => {\n    return observable((destination) => {\n      return source.subscribe({\n        next(value) {\n          observer.next?.(value);\n          destination.next(value);\n        },\n        error(error) {\n          observer.error?.(error);\n          destination.error(error);\n        },\n        complete() {\n          observer.complete?.();\n          destination.complete();\n        },\n      });\n    });\n  };\n}\n\nconst distinctUnsetMarker = Symbol();\nexport function distinctUntilChanged<TValue, TError>(\n  compare: (a: TValue, b: TValue) => boolean = (a, b) => a === b,\n): MonoTypeOperatorFunction<TValue, TError> {\n  return (source) => {\n    return observable((destination) => {\n      let lastValue: TValue | typeof distinctUnsetMarker = distinctUnsetMarker;\n\n      return source.subscribe({\n        next(value) {\n          if (lastValue !== distinctUnsetMarker && compare(lastValue, value)) {\n            return;\n          }\n          lastValue = value;\n          destination.next(value);\n        },\n        error(error) {\n          destination.error(error);\n        },\n        complete() {\n          destination.complete();\n        },\n      });\n    });\n  };\n}\n\nconst isDeepEqual = <T>(a: T, b: T): boolean => {\n  if (a === b) {\n    return true;\n  }\n  const bothAreObjects =\n    a && b && typeof a === 'object' && typeof b === 'object';\n\n  return (\n    !!bothAreObjects &&\n    Object.keys(a).length === Object.keys(b).length &&\n    Object.entries(a).every(([k, v]) => isDeepEqual(v, b[k as keyof T]))\n  );\n};\nexport function distinctUntilDeepChanged<\n  TValue,\n  TError,\n>(): MonoTypeOperatorFunction<TValue, TError> {\n  return distinctUntilChanged(isDeepEqual);\n}\n","import { observable } from './observable';\nimport type { Observable, Observer } from './types';\n\nexport interface BehaviorSubject<TValue> extends Observable<TValue, never> {\n  observable: Observable<TValue, never>;\n  next: (value: TValue) => void;\n  get: () => TValue;\n}\n\nexport interface ReadonlyBehaviorSubject<TValue>\n  extends Omit<BehaviorSubject<TValue>, 'next'> {}\n\n/**\n * @internal\n * An observable that maintains and provides a \"current value\" to subscribers\n * @see https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject\n */\nexport function behaviorSubject<TValue>(\n  initialValue: TValue,\n): BehaviorSubject<TValue> {\n  let value: TValue = initialValue;\n\n  const observerList: Observer<TValue, never>[] = [];\n\n  const addObserver = (observer: Observer<TValue, never>) => {\n    if (value !== undefined) {\n      observer.next(value);\n    }\n    observerList.push(observer);\n  };\n  const removeObserver = (observer: Observer<TValue, never>) => {\n    observerList.splice(observerList.indexOf(observer), 1);\n  };\n\n  const obs = observable<TValue, never>((observer) => {\n    addObserver(observer);\n    return () => {\n      removeObserver(observer);\n    };\n  }) as BehaviorSubject<TValue>;\n\n  obs.next = (nextValue: TValue) => {\n    if (value === nextValue) {\n      return;\n    }\n    value = nextValue;\n    for (const observer of observerList) {\n      observer.next(nextValue);\n    }\n  };\n\n  obs.get = () => value;\n\n  return obs;\n}\n"],"mappings":"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"}

package/dist/parseTRPCMessage-ByQWigsq.cjs

@@ -0,0 +1,73 @@
+const require_utils = require('./utils-DVO6HZiR.cjs');
+
+//#region src/unstable-core-do-not-import/procedure.ts
+const procedureTypes = [
+	"query",
+	"mutation",
+	"subscription"
+];
+
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/parseTRPCMessage.ts
+/* istanbul ignore next -- @preserve */
+function assertIsObject(obj) {
+	if (!require_utils.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, lastEventId } = params;
+	assertIsString(path);
+	if (lastEventId !== void 0) assertIsString(lastEventId);
+	const input = transformer.input.deserialize(rawInput);
+	return {
+		id,
+		jsonrpc,
+		method,
+		params: {
+			input,
+			path,
+			lastEventId
+		}
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'parseTRPCMessage', {
+  enumerable: true,
+  get: function () {
+    return parseTRPCMessage;
+  }
+});
+Object.defineProperty(exports, 'procedureTypes', {
+  enumerable: true,
+  get: function () {
+    return procedureTypes;
+  }
+});

package/dist/parseTRPCMessage-CNyYMSRB.mjs

@@ -0,0 +1,63 @@
+import { isObject } from "./utils-BHZJcBRv.mjs";
+
+//#region src/unstable-core-do-not-import/procedure.ts
+const procedureTypes = [
+	"query",
+	"mutation",
+	"subscription"
+];
+
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/parseTRPCMessage.ts
+/* 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, lastEventId } = params;
+	assertIsString(path);
+	if (lastEventId !== void 0) assertIsString(lastEventId);
+	const input = transformer.input.deserialize(rawInput);
+	return {
+		id,
+		jsonrpc,
+		method,
+		params: {
+			input,
+			path,
+			lastEventId
+		}
+	};
+}
+
+//#endregion
+export { parseTRPCMessage, procedureTypes };
+//# sourceMappingURL=parseTRPCMessage-CNyYMSRB.mjs.map

package/dist/parseTRPCMessage-CNyYMSRB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseTRPCMessage-CNyYMSRB.mjs","names":["obj: unknown","transformer: CombinedDataTransformer"],"sources":["../src/unstable-core-do-not-import/procedure.ts","../src/unstable-core-do-not-import/rpc/parseTRPCMessage.ts"],"sourcesContent":["import type { TRPCError } from './error/TRPCError';\nimport type { Parser } from './parser';\nimport type { ProcedureCallOptions } from './procedureBuilder';\n\nexport const procedureTypes = ['query', 'mutation', 'subscription'] as const;\n/**\n * @public\n */\nexport type ProcedureType = (typeof procedureTypes)[number];\n\ninterface BuiltProcedureDef {\n  meta: unknown;\n  input: unknown;\n  output: unknown;\n}\n\n/**\n *\n * @internal\n */\nexport interface Procedure<\n  TType extends ProcedureType,\n  TDef extends BuiltProcedureDef,\n> {\n  _def: {\n    /**\n     * These are just types, they can't be used at runtime\n     * @internal\n     */\n    $types: {\n      input: TDef['input'];\n      output: TDef['output'];\n    };\n    procedure: true;\n    type: TType;\n    /**\n     * @internal\n     * Meta is not inferrable on individual procedures, only on the router\n     */\n    meta: unknown;\n    experimental_caller: boolean;\n    /**\n     * The input parsers for the procedure\n     */\n    inputs: Parser[];\n  };\n  meta: TDef['meta'];\n  /**\n   * @internal\n   */\n  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;\n}\n\nexport interface QueryProcedure<TDef extends BuiltProcedureDef>\n  extends Procedure<'query', TDef> {}\n\nexport interface MutationProcedure<TDef extends BuiltProcedureDef>\n  extends Procedure<'mutation', TDef> {}\n\nexport interface SubscriptionProcedure<TDef extends BuiltProcedureDef>\n  extends Procedure<'subscription', TDef> {}\n\n/**\n * @deprecated\n */\nexport interface LegacyObservableSubscriptionProcedure<\n  TDef extends BuiltProcedureDef,\n> extends SubscriptionProcedure<TDef> {\n  _observable: true;\n}\n\nexport type AnyQueryProcedure = QueryProcedure<any>;\nexport type AnyMutationProcedure = MutationProcedure<any>;\nexport type AnySubscriptionProcedure =\n  | SubscriptionProcedure<any>\n  | LegacyObservableSubscriptionProcedure<any>;\n\nexport type AnyProcedure =\n  | AnyQueryProcedure\n  | AnyMutationProcedure\n  | AnySubscriptionProcedure;\n\nexport type inferProcedureInput<TProcedure extends AnyProcedure> =\n  undefined extends inferProcedureParams<TProcedure>['$types']['input']\n    ? void | inferProcedureParams<TProcedure>['$types']['input']\n    : inferProcedureParams<TProcedure>['$types']['input'];\n\nexport type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure\n  ? TProcedure['_def']\n  : never;\nexport type inferProcedureOutput<TProcedure> =\n  inferProcedureParams<TProcedure>['$types']['output'];\n\n/**\n * @internal\n */\nexport interface ErrorHandlerOptions<TContext> {\n  error: TRPCError;\n  type: ProcedureType | 'unknown';\n  path: string | undefined;\n  input: unknown;\n  ctx: TContext | undefined;\n}\n","import { procedureTypes, type ProcedureType } from '../procedure';\nimport type { CombinedDataTransformer } from '../transformer';\nimport { isObject } from '../utils';\nimport type { TRPCClientOutgoingMessage } from './envelopes';\n\n/* istanbul ignore next -- @preserve */\nfunction assertIsObject(obj: unknown): asserts obj is Record<string, unknown> {\n  if (!isObject(obj)) {\n    throw new Error('Not an object');\n  }\n}\n\n/* istanbul ignore next -- @preserve */\nfunction assertIsProcedureType(obj: unknown): asserts obj is ProcedureType {\n  if (!procedureTypes.includes(obj as any)) {\n    throw new Error('Invalid procedure type');\n  }\n}\n\n/* istanbul ignore next -- @preserve */\nfunction assertIsRequestId(\n  obj: unknown,\n): asserts obj is number | string | null {\n  if (\n    obj !== null &&\n    typeof obj === 'number' &&\n    isNaN(obj) &&\n    typeof obj !== 'string'\n  ) {\n    throw new Error('Invalid request id');\n  }\n}\n\n/* istanbul ignore next -- @preserve */\nfunction assertIsString(obj: unknown): asserts obj is string {\n  if (typeof obj !== 'string') {\n    throw new Error('Invalid string');\n  }\n}\n\n/* istanbul ignore next -- @preserve */\nfunction assertIsJSONRPC2OrUndefined(\n  obj: unknown,\n): asserts obj is '2.0' | undefined {\n  if (typeof obj !== 'undefined' && obj !== '2.0') {\n    throw new Error('Must be JSONRPC 2.0');\n  }\n}\n\n/** @public */\nexport function parseTRPCMessage(\n  obj: unknown,\n  transformer: CombinedDataTransformer,\n): TRPCClientOutgoingMessage {\n  assertIsObject(obj);\n\n  const { id, jsonrpc, method, params } = obj;\n  assertIsRequestId(id);\n  assertIsJSONRPC2OrUndefined(jsonrpc);\n\n  if (method === 'subscription.stop') {\n    return {\n      id,\n      jsonrpc,\n      method,\n    };\n  }\n  assertIsProcedureType(method);\n  assertIsObject(params);\n  const { input: rawInput, path, lastEventId } = params;\n\n  assertIsString(path);\n  if (lastEventId !== undefined) {\n    assertIsString(lastEventId);\n  }\n\n  const input = transformer.input.deserialize(rawInput);\n\n  return {\n    id,\n    jsonrpc,\n    method,\n    params: {\n      input,\n      path,\n      lastEventId,\n    },\n  };\n}\n"],"mappings":";;;AAIA,MAAa,iBAAiB;CAAC;CAAS;CAAY;AAAe;;;;;ACEnE,SAAS,eAAeA,KAAsD;AAC5E,MAAK,SAAS,IAAI,CAChB,OAAM,IAAI,MAAM;AAEnB;;AAGD,SAAS,sBAAsBA,KAA4C;AACzE,MAAK,eAAe,SAAS,IAAW,CACtC,OAAM,IAAI,MAAM;AAEnB;;AAGD,SAAS,kBACPA,KACuC;AACvC,KACE,QAAQ,eACD,QAAQ,YACf,MAAM,IAAI,WACH,QAAQ,SAEf,OAAM,IAAI,MAAM;AAEnB;;AAGD,SAAS,eAAeA,KAAqC;AAC3D,YAAW,QAAQ,SACjB,OAAM,IAAI,MAAM;AAEnB;;AAGD,SAAS,4BACPA,KACkC;AAClC,YAAW,QAAQ,eAAe,QAAQ,MACxC,OAAM,IAAI,MAAM;AAEnB;;AAGD,SAAgB,iBACdA,KACAC,aAC2B;AAC3B,gBAAe,IAAI;CAEnB,MAAM,EAAE,IAAI,SAAS,QAAQ,QAAQ,GAAG;AACxC,mBAAkB,GAAG;AACrB,6BAA4B,QAAQ;AAEpC,KAAI,WAAW,oBACb,QAAO;EACL;EACA;EACA;CACD;AAEH,uBAAsB,OAAO;AAC7B,gBAAe,OAAO;CACtB,MAAM,EAAE,OAAO,UAAU,MAAM,aAAa,GAAG;AAE/C,gBAAe,KAAK;AACpB,KAAI,uBACF,gBAAe,YAAY;CAG7B,MAAM,QAAQ,YAAY,MAAM,YAAY,SAAS;AAErD,QAAO;EACL;EACA;EACA;EACA,QAAQ;GACN;GACA;GACA;EACD;CACF;AACF"}