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

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## @bgub/fig@0.1.0-alpha.3
+
+### Let Fig's Vite integration own runtime configuration
+
+The new `fig()` Vite integration defines Fig's development gate and installs
+Fast Refresh. TanStack Start composes it automatically, so applications no
+longer need to configure Fig's compile-time mode or SSR package bundling
+themselves.
+
+`@bgub/fig-vite` now uses the application's Fig DOM renderer as a peer instead
+of installing a private renderer copy.
+
+The development gate follows Vite's command rather than its mode: serving
+enables development behavior, while builds—including `--mode development`—strip
+it from production output.
+
+Published npm packages now expose development artifacts through a Fig-owned
+condition, allowing the Vite integration to enable diagnostics and Fast Refresh
+for ordinary installs while explicit static overrides remain authoritative and
+default production imports retain their previous dead-code elimination. A
+static `false` override also disables Fast Refresh instrumentation.
+
 ## @bgub/fig@0.1.0-alpha.2
 
 ### Preload eligible host images during server rendering

package/dist-development/element-B7mCQIMi.js

@@ -0,0 +1,314 @@
+//#region src/data.ts
+const LoadContextCapabilitiesSymbol = Symbol.for("fig.data-load-context");
+function defineLoadContextCapabilities(context, capabilities) {
+	Object.defineProperty(context, LoadContextCapabilitiesSymbol, {
+		configurable: true,
+		enumerable: false,
+		value: capabilities
+	});
+}
+function loadContextCapabilities(context) {
+	return context[LoadContextCapabilitiesSymbol];
+}
+const objectDataErrors = /* @__PURE__ */ new WeakMap();
+let currentDataStore = null;
+function resolveCurrentDataStore(message = "Data resource APIs require a Fig data store.") {
+	if (currentDataStore === null) throw new Error(message);
+	return currentDataStore;
+}
+function setCurrentDataStore(store) {
+	const previousStore = currentDataStore;
+	currentDataStore = store;
+	return previousStore;
+}
+function markDataResourceError(error, key) {
+	if (!isAttributableError(error)) return;
+	let keys = objectDataErrors.get(error);
+	if (keys === void 0) {
+		keys = [];
+		objectDataErrors.set(error, keys);
+	}
+	if (keys.some((existing) => sameDataResourceKey(existing, key))) return;
+	keys.push(key);
+}
+function dataResourceKeysForError(error) {
+	if (!isAttributableError(error)) return void 0;
+	const keys = objectDataErrors.get(error);
+	return keys === void 0 || keys.length === 0 ? void 0 : [...keys];
+}
+function sameDataResourceKey(a, b) {
+	return a.length === b.length && a.every((value, index) => Object.is(value, b[index]));
+}
+function isAttributableError(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+//#endregion
+//#region src/hooks.ts
+let currentDispatcher = null;
+function useState(initialState) {
+	return resolveDispatcher().useState(initialState);
+}
+/**
+* Tracks state returned by a client-side action. The action receives the
+* previous committed state first, then the runner's arguments, then an
+* `AbortSignal` Fig appends (declare the trailing signal parameter — it also
+* drives `Args` inference). Async actions run in a transition priority scope
+* and keep `isPending` true until they settle.
+*
+* Runs are last-run-wins: starting a new run aborts the previous one's
+* signal and retires it — a retired run's settlement (value or rejection)
+* never touches state or pending. The signal also aborts on unmount and
+* when an enclosing Activity hides.
+*/
+function useActionState(action, initialState) {
+	return resolveDispatcher().useActionState(action, initialState);
+}
+function useId() {
+	return resolveDispatcher().useId();
+}
+function useDeferredValue(value, initialValue) {
+	return resolveDispatcher().useDeferredValue(value, initialValue, arguments.length > 1);
+}
+function useMemo(calculate, deps) {
+	return resolveDispatcher().useMemo(calculate, deps);
+}
+function useTransition() {
+	return resolveDispatcher().useTransition();
+}
+function useCallback(callback, deps) {
+	return resolveDispatcher().useMemo(() => callback, deps);
+}
+function useReactive(effect, deps) {
+	resolveDispatcher().useReactive(effect, deps);
+}
+function useBeforePaint(effect, deps) {
+	resolveDispatcher().useBeforePaint(effect, deps);
+}
+function useBeforeLayout(effect, deps) {
+	resolveDispatcher().useBeforeLayout(effect, deps);
+}
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+	return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+function useStableEvent(handler) {
+	return resolveDispatcher().useStableEvent(handler);
+}
+function readContext(context) {
+	return resolveDispatcher("readContext can only be called while rendering a component.").readContext(context);
+}
+function readPromise(promise) {
+	return resolveDispatcher("readPromise can only be called while rendering a component.").readPromise(promise);
+}
+function readData(resource, ...args) {
+	return resolveDispatcher("readData can only be called while rendering a component.").readData(resource, args);
+}
+function preloadData(resource, ...args) {
+	if (currentDispatcher !== null) {
+		currentDispatcher.preloadData(resource, args);
+		return;
+	}
+	resolveDataStore().preloadData(resource, ...args);
+}
+function setCurrentDispatcher(dispatcher) {
+	const previousDispatcher = currentDispatcher;
+	currentDispatcher = dispatcher;
+	return previousDispatcher;
+}
+function resolveDispatcher(message = "Hooks can only be called while rendering a component.") {
+	if (currentDispatcher === null) throw new Error(message);
+	return currentDispatcher;
+}
+function resolveDataStore() {
+	return resolveCurrentDataStore("No ambient Fig data store. Data APIs work synchronously during render, event handlers, actions, and effects — not after an await. Capture readDataStore() (or root.data) synchronously and call the handle instead.");
+}
+//#endregion
+//#region src/mixin.ts
+const FigMixinSymbol = Symbol.for("fig.mixin");
+const FigMixinSlotSymbol = Symbol.for("fig.mixin-slot");
+const FigClientOnlyHostBehaviorSymbol = Symbol.for("fig.client-only-host-behavior");
+/** Creates a render-time host behavior for the `mix` prop. */
+function createMixin(type) {
+	const descriptorType = guardMixinType(type);
+	return (...args) => ({
+		$$typeof: FigMixinSymbol,
+		args,
+		type: descriptorType
+	});
+}
+const maximumResolvedMixins = 1024;
+function resolveHostMix(type, input) {
+	const props = input;
+	const mix = props.mix;
+	delete props.mix;
+	let resolvedMixins = 0;
+	function resolve(value, slot) {
+		if (emptyMixinValue(value)) return;
+		if (Array.isArray(value)) {
+			for (let index = 0; index < value.length; index += 1) resolve(value[index], `${slot}.${index}`);
+			return;
+		}
+		if (!isMixinDescriptor(value)) throw new Error(`The mix prop on <${type}> must contain descriptors created by createMixin().`);
+		resolvedMixins += 1;
+		if (resolvedMixins > maximumResolvedMixins) throw new Error(`The mix prop on <${type}> resolved more than ${maximumResolvedMixins} mixins.`);
+		const context = {
+			[FigMixinSlotSymbol]: slot,
+			props,
+			type
+		};
+		const result = value.type(context, ...value.args);
+		if (emptyMixinValue(result)) return;
+		if (isMixinDescriptor(result) || Array.isArray(result)) {
+			resolve(result, `${slot}.result`);
+			return;
+		}
+		if (typeof result !== "object") throw new Error(`A mixin on <${type}> must return host props, more mixins, or nothing.`);
+		const returnedProps = result;
+		if ("children" in returnedProps || "key" in returnedProps || "unsafeHTML" in returnedProps) throw new Error(`A mixin on <${type}> cannot return children, key, or unsafeHTML.`);
+		const { mix: nestedMix, ...patch } = returnedProps;
+		Object.assign(props, patch);
+		resolve(nestedMix, `${slot}.mix`);
+	}
+	resolve(mix, "0");
+	props.mix = mix;
+	return props;
+}
+function mixinSlot(context) {
+	return context[FigMixinSlotSymbol];
+}
+function markClientOnlyHostBehavior(context, behavior) {
+	if (context.props[FigClientOnlyHostBehaviorSymbol] !== void 0) return;
+	Object.defineProperty(context.props, FigClientOnlyHostBehaviorSymbol, {
+		configurable: true,
+		value: behavior
+	});
+}
+function clientOnlyHostBehavior(props) {
+	const behavior = props[FigClientOnlyHostBehaviorSymbol];
+	return typeof behavior === "string" ? behavior : void 0;
+}
+function emptyMixinValue(value) {
+	return value === false || value === 0 || value === 0n || value === "" || value === null || value === void 0;
+}
+function isMixinDescriptor(value) {
+	return typeof value === "object" && value !== null && "$$typeof" in value && value.$$typeof === FigMixinSymbol;
+}
+function guardMixinType(type) {
+	return (context, ...args) => {
+		const previousDispatcher = setCurrentDispatcher(mixinDispatcher(context.type, mixinSlot(context)));
+		try {
+			return type(context, ...args);
+		} finally {
+			setCurrentDispatcher(previousDispatcher);
+		}
+	};
+}
+function mixinDispatcher(type, slot) {
+	return new Proxy({}, { get(_target, property) {
+		throw new Error(`A mixin on <${type}> (slot ${slot}) called ${String(property)}. Mixins are pure render-time code: hooks and read verbs belong to the component; host lifetimes belong in returned on() or bind behavior.`);
+	} });
+}
+//#endregion
+//#region src/element.ts
+const Fragment = Symbol.for("fig.fragment");
+const FigElementSymbol = Symbol.for("fig.element");
+const FigClientReferenceSymbol = Symbol.for("fig.client-reference");
+const FigActivitySymbol = Symbol.for("fig.activity");
+const FigErrorBoundarySymbol = Symbol.for("fig.error-boundary");
+const FigPortalSymbol = Symbol.for("fig.portal");
+const FigAssetsSymbol = Symbol.for("fig.assets");
+const FigSuspenseSymbol = Symbol.for("fig.suspense");
+const FigViewTransitionSymbol = Symbol.for("fig.view-transition");
+const Assets = Object.assign((props) => props.children, { $$typeof: FigAssetsSymbol });
+const ErrorBoundary = Object.assign((props) => props.children, { $$typeof: FigErrorBoundarySymbol });
+const Suspense = Object.assign((props) => props.children, { $$typeof: FigSuspenseSymbol });
+const Activity = Object.assign((props) => props.children, { $$typeof: FigActivitySymbol });
+const ViewTransition = Object.assign((props) => props.children, { $$typeof: FigViewTransitionSymbol });
+function createElement(type, config, ...children) {
+	const props = { ...config };
+	const key = props.key ?? null;
+	delete props.key;
+	if (children.length === 1) props.children = children[0];
+	else if (children.length > 1) props.children = children;
+	return {
+		$$typeof: FigElementSymbol,
+		type,
+		key,
+		props: "mix" in props && typeof type === "string" ? resolveHostMix(type, props) : props
+	};
+}
+function isValidElement(value) {
+	return hasObjectBrand(value, FigElementSymbol);
+}
+function createPortalNode(children, target, key = null) {
+	return {
+		$$typeof: FigPortalSymbol,
+		children,
+		key,
+		target
+	};
+}
+function isPortal(value) {
+	return hasObjectBrand(value, FigPortalSymbol);
+}
+function clientReference(options) {
+	return Object.assign(() => {
+		throw new Error(`Client reference "${options.id}" cannot be rendered on the server directly.`);
+	}, {
+		$$typeof: FigClientReferenceSymbol,
+		assets: options.assets,
+		id: options.id,
+		ssr: options.ssr
+	});
+}
+function lazy(load) {
+	let promise = null;
+	let rejected = false;
+	const Lazy = (props) => {
+		if (promise === null) {
+			rejected = false;
+			const next = Promise.resolve(load()).then((value) => value, (error) => {
+				if (promise === next) rejected = true;
+				throw error;
+			});
+			promise = next;
+		}
+		try {
+			return createElement(readPromise(promise), props);
+		} catch (error) {
+			if (rejected) {
+				promise = null;
+				rejected = false;
+			}
+			throw error;
+		}
+	};
+	return Lazy;
+}
+function isClientReference(value) {
+	return hasFunctionBrand(value, FigClientReferenceSymbol);
+}
+function isSuspense(value) {
+	return hasFunctionBrand(value, FigSuspenseSymbol);
+}
+function isActivity(value) {
+	return hasFunctionBrand(value, FigActivitySymbol);
+}
+function isErrorBoundary(value) {
+	return hasFunctionBrand(value, FigErrorBoundarySymbol);
+}
+function isViewTransition(value) {
+	return hasFunctionBrand(value, FigViewTransitionSymbol);
+}
+function isAssets(value) {
+	return hasFunctionBrand(value, FigAssetsSymbol);
+}
+function hasObjectBrand(value, brand) {
+	return typeof value === "object" && value !== null && "$$typeof" in value && value.$$typeof === brand;
+}
+function hasFunctionBrand(value, brand) {
+	return typeof value === "function" && "$$typeof" in value && value.$$typeof === brand;
+}
+//#endregion
+export { loadContextCapabilities as $, markClientOnlyHostBehavior as A, useBeforePaint as B, isSuspense as C, FigMixinSymbol as D, lazy as E, readData as F, useReactive as G, useDeferredValue as H, readPromise as I, useSyncExternalStore as J, useStableEvent as K, setCurrentDispatcher as L, resolveHostMix as M, preloadData as N, clientOnlyHostBehavior as O, readContext as P, isAttributableError as Q, useActionState as R, isPortal as S, isViewTransition as T, useId as U, useCallback as V, useMemo as W, dataResourceKeysForError as X, useTransition as Y, defineLoadContextCapabilities as Z, createPortalNode as _, FigAssetsSymbol as a, isClientReference as b, FigErrorBoundarySymbol as c, FigViewTransitionSymbol as d, markDataResourceError as et, Fragment as f, createElement as g, clientReference as h, FigActivitySymbol as i, mixinSlot as j, createMixin as k, FigPortalSymbol as l, ViewTransition as m, Assets as n, setCurrentDataStore as nt, FigClientReferenceSymbol as o, Suspense as p, useState as q, ErrorBoundary as r, FigElementSymbol as s, Activity as t, resolveCurrentDataStore as tt, FigSuspenseSymbol as u, isActivity as v, isValidElement as w, isErrorBoundary as x, isAssets as y, useBeforeLayout as z };
+
+//# sourceMappingURL=element-B7mCQIMi.js.map

package/dist-development/element-B7mCQIMi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-B7mCQIMi.js","names":["runtimeType"],"sources":["../src/data.ts","../src/hooks.ts","../src/mixin.ts","../src/element.ts"],"sourcesContent":["export type DataResourceKeyInput =\n  | string\n  | number\n  | boolean\n  | null\n  | readonly DataResourceKeyInput[]\n  | { readonly [key: string]: DataResourceKeyInput };\n\nexport type DataResourceKey = readonly [string, ...DataResourceKeyInput[]];\n\nexport interface DataResourceLoadContext {\n  signal: AbortSignal;\n}\n\nexport type DataResourceLoader<TArgs extends unknown[], TValue> = (\n  ...argsAndContext: [...TArgs, DataResourceLoadContext]\n) => TValue | PromiseLike<TValue>;\n\nexport interface DataResource<\n  TArgs extends unknown[] = unknown[],\n  TValue = unknown,\n> {\n  readonly $$typeof: symbol;\n  readonly debugArgs?: (...args: TArgs) => DataResourceKeyInput;\n  readonly key: (...args: TArgs) => DataResourceKey;\n  readonly load?: DataResourceLoader<TArgs, TValue>;\n}\n\nexport type DataRefreshResult<T> =\n  | { status: \"fulfilled\"; value: T }\n  | { status: \"rejected\"; error: unknown; staleValue?: T }\n  | {\n      status: \"aborted\";\n      reason: \"superseded\" | \"store-disposed\" | \"evicted\";\n      staleValue?: T;\n    }\n  | {\n      status: \"unsupported\";\n      reason: \"no-client-loader\";\n      staleValue?: T;\n    };\n\nexport interface FigDataHydrationEntry {\n  key: DataResourceKey;\n  value: unknown;\n}\n\nexport type FigDataEntryStatus =\n  | \"pending\"\n  | \"fulfilled\"\n  | \"rejected\"\n  | \"refreshing\";\n\nexport interface DataStoreEntrySnapshot {\n  canonicalKey: string;\n  error?: unknown;\n  hasValue: boolean;\n  key: DataResourceKey;\n  pending: boolean;\n  refreshError?: unknown;\n  stale: boolean;\n  status: FigDataEntryStatus;\n  subscriberCount: number;\n  value?: unknown;\n}\n\n// The explicit, app-facing store surface (FigRoot.data, readDataStore()).\n// The free functions in @bgub/fig resolve the ambient store slot, which\n// is only set while Fig executes synchronously — render, event handlers, the\n// synchronous prefix of actions and transitions, and effects. After an\n// `await` the slot is gone, so async flows capture this handle first and call\n// its methods instead.\nexport interface FigDataStoreHandle {\n  // The awaitable read for code outside render (route loaders, actions after\n  // an await): resolve the value this key would render with — the cached\n  // value when the entry has one (kicking the same background revalidation a\n  // stale readData does), the in-flight load's settlement on a cache miss —\n  // and reject with the error readData would throw. Does not subscribe;\n  // pair with readData in the component, which claims the settled entry\n  // within the preload retention window.\n  ensureData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    ...args: TArgs\n  ): Promise<TValue>;\n  hydrate(entries: readonly FigDataHydrationEntry[]): void;\n  invalidateData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    ...args: TArgs\n  ): void;\n  invalidateDataError(error: unknown): boolean;\n  invalidateDataKey(key: DataResourceKey): void;\n  invalidateDataPrefix(prefix: DataResourceKey): void;\n  preloadData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    ...args: TArgs\n  ): void;\n  refreshData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    ...args: TArgs\n  ): Promise<DataRefreshResult<TValue>>;\n  run<T>(callback: () => T): T;\n}\n\n/**\n * A root-neutral data store. A renderer adopts it exactly once, preserving\n * entries loaded before rendering while attaching subscriber scheduling.\n */\nexport interface FigDataStoreController extends FigDataStoreHandle {\n  dispose(): void;\n  snapshot(): FigDataHydrationEntry[];\n}\n\nexport interface FigDataStoreOptions {\n  initialData?: readonly FigDataHydrationEntry[];\n  partition?: DataResourceKeyInput;\n}\n\nexport interface FigDataStore extends FigDataStoreHandle {\n  commitDataDependencies(owner: object, previousOwner: object | null): void;\n  deleteDataOwner(owner: object): void;\n  releaseDataOwner(owner: object): void;\n  resetDataDependencies(owner: object): void;\n  dispose(): void;\n  inspectDataDependencyCanonicalKeys(owner: object): string[];\n  inspectDataEntries(): DataStoreEntrySnapshot[];\n  snapshot(): FigDataHydrationEntry[];\n  // Renderer plumbing, not handle surface: args stay an array because the\n  // subscribing owner trails them.\n  readData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    args: TArgs,\n    owner: object,\n  ): TValue;\n}\n\n// The host callbacks a renderer hands to the data-store factory. Structurally\n// compatible with @bgub/fig's DataStoreHost so its renderer store can\n// register directly.\nexport interface FigDataStoreHost {\n  getLane(): unknown;\n  partition?: DataResourceKeyInput;\n  schedule(owner: object, lane: unknown): void;\n}\n\nexport type FigDataStoreFactory = (host: FigDataStoreHost) => FigDataStore;\n\n// The internal, generation-guarded metadata a store attaches to each loader\n// context (symbol-keyed: DataResourceLoadContext stays { signal } publicly).\n// Adapters use the resolved key and decode Payload rows through the calling\n// store without recomputing identity or exposing these capabilities to loaders.\nexport type LoadContextHydrate = (\n  entries: readonly FigDataHydrationEntry[],\n) => void;\nexport type LoadContextAttributeError = (error: unknown) => void;\n\nexport interface LoadContextCapabilities {\n  attributeError: LoadContextAttributeError;\n  hydrate: LoadContextHydrate;\n  // Store contexts always provide this; optional keeps synthetic decoder\n  // contexts usable without pretending they belong to a cache entry.\n  key?: DataResourceKey;\n}\n\nconst LoadContextCapabilitiesSymbol = Symbol.for(\"fig.data-load-context\");\ntype DataResourceLoadContextWithCapabilities = DataResourceLoadContext & {\n  [LoadContextCapabilitiesSymbol]?: LoadContextCapabilities;\n};\n\nexport function defineLoadContextCapabilities(\n  context: DataResourceLoadContext,\n  capabilities: LoadContextCapabilities,\n): void {\n  Object.defineProperty(context, LoadContextCapabilitiesSymbol, {\n    configurable: true,\n    enumerable: false,\n    value: capabilities,\n  });\n}\n\nexport function loadContextCapabilities(\n  context: DataResourceLoadContext,\n): LoadContextCapabilities | undefined {\n  return (context as DataResourceLoadContextWithCapabilities)[\n    LoadContextCapabilitiesSymbol\n  ];\n}\n\nconst objectDataErrors = new WeakMap<object, DataResourceKey[]>();\n\nlet currentDataStore: FigDataStore | null = null;\n\nexport function resolveCurrentDataStore(\n  message = \"Data resource APIs require a Fig data store.\",\n): FigDataStore {\n  if (currentDataStore === null) throw new Error(message);\n  return currentDataStore;\n}\n\nexport function setCurrentDataStore(\n  store: FigDataStore | null,\n): FigDataStore | null {\n  const previousStore = currentDataStore;\n  currentDataStore = store;\n  return previousStore;\n}\n\nexport function markDataResourceError(\n  error: unknown,\n  key: DataResourceKey,\n): void {\n  // Only object errors are attributed: the WeakMap keys them by identity, so the\n  // registry is GC-safe and cannot cross-attribute. Primitive rejection values\n  // would collide by value and accumulate forever in a plain Map, so a thrown\n  // primitive simply carries no resource-key metadata.\n  if (!isAttributableError(error)) return;\n\n  let keys = objectDataErrors.get(error);\n  if (keys === undefined) {\n    keys = [];\n    objectDataErrors.set(error, keys);\n  }\n\n  if (keys.some((existing) => sameDataResourceKey(existing, key))) return;\n\n  keys.push(key);\n}\n\nexport function dataResourceKeysForError(\n  error: unknown,\n): DataResourceKey[] | undefined {\n  if (!isAttributableError(error)) return undefined;\n\n  const keys = objectDataErrors.get(error);\n  return keys === undefined || keys.length === 0 ? undefined : [...keys];\n}\n\nfunction sameDataResourceKey(a: DataResourceKey, b: DataResourceKey): boolean {\n  return (\n    a.length === b.length &&\n    a.every((value, index) => Object.is(value, b[index]))\n  );\n}\n\n// The single rule for which errors can carry attribution: identity-keyed\n// (WeakMap/WeakSet) registries require object errors. Shared with the store's\n// per-generation value-error sets so the two can never disagree.\nexport function isAttributableError(value: unknown): value is object {\n  return (\n    (typeof value === \"object\" || typeof value === \"function\") && value !== null\n  );\n}\n","import type { FigContext } from \"./context.ts\";\nimport type { DataResource, FigDataStore } from \"./data.ts\";\nimport { resolveCurrentDataStore } from \"./data.ts\";\nimport type { TransitionOptions } from \"./transition.ts\";\n\n// The useState updater: accepts the next state, or an updater function of\n// the previous state for stale-closure safety.\nexport type StateSetter<S> = (next: S | ((previous: S) => S)) => void;\nexport type ExternalStoreSubscribe = (callback: () => void) => () => void;\n// Fig appends the AbortSignal after the runner's args (the data-loader\n// shape). The signal aborts when a newer run supersedes this one, when the\n// owning component unmounts, and when an enclosing Activity hides.\nexport type ActionStateAction<S, Args extends unknown[]> = (\n  previousState: S,\n  ...argsAndSignal: [...Args, AbortSignal]\n) => S | PromiseLike<S>;\nexport type ActionStateRunner<Args extends unknown[]> = (...args: Args) => void;\n\n/**\n * Runs state updates scheduled by `callback` at transition priority. If\n * `callback` returns a thenable, `useTransition` keeps `isPending` true until\n * it settles and updates after an `await` remain in the transition priority\n * scope.\n *\n * The callback receives an `AbortSignal` that aborts when a newer transition\n * starts from the same hook, when the owning component unmounts, and when an\n * enclosing Activity hides. Each `useTransition` hook is one cancellation\n * domain — use separate hooks for independently cancellable workflows. An\n * aborted run is retired: its pending slot is released immediately and its\n * settlement (including an aborted fetch's rejection) is inert.\n */\nexport type StartTransition = (\n  callback: (signal: AbortSignal) => void | PromiseLike<void>,\n  options?: TransitionOptions,\n) => void;\ntype Callback = (...args: never[]) => unknown;\n\nexport interface RenderDispatcher {\n  useState<S>(initialState: S | (() => S)): [S, StateSetter<S>];\n  useActionState<S, Args extends unknown[]>(\n    action: ActionStateAction<S, Args>,\n    initialState: S,\n  ): [S, ActionStateRunner<Args>, boolean];\n  useId(): string;\n  useDeferredValue<T>(\n    value: T,\n    initialValue: T | undefined,\n    hasInitialValue: boolean,\n  ): T;\n  useMemo<T>(calculate: () => T, deps: DependencyList): T;\n  useTransition(): [boolean, StartTransition];\n  useReactive(effect: EffectCallback, deps?: DependencyList): void;\n  useBeforePaint(effect: EffectCallback, deps?: DependencyList): void;\n  useBeforeLayout(effect: EffectCallback, deps?: DependencyList): void;\n  useSyncExternalStore<T>(\n    subscribe: ExternalStoreSubscribe,\n    getSnapshot: () => T,\n    getServerSnapshot?: () => T,\n  ): T;\n  useStableEvent<Args extends unknown[], Result>(\n    handler: (...args: Args) => Result,\n  ): (...args: StableEventCallerArgs<Args>) => Result;\n  readContext<T>(context: FigContext<T>): T;\n  readData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    args: TArgs,\n  ): TValue;\n  preloadData<TArgs extends unknown[], TValue>(\n    resource: DataResource<TArgs, TValue>,\n    args: TArgs,\n  ): void;\n  readPromise<T>(promise: PromiseLike<T>): T;\n}\n\nexport type EffectCallback = (signal: AbortSignal) => undefined;\nexport type DependencyList = readonly unknown[];\n\nexport type StableEventCallerArgs<Args extends unknown[]> = Args extends [\n  ...infer CallerArgs,\n  AbortSignal,\n]\n  ? CallerArgs\n  : Args;\n\n// Fig appends the AbortSignal when invoking the handler; callers never pass\n// it, so a declared trailing signal is stripped from the callable signature.\nlet currentDispatcher: RenderDispatcher | null = null;\n\nexport function useState<S>(initialState: S | (() => S)): [S, StateSetter<S>] {\n  return resolveDispatcher().useState(initialState);\n}\n\n/**\n * Tracks state returned by a client-side action. The action receives the\n * previous committed state first, then the runner's arguments, then an\n * `AbortSignal` Fig appends (declare the trailing signal parameter — it also\n * drives `Args` inference). Async actions run in a transition priority scope\n * and keep `isPending` true until they settle.\n *\n * Runs are last-run-wins: starting a new run aborts the previous one's\n * signal and retires it — a retired run's settlement (value or rejection)\n * never touches state or pending. The signal also aborts on unmount and\n * when an enclosing Activity hides.\n */\nexport function useActionState<S, Args extends unknown[]>(\n  action: ActionStateAction<S, Args>,\n  initialState: S,\n): [S, ActionStateRunner<Args>, boolean] {\n  return resolveDispatcher().useActionState(action, initialState);\n}\n\nexport function useId(): string {\n  return resolveDispatcher().useId();\n}\n\nexport function useDeferredValue<T>(value: T, initialValue?: T): T {\n  return resolveDispatcher().useDeferredValue(\n    value,\n    initialValue,\n    arguments.length > 1,\n  );\n}\n\nexport function useMemo<T>(calculate: () => T, deps: DependencyList): T {\n  return resolveDispatcher().useMemo(calculate, deps);\n}\n\nexport function useTransition(): [boolean, StartTransition] {\n  return resolveDispatcher().useTransition();\n}\n\nexport function useCallback<T extends Callback>(\n  callback: T,\n  deps: DependencyList,\n): T {\n  return resolveDispatcher().useMemo(() => callback, deps);\n}\n\nexport function useReactive(\n  effect: EffectCallback,\n  deps?: DependencyList,\n): void {\n  resolveDispatcher().useReactive(effect, deps);\n}\n\nexport function useBeforePaint(\n  effect: EffectCallback,\n  deps?: DependencyList,\n): void {\n  resolveDispatcher().useBeforePaint(effect, deps);\n}\n\nexport function useBeforeLayout(\n  effect: EffectCallback,\n  deps?: DependencyList,\n): void {\n  resolveDispatcher().useBeforeLayout(effect, deps);\n}\n\nexport function useSyncExternalStore<T>(\n  subscribe: ExternalStoreSubscribe,\n  getSnapshot: () => T,\n  getServerSnapshot?: () => T,\n): T {\n  return resolveDispatcher().useSyncExternalStore(\n    subscribe,\n    getSnapshot,\n    getServerSnapshot,\n  );\n}\n\nexport function useStableEvent<Args extends unknown[], Result>(\n  handler: (...args: Args) => Result,\n): (...args: StableEventCallerArgs<Args>) => Result {\n  return resolveDispatcher().useStableEvent(handler);\n}\n\nexport function readContext<T>(context: FigContext<T>): T {\n  return resolveDispatcher(\n    \"readContext can only be called while rendering a component.\",\n  ).readContext(context);\n}\n\nexport function readPromise<T>(promise: PromiseLike<T>): T {\n  return resolveDispatcher(\n    \"readPromise can only be called while rendering a component.\",\n  ).readPromise(promise);\n}\n\nexport function readData<TArgs extends unknown[], TValue>(\n  resource: DataResource<TArgs, TValue>,\n  ...args: TArgs\n): TValue {\n  return resolveDispatcher(\n    \"readData can only be called while rendering a component.\",\n  ).readData(resource, args);\n}\n\nexport function preloadData<TArgs extends unknown[], TValue>(\n  resource: DataResource<TArgs, TValue>,\n  ...args: TArgs\n): void {\n  if (currentDispatcher !== null) {\n    currentDispatcher.preloadData(resource, args);\n    return;\n  }\n\n  resolveDataStore().preloadData(resource, ...args);\n}\n\nexport function setCurrentDispatcher(\n  dispatcher: RenderDispatcher | null,\n): RenderDispatcher | null {\n  const previousDispatcher = currentDispatcher;\n  currentDispatcher = dispatcher;\n  return previousDispatcher;\n}\n\nfunction resolveDispatcher(\n  message = \"Hooks can only be called while rendering a component.\",\n): RenderDispatcher {\n  if (currentDispatcher === null) {\n    throw new Error(message);\n  }\n\n  return currentDispatcher;\n}\n\nfunction resolveDataStore(): FigDataStore {\n  return resolveCurrentDataStore(\n    \"No ambient Fig data store. Data APIs work synchronously during render, \" +\n      \"event handlers, actions, and effects — not after an await. Capture \" +\n      \"readDataStore() (or root.data) synchronously and call the handle \" +\n      \"instead.\",\n  );\n}\n","import type { Props } from \"./element.ts\";\nimport { type RenderDispatcher, setCurrentDispatcher } from \"./hooks.ts\";\n\ndeclare const __FIG_DEV__: boolean | undefined;\n\nconst __DEV__ = typeof __FIG_DEV__ === \"boolean\" ? __FIG_DEV__ : false;\n\nexport interface MixinContext {\n  /** The intrinsic host name receiving this mixin. */\n  readonly type: string;\n  /** Props composed by the host and every preceding mixin. */\n  readonly props: Readonly<Props>;\n}\n\nexport type EmptyMixinValue = false | 0 | 0n | \"\" | null | undefined;\n\nexport type MixinInput =\n  | MixinDescriptor\n  | EmptyMixinValue\n  | ReadonlyArray<MixinInput>;\n\nexport type MixinResult = Props | MixinInput;\n\nexport type MixinType<TArgs extends unknown[] = unknown[]> = (\n  context: MixinContext,\n  ...args: TArgs\n) => MixinResult;\n\ntype MixinRuntimeType = (\n  context: MixinContext,\n  ...args: unknown[]\n) => MixinResult;\n\nexport interface MixinDescriptor {\n  readonly $$typeof: symbol;\n  readonly args: readonly unknown[];\n  readonly type: MixinRuntimeType;\n}\n\nexport type MixinFactory<TArgs extends unknown[]> = (\n  ...args: TArgs\n) => MixinDescriptor;\n\n// Registered symbols: descriptors and contexts must stay recognizable when\n// duplicate copies of this module are live (linked source next to a\n// prebundled copy).\nexport const FigMixinSymbol = Symbol.for(\"fig.mixin\");\nconst FigMixinSlotSymbol = Symbol.for(\"fig.mixin-slot\");\nconst FigClientOnlyHostBehaviorSymbol = Symbol.for(\n  \"fig.client-only-host-behavior\",\n);\ntype ClientOnlyHostProps = object & {\n  [FigClientOnlyHostBehaviorSymbol]?: string;\n};\n\n/** Creates a render-time host behavior for the `mix` prop. */\nexport function createMixin<TArgs extends unknown[]>(\n  type: MixinType<TArgs>,\n): MixinFactory<TArgs> {\n  const runtimeType = type as MixinRuntimeType;\n  const descriptorType = __DEV__ ? guardMixinType(runtimeType) : runtimeType;\n  return (...args) => ({\n    $$typeof: FigMixinSymbol,\n    args,\n    type: descriptorType,\n  });\n}\n\nconst maximumResolvedMixins = 1024;\n\nexport function resolveHostMix<P extends Props>(type: string, input: P): P {\n  const props: Props = input;\n  const mix = props.mix;\n  delete props.mix;\n  let resolvedMixins = 0;\n\n  function resolve(value: unknown, slot: string): void {\n    if (emptyMixinValue(value)) return;\n    if (Array.isArray(value)) {\n      for (let index = 0; index < value.length; index += 1) {\n        resolve(value[index], `${slot}.${index}`);\n      }\n      return;\n    }\n    if (!isMixinDescriptor(value)) {\n      throw new Error(\n        `The mix prop on <${type}> must contain descriptors created by createMixin().`,\n      );\n    }\n\n    resolvedMixins += 1;\n    if (resolvedMixins > maximumResolvedMixins) {\n      throw new Error(\n        `The mix prop on <${type}> resolved more than ${maximumResolvedMixins} mixins.`,\n      );\n    }\n\n    const context: MixinRuntimeContext = {\n      [FigMixinSlotSymbol]: slot,\n      props,\n      type,\n    };\n    const result = value.type(context, ...value.args);\n    if (emptyMixinValue(result)) return;\n\n    if (isMixinDescriptor(result) || Array.isArray(result)) {\n      resolve(result, `${slot}.result`);\n      return;\n    }\n    if (typeof result !== \"object\") {\n      throw new Error(\n        `A mixin on <${type}> must return host props, more mixins, or nothing.`,\n      );\n    }\n    const returnedProps = result as Props;\n\n    if (\n      \"children\" in returnedProps ||\n      \"key\" in returnedProps ||\n      \"unsafeHTML\" in returnedProps\n    ) {\n      throw new Error(\n        `A mixin on <${type}> cannot return children, key, or unsafeHTML.`,\n      );\n    }\n\n    const { mix: nestedMix, ...patch } = returnedProps;\n    Object.assign(props, patch);\n    resolve(nestedMix, `${slot}.mix`);\n  }\n\n  resolve(mix, \"0\");\n  props.mix = mix;\n  return props as P;\n}\n\ninterface MixinRuntimeContext extends MixinContext {\n  readonly [FigMixinSlotSymbol]: string;\n}\n\nexport function mixinSlot(context: MixinContext): string {\n  return (context as MixinRuntimeContext)[FigMixinSlotSymbol];\n}\n\nexport function markClientOnlyHostBehavior(\n  context: MixinContext,\n  behavior: string,\n): void {\n  const props = context.props as ClientOnlyHostProps;\n  if (props[FigClientOnlyHostBehaviorSymbol] !== undefined) return;\n  Object.defineProperty(context.props, FigClientOnlyHostBehaviorSymbol, {\n    configurable: true,\n    value: behavior,\n  });\n}\n\nexport function clientOnlyHostBehavior(props: object): string | undefined {\n  const behavior = (props as ClientOnlyHostProps)[\n    FigClientOnlyHostBehaviorSymbol\n  ];\n  return typeof behavior === \"string\" ? behavior : undefined;\n}\n\nfunction emptyMixinValue(value: unknown): value is EmptyMixinValue {\n  return (\n    value === false ||\n    value === 0 ||\n    value === 0n ||\n    value === \"\" ||\n    value === null ||\n    value === undefined\n  );\n}\n\nfunction isMixinDescriptor(value: unknown): value is MixinDescriptor {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"$$typeof\" in value &&\n    value.$$typeof === FigMixinSymbol\n  );\n}\n\n// Dev-only: the wrapper lives in the createMixin module copy, so it guards the\n// dispatcher used by hooks imported alongside that factory even when another\n// linked or prebundled copy resolves the descriptor.\nfunction guardMixinType(type: MixinRuntimeType): MixinRuntimeType {\n  return (context, ...args) => {\n    const previousDispatcher = setCurrentDispatcher(\n      mixinDispatcher(context.type, mixinSlot(context)),\n    );\n    try {\n      return type(context, ...args);\n    } finally {\n      setCurrentDispatcher(previousDispatcher);\n    }\n  };\n}\n\nfunction mixinDispatcher(type: string, slot: string): RenderDispatcher {\n  return new Proxy({} as RenderDispatcher, {\n    get(_target, property) {\n      throw new Error(\n        `A mixin on <${type}> (slot ${slot}) called ${String(property)}. ` +\n          \"Mixins are pure render-time code: hooks and read verbs belong to \" +\n          \"the component; host lifetimes belong in returned on() or bind \" +\n          \"behavior.\",\n      );\n    },\n  });\n}\n","import type { DataResourceKey } from \"./data.ts\";\nimport { readPromise } from \"./hooks.ts\";\nimport type { ClientReferenceAssets } from \"./resource.ts\";\nimport { resolveHostMix } from \"./mixin.ts\";\n\nexport type Key = string | number;\nexport type Props = Record<string, any>;\nexport type ComponentType<P = Props> = (\n  props: P & { children?: FigNode },\n) => FigNode;\nexport type ComponentProps<T extends ComponentType<any>> =\n  Parameters<T> extends [infer P, ...unknown[]]\n    ? P extends Props\n      ? P\n      : Props\n    : {};\nexport type ElementType<P = Props> =\n  | string\n  | typeof Fragment\n  | FigAssets\n  | FigClientReference<P>\n  | FigErrorBoundary\n  | FigSuspense\n  | FigActivity\n  | FigViewTransition\n  | ComponentType<P>;\nexport type AwaitedFigNode =\n  | FigElement<any>\n  | FigPortal<any>\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | FigNode[];\nexport type FigNode = AwaitedFigNode | PromiseLike<AwaitedFigNode>;\n\nexport interface FigElement<P = Props> {\n  readonly $$typeof: symbol;\n  readonly type: ElementType<any>;\n  readonly key: Key | null;\n  readonly props: P & { children?: FigNode };\n}\n\nexport interface FigPortal<Target = unknown> {\n  readonly $$typeof: symbol;\n  readonly children: FigNode;\n  readonly key: Key | null;\n  readonly target: Target;\n}\n\nexport interface ClientReferenceOptions<P extends Props = Props> {\n  assets?: ClientReferenceAssets;\n  id: string;\n  ssr?: ComponentType<P>;\n}\n\nexport interface FigClientReference<P = Props> {\n  (props: P & { children?: FigNode }): FigNode;\n  readonly $$typeof: symbol;\n  readonly assets?: ClientReferenceAssets;\n  readonly id: string;\n  readonly ssr?: ComponentType<P>;\n}\n\nexport type LazyLoader<T extends ComponentType<any> = ComponentType<any>> =\n  () => PromiseLike<T>;\n\nexport interface SuspenseProps {\n  fallback?: FigNode;\n  children?: FigNode;\n}\n\nexport interface FigSuspense {\n  (props: SuspenseProps): FigNode;\n  readonly $$typeof: symbol;\n}\n\nexport type ActivityMode = \"visible\" | \"hidden\";\n\nexport interface ActivityProps {\n  mode: ActivityMode;\n  children?: FigNode;\n}\n\nexport interface FigActivity {\n  (props: ActivityProps): FigNode;\n  readonly $$typeof: symbol;\n}\n\nexport type ViewTransitionClass = \"auto\" | \"none\" | (string & {});\n\nexport type ViewTransitionPhase = \"enter\" | \"exit\" | \"share\" | \"update\";\n\n// Renderer-neutral identity for one named host surface in the native\n// transition. Renderer packages can resolve it into their own imperative\n// handles without putting host types in core.\nexport interface ViewTransitionSurface {\n  readonly name: string;\n}\n\nexport interface ViewTransitionEvent {\n  readonly phase: ViewTransitionPhase;\n  readonly surfaces: readonly ViewTransitionSurface[];\n  readonly types: readonly string[];\n}\n\nexport type ViewTransitionCallback = (\n  event: ViewTransitionEvent,\n  signal: AbortSignal,\n) => undefined;\n\nexport interface ViewTransitionProps {\n  name?: string;\n  children?: FigNode;\n  default?: ViewTransitionClass;\n  enter?: ViewTransitionClass;\n  exit?: ViewTransitionClass;\n  share?: ViewTransitionClass;\n  update?: ViewTransitionClass;\n  onTransition?: ViewTransitionCallback;\n}\n\nexport interface FigViewTransition {\n  (props: ViewTransitionProps): FigNode;\n  readonly $$typeof: symbol;\n}\n\nexport interface ErrorBoundaryProps {\n  // A function fallback receives the caught error so error UIs can render\n  // it (message, retry affordance) without smuggling state above the\n  // boundary through onError. Callable thenables are nodes, so the runtime\n  // distinguishes them from render fallbacks before invoking the function.\n  fallback?: FigNode | ((error: unknown, info: ErrorInfo) => FigNode);\n  onError?: (error: unknown, info: ErrorInfo) => void;\n  children?: FigNode;\n}\n\nexport interface ErrorInfo {\n  componentStack: string;\n  dataResourceKeys?: DataResourceKey[];\n}\n\nexport interface FigErrorBoundary {\n  (props: ErrorBoundaryProps): FigNode;\n  readonly $$typeof: symbol;\n}\n\nexport interface FigAssets {\n  (props: Props & { children?: FigNode }): FigNode;\n  readonly $$typeof: symbol;\n}\n\nexport const Fragment = Symbol.for(\"fig.fragment\");\nexport const FigElementSymbol = Symbol.for(\"fig.element\");\nexport const FigClientReferenceSymbol = Symbol.for(\"fig.client-reference\");\nexport const FigActivitySymbol = Symbol.for(\"fig.activity\");\nexport const FigErrorBoundarySymbol = Symbol.for(\"fig.error-boundary\");\nexport const FigPortalSymbol = Symbol.for(\"fig.portal\");\nexport const FigAssetsSymbol = Symbol.for(\"fig.assets\");\nexport const FigSuspenseSymbol = Symbol.for(\"fig.suspense\");\nexport const FigViewTransitionSymbol = Symbol.for(\"fig.view-transition\");\n\nexport const Assets: FigAssets = Object.assign(\n  (props: Props & { children?: FigNode }) => props.children,\n  { $$typeof: FigAssetsSymbol },\n);\n\nexport const ErrorBoundary: FigErrorBoundary = Object.assign(\n  (props: ErrorBoundaryProps) => props.children,\n  { $$typeof: FigErrorBoundarySymbol },\n);\n\nexport const Suspense: FigSuspense = Object.assign(\n  (props: SuspenseProps) => props.children,\n  { $$typeof: FigSuspenseSymbol },\n);\n\nexport const Activity: FigActivity = Object.assign(\n  (props: ActivityProps) => props.children,\n  { $$typeof: FigActivitySymbol },\n);\n\nexport const ViewTransition: FigViewTransition = Object.assign(\n  (props: ViewTransitionProps) => props.children,\n  { $$typeof: FigViewTransitionSymbol },\n);\n\nexport function createElement<P extends Props>(\n  type: ElementType<P>,\n  config?: (P & { key?: Key | null }) | null,\n  ...children: FigNode[]\n): FigElement<P> {\n  const props = { ...config } as P & {\n    children?: FigNode;\n    key?: Key | null;\n  };\n  const key = props.key ?? null;\n  delete props.key;\n\n  if (children.length === 1) props.children = children[0];\n  else if (children.length > 1) props.children = children;\n\n  return {\n    $$typeof: FigElementSymbol,\n    type,\n    key,\n    props:\n      \"mix\" in props && typeof type === \"string\"\n        ? resolveHostMix(type, props)\n        : props,\n  };\n}\n\nexport function isValidElement(value: unknown): value is FigElement {\n  return hasObjectBrand(value, FigElementSymbol);\n}\n\nexport function createPortalNode<Target>(\n  children: FigNode,\n  target: Target,\n  key: Key | null = null,\n): FigPortal<Target> {\n  return { $$typeof: FigPortalSymbol, children, key, target };\n}\n\nexport function isPortal(value: unknown): value is FigPortal {\n  return hasObjectBrand(value, FigPortalSymbol);\n}\n\nexport function clientReference<P extends Props = Props>(\n  options: ClientReferenceOptions<P>,\n): FigClientReference<P> {\n  return Object.assign(\n    (): never => {\n      throw new Error(\n        `Client reference \"${options.id}\" cannot be rendered on the server directly.`,\n      );\n    },\n    {\n      $$typeof: FigClientReferenceSymbol,\n      assets: options.assets,\n      id: options.id,\n      ssr: options.ssr,\n    },\n  );\n}\n\nexport function lazy<T extends ComponentType<any>>(\n  load: LazyLoader<T>,\n): ComponentType<ComponentProps<T>> {\n  let promise: PromiseLike<T> | null = null;\n  let rejected = false;\n\n  const Lazy: ComponentType<ComponentProps<T>> = (props) => {\n    if (promise === null) {\n      rejected = false;\n      const next = Promise.resolve(load()).then(\n        (value) => value,\n        (error) => {\n          if (promise === next) rejected = true;\n          throw error;\n        },\n      );\n      promise = next;\n    }\n\n    try {\n      return createElement(readPromise(promise), props);\n    } catch (error) {\n      if (rejected) {\n        promise = null;\n        rejected = false;\n      }\n      throw error;\n    }\n  };\n\n  return Lazy;\n}\n\nexport function isClientReference(value: unknown): value is FigClientReference {\n  return hasFunctionBrand(value, FigClientReferenceSymbol);\n}\n\nexport function isSuspense(value: unknown): value is FigSuspense {\n  return hasFunctionBrand(value, FigSuspenseSymbol);\n}\n\nexport function isActivity(value: unknown): value is FigActivity {\n  return hasFunctionBrand(value, FigActivitySymbol);\n}\n\nexport function isErrorBoundary(value: unknown): value is FigErrorBoundary {\n  return hasFunctionBrand(value, FigErrorBoundarySymbol);\n}\n\nexport function isViewTransition(value: unknown): value is FigViewTransition {\n  return hasFunctionBrand(value, FigViewTransitionSymbol);\n}\n\nexport function isAssets(value: unknown): value is FigAssets {\n  return hasFunctionBrand(value, FigAssetsSymbol);\n}\n\nfunction hasObjectBrand(value: unknown, brand: symbol): boolean {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"$$typeof\" in value &&\n    value.$$typeof === brand\n  );\n}\n\nfunction hasFunctionBrand(value: unknown, brand: symbol): boolean {\n  return (\n    typeof value === \"function\" &&\n    \"$$typeof\" in value &&\n    value.$$typeof === brand\n  );\n}\n"],"mappings":"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"}

