@highstate/designer 0.9.16 → 0.9.18

package/.output/server/node_modules/@trpc/server/dist/observable-CUiPknO-.mjs

@@ -0,0 +1,158 @@
+import { observable } from "./observable-UMO3vUa_.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) {
+						var _observer$next;
+						(_observer$next = observer.next) === null || _observer$next === void 0 || _observer$next.call(observer, value);
+					}
+				},
+				error(error) {
+					for (const observer of observers) {
+						var _observer$error;
+						(_observer$error = observer.error) === null || _observer$error === void 0 || _observer$error.call(observer, error);
+					}
+				},
+				complete() {
+					for (const observer of observers) {
+						var _observer$complete;
+						(_observer$complete = observer.complete) === null || _observer$complete === void 0 || _observer$complete.call(observer);
+					}
+				}
+			});
+		}
+		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) {
+					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 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-CUiPknO-.mjs.map

package/.output/server/node_modules/@trpc/server/dist/observable-UMO3vUa_.mjs

@@ -0,0 +1,158 @@
+//#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) {
+					var _observer$next;
+					if (isDone) return;
+					(_observer$next = observer.next) === null || _observer$next === void 0 || _observer$next.call(observer, value);
+				},
+				error(err) {
+					var _observer$error;
+					if (isDone) return;
+					isDone = true;
+					(_observer$error = observer.error) === null || _observer$error === void 0 || _observer$error.call(observer, err);
+					unsubscribe();
+				},
+				complete() {
+					var _observer$complete;
+					if (isDone) return;
+					isDone = true;
+					(_observer$complete = observer.complete) === null || _observer$complete === void 0 || _observer$complete.call(observer);
+					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 === null || unsub === void 0 || 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
+export { isObservable, observable, observableToAsyncIterable, observableToPromise };
+//# sourceMappingURL=observable-UMO3vUa_.mjs.map

package/.output/server/node_modules/@trpc/server/dist/parseTRPCMessage-ByIHyFRz.mjs

@@ -0,0 +1,63 @@
+import { isObject } from "./utils-DdbbrDku.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-ByIHyFRz.mjs.map