@bgub/fig 0.0.1

package/dist/data-store-CRnNAT9-.js

@@ -0,0 +1,611 @@
+import { i as setCurrentDataStore, n as markDataResourceError, r as resolveCurrentDataStore, t as dataResourceKeysForError } from "./data-h46EcMnE.js";
+//#region src/data-store.ts
+const DataResourceSymbol = Symbol.for("fig.data-resource");
+const DataStoreFactorySymbol = Symbol.for("fig.data-store-factory");
+const DEFAULT_INACTIVE_RETENTION_MS = 300 * 1e3;
+const DEFAULT_PRELOAD_RETENTION_MS = 30 * 1e3;
+const dataStoreFactory = createDataStore;
+function dataResource(options) {
+	const resource = {
+		$$typeof: DataResourceSymbol,
+		debugArgs: options.debugArgs,
+		key: options.key,
+		load: options.load
+	};
+	resource[DataStoreFactorySymbol] = dataStoreFactory;
+	return resource;
+}
+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 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 createDataStore(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.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.abortActiveLoad(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));
+	}
+	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);
+		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);
+	}
+	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, key } = this.entryFor(resource, args, true);
+		this.clearInactiveTimer(entry);
+		this.clearPreloadTimer(entry);
+		this.addOwnerKey(owner, key);
+		if (entry.status === "fulfilled" && entry.stale && entry.pending === null && entry.refreshError === void 0 && resource.load !== void 0) this.startLoad(entry, resource, args, {
+			lane: this.host.getLane(),
+			refresh: true
+		});
+		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 = null;
+		const key = this.storeKey(normalized.canonical);
+		const current = this.entries.get(key);
+		if (current !== void 0) return {
+			entry: current,
+			key
+		};
+		if (!create) return {
+			entry: null,
+			key
+		};
+		const entry = this.createEntry(normalized, key, resource, fingerprint, "pending", void 0);
+		if (this.disposed) return {
+			entry,
+			key
+		};
+		this.entries.set(key, entry);
+		this.notifyEntryChange(entry);
+		return {
+			entry,
+			key
+		};
+	}
+	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,
+			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
+		};
+	}
+	hydrateEntry(entry, key, value) {
+		this.clearInactiveTimer(entry);
+		this.abortActiveLoad(entry, "superseded");
+		entry.error = void 0;
+		entry.generation += 1;
+		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.abortActiveLoad(entry, "superseded");
+		const controller = new AbortController();
+		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, { signal: controller.signal });
+		} 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();
+			entry.controller = null;
+			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);
+			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;
+			entry.pending = null;
+			if (hadValue) {
+				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;
+	}
+	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);
+	}
+	abortActiveLoad(entry, reason) {
+		const pending = entry.pending;
+		if (pending === null) return;
+		entry.controller?.abort();
+		entry.controller = null;
+		entry.pending = null;
+		pending.resolve(abortedRefreshResult(entry, reason));
+	}
+	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.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 || !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) 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.abortActiveLoad(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) {
+		entry.invalidationVersion += 1;
+		entry.stale = true;
+		entry.refreshError = void 0;
+		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) {
+		if (entries.length === 0) return;
+		const lane = this.host.getLane();
+		for (const entry of entries) this.invalidateEntry(entry, lane);
+	}
+};
+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 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 && 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
+export { invalidateDataError as a, normalizeDataResourceKey as c, runWithDataStore as d, invalidateData as i, readDataStore as l, currentDataStore as n, invalidateDataKey as o, dataResource as r, invalidateDataPrefix as s, createDataStore as t, refreshData as u };
+
+//# sourceMappingURL=data-store-CRnNAT9-.js.map