@trpc/server/dist/observable-xBsJ11Ns.cjs

The tRPC server library

const require_observable = require("./observable-C-LvH26G.cjs");
//#region src/observable/operators.ts
function map(project) {
	return (source) => {
		return require_observable.observable((destination) => {
			let index = 0;
			return source.subscribe({
				next(value) {
					destination.next(project(value, index++));
				},
				error(error) {
					destination.error(error);
				},
				complete() {
					destination.complete();
				}
			});
		});
	};
}
function share(_opts) {
	return (source) => {
		let refCount = 0;
		let subscription = null;
		let isConnecting = false;
		let observers = /* @__PURE__ */ new Set();
		function startIfNeeded() {
			if (subscription || isConnecting) return;
			isConnecting = true;
			let isDone = false;
			let sourceSubscription;
			try {
				sourceSubscription = source.subscribe({
					next(value) {
						notify(observers, (observer) => {
							var _observer$next;
							return (_observer$next = observer.next) === null || _observer$next === void 0 ? void 0 : _observer$next.call(observer, value);
						});
					},
					error(error) {
						isDone = true;
						terminate((observer) => {
							var _observer$error;
							return (_observer$error = observer.error) === null || _observer$error === void 0 ? void 0 : _observer$error.call(observer, error);
						});
					},
					complete() {
						isDone = true;
						terminate((observer) => {
							var _observer$complete;
							return (_observer$complete = observer.complete) === null || _observer$complete === void 0 ? void 0 : _observer$complete.call(observer);
						});
					}
				});
			} finally {
				isConnecting = false;
			}
			if (isDone) sourceSubscription.unsubscribe();
			else subscription = sourceSubscription;
		}
		function notify(targets, callback) {
			for (const observer of [...targets]) if (targets.has(observer)) callback(observer);
		}
		function terminate(callback) {
			const _sub = subscription;
			const terminatedObservers = observers;
			subscription = null;
			observers = /* @__PURE__ */ new Set();
			isConnecting = false;
			try {
				notify(terminatedObservers, callback);
			} finally {
				_sub === null || _sub === void 0 || _sub.unsubscribe();
			}
		}
		function resetSource() {
			const _sub = subscription;
			subscription = null;
			_sub === null || _sub === void 0 || _sub.unsubscribe();
		}
		function resetIfNeeded() {
			if (refCount === 0 && subscription) resetSource();
		}
		return require_observable.observable((subscriber) => {
			refCount++;
			const subscriberObservers = observers;
			subscriberObservers.add(subscriber);
			startIfNeeded();
			return { unsubscribe() {
				refCount--;
				resetIfNeeded();
				subscriberObservers.delete(subscriber);
			} };
		});
	};
}
function tap(observer) {
	return (source) => {
		return require_observable.observable((destination) => {
			return source.subscribe({
				next(value) {
					var _observer$next2;
					(_observer$next2 = observer.next) === null || _observer$next2 === void 0 || _observer$next2.call(observer, value);
					destination.next(value);
				},
				error(error) {
					var _observer$error2;
					(_observer$error2 = observer.error) === null || _observer$error2 === void 0 || _observer$error2.call(observer, error);
					destination.error(error);
				},
				complete() {
					var _observer$complete2;
					(_observer$complete2 = observer.complete) === null || _observer$complete2 === void 0 || _observer$complete2.call(observer);
					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;
	return !!(a && b && typeof a === "object" && typeof b === "object") && 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;
	}
});