package/dist-development/index.js

@@ -0,0 +1,4 @@
+import { c as ensureData, d as invalidateDataKey, f as invalidateDataPrefix, g as refreshData, h as readDataStore, i as createDataStore, l as invalidateData, n as transition, s as dataResource, u as invalidateDataError, y as createContext } from "./transition-B4XiOWAj.js";
+import { B as useBeforePaint, E as lazy, F as readData, G as useReactive, H as useDeferredValue, I as readPromise, J as useSyncExternalStore, K as useStableEvent, N as preloadData, P as readContext, R as useActionState, U as useId, V as useCallback, W as useMemo, Y as useTransition, f as Fragment, g as createElement, h as clientReference, k as createMixin, m as ViewTransition, p as Suspense, q as useState, r as ErrorBoundary, t as Activity, w as isValidElement, z as useBeforeLayout } from "./element-B7mCQIMi.js";
+import { _ as title, c as font, d as modulepreload, f as preconnect, g as stylesheet, h as script, o as assets, p as preload, u as meta } from "./resource-CP2OynG0.js";
+export { Activity, ErrorBoundary, Fragment, Suspense, ViewTransition, assets, clientReference, createContext, createDataStore, createElement, createMixin, dataResource, ensureData, font, invalidateData, invalidateDataError, invalidateDataKey, invalidateDataPrefix, isValidElement, lazy, meta, modulepreload, preconnect, preload, preloadData, readContext, readData, readDataStore, readPromise, refreshData, script, stylesheet, title, transition, useActionState, useBeforeLayout, useBeforePaint, useCallback, useDeferredValue, useId, useMemo, useReactive, useStableEvent, useState, useSyncExternalStore, useTransition };

