@drfed/web 0.0.0-stage → 0.1.0-dev.0

package/.output/server/_libs/solid-relay+tiny-invariant.mjs

@@ -0,0 +1,1029 @@
+import { r as __toESM } from "../_runtime.mjs";
+import { n as require_relay_runtime, t as require_experimental } from "./relay-runtime.mjs";
+import { A as batch, F as createContext, I as createEffect, J as onCleanup, L as createMemo, N as createComponent, P as createComputed, V as createSignal, Y as onMount, i as unwrap, n as createStore, nt as useContext, r as reconcile, tt as untrack, z as createResource } from "./solid-js.mjs";
+import { n as OpaqueReference } from "./seroval.mjs";
+import { t as dequal } from "./dequal.mjs";
+//#region ../../node_modules/.pnpm/tiny-invariant@1.3.3/node_modules/tiny-invariant/dist/esm/tiny-invariant.js
+var import_relay_runtime = /* @__PURE__ */ __toESM(require_relay_runtime(), 1);
+var prefix = "Invariant failed";
+function invariant(condition, message) {
+	if (condition) return;
+	throw new Error(prefix);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/solid-relay@1.0.0-beta.29_relay-runtime@21.0.1_seroval@1.6.3_solid-js@1.9.14/node_modules/solid-relay/dist/index.mjs
+var import_experimental = /* @__PURE__ */ __toESM(require_experimental(), 1);
+var { __internal: __internal$5, createOperationDescriptor: createOperationDescriptor$3, getRequest: getRequest$4, getRequestIdentifier, Observable: Observable$1, PreloadableQueryRegistry, ReplaySubject: ReplaySubject$2 } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+var fetchKey = 100001;
+/**
+* Preloads a query and returns a `PreloadedQuery` reference.
+*
+* Use this to start fetching before render (for example during route preload),
+* then consume the returned reference with `createPreloadedQuery`.
+*
+* @param environment - Relay environment used to execute and retain the query.
+* @param preloadableRequest - Query document or preloadable concrete request.
+* @param variables - Variables for the query operation.
+* @param options - Options for the preload request.
+* @returns A query reference that can be consumed by `createPreloadedQuery`.
+*/
+function loadQuery(environment, preloadableRequest, variables, options) {
+	fetchKey++;
+	const fetchPolicy = options?.fetchPolicy ?? "store-or-network";
+	const networkCacheConfig = {
+		...options?.networkCacheConfig,
+		force: true
+	};
+	let retainReference;
+	let didExecuteNetworkSource = false;
+	const executeWithNetworkSource = (operation, networkObservable) => {
+		didExecuteNetworkSource = true;
+		return environment.executeWithSource({
+			operation,
+			source: networkObservable
+		});
+	};
+	const executionSubject = new ReplaySubject$2();
+	const returnedObservable = Observable$1.create((sink) => executionSubject.subscribe(sink));
+	let networkRequestSubscription;
+	let networkError = null;
+	let didMakeNetworkRequest = false;
+	const makeNetworkRequest = (params) => {
+		didMakeNetworkRequest = true;
+		const subject = new ReplaySubject$2();
+		const identifier = "raw-network-request-" + getRequestIdentifier(params, variables);
+		networkRequestSubscription = __internal$5.fetchQueryDeduped(environment, identifier, () => {
+			return environment.getNetwork().execute(params, variables, networkCacheConfig);
+		}).subscribe({
+			error(err) {
+				networkError = err;
+				subject.error(err);
+			},
+			next(data) {
+				subject.next(data);
+			},
+			complete() {
+				subject.complete();
+			}
+		});
+		return Observable$1.create((sink) => {
+			const subjectSubscription = subject.subscribe(sink);
+			return () => {
+				subjectSubscription.unsubscribe();
+				networkRequestSubscription?.unsubscribe();
+			};
+		});
+	};
+	let executionSubcription;
+	const executeDeduped = (operation, fetchFn) => {
+		didMakeNetworkRequest = true;
+		executionSubcription = __internal$5.fetchQueryDeduped(environment, operation.request.identifier, fetchFn).subscribe({
+			error(err) {
+				executionSubject.error(err);
+			},
+			next(data) {
+				executionSubject.next(data);
+			},
+			complete() {
+				executionSubject.complete();
+			}
+		});
+	};
+	const checkAvailabilityAndExecute = (concreteRequest) => {
+		const operation = createOperationDescriptor$3(concreteRequest, variables, networkCacheConfig);
+		retainReference = environment.retain(operation);
+		if (fetchPolicy === "store-only") return;
+		if (fetchPolicy !== "store-or-network" || environment.check(operation).status !== "available") executeDeduped(operation, () => {
+			return executeWithNetworkSource(operation, makeNetworkRequest(concreteRequest.params));
+		});
+	};
+	let params;
+	let cancelOnLoadCallback;
+	let queryId;
+	if ("kind" in preloadableRequest && preloadableRequest.kind === "PreloadableConcreteRequest") {
+		params = preloadableRequest.params;
+		queryId = params.id;
+		invariant(queryId != null, `Relay: \`loadQuery\` requires that preloadable query \`${params.name}\` has a persisted query id`);
+		const module = PreloadableQueryRegistry.get(queryId);
+		if (module != null) checkAvailabilityAndExecute(module);
+		else {
+			const networkObservable = fetchPolicy === "store-only" ? null : makeNetworkRequest(params);
+			cancelOnLoadCallback = PreloadableQueryRegistry.onLoad(queryId, (preloadedModule) => {
+				cancelOnLoadCallback();
+				const operation = createOperationDescriptor$3(preloadedModule, variables, networkCacheConfig);
+				retainReference = environment.retain(operation);
+				if (networkObservable != null) executeDeduped(operation, () => executeWithNetworkSource(operation, networkObservable));
+			}).dispose;
+		}
+	} else {
+		const request = getRequest$4(preloadableRequest);
+		params = request.params;
+		queryId = "cacheID" in params && params.cacheID != null ? params.cacheID : params.id;
+		checkAvailabilityAndExecute(request);
+	}
+	let isDisposed = false;
+	let isReleased = false;
+	let isNetworkRequestCanceled = false;
+	const releaseQuery = () => {
+		if (isReleased) return;
+		retainReference?.dispose();
+		isReleased = true;
+	};
+	const cancelNetworkRequest = () => {
+		if (isNetworkRequestCanceled) return;
+		if (didExecuteNetworkSource) executionSubcription?.unsubscribe();
+		else networkRequestSubscription?.unsubscribe();
+		cancelOnLoadCallback?.();
+		isNetworkRequestCanceled = true;
+	};
+	return {
+		kind: "PreloadedQuery",
+		id: queryId,
+		name: params.name,
+		variables,
+		fetchKey,
+		fetchPolicy,
+		networkCacheConfig,
+		controls: new OpaqueReference({
+			environment,
+			source: didMakeNetworkRequest ? returnedObservable : void 0,
+			getNetworkError: () => networkError,
+			dispose: () => {
+				if (isDisposed) return;
+				releaseQuery();
+				cancelNetworkRequest();
+				isDisposed = true;
+			},
+			isDisposed: () => isDisposed || isReleased,
+			releaseQuery
+		})
+	};
+}
+var RelayContext = createContext();
+/**
+* Provides a Relay environment to Solid Relay primitives in the subtree.
+*
+* Wrap your application (or route subtree) with this provider before calling
+* primitives such as `createLazyLoadQuery`, `createFragment`, or `createMutation`.
+*/
+function RelayEnvironmentProvider(props) {
+	const environment = createMemo(() => props.environment);
+	return createComponent(RelayContext.Provider, {
+		get value() {
+			return {
+				environment,
+				dataStores: /* @__PURE__ */ new WeakMap()
+			};
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+/**
+* Returns the current Relay environment accessor from context.
+*
+* Throws if called outside `RelayEnvironmentProvider`.
+*/
+function useRelayEnvironment() {
+	const context = useContext(RelayContext);
+	invariant(context != null, "useRelayEnvironment: Expected to have found a Relay environment provided by a `RelayEnvironmentProvider` component. This usually means that useRelayEnvironment was used in a component that is not a descendant of a `RelayEnvironmentProvider`. Please make sure a `RelayEnvironmentProvider` has been rendered somewhere as a parent or ancestor of your component.");
+	return context.environment;
+}
+function useDataStores() {
+	return useContext(RelayContext)?.dataStores;
+}
+var createDataStore = (init, resourceAccessor) => {
+	const [store, setStore] = createStableStore(init, untrack(() => resourceAccessor()));
+	const readData = () => {
+		resourceAccessor()?.();
+		const error = Reflect.get(store, "error");
+		if (error) throw error;
+		return Reflect.get(store, "data");
+	};
+	Object.defineProperties(readData, {
+		latest: { get: () => Reflect.get(store, "data") },
+		error: { get: () => Reflect.get(store, "error") },
+		pending: { get: () => Reflect.get(store, "pending") }
+	});
+	return [readData, setStore];
+};
+function createStableStore(init, resource) {
+	const stores = useDataStores();
+	if (resource) {
+		const existing = stores?.get(resource);
+		if (existing) return existing;
+	}
+	const store = createStore(init);
+	if (resource) stores?.set(resource, store);
+	return store;
+}
+var { FRAGMENT_OWNER_KEY: FRAGMENT_OWNER_KEY$1, RequestDescriptor } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+var OWNER_PROTO = {};
+function cleanSnapshot(input) {
+	if (typeof input !== "object" || input === null) return input;
+	if (Array.isArray(input)) return input.map(cleanSnapshot);
+	return Object.fromEntries(Object.entries(input).map(([key, value]) => {
+		if (key === FRAGMENT_OWNER_KEY$1) {
+			const wrapped = { ...value };
+			Object.setPrototypeOf(wrapped, OWNER_PROTO);
+			return [key, wrapped];
+		}
+		return [key, cleanSnapshot(value)];
+	}));
+}
+var { observeFragment: observeFragment$1 } = import_experimental.default?.default?.__esModule ? import_experimental.default.default : import_experimental.default;
+function createFragment(fragment, key, options) {
+	return createFragmentInternal(fragment, key, void 0, options);
+}
+function createFragmentInternal(fragment, key, options, createResourceOptions) {
+	const environment = useRelayEnvironment();
+	const subscribeResult = (source, onResult) => {
+		return source.subscribe({ next(res) {
+			batch(() => {
+				switch (res.state) {
+					case "ok":
+						setResult("error", void 0);
+						setResult("pending", false);
+						setResult("data", reconcile(cleanSnapshot(res.value), {
+							key: "__id",
+							merge: true
+						}));
+						break;
+					case "error":
+						setResult("data", void 0);
+						setResult("error", res.error);
+						setResult("pending", false);
+						break;
+					case "loading":
+						setResult("data", void 0);
+						setResult("error", void 0);
+						setResult("pending", true);
+						break;
+				}
+			});
+			onResult?.(res);
+		} });
+	};
+	const [subscription, setSubscription] = createSignal();
+	createEffect(() => {
+		const sub = subscription();
+		if (sub) onCleanup(() => {
+			sub.unsubscribe();
+		});
+	});
+	const setResultQueue = [];
+	let setResult = (...args) => {
+		setResultQueue.push(args);
+	};
+	let fetchedInSameEnv = false;
+	const [resource] = createResource(() => {
+		return batch(() => {
+			setSubscription(void 0);
+			setResult("pending", false);
+			environment();
+			const k = unwrap(key());
+			if (!k) {
+				setResult("data", void 0);
+				setResult("error", void 0);
+				return;
+			}
+			return {
+				key: k,
+				parentOperation: options?.().parentOperation
+			};
+		});
+	}, ({ key, parentOperation }) => {
+		setResult("pending", true);
+		fetchedInSameEnv = true;
+		const observe = () => {
+			let settled;
+			let resolve;
+			let reject;
+			setSubscription(subscribeResult(observeFragment$1(environment(), fragment, key), (res) => {
+				if (res.state === "ok") {
+					settled ??= { ok: true };
+					resolve?.(true);
+				} else if (res.state === "error") {
+					settled ??= {
+						ok: false,
+						error: res.error
+					};
+					reject?.(res.error);
+				}
+			}));
+			if (settled?.ok) return true;
+			if (settled) return Promise.reject(settled.error);
+			return new Promise((res, rej) => {
+				resolve = res;
+				reject = rej;
+			});
+		};
+		if (!parentOperation) return observe();
+		return new Promise((resolve, reject) => {
+			parentOperation.subscribe({
+				complete: resolve,
+				error: reject
+			});
+		}).then(observe);
+	}, {
+		deferStream: createResourceOptions?.deferStream,
+		storage(init) {
+			const [value, setValue] = createSignal(init);
+			return [value, (next) => {
+				const current = untrack(value);
+				const nextValue = typeof next === "function" ? next(current) : next;
+				const k = unwrap(untrack(key));
+				if (!fetchedInSameEnv && !current && nextValue && k) setSubscription(subscribeResult(observeFragment$1(environment(), fragment, k)));
+				setValue(() => nextValue);
+			}];
+		}
+	});
+	const store = createDataStore({
+		data: void 0,
+		error: void 0,
+		pending: false
+	}, () => resource);
+	for (const args of setResultQueue) store[1].apply(void 0, args);
+	setResult = store[1];
+	return store[0];
+}
+var caches = /* @__PURE__ */ new WeakMap();
+function getQueryCache(environment) {
+	let cache = caches.get(environment);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		caches.set(environment, cache);
+	}
+	return cache;
+}
+var access = (v) => typeof v === "function" && !v.length ? v() : v;
+var { createOperationDescriptor: createOperationDescriptor$2, getRequest: getRequest$3 } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+function createMemoOperationDescriptor(gqlQuery, variables, cacheConfig) {
+	const memoizedVariables = createMemo(() => access(variables), void 0, { equals: dequal });
+	const memoizedCacheConfig = createMemo(() => access(cacheConfig), void 0, { equals: dequal });
+	return createMemo(() => {
+		const variables = memoizedVariables();
+		if (!variables) return;
+		return createOperationDescriptor$2(getRequest$3(access(gqlQuery)), variables, memoizedCacheConfig());
+	});
+}
+var { FRAGMENT_OWNER_KEY, FRAGMENTS_KEY, ID_KEY } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+var getQueryRef = (operation) => ({
+	[ID_KEY]: operation.fragment.dataID,
+	[FRAGMENTS_KEY]: { [operation.fragment.node.name]: operation.request.variables },
+	[FRAGMENT_OWNER_KEY]: operation.request
+});
+var { __internal: __internal$4, getRequest: getRequest$2, Observable, ReplaySubject: ReplaySubject$1 } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+var { observeFragment } = import_experimental.default?.default?.__esModule ? import_experimental.default.default : import_experimental.default;
+/**
+* Reads query data and subscribes to store updates for the current component.
+*
+* It fetches according to the provided fetch policy and returns a reactive
+* data store containing the query response.
+*
+* @param gqlQuery - GraphQL query document.
+* @param variables - Query variables or an accessor for reactive variables.
+* @param options.fetchPolicy - Query fetch policy.
+* @param options.networkCacheConfig - Network cache configuration.
+* @param options.deferStream - Whether to defer the SSR stream until the data is resolved.
+* @returns A `DataStore` containing the query data state.
+*/
+function createLazyLoadQuery(gqlQuery, variables, options) {
+	const environment = useRelayEnvironment();
+	const operation = createMemoOperationDescriptor(gqlQuery, variables, options?.networkCacheConfig);
+	return createLazyLoadQueryInternal({
+		query: operation,
+		fragment: () => getRequest$2(access(gqlQuery)).fragment,
+		fetchObservable: createMemo(() => {
+			const op = operation();
+			const env = environment();
+			if (!op || !env) return;
+			return __internal$4.fetchQuery(env, op);
+		}),
+		fetchPolicy: () => access(options?.fetchPolicy),
+		deferStream: options?.deferStream
+	});
+}
+function createLazyLoadQueryInternal(params) {
+	const environment = useRelayEnvironment();
+	const queryCache = createMemo(() => getQueryCache(environment()));
+	const isLiveQuery = createMemo(() => params.query()?.request.node.params.metadata.live !== void 0);
+	const fetchPolicy = createMemo(() => params.fetchPolicy?.() ?? (isLiveQuery() ? "store-and-network" : "store-or-network"));
+	const cacheKey = createMemo(() => {
+		const query = params.query();
+		if (!query) return;
+		return [
+			fetchPolicy(),
+			query.request.identifier,
+			params.fetchKey?.()
+		].filter((v) => v != null).join("-");
+	});
+	const cacheEntry = createMemo(() => {
+		const operation = params.query();
+		const key = cacheKey();
+		if (!operation || !key) return;
+		const cache = queryCache();
+		const existing = cache.get(key);
+		if (existing != null) return existing;
+		const hasFullQuery = environment().check(operation).status === "available";
+		const shouldFetch = (() => {
+			switch (fetchPolicy()) {
+				case "store-only": return false;
+				case "store-or-network": return !hasFullQuery;
+				case "store-and-network":
+				case "network-only": return true;
+			}
+		})();
+		const replaySubject = new ReplaySubject$1();
+		let subscriptionTarget = shouldFetch ? environment().executeWithSource({
+			operation,
+			source: __internal$4.fetchQueryDeduped(environment(), operation.request.identifier, () => Observable.create((sink) => replaySubject.subscribe(sink)))
+		}) : void 0;
+		let fetchedInSameEnv = false;
+		const [resource] = createResource(() => shouldFetch && params.fetchObservable(), async (observable) => {
+			subscriptionTarget = observable;
+			fetchedInSameEnv = true;
+			let pr = Promise.withResolvers();
+			observable.subscribe({
+				next(response) {
+					const nextPr = Promise.withResolvers();
+					pr.resolve({
+						value: response,
+						next: nextPr.promise
+					});
+					pr = nextPr;
+				},
+				error(error) {
+					pr.reject(error);
+				},
+				complete() {
+					pr.resolve(null);
+				}
+			});
+			return await pr.promise;
+		}, {
+			deferStream: params.deferStream,
+			storage(init) {
+				const [value, setValue] = createSignal(init);
+				return [value, (next) => {
+					const current = untrack(value);
+					const nextValue = typeof next === "function" ? next(current) : next;
+					let result = nextValue;
+					if (!fetchedInSameEnv && nextValue) (async () => {
+						try {
+							while (result) {
+								replaySubject.next(result.value);
+								result = await result.next;
+							}
+							replaySubject.complete();
+						} catch (error) {
+							replaySubject.error(error instanceof Error ? error : new Error(String(error)));
+						}
+					})();
+					setValue(() => nextValue);
+				}];
+			}
+		});
+		let entry;
+		if (shouldFetch) {
+			const subscription = subscriptionTarget?.subscribe({});
+			let retainCount = 0;
+			let retention;
+			entry = {
+				resource,
+				retain: (environment) => {
+					retainCount++;
+					if (retainCount === 1) retention = environment.retain(operation);
+					return { dispose: () => {
+						retainCount = Math.max(retainCount - 1, 0);
+						if (retainCount === 0) {
+							retention?.dispose();
+							if (isLiveQuery()) subscription?.unsubscribe();
+							cache.delete(key);
+						}
+					} };
+				}
+			};
+			cache.set(key, entry);
+		}
+		return entry;
+	});
+	createComputed(() => {
+		const entry = cacheEntry();
+		if (!entry) return;
+		onCleanup(entry.retain(environment()).dispose);
+	});
+	const [result, setResult] = createDataStore({
+		data: void 0,
+		error: void 0,
+		pending: false
+	}, () => cacheEntry()?.resource);
+	createComputed(() => {
+		batch(() => {
+			setResult("data", void 0);
+			setResult("error", void 0);
+			setResult("pending", false);
+			const operation = params.query();
+			const env = environment();
+			if (!operation || !env) return;
+			setResult("pending", true);
+			const fragmentSubscription = observeFragment(env, params.fragment(), getQueryRef(operation)).subscribe({ next(state) {
+				batch(() => {
+					switch (state.state) {
+						case "ok":
+							setResult("error", void 0);
+							setResult("pending", false);
+							setResult("data", reconcile(cleanSnapshot(state.value), {
+								key: "__id",
+								merge: true
+							}));
+							break;
+						case "error":
+							setResult("data", void 0);
+							setResult("error", state.error);
+							setResult("pending", false);
+							break;
+						case "loading":
+							setResult("data", void 0);
+							setResult("error", void 0);
+							setResult("pending", true);
+							break;
+					}
+				});
+			} });
+			onCleanup(() => {
+				fragmentSubscription.unsubscribe();
+			});
+		});
+	});
+	return result;
+}
+var { commitMutation } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+/**
+* Creates a mutation commit function and an in-flight state accessor.
+*
+* The returned commit function forwards to Relay's `commitMutation` and
+* keeps `isMutationInFlight` updated while one or more commits are active.
+*
+* @param mutation - GraphQL mutation document.
+* @returns A tuple of `[commitMutation, isMutationInFlight]`.
+*/
+function createMutation(mutation) {
+	const environment = useRelayEnvironment();
+	const inFlightMutations = /* @__PURE__ */ new Set();
+	const [isMutationInFlight, setIsMutationInFlight] = createSignal(false);
+	const cleanup = (disposable) => {
+		inFlightMutations.delete(disposable);
+		setIsMutationInFlight(inFlightMutations.size > 0);
+	};
+	const commit = (config) => {
+		setIsMutationInFlight(true);
+		const disposable = commitMutation(environment(), {
+			...config,
+			mutation,
+			onCompleted: (response, errors) => {
+				cleanup(disposable);
+				config.onCompleted?.(response, errors);
+			},
+			onError: (error) => {
+				cleanup(disposable);
+				config.onError?.(error);
+			},
+			onUnsubscribe: () => {
+				cleanup(disposable);
+				config.onUnsubscribe?.();
+			}
+		});
+		inFlightMutations.add(disposable);
+		return disposable;
+	};
+	return [commit, isMutationInFlight];
+}
+function createFetchTracker() {
+	let currentSubscription = null;
+	const [isFetching, setIsFetching] = createSignal(false);
+	const disposeFetch = () => {
+		if (currentSubscription != null) {
+			currentSubscription.unsubscribe();
+			currentSubscription = null;
+		}
+		setIsFetching(false);
+	};
+	const startFetch = (subscription) => {
+		currentSubscription = subscription;
+		setIsFetching(true);
+	};
+	const completeFetch = () => {
+		currentSubscription = null;
+		setIsFetching(false);
+	};
+	onCleanup(disposeFetch);
+	return {
+		disposeFetch,
+		startFetch,
+		completeFetch,
+		isFetching
+	};
+}
+var { ConnectionInterface, getValueAtPath: getValueAtPath$1 } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+function getConnectionState(direction, fragmentNode, fragmentData, connectionPathInFragmentData) {
+	const { EDGES, PAGE_INFO, HAS_NEXT_PAGE, HAS_PREV_PAGE, END_CURSOR, START_CURSOR } = ConnectionInterface.get();
+	const connection = getValueAtPath$1(fragmentData, connectionPathInFragmentData);
+	if (connection == null) return {
+		cursor: null,
+		hasMore: false
+	};
+	invariant(typeof connection === "object", `Relay: Expected connection in fragment \`${fragmentNode.name}\` to have been \`null\`, or a plain object with ${EDGES} and ${PAGE_INFO} properties. Instead got \`${connection}\`.`);
+	const edges = connection[EDGES];
+	const pageInfo = connection[PAGE_INFO];
+	if (edges == null || pageInfo == null) return {
+		cursor: null,
+		hasMore: false
+	};
+	invariant(Array.isArray(edges), `Relay: Expected connection in fragment \`${fragmentNode.name}\` to have a plural \`${EDGES}\` field. Instead got \`${edges}\`.`);
+	invariant(typeof pageInfo === "object", `Relay: Expected connection in fragment \`${fragmentNode.name}\` to have a \`${PAGE_INFO}\` field. Instead got \`${pageInfo}\`.`);
+	const cursor = direction === "forward" ? pageInfo[END_CURSOR] ?? null : pageInfo[START_CURSOR] ?? null;
+	invariant(cursor === null || typeof cursor === "string", `Relay: Expected page info for connection in fragment \`${fragmentNode.name}\` to have a valid \`${START_CURSOR}\`. Instead got \`${cursor}\`.`);
+	return {
+		cursor,
+		hasMore: direction === "forward" ? cursor != null && pageInfo[HAS_NEXT_PAGE] === true : cursor != null && pageInfo[HAS_PREV_PAGE] === true
+	};
+}
+var useIsMounted = () => {
+	const [isMounted, setIsMounted] = createSignal(false);
+	onMount(() => {
+		setIsMounted(true);
+		onCleanup(() => setIsMounted(false));
+	});
+	return isMounted;
+};
+var { __internal: __internal$3, getSelector: getSelector$2 } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+function useIsOperationNodeActive(fragmentNode, fragmentRef) {
+	const environment = useRelayEnvironment();
+	const selector = createMemo(() => getSelector$2(fragmentNode, fragmentRef()));
+	const observable = createMemo(() => {
+		const s = selector();
+		if (s == null) return null;
+		invariant(s.kind === "SingularReaderSelector", "useIsOperationNodeActive: Plural fragments are not supported.");
+		return __internal$3.getObservableForActiveRequest(environment(), s.owner);
+	});
+	const [isActive, setIsActive] = createSignal(false);
+	createEffect(() => {
+		let subscription;
+		const obs = observable();
+		setIsActive(obs != null);
+		if (obs != null) {
+			const onCompleteOrError = () => setIsActive(false);
+			subscription = obs.subscribe({
+				complete: onCompleteOrError,
+				error: onCompleteOrError
+			});
+		}
+		onCleanup(() => {
+			subscription?.unsubscribe();
+		});
+	});
+	return isActive;
+}
+var { getRequest: getRequest$1 } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+var initialNullQueryReferenceState = { kind: "NullQueryReference" };
+/**
+* Creates imperative helpers for preloading queries.
+*
+* Returns a tuple:
+* - an accessor for the current `PreloadedQuery` reference
+* - a `loadQuery` function to start loading with variables
+* - a `disposeQuery` function to clear and dispose the current reference
+*
+* @param preloadableRequest - Query document or preloadable concrete request.
+* @param initialQueryReference - Optional initial query reference.
+* @returns `[queryRef, loadQuery, disposeQuery]`.
+*/
+function createQueryLoader(preloadableRequest, initialQueryReference) {
+	const environment = useRelayEnvironment();
+	const isMounted = useIsMounted();
+	const [queryReference, setQueryReference] = createSignal(initialQueryReference ?? initialNullQueryReferenceState);
+	createEffect(() => {
+		const ref = queryReference();
+		onCleanup(() => {
+			if ("controls" in ref) if (requestIsLiveQuery(preloadableRequest)) ref.controls?.value.dispose();
+			else ref.controls?.value.releaseQuery();
+		});
+	});
+	return [
+		() => {
+			const ref = queryReference();
+			return ref.kind === "NullQueryReference" ? null : ref;
+		},
+		(variables, options) => {
+			const mergedOptions = options != null && Object.hasOwn(options, "__environment") ? {
+				fetchPolicy: options.fetchPolicy,
+				networkCacheConfig: options.networkCacheConfig
+			} : options;
+			if (untrack(isMounted)) setQueryReference(loadQuery(options?.__environment ?? untrack(environment), preloadableRequest, variables, mergedOptions));
+		},
+		() => {
+			if (untrack(isMounted)) setQueryReference(initialNullQueryReferenceState);
+		}
+	];
+}
+function requestIsLiveQuery(preloadableRequest) {
+	if ("kind" in preloadableRequest && preloadableRequest.kind === "PreloadableConcreteRequest") return preloadableRequest.params.metadata.live !== void 0;
+	return getRequest$1(preloadableRequest).params.metadata.live !== void 0;
+}
+var { __internal: __internal$2, createOperationDescriptor: createOperationDescriptor$1, getFragment: getFragment$1, getFragmentIdentifier: getFragmentIdentifier$1, getRefetchMetadata: getRefetchMetadata$1, getSelector: getSelector$1, getValueAtPath, ReplaySubject } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+var { waitForFragmentData } = import_experimental.default?.default?.__esModule ? import_experimental.default.default : import_experimental.default;
+function createRefetchableFragmentInternal(fragment, key, componentDisplayName = "createRefetchableFragment()", options) {
+	const parentEnvironment = useRelayEnvironment();
+	const parentFragmentRef = () => unwrap(key());
+	const isMounted = useIsMounted();
+	const fragmentNode = getFragment$1(fragment);
+	const { refetchableRequest, fragmentRefPathInResponse, identifierInfo } = getRefetchMetadata$1(fragmentNode, componentDisplayName);
+	const fragmentIdentifier = createMemo(() => getFragmentIdentifier$1(fragmentNode, parentFragmentRef()));
+	const [state, setState] = createSignal({
+		fetchPolicy: void 0,
+		mirroredEnvironment: parentEnvironment(),
+		mirroredFragmentIdentifier: fragmentIdentifier(),
+		onComplete: void 0,
+		refetchEnvironment: null,
+		refetchQuery: null
+	});
+	const environment = createMemo(() => state().refetchEnvironment ?? parentEnvironment());
+	const [preloadedQueryRef, loadQuery, disposeQuery] = createQueryLoader(refetchableRequest);
+	const [fragmentRef, setFragmentRef] = createSignal(parentFragmentRef());
+	createComputed(() => {
+		if (untrack(fragmentRef) !== parentFragmentRef()) setFragmentRef(() => parentFragmentRef());
+	});
+	const refetchObservable = createMemo(() => {
+		const refetchQuery = state().refetchQuery;
+		const preloadedQuery = preloadedQueryRef();
+		if (!refetchQuery || !preloadedQuery) return;
+		const fetchObservable = preloadedQuery.controls?.value.source != null ? preloadedQuery.controls.value.source : __internal$2.fetchQuery(environment(), refetchQuery);
+		const replaySubject = new ReplaySubject();
+		fetchObservable.subscribe({
+			next: (value) => replaySubject.next(value),
+			unsubscribe: () => replaySubject.unsubscribe(),
+			complete() {
+				replaySubject.complete();
+				state().onComplete?.(null);
+			},
+			error(err) {
+				replaySubject.error(err);
+				state().onComplete?.(err);
+			}
+		});
+		return replaySubject;
+	});
+	createComputed(() => {
+		const refetchQuery = state().refetchQuery;
+		if (!refetchQuery) return;
+		const obs = refetchObservable();
+		if (!obs) return;
+		obs.subscribe({ async complete() {
+			const data = await waitForFragmentData(environment(), refetchableRequest.fragment, getQueryRef(refetchQuery));
+			if (!data) return;
+			const refetchedFragmentRef = getValueAtPath(unwrap(data), fragmentRefPathInResponse);
+			if (!refetchedFragmentRef) return;
+			setFragmentRef(unwrap(refetchedFragmentRef));
+		} });
+	});
+	const refetch = (action) => setState((state) => ({
+		...state,
+		fetchPolicy: action.fetchPolicy,
+		mirroredEnvironment: state.refetchEnvironment ?? state.mirroredEnvironment,
+		onComplete: action.onComplete,
+		refetchEnvironment: action.refetchEnvironment,
+		refetchQuery: action.refetchQuery
+	}));
+	const reset = (action) => setState({
+		fetchPolicy: void 0,
+		mirroredEnvironment: action.environment,
+		mirroredFragmentIdentifier: action.fragmentIdentifier,
+		onComplete: void 0,
+		refetchEnvironment: void 0,
+		refetchQuery: null
+	});
+	createEffect(() => {
+		const env = environment();
+		const fragmentIdent = fragmentIdentifier();
+		if (env !== state().mirroredEnvironment || fragmentIdent !== state().mirroredFragmentIdentifier) {
+			reset({
+				environment: env,
+				fragmentIdentifier: fragmentIdent
+			});
+			disposeQuery();
+		}
+	});
+	const fragmentData = createFragmentInternal(fragment, parentFragmentRef, () => ({ parentOperation: refetchObservable() }), options);
+	return {
+		fragmentData,
+		fragmentRef,
+		refetch: (providedRefetchVariables, options) => {
+			const fragmentRef = parentFragmentRef();
+			const identifierValue = identifierInfo?.identifierField != null && fragmentData.latest != null && typeof fragmentData.latest === "object" ? fragmentData.latest[identifierInfo.identifierField] : null;
+			if (!untrack(isMounted)) {
+				console.warn(`Relay: Unexpected call to \`refetch\` on unmounted component for fragment \`${fragmentNode.name}\` in \`${componentDisplayName}\`. It looks like some instances of your component are still trying to fetch data but they already unmounted. Please make sure you clear all timers, intervals, async calls, etc that may trigger a fetch.`);
+				return { dispose: () => {} };
+			}
+			if (fragmentRef === null) console.warn(`Relay: Unexpected call to \`refetch\` while using a null fragment ref for fragment \`fragmentNode.name\` in \`${componentDisplayName}\`. When calling \`refetch\`, we expect initial fragment data to be non-null. Please make sure you're passing a valid fragment ref to \`${componentDisplayName}\` before calling \`refetch\`, or make sure you pass all required variables to \`refetch\`.`);
+			const fetchPolicy = options?.fetchPolicy;
+			const onComplete = options?.onComplete;
+			const fragmentSelector = getSelector$1(fragmentNode, fragmentRef);
+			let parentVariables;
+			let fragmentVariables;
+			if (fragmentSelector == null) {
+				parentVariables = {};
+				fragmentVariables = {};
+			} else if (fragmentSelector.kind === "PluralReaderSelector") {
+				const selector = fragmentSelector;
+				parentVariables = selector.selectors[0]?.owner.variables ?? {};
+				fragmentVariables = selector.selectors[0]?.variables ?? {};
+			} else {
+				const selector = fragmentSelector;
+				parentVariables = selector.owner.variables;
+				fragmentVariables = selector.variables;
+			}
+			const refetchVariables = {
+				...parentVariables,
+				...fragmentVariables,
+				...providedRefetchVariables
+			};
+			if (identifierInfo != null && !Object.hasOwn(providedRefetchVariables, identifierInfo.identifierQueryVariableName)) {
+				if (typeof identifierValue !== "string") console.warn(`Relay: Expected result to have a string  \`${identifierInfo.identifierField}\` in order to refetch, got \`${String(identifierValue)}\`. `);
+				refetchVariables[identifierInfo.identifierQueryVariableName] = identifierValue;
+			}
+			const refetchQuery = createOperationDescriptor$1(refetchableRequest, refetchVariables, { force: true });
+			batch(() => {
+				loadQuery(refetchQuery.request.variables, {
+					fetchPolicy,
+					__environment: state().refetchEnvironment
+				});
+				refetch({
+					fetchPolicy,
+					onComplete,
+					refetchEnvironment: state().refetchEnvironment,
+					refetchQuery
+				});
+			});
+			return { dispose: disposeQuery };
+		}
+	};
+}
+var { __internal: __internal$1, createOperationDescriptor, getFragment, getFragmentIdentifier, getPaginationMetadata, getPaginationVariables, getRefetchMetadata, getSelector } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+function createPaginationFragment(fragment, key) {
+	const fragmentNode = getFragment(fragment);
+	const componentDisplayName = "createPaginationFragment()";
+	const { connectionPathInFragmentData, paginationRequest, paginationMetadata } = getPaginationMetadata(fragmentNode, componentDisplayName);
+	const { fragmentData, fragmentRef, refetch } = createRefetchableFragmentInternal(fragment, key, componentDisplayName);
+	const fragmentIdentifier = createMemo(() => getFragmentIdentifier(fragmentNode, fragmentRef()));
+	const [loadPrevious, hasPrevious, isLoadingPrevious, disposeFetchPrevious] = createLoadMore({
+		direction: "backward",
+		fragmentNode,
+		fragmentRef,
+		fragmentIdentifier,
+		fragmentData,
+		connectionPathInFragmentData,
+		paginationRequest,
+		paginationMetadata,
+		componentDisplayName
+	});
+	const [loadNext, hasNext, isLoadingNext, disposeFetchNext] = createLoadMore({
+		direction: "forward",
+		fragmentNode,
+		fragmentRef,
+		fragmentIdentifier,
+		fragmentData,
+		connectionPathInFragmentData,
+		paginationRequest,
+		paginationMetadata,
+		componentDisplayName
+	});
+	const refetchPagination = (variables, options) => {
+		disposeFetchNext();
+		disposeFetchPrevious();
+		return refetch(variables, options);
+	};
+	Object.defineProperties(fragmentData, {
+		loadNext: { value: loadNext },
+		loadPrevious: { value: loadPrevious },
+		hasNext: { get: hasNext },
+		hasPrevious: { get: hasPrevious },
+		isLoadingNext: { get: isLoadingNext },
+		isLoadingPrevious: { get: isLoadingPrevious },
+		refetch: { value: refetchPagination }
+	});
+	return fragmentData;
+}
+function createLoadMore({ direction, fragmentNode, fragmentRef, fragmentIdentifier, fragmentData, connectionPathInFragmentData, paginationRequest, paginationMetadata, componentDisplayName }) {
+	const environment = useRelayEnvironment();
+	const [isLoadingMore, reallySetIsLoadingMore] = createSignal(false);
+	const setIsLoadingMore = (value) => {
+		const schedule = untrack(environment).getScheduler()?.schedule;
+		if (schedule) schedule(() => {
+			reallySetIsLoadingMore(value);
+		});
+		else reallySetIsLoadingMore(value);
+	};
+	const { isFetching, startFetch, disposeFetch, completeFetch } = createFetchTracker();
+	const { identifierInfo } = getRefetchMetadata(fragmentNode, componentDisplayName);
+	const identifierValue = createMemo(() => identifierInfo?.identifierField != null && fragmentData.latest != null ? fragmentData.latest[identifierInfo.identifierField] : null);
+	const isMounted = useIsMounted();
+	const [mirroredEnvironment, setMirroredEnvironment] = createSignal(environment());
+	const [mirroredFragmentIdentifier, setMirroredFragmentIdentifier] = createSignal(fragmentIdentifier());
+	const isParentQueryActive = useIsOperationNodeActive(fragmentNode, fragmentRef);
+	const shouldReset = createMemo(() => environment() !== mirroredEnvironment() || fragmentIdentifier() !== mirroredFragmentIdentifier());
+	createEffect(() => {
+		if (shouldReset()) batch(() => {
+			disposeFetch();
+			setIsLoadingMore(false);
+			setMirroredEnvironment(untrack(environment));
+			setMirroredFragmentIdentifier(untrack(fragmentIdentifier));
+		});
+	});
+	const connectionState = createMemo(() => getConnectionState(direction, fragmentNode, fragmentData.latest, connectionPathInFragmentData));
+	const isRequestInvalid = createMemo(() => fragmentData.latest == null || isParentQueryActive());
+	return [
+		(count, options) => {
+			if (!untrack(isMounted)) {
+				console.warn(`Relay: Unexpected fetch on unmounted component for fragment \`${fragmentNode.name}\` in \`${componentDisplayName}\`. It looks like some instances of your component are still trying to fetch data but they already unmounted. Please make sure you clear all timers, intervals, async calls, etc that may trigger a fetch.`);
+				return { dispose: () => {} };
+			}
+			const fragmentSelector = getSelector(fragmentNode, untrack(fragmentRef));
+			if (untrack(isFetching) || untrack(isRequestInvalid)) {
+				if (fragmentSelector == null) console.warn(`Relay: Unexpected fetch while using a null fragment ref for fragment \`${fragmentNode.name}\` in \`${componentDisplayName}\`. When fetching more items, we expect initial fragment data to be non-null. Please make sure you're passing a valid fragment ref to \`${componentDisplayName}\` before paginating.`);
+				options?.onComplete?.(null);
+				return { dispose: () => {} };
+			}
+			invariant(fragmentSelector != null && fragmentSelector.kind !== "PluralReaderSelector", `Relay: Expected to be able to find a non-plural fragment owner for fragment \`${fragmentNode.name}\` when using \`${componentDisplayName}\`. If you're seeing this, this is likely a bug in Relay.`);
+			const selector = fragmentSelector;
+			const parentVariables = selector.owner.variables;
+			const fragmentVariables = selector.variables;
+			const baseVariables = {
+				...parentVariables,
+				...fragmentVariables
+			};
+			const paginationVariables = getPaginationVariables(direction, count, untrack(connectionState).cursor, baseVariables, {}, paginationMetadata);
+			if (identifierInfo != null) {
+				const value = untrack(identifierValue);
+				if (typeof value !== "string") console.warn(`Relay: Expected result to have a string  \`${identifierInfo.identifierField}\` in order to refetch, got \`${String(value)}\`.`);
+				paginationVariables[identifierInfo.identifierQueryVariableName] = value;
+			}
+			const paginationQuery = createOperationDescriptor(paginationRequest, paginationVariables, { force: true });
+			__internal$1.fetchQuery(untrack(environment), paginationQuery).subscribe({
+				start(subscription) {
+					startFetch(subscription);
+					setIsLoadingMore(true);
+				},
+				complete() {
+					completeFetch();
+					setIsLoadingMore(false);
+					options?.onComplete?.(null);
+				},
+				error(error) {
+					completeFetch();
+					setIsLoadingMore(false);
+					options?.onComplete?.(error);
+				},
+				unsubscribe() {
+					setIsLoadingMore(false);
+				}
+			});
+			return { dispose: disposeFetch };
+		},
+		() => connectionState().hasMore,
+		isLoadingMore,
+		disposeFetch
+	];
+}
+var { __internal, getRequest } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+function createPreloadedQuery(query, preloadedQuery) {
+	const environment = useRelayEnvironment();
+	const [maybePreloaded] = createResource(() => access(preloadedQuery), (v) => v);
+	const operation = createMemoOperationDescriptor(query, () => maybePreloaded.latest?.variables, () => maybePreloaded.latest?.networkCacheConfig ?? void 0);
+	createEffect(() => {
+		const preloaded = maybePreloaded.latest;
+		if (preloaded) onCleanup(() => {
+			preloaded.controls?.value.dispose();
+		});
+	});
+	return createLazyLoadQueryInternal({
+		query: operation,
+		fragment: () => getRequest(query).fragment,
+		fetchKey: () => maybePreloaded.latest?.fetchKey,
+		fetchPolicy: () => maybePreloaded.latest?.fetchPolicy,
+		fetchObservable: () => {
+			const preloaded = maybePreloaded.latest;
+			const op = operation();
+			if (!preloaded || !op) return;
+			invariant(preloaded.controls == null || !preloaded.controls?.value.isDisposed(), "usePreloadedQuery(): Expected preloadedQuery to not be disposed yet. This is because disposing the query marks it for future garbage collection, and as such query results may no longer be present in the Relay store.");
+			const fallback = __internal.fetchQuery(environment(), op);
+			if (preloaded.controls?.value.source == null) return fallback;
+			invariant(preloaded.controls == null || environment() === preloaded.controls.value.environment, "usePreloadedQuery(): usePreloadedQuery was passed a preloaded query that was created with a different environment than the one that is currently in context.");
+			return preloaded.controls.value.source.ifEmpty(fallback);
+		}
+	});
+}
+var { requestSubscription } = import_relay_runtime.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime.default;
+//#endregion
+export { createPaginationFragment as a, useRelayEnvironment as c, createMutation as i, createFragment as n, createPreloadedQuery as o, createLazyLoadQuery as r, loadQuery as s, RelayEnvironmentProvider as t };