@bgub/fig 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist-development/transition-B4XiOWAj.js

@@ -0,0 +1,750 @@
+import { Q as isAttributableError, X as dataResourceKeysForError, Z as defineLoadContextCapabilities, et as markDataResourceError, nt as setCurrentDataStore, tt as resolveCurrentDataStore } from "./element-B7mCQIMi.js";
+//#region src/context.ts
+const FigContextSymbol = Symbol.for("fig.context");
+function createContext(defaultValue) {
+	return Object.assign((props) => props.children, {
+		$$typeof: FigContextSymbol,
+		defaultValue
+	});
+}
+function isContext(value) {
+	return typeof value === "function" && "$$typeof" in value && value.$$typeof === FigContextSymbol;
+}
+//#endregion
+//#region src/data-store.ts
+const DataResourceSymbol = Symbol.for("fig.data-resource");
+const DataStoreFactorySymbol = Symbol.for("fig.data-store-factory");
+const DataStoreControllerSymbol = Symbol.for("fig.data-store-controller");
+const DEFAULT_INACTIVE_RETENTION_MS = 300 * 1e3;
+const DEFAULT_PRELOAD_RETENTION_MS = 30 * 1e3;
+const dataStoreFactory = createRendererDataStore;
+function dataResource(options) {
+	return {
+		$$typeof: DataResourceSymbol,
+		[DataStoreFactorySymbol]: dataStoreFactory,
+		debugArgs: options.debugArgs,
+		key: options.key,
+		load: options.load
+	};
+}
+function ensureData(resource, ...args) {
+	return resolveDataMutationStore("ensureData").ensureData(resource, ...args);
+}
+function invalidateData(resource, ...args) {
+	resolveDataMutationStore("invalidateData").invalidateData(resource, ...args);
+}
+function invalidateDataError(error) {
+	return resolveDataMutationStore("invalidateDataError").invalidateDataError(error);
+}
+function invalidateDataKey(key) {
+	resolveDataMutationStore("invalidateDataKey").invalidateDataKey(key);
+}
+function invalidateDataPrefix(prefix) {
+	resolveDataMutationStore("invalidateDataPrefix").invalidateDataPrefix(prefix);
+}
+function refreshData(resource, ...args) {
+	return resolveDataMutationStore("refreshData").refreshData(resource, ...args);
+}
+function readDataStore() {
+	return resolveCurrentDataStore("readDataStore() must be called synchronously while Fig is executing — during render, an event handler, an action, or an effect. Capture the handle there and use it after awaits.");
+}
+function createDataStore(options = {}) {
+	const state = { host: null };
+	const store = createRendererDataStore({
+		getLane: () => state.host === null ? null : state.host.getLane(),
+		partition: options.partition,
+		schedule: (owner, lane) => state.host?.schedule(owner, lane)
+	});
+	Object.defineProperty(store, DataStoreControllerSymbol, { value: state });
+	if (options.initialData !== void 0) store.hydrate(options.initialData);
+	return store;
+}
+function isDataStoreController(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && Object.hasOwn(value, DataStoreControllerSymbol);
+}
+function attachDataStore(controller, host, initialData) {
+	if (host.partition !== void 0 || initialData !== void 0) throw new Error("Pass partition and initialData to createDataStore(), not the renderer, when adopting a data store.");
+	const state = controller[DataStoreControllerSymbol];
+	if (state === void 0) throw new Error("dataStore must be created with createDataStore().");
+	if (state.host !== null) throw new Error("A data store can only be adopted by one Fig renderer.");
+	state.host = host;
+	return controller;
+}
+function resolveDataMutationStore(name) {
+	return resolveCurrentDataStore(`${name}() must be called synchronously while Fig is executing — during render, an event handler, an action, or an effect. Capture readDataStore() (or root.data) synchronously and call the handle instead.`);
+}
+function createRendererDataStore(host) {
+	return new DefaultDataStore(host);
+}
+function normalizeDataResourceKey(key) {
+	return normalizeKey(key).canonical;
+}
+var DefaultDataStore = class {
+	host;
+	entries = /* @__PURE__ */ new Map();
+	inactiveRetentionMs;
+	ownerKeys = /* @__PURE__ */ new WeakMap();
+	pendingOwnerKeys = /* @__PURE__ */ new WeakMap();
+	partitionKey;
+	preloadRetentionMs;
+	disposed = false;
+	constructor(host) {
+		this.host = host;
+		this.inactiveRetentionMs = host.inactiveRetentionMs ?? DEFAULT_INACTIVE_RETENTION_MS;
+		this.partitionKey = host.partition === void 0 ? "" : encodeValue(host.partition, createEncodePath("partition"));
+		this.preloadRetentionMs = host.preloadRetentionMs ?? DEFAULT_PRELOAD_RETENTION_MS;
+	}
+	commitDataDependencies(owner, previousOwner) {
+		const nextKeys = this.pendingOwnerKeys.get(owner) ?? null;
+		const ownerKeys = this.ownerKeys.get(owner) ?? null;
+		const previousOwnerKeys = previousOwner === null ? null : this.ownerKeys.get(previousOwner) ?? null;
+		this.pendingOwnerKeys.delete(owner);
+		if ((nextKeys === null || nextKeys.size === 0) && ownerKeys === null && previousOwnerKeys === null) return;
+		let orphanCandidates = null;
+		orphanCandidates = this.collectSubscribedEntries(ownerKeys, orphanCandidates);
+		orphanCandidates = this.collectSubscribedEntries(previousOwnerKeys, orphanCandidates);
+		this.deleteDataOwner(owner, nextKeys);
+		if (previousOwner !== null) this.deleteDataOwner(previousOwner, nextKeys);
+		if (nextKeys !== null && nextKeys.size > 0) {
+			this.ownerKeys.set(owner, nextKeys);
+			for (const key of nextKeys) {
+				const entry = this.entries.get(key);
+				if (entry !== void 0) {
+					this.clearInactiveTimer(entry);
+					entry.subscribers.add(owner);
+					this.notifyEntryChange(entry);
+				}
+			}
+		}
+		if (orphanCandidates !== null) for (const entry of orphanCandidates) this.abortOrphanedLoad(entry);
+	}
+	releaseDataOwner(owner) {
+		const orphanCandidates = this.collectSubscribedEntries(this.ownerKeys.get(owner) ?? null, null);
+		this.deleteDataOwner(owner);
+		if (orphanCandidates !== null) for (const entry of orphanCandidates) this.abortOrphanedLoad(entry);
+	}
+	resetDataDependencies(owner) {
+		this.pendingOwnerKeys.delete(owner);
+	}
+	deleteDataOwner(owner, retainedKeys = null) {
+		this.pendingOwnerKeys.delete(owner);
+		const keys = this.ownerKeys.get(owner);
+		if (keys === void 0) return;
+		this.ownerKeys.delete(owner);
+		for (const key of keys) {
+			const entry = this.entries.get(key);
+			if (entry === void 0) continue;
+			entry.subscribers.delete(owner);
+			this.notifyEntryChange(entry);
+			if (retainedKeys?.has(key) !== true) this.scheduleInactiveCleanup(entry);
+		}
+	}
+	collectSubscribedEntries(keys, into) {
+		if (keys === null) return into;
+		for (const key of keys) {
+			const entry = this.entries.get(key);
+			if (entry !== void 0) {
+				into ??= /* @__PURE__ */ new Set();
+				into.add(entry);
+			}
+		}
+		return into;
+	}
+	abortOrphanedLoad(entry) {
+		if (this.entries.get(entry.storeKey) !== entry) return;
+		if (entry.subscribers.size > 0 || entry.preloadTimer !== null || entry.ensureRetainers > 0 || entry.pending === null || entryHasValue(entry)) return;
+		this.evictEntry(entry, "evicted");
+	}
+	dispose() {
+		this.disposed = true;
+		for (const entry of this.entries.values()) {
+			this.clearInactiveTimer(entry);
+			this.clearPreloadTimer(entry);
+			this.abortEntryGenerations(entry, "store-disposed");
+			this.notifyEntryChange(entry);
+		}
+	}
+	hydrate(entries) {
+		if (this.disposed) return;
+		for (const hydrated of entries) {
+			const normalized = normalizeKey(hydrated.key);
+			const storeKey = this.storeKey(normalized.canonical);
+			const current = this.entries.get(storeKey);
+			if (current !== void 0) {
+				this.hydrateEntry(current, normalized.key, hydrated.value);
+				this.publish(current);
+				continue;
+			}
+			const entry = this.createEntry(normalized, storeKey, null, null, "fulfilled", hydrated.value);
+			this.entries.set(storeKey, entry);
+			this.notifyEntryChange(entry);
+		}
+	}
+	snapshot() {
+		const entries = [];
+		for (const entry of this.entries.values()) if (entryHasValue(entry)) entries.push({
+			key: entry.key,
+			value: entry.value
+		});
+		return entries;
+	}
+	inspectDataEntries() {
+		return Array.from(this.entries.values(), (entry) => this.snapshotEntry(entry));
+	}
+	inspectDataDependencyCanonicalKeys(owner) {
+		const keys = this.ownerKeys.get(owner);
+		if (keys === void 0) return [];
+		const dependencies = [];
+		for (const key of keys) {
+			const entry = this.entries.get(key);
+			if (entry !== void 0) dependencies.push(entry.canonicalKey);
+		}
+		return dependencies;
+	}
+	invalidateData(resource, ...args) {
+		if (this.disposed) return;
+		const entry = this.entryFor(resource, args, false);
+		if (entry === null) return;
+		this.invalidateEntry(entry, this.host.getLane());
+	}
+	invalidateDataError(error) {
+		if (this.disposed) return false;
+		const keys = dataResourceKeysForError(error);
+		if (keys === void 0 || keys.length === 0) return false;
+		const entries = [];
+		for (const key of keys) {
+			const entry = this.entryForKey(key);
+			if (entry !== null) entries.push(entry);
+		}
+		this.invalidateEntries(entries, error);
+		return true;
+	}
+	invalidateDataKey(key) {
+		if (this.disposed) return;
+		const entry = this.entryForKey(key);
+		if (entry === null) return;
+		this.invalidateEntry(entry, this.host.getLane());
+	}
+	invalidateDataPrefix(prefix) {
+		if (this.disposed) return;
+		const prefixCanonical = normalizeKey(prefix).canonical;
+		const entries = [];
+		for (const entry of this.entries.values()) if (canonicalKeyStartsWith(entry.canonicalKey, prefixCanonical)) entries.push(entry);
+		this.invalidateEntries(entries);
+	}
+	async ensureData(resource, ...args) {
+		for (;;) {
+			if (this.disposed) throw new Error("ensureData() requires a live data store; this store was disposed.");
+			const entry = this.entryFor(resource, args, true);
+			this.clearInactiveTimer(entry);
+			this.retainPreload(entry);
+			if (entryHasValue(entry)) {
+				this.revalidateIfStale(entry, resource, args);
+				return entry.value;
+			}
+			if (entry.status === "rejected") throwDataResourceError(entry);
+			entry.ensureRetainers += 1;
+			try {
+				if (entry.pending !== null) await entry.pending.promise;
+				else await this.startLoad(entry, resource, args, {
+					lane: this.host.getLane(),
+					refresh: false
+				});
+			} finally {
+				entry.ensureRetainers -= 1;
+				if (this.entries.get(entry.storeKey) === entry) this.retainPreload(entry);
+			}
+		}
+	}
+	preloadData(resource, ...args) {
+		if (this.disposed || resource.load === void 0) return;
+		const entry = this.entryFor(resource, args, true);
+		this.clearInactiveTimer(entry);
+		this.retainPreload(entry);
+		if (entry.pending !== null) return;
+		if (entry.status === "fulfilled" && !entry.stale) return;
+		this.startLoad(entry, resource, args, {
+			lane: this.host.getLane(),
+			refresh: entry.status === "fulfilled"
+		});
+	}
+	readData(resource, args, owner) {
+		const entry = this.entryFor(resource, args, true);
+		this.clearInactiveTimer(entry);
+		this.clearPreloadTimer(entry);
+		this.addOwnerKey(owner, entry.storeKey);
+		this.revalidateIfStale(entry, resource, args);
+		if (entry.status === "pending" && entry.pending === null) this.startLoad(entry, resource, args, {
+			lane: this.host.getLane(),
+			refresh: false
+		});
+		return this.readCurrentValue(entry);
+	}
+	refreshData(resource, ...args) {
+		if (this.disposed) return Promise.resolve({
+			reason: "store-disposed",
+			staleValue: void 0,
+			status: "aborted"
+		});
+		if (resource.load === void 0) {
+			const entry = this.entryFor(resource, args, false);
+			if (entry === null) return Promise.resolve(unsupportedRefreshResult());
+			this.clearInactiveTimer(entry);
+			return Promise.resolve(unsupportedRefreshResult(entry));
+		}
+		const entry = this.entryFor(resource, args, true);
+		this.clearInactiveTimer(entry);
+		if (entry.pending !== null && entry.status !== "refreshing") return entry.pending.promise;
+		return this.startLoad(entry, resource, args, {
+			lane: this.host.getLane(),
+			refresh: entry.status === "fulfilled" || entry.status === "refreshing"
+		});
+	}
+	run(callback) {
+		const previousStore = setCurrentDataStore(this);
+		try {
+			return callback();
+		} finally {
+			setCurrentDataStore(previousStore);
+		}
+	}
+	addOwnerKey(owner, key) {
+		let keys = this.pendingOwnerKeys.get(owner);
+		if (keys === void 0) {
+			keys = /* @__PURE__ */ new Set();
+			this.pendingOwnerKeys.set(owner, keys);
+		}
+		keys.add(key);
+	}
+	entryFor(resource, args, create) {
+		const normalized = normalizeKey(resource.key(...args));
+		const fingerprint = fingerprintFor(resource, args);
+		const key = this.storeKey(normalized.canonical);
+		const current = this.entries.get(key);
+		if (current !== void 0) {
+			diagnoseEntryDrift(current, resource, normalized.canonical, fingerprint);
+			return current;
+		}
+		if (!create) return null;
+		const entry = this.createEntry(normalized, key, resource, fingerprint, "pending", void 0);
+		if (this.disposed) return entry;
+		this.entries.set(key, entry);
+		this.notifyEntryChange(entry);
+		return entry;
+	}
+	revalidateIfStale(entry, resource, args) {
+		if (entry.status !== "fulfilled" || !entry.stale || entry.pending !== null || entry.refreshError !== void 0 || resource.load === void 0) return;
+		this.startLoad(entry, resource, args, {
+			lane: this.host.getLane(),
+			refresh: true
+		});
+	}
+	entryForKey(key) {
+		const normalized = normalizeKey(key);
+		return this.entries.get(this.storeKey(normalized.canonical)) ?? null;
+	}
+	createEntry(normalized, storeKey, resource, fingerprint, status, value) {
+		return {
+			canonicalKey: normalized.canonical,
+			controller: null,
+			ensureRetainers: 0,
+			error: void 0,
+			fingerprint,
+			generation: 0,
+			invalidationVersion: 0,
+			inactiveTimer: null,
+			key: normalized.key,
+			lane: null,
+			pending: null,
+			preloadTimer: null,
+			refreshError: void 0,
+			resource,
+			stale: false,
+			status,
+			storeKey,
+			subscribers: /* @__PURE__ */ new Set(),
+			value,
+			valueController: null,
+			valueErrors: /* @__PURE__ */ new WeakSet()
+		};
+	}
+	hydrateEntry(entry, key, value) {
+		this.clearInactiveTimer(entry);
+		this.abortEntryGenerations(entry, "superseded");
+		entry.error = void 0;
+		entry.generation += 1;
+		entry.valueErrors = /* @__PURE__ */ new WeakSet();
+		entry.invalidationVersion = 0;
+		entry.key = key;
+		entry.lane = null;
+		entry.refreshError = void 0;
+		entry.stale = false;
+		entry.status = "fulfilled";
+		entry.value = value;
+	}
+	storeKey(canonicalKey) {
+		return this.partitionKey === "" ? canonicalKey : `${this.partitionKey}:${canonicalKey}`;
+	}
+	startLoad(entry, resource, args, options) {
+		const hadValue = entryHasValue(entry);
+		const load = resource.load;
+		if (this.disposed) return Promise.resolve(abortedRefreshResult(entry, "store-disposed"));
+		if (load === void 0) {
+			const error = /* @__PURE__ */ new Error(`Data resource "${entry.canonicalKey}" has no loader and no hydrated value.`);
+			entry.error = error;
+			entry.status = "rejected";
+			markDataResourceError(error, entry.key);
+			this.notifyEntryChange(entry);
+			return Promise.resolve(unsupportedRefreshResult(entry));
+		}
+		this.abortPendingLoad(entry, "superseded");
+		const controller = new AbortController();
+		const valueErrors = /* @__PURE__ */ new WeakSet();
+		const generation = entry.generation + 1;
+		const invalidationVersion = entry.invalidationVersion;
+		const pending = createPendingResult();
+		entry.controller = controller;
+		entry.generation = generation;
+		entry.lane = options.lane;
+		entry.pending = pending;
+		entry.status = options.refresh && hadValue ? "refreshing" : "pending";
+		this.notifyEntryChange(entry);
+		let loaded;
+		try {
+			loaded = load(...args, this.createLoadContext(entry, controller, valueErrors));
+		} catch (error) {
+			loaded = Promise.reject(error);
+		}
+		const settleAborted = () => {
+			const result = abortedRefreshResult(entry, "superseded");
+			pending.resolve(result);
+			return result;
+		};
+		const fulfill = (value) => {
+			if (entry.generation !== generation || controller.signal.aborted) return settleAborted();
+			const superseded = entry.valueController;
+			entry.controller = null;
+			entry.valueController = controller;
+			entry.valueErrors = valueErrors;
+			entry.error = void 0;
+			entry.pending = null;
+			entry.refreshError = void 0;
+			entry.stale = entry.invalidationVersion !== invalidationVersion;
+			entry.status = "fulfilled";
+			entry.value = value;
+			this.publish(entry);
+			superseded?.abort();
+			const result = {
+				status: "fulfilled",
+				value
+			};
+			pending.resolve(result);
+			return result;
+		};
+		const reject = (error) => {
+			if (entry.generation !== generation || controller.signal.aborted) return settleAborted();
+			entry.controller = null;
+			controller.abort();
+			entry.pending = null;
+			if (hadValue && entryHasValue(entry)) {
+				entry.refreshError = error;
+				entry.stale = true;
+				entry.status = "fulfilled";
+				this.publish(entry);
+				const result = {
+					error,
+					staleValue: entry.value,
+					status: "rejected"
+				};
+				pending.resolve(result);
+				return result;
+			}
+			entry.error = error;
+			entry.status = "rejected";
+			markDataResourceError(error, entry.key);
+			this.publish(entry);
+			const result = {
+				error,
+				status: "rejected"
+			};
+			pending.resolve(result);
+			return result;
+		};
+		if (!isThenable(loaded)) {
+			fulfill(loaded);
+			return pending.promise;
+		}
+		Promise.resolve(loaded).then(fulfill, reject);
+		return pending.promise;
+	}
+	createLoadContext(entry, controller, valueErrors) {
+		const context = { signal: controller.signal };
+		defineLoadContextCapabilities(context, {
+			key: entry.key,
+			attributeError: (error) => {
+				if (this.disposed || controller.signal.aborted) return;
+				markDataResourceError(error, entry.key);
+				if (isAttributableError(error)) valueErrors.add(error);
+			},
+			hydrate: (entries) => {
+				if (this.disposed || controller.signal.aborted) return;
+				const foreign = entries.filter((hydrated) => this.storeKey(normalizeKey(hydrated.key).canonical) !== entry.storeKey);
+				if (foreign.length !== entries.length) warn(`Data rows targeting the loading key ${entry.canonicalKey} were skipped: a loader cannot hydrate its own entry.`);
+				if (foreign.length > 0) this.hydrate(foreign);
+			}
+		});
+		return context;
+	}
+	publish(entry) {
+		this.notifyEntryChange(entry);
+		this.scheduleInactiveCleanup(entry);
+		this.scheduleSubscribers(entry, entry.lane ?? this.host.getLane());
+	}
+	scheduleSubscribers(entry, lane) {
+		for (const subscriber of entry.subscribers) this.host.schedule(subscriber, lane);
+	}
+	abortPendingLoad(entry, reason) {
+		entry.controller?.abort();
+		entry.controller = null;
+		const pending = entry.pending;
+		if (pending === null) return;
+		entry.pending = null;
+		pending.resolve(abortedRefreshResult(entry, reason));
+	}
+	abortEntryGenerations(entry, reason) {
+		this.abortPendingLoad(entry, reason);
+		entry.valueController?.abort();
+		entry.valueController = null;
+	}
+	retainPreload(entry) {
+		this.clearPreloadTimer(entry);
+		if (this.disposed || !Number.isFinite(this.preloadRetentionMs)) return;
+		entry.preloadTimer = scheduleStoreTimer(() => {
+			entry.preloadTimer = null;
+			if (entry.subscribers.size === 0 && entry.ensureRetainers === 0 && entry.pending !== null && !entryHasValue(entry)) {
+				this.evictEntry(entry, "evicted");
+				return;
+			}
+			this.scheduleInactiveCleanup(entry);
+		}, Math.max(0, this.preloadRetentionMs));
+	}
+	scheduleInactiveCleanup(entry) {
+		if (this.disposed || entry.subscribers.size > 0 || entry.pending !== null || entry.preloadTimer !== null || entry.ensureRetainers > 0 || !Number.isFinite(this.inactiveRetentionMs)) return;
+		this.clearInactiveTimer(entry);
+		entry.inactiveTimer = scheduleStoreTimer(() => {
+			entry.inactiveTimer = null;
+			if (entry.subscribers.size > 0 || entry.pending !== null || entry.preloadTimer !== null || entry.ensureRetainers > 0) return;
+			this.evictEntry(entry, "evicted");
+		}, Math.max(0, this.inactiveRetentionMs));
+	}
+	evictEntry(entry, reason) {
+		if (this.entries.get(entry.storeKey) !== entry) return;
+		this.clearInactiveTimer(entry);
+		this.clearPreloadTimer(entry);
+		this.abortEntryGenerations(entry, reason);
+		this.entries.delete(entry.storeKey);
+		this.host.onEntryEvict?.(this.snapshotEntry(entry));
+	}
+	clearInactiveTimer(entry) {
+		if (entry.inactiveTimer === null) return;
+		clearTimeout(entry.inactiveTimer);
+		entry.inactiveTimer = null;
+	}
+	clearPreloadTimer(entry) {
+		if (entry.preloadTimer === null) return;
+		clearTimeout(entry.preloadTimer);
+		entry.preloadTimer = null;
+	}
+	notifyEntryChange(entry) {
+		this.host.onEntryChange?.(this.snapshotEntry(entry));
+	}
+	snapshotEntry(entry) {
+		const hasValue = entryHasValue(entry);
+		return {
+			canonicalKey: entry.canonicalKey,
+			error: entry.status === "rejected" ? entry.error : void 0,
+			hasValue,
+			key: entry.key,
+			pending: entry.pending !== null,
+			refreshError: entry.refreshError,
+			stale: entry.stale,
+			status: entry.status,
+			subscriberCount: entry.subscribers.size,
+			value: hasValue ? entry.value : void 0
+		};
+	}
+	readCurrentValue(entry) {
+		if (entryHasValue(entry)) return entry.value;
+		if (entry.status === "rejected") throwDataResourceError(entry);
+		if (entry.pending === null) throw new Error(`Data resource "${entry.canonicalKey}" has no pending load.`);
+		throw entry.pending.promise;
+	}
+	invalidateEntry(entry, lane, attributedError) {
+		entry.invalidationVersion += 1;
+		entry.stale = true;
+		entry.refreshError = void 0;
+		if (isAttributableError(attributedError) && entry.valueErrors.has(attributedError)) {
+			entry.valueController?.abort();
+			entry.valueController = null;
+			entry.valueErrors = /* @__PURE__ */ new WeakSet();
+			entry.value = void 0;
+			entry.error = void 0;
+			entry.status = "pending";
+		} else if (entry.status === "rejected") {
+			entry.error = void 0;
+			entry.status = "pending";
+		}
+		this.notifyEntryChange(entry);
+		if (entry.subscribers.size === 0) return;
+		this.scheduleSubscribers(entry, lane);
+	}
+	invalidateEntries(entries, attributedError) {
+		if (entries.length === 0) return;
+		const lane = this.host.getLane();
+		for (const entry of entries) this.invalidateEntry(entry, lane, attributedError);
+	}
+};
+function normalizeKey(key) {
+	if (!Array.isArray(key) || typeof key[0] !== "string") throw new Error("Data resource keys must be arrays starting with a string.");
+	return {
+		canonical: encodeArray(key, createEncodePath("key")),
+		key
+	};
+}
+function canonicalKeyStartsWith(key, prefix) {
+	if (key === prefix) return true;
+	const arrayPrefix = prefix.slice(0, -1);
+	return key.startsWith(arrayPrefix) && key[arrayPrefix.length] === ",";
+}
+function entryHasValue(entry) {
+	return entry.status === "fulfilled" || entry.status === "refreshing";
+}
+function throwDataResourceError(entry) {
+	markDataResourceError(entry.error, entry.key);
+	throw entry.error;
+}
+function abortedRefreshResult(entry, reason) {
+	return {
+		reason,
+		staleValue: entryHasValue(entry) ? entry.value : void 0,
+		status: "aborted"
+	};
+}
+function unsupportedRefreshResult(entry) {
+	const result = {
+		reason: "no-client-loader",
+		status: "unsupported"
+	};
+	if (entry !== void 0) result.staleValue = entryHasValue(entry) ? entry.value : void 0;
+	return result;
+}
+function fingerprintFor(resource, args) {
+	if (resource.debugArgs !== void 0) return encodeValue(resource.debugArgs(...args), createEncodePath("debugArgs"));
+	try {
+		return encodeArray(args, createEncodePath("args"));
+	} catch {
+		return null;
+	}
+}
+function diagnoseEntryDrift(entry, resource, key, fingerprint) {
+	if (entry.resource === null) entry.resource = resource;
+	else if (entry.resource !== resource) warn(`Data resource key ${key} was read by multiple resource definitions.`);
+	if (entry.fingerprint !== null && fingerprint !== null && entry.fingerprint !== fingerprint) warn(`Data resource key ${key} was read with different argument fingerprints.`);
+}
+function warn(message) {
+	if (typeof console === "undefined") return;
+	console.warn(message);
+}
+function createEncodePath(root) {
+	return {
+		root,
+		segments: []
+	};
+}
+function formatEncodePath(path) {
+	let text = path.root;
+	for (const segment of path.segments) text += typeof segment === "number" ? `[${segment}]` : `.${segment}`;
+	return text;
+}
+function encodeArray(values, path) {
+	const parts = [];
+	for (let index = 0; index < values.length; index += 1) {
+		path.segments.push(index);
+		parts.push(encodeValue(values[index], path));
+		path.segments.pop();
+	}
+	return `[${parts.join(",")}]`;
+}
+function encodeObject(value, path) {
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new Error(`Invalid data resource key value at ${formatEncodePath(path)}.`);
+	const record = value;
+	const keys = Object.keys(record).sort();
+	const parts = [];
+	for (const key of keys) {
+		const child = record[key];
+		if (child === void 0) throw new Error(`Invalid undefined data resource key value at ${formatEncodePath(path)}.`);
+		path.segments.push(key);
+		parts.push(`${JSON.stringify(key)}:${encodeValue(child, path)}`);
+		path.segments.pop();
+	}
+	return `{${parts.join(",")}}`;
+}
+function encodeValue(value, path) {
+	if (value === null) return "null";
+	switch (typeof value) {
+		case "string": return JSON.stringify(value);
+		case "boolean": return value ? "true" : "false";
+		case "number":
+			if (!Number.isFinite(value)) throw new Error(`Invalid number in data resource key at ${formatEncodePath(path)}.`);
+			return Object.is(value, -0) ? "0" : JSON.stringify(value);
+		case "object":
+			if (Array.isArray(value)) return encodeArray(value, path);
+			return encodeObject(value, path);
+		default: throw new Error(`Invalid data resource key value at ${formatEncodePath(path)}.`);
+	}
+}
+function isThenable(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function createPendingResult() {
+	let resolve = () => void 0;
+	return {
+		promise: new Promise((settle) => {
+			resolve = settle;
+		}),
+		resolve
+	};
+}
+function scheduleStoreTimer(callback, delay) {
+	const timer = setTimeout(callback, delay);
+	const unref = timer.unref;
+	if (unref !== void 0) unref.call(timer);
+	return timer;
+}
+function runWithDataStore(store, callback) {
+	return store.run(callback);
+}
+function currentDataStore() {
+	return resolveCurrentDataStore();
+}
+//#endregion
+//#region src/transition.ts
+let transitionHandler = (callback) => callback();
+/**
+* Runs state updates scheduled by `callback` at transition priority. If
+* `callback` returns a thenable, updates after an `await` remain in the
+* transition priority scope until it settles.
+*/
+function transition(callback, options) {
+	return transitionHandler(callback, options);
+}
+function setTransitionHandler(handler) {
+	const previous = transitionHandler;
+	transitionHandler = handler;
+	return previous;
+}
+//#endregion
+export { runWithDataStore as _, createRendererDataStore as a, isContext as b, ensureData as c, invalidateDataKey as d, invalidateDataPrefix as f, refreshData as g, readDataStore as h, createDataStore as i, invalidateData as l, normalizeDataResourceKey as m, transition as n, currentDataStore as o, isDataStoreController as p, attachDataStore as r, dataResource as s, setTransitionHandler as t, invalidateDataError as u, FigContextSymbol as v, createContext as y };
+
+//# sourceMappingURL=transition-B4XiOWAj.js.map