package/dist-development/internal.js

@@ -0,0 +1,172 @@
+import { _ as runWithDataStore, a as createRendererDataStore, b as isContext, i as createDataStore, m as normalizeDataResourceKey, o as currentDataStore, p as isDataStoreController, r as attachDataStore, t as setTransitionHandler, v as FigContextSymbol } from "./transition-B4XiOWAj.js";
+import { $ as loadContextCapabilities, A as markClientOnlyHostBehavior, C as isSuspense, D as FigMixinSymbol, L as setCurrentDispatcher, M as resolveHostMix, O as clientOnlyHostBehavior, S as isPortal, T as isViewTransition, X as dataResourceKeysForError, Z as defineLoadContextCapabilities, _ as createPortalNode, a as FigAssetsSymbol, b as isClientReference, c as FigErrorBoundarySymbol, d as FigViewTransitionSymbol, et as markDataResourceError, i as FigActivitySymbol, j as mixinSlot, l as FigPortalSymbol, n as Assets, nt as setCurrentDataStore, o as FigClientReferenceSymbol, s as FigElementSymbol, tt as resolveCurrentDataStore, u as FigSuspenseSymbol, v as isActivity, w as isValidElement, x as isErrorBoundary, y as isAssets } from "./element-B7mCQIMi.js";
+import { a as assetResourceKey, b as trackThenable, i as assetResourceHostAttributes, l as isFigAssetResource, m as preventAssetResourceHoist, n as assetResourceFromHostAttributes, r as assetResourceFromHostProps, s as clientReferenceAssets, t as assetResourceDestination, v as isThenable, y as readThenable } from "./resource-CP2OynG0.js";
+import { _ as serializePayloadArray, b as serializePayloadSet, c as definePayloadGraphElement, d as encodePayloadValueWithGraph, g as rollbackPayloadGraph, h as jsonPayloadCodec, i as decodePayloadDataEntries, l as encodePayloadDataEntries, m as isPlainPayloadValue, n as checkpointPayloadGraph, o as decodePayloadValue, p as isPayloadSpecialModel, r as createPayloadGraphEncodeContext, t as assertPayloadCodecMatches, u as encodePayloadValue, v as serializePayloadMap, y as serializePayloadPlainObject } from "./payload-format-KTNaSI4h.js";
+//#region src/children.ts
+function collectChildren(node) {
+	const children = [];
+	collectChild(node, children);
+	return children;
+}
+function collectChild(node, children) {
+	if (Array.isArray(node)) {
+		for (const child of node) collectChild(child, children);
+		return;
+	}
+	if (node === null || node === void 0 || typeof node === "boolean") return;
+	if (typeof node === "string" || typeof node === "number") {
+		appendTextChild(children, String(node));
+		return;
+	}
+	if (isValidElement(node) || isPortal(node)) {
+		children.push(node);
+		return;
+	}
+	if (isThenable(node)) {
+		children.push(node);
+		return;
+	}
+	throw invalidChildError(node);
+}
+function appendTextChild(children, text) {
+	if (text === "") return;
+	const previous = children.at(-1);
+	if (typeof previous === "string") children[children.length - 1] = `${previous}${text}`;
+	else children.push(text);
+}
+function invalidChildError(value) {
+	return /* @__PURE__ */ new Error(`Invalid Fig child: ${describeInvalidChild(value)}. Render a string, number, element, promise, array, boolean, null, or undefined.`);
+}
+function describeInvalidChild(value) {
+	if (typeof value !== "object" || value === null) return typeof value;
+	const keys = Object.keys(value);
+	return keys.length === 0 ? "object" : `object with keys ${keys.join(", ")}`;
+}
+//#endregion
+//#region src/dom-nesting.ts
+const phrasingContainers = "|a|button|p|";
+const scopeTerminators = "|applet|caption|desc|foreignobject|html|marquee|object|table|td|template|th|title|";
+const pAutoClosingTags = "|address|article|aside|blockquote|center|details|dialog|dir|div|dl|fieldset|figcaption|figure|footer|form|h1|h2|h3|h4|h5|h6|header|hgroup|hr|main|menu|nav|ol|p|pre|section|table|ul|";
+const headChildren = "|base|basefont|bgsound|link|meta|title|noscript|noframes|script|style|template|";
+const specialTags = "|address|applet|area|article|aside|base|basefont|bgsound|blockquote|body|br|button|caption|center|col|colgroup|dd|details|dir|div|dl|dt|embed|fieldset|figcaption|figure|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|header|hgroup|hr|html|iframe|img|input|keygen|li|link|listing|main|marquee|menu|meta|nav|noembed|noframes|noscript|object|ol|p|param|plaintext|pre|script|section|select|source|style|summary|table|tbody|td|template|textarea|tfoot|th|thead|title|tr|track|ul|wbr|xmp|mi|mo|mn|ms|mtext|annotation-xml|foreignobject|desc|";
+function validateInstanceNesting(type, ancestors) {
+	const child = normalizedTag(type);
+	const parent = ancestors[0] === void 0 ? null : normalizedTag(ancestors[0]);
+	if (parent !== null && !validWithParent(child, parent)) throw invalidNestingError(`<${child}> cannot be a child of <${parent}>.${hintFor(child, parent)}`);
+	const invalidAncestor = invalidAncestorFor(child, ancestors);
+	if (invalidAncestor !== null) throw invalidNestingError(`<${child}> cannot appear inside <${invalidAncestor}>.`);
+}
+function validateTextNesting(text, ancestors) {
+	if (!/[^ \t\n\r\f]/.test(text)) return;
+	const parent = ancestors[0] === void 0 ? null : normalizedTag(ancestors[0]);
+	if (parent === null || validTextWithParent(parent)) return;
+	throw invalidNestingError(`text cannot be a child of <${parent}>.`);
+}
+function validWithParent(child, parent) {
+	switch (parent) {
+		case "select": return child === "hr" || child === "option" || child === "optgroup" || child === "script" || child === "template";
+		case "optgroup": return child === "option";
+		case "option": return false;
+		case "tr": return child === "th" || child === "td" || scriptLike(child);
+		case "tbody":
+		case "thead":
+		case "tfoot": return child === "tr" || scriptLike(child);
+		case "colgroup": return child === "col" || child === "template";
+		case "table": return child === "caption" || child === "colgroup" || child === "tbody" || child === "tfoot" || child === "thead" || scriptLike(child);
+		case "head": return tagIn(headChildren, child);
+		case "html": return child === "head" || child === "body";
+		case "frameset": return child === "frame";
+	}
+	switch (child) {
+		case "caption":
+		case "col":
+		case "colgroup":
+		case "tbody":
+		case "tfoot":
+		case "thead":
+		case "tr": return parent === "template";
+		case "td":
+		case "th": return parent === "tr" || parent === "template";
+		case "option": return parent === "datalist" || parent === "template";
+		case "optgroup": return parent === "template";
+		case "head":
+		case "body":
+		case "frameset": return parent === "html" || parent === "template";
+		case "frame": return parent === "template";
+		case "html": return false;
+	}
+	return true;
+}
+function validTextWithParent(parent) {
+	return parent === "option" || parent === "select" || parent === "optgroup" || validWithParent("#text", parent);
+}
+function invalidAncestorFor(child, ancestors) {
+	let inScope = true;
+	let inButtonScope = true;
+	let inListScope = true;
+	let inTemplate = false;
+	for (const ancestorType of ancestors) {
+		const ancestor = normalizedTag(ancestorType);
+		if (child === ancestor && tagIn(phrasingContainers, child)) {
+			if (child === "p" ? inButtonScope : inScope) return ancestor;
+		}
+		if (inButtonScope && ancestor === "p" && tagIn(pAutoClosingTags, child)) return ancestor;
+		if (inListScope && listItemAncestor(child, ancestor)) return ancestor;
+		if (!inTemplate && ancestor === "form" && child === "form") return ancestor;
+		if (tagIn(scopeTerminators, ancestor)) {
+			if (ancestor === "template") inTemplate = true;
+			inScope = false;
+			inButtonScope = false;
+		} else if (ancestor === "button") inButtonScope = false;
+		if (tagIn(specialTags, ancestor) && ancestor !== "address" && ancestor !== "div" && ancestor !== "p") inListScope = false;
+	}
+	return null;
+}
+function listItemAncestor(child, ancestor) {
+	if (child === "li") return ancestor === "li";
+	if (child === "dd" || child === "dt") return ancestor === "dd" || ancestor === "dt";
+	return false;
+}
+function normalizedTag(type) {
+	return type.toLowerCase();
+}
+function scriptLike(tag) {
+	return tag === "script" || tag === "style" || tag === "template";
+}
+function hintFor(child, parent) {
+	if (parent === "table" && child === "tr") return " Add a <tbody>, <thead>, or <tfoot>.";
+	return "";
+}
+function invalidNestingError(message) {
+	return /* @__PURE__ */ new Error(`Invalid DOM nesting: ${message}`);
+}
+function tagIn(tags, tag) {
+	return tags.includes(`|${tag}|`);
+}
+//#endregion
+//#region src/suspense-protocol.ts
+const SUSPENSE_MARKER_PREFIX = "fig:suspense:";
+const SUSPENSE_COMPLETED_MARKER = "fig:suspense:completed";
+const SUSPENSE_CLIENT_MARKER = "fig:suspense:client";
+const SUSPENSE_PENDING_PREFIX = "fig:suspense:pending:";
+const SUSPENSE_END_MARKER = "/fig:suspense";
+const TEXT_SEPARATOR_DATA = ",";
+const ACTIVITY_TEMPLATE_ATTRIBUTE = "data-fig-activity";
+const VIEW_TRANSITION_NAME_ATTRIBUTE = "data-fig-vt-name";
+const VIEW_TRANSITION_CLASS_ATTRIBUTE = "data-fig-vt-class";
+const VIEW_TRANSITION_PENDING_PROPERTY = "__figViewTransition";
+const VIEW_TRANSITION_TIMEOUT_MS = 6e4;
+const HYDRATION_SKIP_ATTRIBUTE = "data-fig-hydration-skip";
+const EARLY_EVENT_QUEUE_PROPERTY = "__figEarlyEvents";
+const EARLY_EVENT_HANDLER_PROPERTY = "__figEarlyEventHandler";
+const REPLAYABLE_EVENT_TYPES = [
+	"click",
+	"keydown",
+	"keyup",
+	"pointerdown",
+	"pointerup"
+];
+//#endregion
+export { ACTIVITY_TEMPLATE_ATTRIBUTE, Assets, EARLY_EVENT_HANDLER_PROPERTY, EARLY_EVENT_QUEUE_PROPERTY, FigActivitySymbol, FigAssetsSymbol, FigClientReferenceSymbol, FigContextSymbol, FigElementSymbol, FigErrorBoundarySymbol, FigMixinSymbol, FigPortalSymbol, FigSuspenseSymbol, FigViewTransitionSymbol, HYDRATION_SKIP_ATTRIBUTE, REPLAYABLE_EVENT_TYPES, SUSPENSE_CLIENT_MARKER, SUSPENSE_COMPLETED_MARKER, SUSPENSE_END_MARKER, SUSPENSE_MARKER_PREFIX, SUSPENSE_PENDING_PREFIX, TEXT_SEPARATOR_DATA, VIEW_TRANSITION_CLASS_ATTRIBUTE, VIEW_TRANSITION_NAME_ATTRIBUTE, VIEW_TRANSITION_PENDING_PROPERTY, VIEW_TRANSITION_TIMEOUT_MS, assertPayloadCodecMatches, assetResourceDestination, assetResourceFromHostAttributes, assetResourceFromHostProps, assetResourceHostAttributes, assetResourceKey, attachDataStore, checkpointPayloadGraph, clientOnlyHostBehavior, clientReferenceAssets, collectChildren, createDataStore, createPayloadGraphEncodeContext, createPortalNode, createRendererDataStore, currentDataStore, dataResourceKeysForError, decodePayloadDataEntries, decodePayloadValue, defineLoadContextCapabilities, definePayloadGraphElement, describeInvalidChild, encodePayloadDataEntries, encodePayloadValue, encodePayloadValueWithGraph, invalidChildError, isActivity, isAssets, isClientReference, isContext, isDataStoreController, isErrorBoundary, isFigAssetResource, isPayloadSpecialModel, isPlainPayloadValue, isPortal, isSuspense, isThenable, isViewTransition, jsonPayloadCodec, loadContextCapabilities, markClientOnlyHostBehavior, markDataResourceError, mixinSlot, normalizeDataResourceKey, preventAssetResourceHoist, readThenable, resolveCurrentDataStore, resolveHostMix, rollbackPayloadGraph, runWithDataStore, serializePayloadArray, serializePayloadMap, serializePayloadPlainObject, serializePayloadSet, setCurrentDataStore, setCurrentDispatcher, setTransitionHandler, trackThenable, validateInstanceNesting, validateTextNesting };
+
+//# sourceMappingURL=internal.js.map