@powerhousedao/powerhouse-vetra-packages 6.2.3-dev.1 → 6.2.3-dev.11

package/dist/browser/state-schemas-DuA5rB1e.js

@@ -0,0 +1,694 @@
+import { c as Kind } from "./parser-BBzK7bLd.js";
+import { r as typeDefsDoc } from "./documents-C-lAnv6o.js";
+import { d as makeMinimalObjectForStateType, h as validateStateObject, i as StateValidationError, p as makeStateSchemaNameForScope, r as ensureValidStateSchemaName, t as Button, u as makeInitialSchemaDoc } from "./button-sZQCXeCo.js";
+import { f as useComposedRefs, h as twMerge, i as Primitive, n as useId$1, o as createSlot, p as composeEventHandlers, r as useCallbackRef, s as useControllableState, t as Presence, u as createContextScope } from "./dist-D3_ER0Dn.js";
+import { n as safeParseSdl, r as useSchemaContext } from "./schema-context-p2bhyog_.js";
+import * as React$1 from "react";
+import React, { Suspense, lazy, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region ../../node_modules/.pnpm/@radix-ui+react-collection@1.1.7_@types+react-dom@19.2.3_@types+react@19.2.14__@types+r_b94f5365b88697a700662930c56ccffc/node_modules/@radix-ui/react-collection/dist/index.mjs
+function createCollection(name) {
+	const PROVIDER_NAME = name + "CollectionProvider";
+	const [createCollectionContext, createCollectionScope] = createContextScope(PROVIDER_NAME);
+	const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(PROVIDER_NAME, {
+		collectionRef: { current: null },
+		itemMap: /* @__PURE__ */ new Map()
+	});
+	const CollectionProvider = (props) => {
+		const { scope, children } = props;
+		const ref = React.useRef(null);
+		const itemMap = React.useRef(/* @__PURE__ */ new Map()).current;
+		return /* @__PURE__ */ jsx(CollectionProviderImpl, {
+			scope,
+			itemMap,
+			collectionRef: ref,
+			children
+		});
+	};
+	CollectionProvider.displayName = PROVIDER_NAME;
+	const COLLECTION_SLOT_NAME = name + "CollectionSlot";
+	const CollectionSlotImpl = createSlot(COLLECTION_SLOT_NAME);
+	const CollectionSlot = React.forwardRef((props, forwardedRef) => {
+		const { scope, children } = props;
+		return /* @__PURE__ */ jsx(CollectionSlotImpl, {
+			ref: useComposedRefs(forwardedRef, useCollectionContext(COLLECTION_SLOT_NAME, scope).collectionRef),
+			children
+		});
+	});
+	CollectionSlot.displayName = COLLECTION_SLOT_NAME;
+	const ITEM_SLOT_NAME = name + "CollectionItemSlot";
+	const ITEM_DATA_ATTR = "data-radix-collection-item";
+	const CollectionItemSlotImpl = createSlot(ITEM_SLOT_NAME);
+	const CollectionItemSlot = React.forwardRef((props, forwardedRef) => {
+		const { scope, children, ...itemData } = props;
+		const ref = React.useRef(null);
+		const composedRefs = useComposedRefs(forwardedRef, ref);
+		const context = useCollectionContext(ITEM_SLOT_NAME, scope);
+		React.useEffect(() => {
+			context.itemMap.set(ref, {
+				ref,
+				...itemData
+			});
+			return () => void context.itemMap.delete(ref);
+		});
+		return /* @__PURE__ */ jsx(CollectionItemSlotImpl, {
+			[ITEM_DATA_ATTR]: "",
+			ref: composedRefs,
+			children
+		});
+	});
+	CollectionItemSlot.displayName = ITEM_SLOT_NAME;
+	function useCollection(scope) {
+		const context = useCollectionContext(name + "CollectionConsumer", scope);
+		return React.useCallback(() => {
+			const collectionNode = context.collectionRef.current;
+			if (!collectionNode) return [];
+			const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
+			return Array.from(context.itemMap.values()).sort((a, b) => orderedNodes.indexOf(a.ref.current) - orderedNodes.indexOf(b.ref.current));
+		}, [context.collectionRef, context.itemMap]);
+	}
+	return [
+		{
+			Provider: CollectionProvider,
+			Slot: CollectionSlot,
+			ItemSlot: CollectionItemSlot
+		},
+		useCollection,
+		createCollectionScope
+	];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-direction@1.1.1_@types+react@19.2.14_react@19.2.6/node_modules/@radix-ui/react-direction/dist/index.mjs
+var DirectionContext = React$1.createContext(void 0);
+function useDirection(localDir) {
+	const globalDir = React$1.useContext(DirectionContext);
+	return localDir || globalDir || "ltr";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-roving-focus@1.1.11_@types+react-dom@19.2.3_@types+react@19.2.14__@type_b849ea542e77d5b397b1fe12d9f00b2e/node_modules/@radix-ui/react-roving-focus/dist/index.mjs
+var ENTRY_FOCUS = "rovingFocusGroup.onEntryFocus";
+var EVENT_OPTIONS = {
+	bubbles: false,
+	cancelable: true
+};
+var GROUP_NAME = "RovingFocusGroup";
+var [Collection, useCollection, createCollectionScope] = createCollection(GROUP_NAME);
+var [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContextScope(GROUP_NAME, [createCollectionScope]);
+var [RovingFocusProvider, useRovingFocusContext] = createRovingFocusGroupContext(GROUP_NAME);
+var RovingFocusGroup = React$1.forwardRef((props, forwardedRef) => {
+	return /* @__PURE__ */ jsx(Collection.Provider, {
+		scope: props.__scopeRovingFocusGroup,
+		children: /* @__PURE__ */ jsx(Collection.Slot, {
+			scope: props.__scopeRovingFocusGroup,
+			children: /* @__PURE__ */ jsx(RovingFocusGroupImpl, {
+				...props,
+				ref: forwardedRef
+			})
+		})
+	});
+});
+RovingFocusGroup.displayName = GROUP_NAME;
+var RovingFocusGroupImpl = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeRovingFocusGroup, orientation, loop = false, dir, currentTabStopId: currentTabStopIdProp, defaultCurrentTabStopId, onCurrentTabStopIdChange, onEntryFocus, preventScrollOnEntryFocus = false, ...groupProps } = props;
+	const ref = React$1.useRef(null);
+	const composedRefs = useComposedRefs(forwardedRef, ref);
+	const direction = useDirection(dir);
+	const [currentTabStopId, setCurrentTabStopId] = useControllableState({
+		prop: currentTabStopIdProp,
+		defaultProp: defaultCurrentTabStopId ?? null,
+		onChange: onCurrentTabStopIdChange,
+		caller: GROUP_NAME
+	});
+	const [isTabbingBackOut, setIsTabbingBackOut] = React$1.useState(false);
+	const handleEntryFocus = useCallbackRef(onEntryFocus);
+	const getItems = useCollection(__scopeRovingFocusGroup);
+	const isClickFocusRef = React$1.useRef(false);
+	const [focusableItemsCount, setFocusableItemsCount] = React$1.useState(0);
+	React$1.useEffect(() => {
+		const node = ref.current;
+		if (node) {
+			node.addEventListener(ENTRY_FOCUS, handleEntryFocus);
+			return () => node.removeEventListener(ENTRY_FOCUS, handleEntryFocus);
+		}
+	}, [handleEntryFocus]);
+	return /* @__PURE__ */ jsx(RovingFocusProvider, {
+		scope: __scopeRovingFocusGroup,
+		orientation,
+		dir: direction,
+		loop,
+		currentTabStopId,
+		onItemFocus: React$1.useCallback((tabStopId) => setCurrentTabStopId(tabStopId), [setCurrentTabStopId]),
+		onItemShiftTab: React$1.useCallback(() => setIsTabbingBackOut(true), []),
+		onFocusableItemAdd: React$1.useCallback(() => setFocusableItemsCount((prevCount) => prevCount + 1), []),
+		onFocusableItemRemove: React$1.useCallback(() => setFocusableItemsCount((prevCount) => prevCount - 1), []),
+		children: /* @__PURE__ */ jsx(Primitive.div, {
+			tabIndex: isTabbingBackOut || focusableItemsCount === 0 ? -1 : 0,
+			"data-orientation": orientation,
+			...groupProps,
+			ref: composedRefs,
+			style: {
+				outline: "none",
+				...props.style
+			},
+			onMouseDown: composeEventHandlers(props.onMouseDown, () => {
+				isClickFocusRef.current = true;
+			}),
+			onFocus: composeEventHandlers(props.onFocus, (event) => {
+				const isKeyboardFocus = !isClickFocusRef.current;
+				if (event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut) {
+					const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS);
+					event.currentTarget.dispatchEvent(entryFocusEvent);
+					if (!entryFocusEvent.defaultPrevented) {
+						const items = getItems().filter((item) => item.focusable);
+						focusFirst([
+							items.find((item) => item.active),
+							items.find((item) => item.id === currentTabStopId),
+							...items
+						].filter(Boolean).map((item) => item.ref.current), preventScrollOnEntryFocus);
+					}
+				}
+				isClickFocusRef.current = false;
+			}),
+			onBlur: composeEventHandlers(props.onBlur, () => setIsTabbingBackOut(false))
+		})
+	});
+});
+var ITEM_NAME = "RovingFocusGroupItem";
+var RovingFocusGroupItem = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeRovingFocusGroup, focusable = true, active = false, tabStopId, children, ...itemProps } = props;
+	const autoId = useId$1();
+	const id = tabStopId || autoId;
+	const context = useRovingFocusContext(ITEM_NAME, __scopeRovingFocusGroup);
+	const isCurrentTabStop = context.currentTabStopId === id;
+	const getItems = useCollection(__scopeRovingFocusGroup);
+	const { onFocusableItemAdd, onFocusableItemRemove, currentTabStopId } = context;
+	React$1.useEffect(() => {
+		if (focusable) {
+			onFocusableItemAdd();
+			return () => onFocusableItemRemove();
+		}
+	}, [
+		focusable,
+		onFocusableItemAdd,
+		onFocusableItemRemove
+	]);
+	return /* @__PURE__ */ jsx(Collection.ItemSlot, {
+		scope: __scopeRovingFocusGroup,
+		id,
+		focusable,
+		active,
+		children: /* @__PURE__ */ jsx(Primitive.span, {
+			tabIndex: isCurrentTabStop ? 0 : -1,
+			"data-orientation": context.orientation,
+			...itemProps,
+			ref: forwardedRef,
+			onMouseDown: composeEventHandlers(props.onMouseDown, (event) => {
+				if (!focusable) event.preventDefault();
+				else context.onItemFocus(id);
+			}),
+			onFocus: composeEventHandlers(props.onFocus, () => context.onItemFocus(id)),
+			onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+				if (event.key === "Tab" && event.shiftKey) {
+					context.onItemShiftTab();
+					return;
+				}
+				if (event.target !== event.currentTarget) return;
+				const focusIntent = getFocusIntent(event, context.orientation, context.dir);
+				if (focusIntent !== void 0) {
+					if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return;
+					event.preventDefault();
+					let candidateNodes = getItems().filter((item) => item.focusable).map((item) => item.ref.current);
+					if (focusIntent === "last") candidateNodes.reverse();
+					else if (focusIntent === "prev" || focusIntent === "next") {
+						if (focusIntent === "prev") candidateNodes.reverse();
+						const currentIndex = candidateNodes.indexOf(event.currentTarget);
+						candidateNodes = context.loop ? wrapArray(candidateNodes, currentIndex + 1) : candidateNodes.slice(currentIndex + 1);
+					}
+					setTimeout(() => focusFirst(candidateNodes));
+				}
+			}),
+			children: typeof children === "function" ? children({
+				isCurrentTabStop,
+				hasTabStop: currentTabStopId != null
+			}) : children
+		})
+	});
+});
+RovingFocusGroupItem.displayName = ITEM_NAME;
+var MAP_KEY_TO_FOCUS_INTENT = {
+	ArrowLeft: "prev",
+	ArrowUp: "prev",
+	ArrowRight: "next",
+	ArrowDown: "next",
+	PageUp: "first",
+	Home: "first",
+	PageDown: "last",
+	End: "last"
+};
+function getDirectionAwareKey(key, dir) {
+	if (dir !== "rtl") return key;
+	return key === "ArrowLeft" ? "ArrowRight" : key === "ArrowRight" ? "ArrowLeft" : key;
+}
+function getFocusIntent(event, orientation, dir) {
+	const key = getDirectionAwareKey(event.key, dir);
+	if (orientation === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key)) return void 0;
+	if (orientation === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key)) return void 0;
+	return MAP_KEY_TO_FOCUS_INTENT[key];
+}
+function focusFirst(candidates, preventScroll = false) {
+	const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
+	for (const candidate of candidates) {
+		if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
+		candidate.focus({ preventScroll });
+		if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+	}
+}
+function wrapArray(array, startIndex) {
+	return array.map((_, index) => array[(startIndex + index) % array.length]);
+}
+var Root = RovingFocusGroup;
+var Item = RovingFocusGroupItem;
+//#endregion
+//#region editors/document-model-editor/components/state-error.tsx
+function StateValidationErrorMessage({ error }) {
+	const { payload } = error;
+	switch (payload.kind) {
+		case "MISSING": return /* @__PURE__ */ jsxs("span", { children: [
+			"Field ",
+			/* @__PURE__ */ jsx("strong", { children: payload.field }),
+			" is missing."
+		] });
+		case "MISSING_OPTIONAL": return /* @__PURE__ */ jsxs("span", { children: [
+			"Optional field ",
+			/* @__PURE__ */ jsx("strong", { children: payload.field }),
+			" is not defined."
+		] });
+		case "UNKNOWN_FIELD": return /* @__PURE__ */ jsxs("span", { children: [
+			"Field ",
+			/* @__PURE__ */ jsx("strong", { children: payload.field }),
+			" is not a known field."
+		] });
+		case "NON_NULL": return /* @__PURE__ */ jsxs("span", { children: [
+			"Field ",
+			/* @__PURE__ */ jsx("strong", { children: payload.field }),
+			" cannot be null."
+		] });
+		case "TYPE": return /* @__PURE__ */ jsxs("span", { children: [
+			"Field ",
+			/* @__PURE__ */ jsx("strong", { children: payload.field }),
+			payload.expectedType ? /* @__PURE__ */ jsxs(Fragment, { children: [
+				" ",
+				"must be a",
+				" ",
+				/* @__PURE__ */ jsx("strong", { children: payload.expectedType.replace(/!/g, "") }),
+				"."
+			] }) : /* @__PURE__ */ jsx(Fragment, { children: " has an invalid value." })
+		] });
+		case "RECURSIVE_TYPE": return /* @__PURE__ */ jsxs("span", { children: [
+			"Field ",
+			/* @__PURE__ */ jsx("strong", { children: payload.typeName }),
+			" has a recursive type. It must be optional."
+		] });
+		default: return /* @__PURE__ */ jsx("span", { children: "Invalid value." });
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-tabs@1.1.13_@types+react-dom@19.2.3_@types+react@19.2.14__@types+react@_08684373bbac196273bdefb5472f93a8/node_modules/@radix-ui/react-tabs/dist/index.mjs
+var TABS_NAME = "Tabs";
+var [createTabsContext, createTabsScope] = createContextScope(TABS_NAME, [createRovingFocusGroupScope]);
+var useRovingFocusGroupScope = createRovingFocusGroupScope();
+var [TabsProvider, useTabsContext] = createTabsContext(TABS_NAME);
+var Tabs$1 = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeTabs, value: valueProp, onValueChange, defaultValue, orientation = "horizontal", dir, activationMode = "automatic", ...tabsProps } = props;
+	const direction = useDirection(dir);
+	const [value, setValue] = useControllableState({
+		prop: valueProp,
+		onChange: onValueChange,
+		defaultProp: defaultValue ?? "",
+		caller: TABS_NAME
+	});
+	return /* @__PURE__ */ jsx(TabsProvider, {
+		scope: __scopeTabs,
+		baseId: useId$1(),
+		value,
+		onValueChange: setValue,
+		orientation,
+		dir: direction,
+		activationMode,
+		children: /* @__PURE__ */ jsx(Primitive.div, {
+			dir: direction,
+			"data-orientation": orientation,
+			...tabsProps,
+			ref: forwardedRef
+		})
+	});
+});
+Tabs$1.displayName = TABS_NAME;
+var TAB_LIST_NAME = "TabsList";
+var TabsList$1 = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeTabs, loop = true, ...listProps } = props;
+	const context = useTabsContext(TAB_LIST_NAME, __scopeTabs);
+	return /* @__PURE__ */ jsx(Root, {
+		asChild: true,
+		...useRovingFocusGroupScope(__scopeTabs),
+		orientation: context.orientation,
+		dir: context.dir,
+		loop,
+		children: /* @__PURE__ */ jsx(Primitive.div, {
+			role: "tablist",
+			"aria-orientation": context.orientation,
+			...listProps,
+			ref: forwardedRef
+		})
+	});
+});
+TabsList$1.displayName = TAB_LIST_NAME;
+var TRIGGER_NAME = "TabsTrigger";
+var TabsTrigger$1 = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeTabs, value, disabled = false, ...triggerProps } = props;
+	const context = useTabsContext(TRIGGER_NAME, __scopeTabs);
+	const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeTabs);
+	const triggerId = makeTriggerId(context.baseId, value);
+	const contentId = makeContentId(context.baseId, value);
+	const isSelected = value === context.value;
+	return /* @__PURE__ */ jsx(Item, {
+		asChild: true,
+		...rovingFocusGroupScope,
+		focusable: !disabled,
+		active: isSelected,
+		children: /* @__PURE__ */ jsx(Primitive.button, {
+			type: "button",
+			role: "tab",
+			"aria-selected": isSelected,
+			"aria-controls": contentId,
+			"data-state": isSelected ? "active" : "inactive",
+			"data-disabled": disabled ? "" : void 0,
+			disabled,
+			id: triggerId,
+			...triggerProps,
+			ref: forwardedRef,
+			onMouseDown: composeEventHandlers(props.onMouseDown, (event) => {
+				if (!disabled && event.button === 0 && event.ctrlKey === false) context.onValueChange(value);
+				else event.preventDefault();
+			}),
+			onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+				if ([" ", "Enter"].includes(event.key)) context.onValueChange(value);
+			}),
+			onFocus: composeEventHandlers(props.onFocus, () => {
+				const isAutomaticActivation = context.activationMode !== "manual";
+				if (!isSelected && !disabled && isAutomaticActivation) context.onValueChange(value);
+			})
+		})
+	});
+});
+TabsTrigger$1.displayName = TRIGGER_NAME;
+var CONTENT_NAME = "TabsContent";
+var TabsContent$1 = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeTabs, value, forceMount, children, ...contentProps } = props;
+	const context = useTabsContext(CONTENT_NAME, __scopeTabs);
+	const triggerId = makeTriggerId(context.baseId, value);
+	const contentId = makeContentId(context.baseId, value);
+	const isSelected = value === context.value;
+	const isMountAnimationPreventedRef = React$1.useRef(isSelected);
+	React$1.useEffect(() => {
+		const rAF = requestAnimationFrame(() => isMountAnimationPreventedRef.current = false);
+		return () => cancelAnimationFrame(rAF);
+	}, []);
+	return /* @__PURE__ */ jsx(Presence, {
+		present: forceMount || isSelected,
+		children: ({ present }) => /* @__PURE__ */ jsx(Primitive.div, {
+			"data-state": isSelected ? "active" : "inactive",
+			"data-orientation": context.orientation,
+			role: "tabpanel",
+			"aria-labelledby": triggerId,
+			hidden: !present,
+			id: contentId,
+			tabIndex: 0,
+			...contentProps,
+			ref: forwardedRef,
+			style: {
+				...props.style,
+				animationDuration: isMountAnimationPreventedRef.current ? "0s" : void 0
+			},
+			children: present && children
+		})
+	});
+});
+TabsContent$1.displayName = CONTENT_NAME;
+function makeTriggerId(baseId, value) {
+	return `${baseId}-trigger-${value}`;
+}
+function makeContentId(baseId, value) {
+	return `${baseId}-content-${value}`;
+}
+var Root2 = Tabs$1;
+var List = TabsList$1;
+var Trigger = TabsTrigger$1;
+var Content = TabsContent$1;
+//#endregion
+//#region editors/document-model-editor/components/tabs.tsx
+const Tabs = Root2;
+const TabsList = React$1.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(List, {
+	ref,
+	className: twMerge("flex items-center justify-center rounded-xl bg-background p-1 shadow-inner", className),
+	...props
+}));
+TabsList.displayName = List.displayName;
+const TabsTrigger = React$1.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(Trigger, {
+	ref,
+	className: twMerge("flex w-full items-center justify-center rounded-lg p-1 text-sm whitespace-nowrap text-muted-foreground transition-all disabled:disabled-effect data-[state=active]:bg-accent data-[state=active]:text-foreground data-[state=active]:shadow-tab", className),
+	...props
+}));
+TabsTrigger.displayName = Trigger.displayName;
+const TabsContent = React$1.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(Content, {
+	ref,
+	className,
+	...props
+}));
+TabsContent.displayName = Content.displayName;
+//#endregion
+//#region editors/document-model-editor/components/state-schemas.tsx
+const GraphqlEditor = lazy(() => import("./graphql-editor-BMhHl2XP.js"));
+const JSONEditor = lazy(() => import("./json-editor-DBhkG5TF.js"));
+function StateEditor({ modelName, stateSchema, initialValue, setStateSchema, setInitialState, scope }) {
+	const { sharedSchema: sharedSchemaSdl, error: sharedSchemaError } = useSchemaContext();
+	const [showStandardLib, setShowStandardLib] = useState(false);
+	const [syncWithSchema, setSyncWithSchema] = useState(true);
+	const customLinter = useCallback((doc) => ensureValidStateSchemaName(doc, modelName, scope), [modelName, scope]);
+	const schemaErrors = useMemo(() => {
+		const errors = ensureValidStateSchemaName(stateSchema, modelName, scope);
+		if (sharedSchemaError) return [...errors, sharedSchemaError];
+		return errors;
+	}, [
+		stateSchema,
+		modelName,
+		scope,
+		sharedSchemaError
+	]);
+	const handleToggleStandardLib = useCallback(() => {
+		setShowStandardLib((prev) => !prev);
+	}, []);
+	const handleSchemaUpdate = useCallback((newDoc) => setStateSchema(newDoc, scope), [setStateSchema, scope]);
+	const handleInitialStateUpdate = useCallback((newDoc) => setInitialState(newDoc, scope), [setInitialState, scope]);
+	const hasSyncedRef = useRef(false);
+	const { initialValueErrors, fixedState } = useMemo(() => {
+		const existingValue = initialValue || "{}";
+		const sharedSchemaDocumentNode = safeParseSdl(sharedSchemaSdl);
+		if (!sharedSchemaDocumentNode) return {
+			initialValueErrors: [],
+			fixedState: null
+		};
+		const stateTypeName = makeStateSchemaNameForScope(modelName, scope);
+		if (!stateTypeName) return {
+			initialValueErrors: [],
+			fixedState: null
+		};
+		const stateTypeDefinitionNode = sharedSchemaDocumentNode.definitions.find((def) => def.kind === Kind.OBJECT_TYPE_DEFINITION && def.name.value === stateTypeName);
+		if (!stateTypeDefinitionNode || stateTypeDefinitionNode.kind !== Kind.OBJECT_TYPE_DEFINITION) return {
+			initialValueErrors: [],
+			fixedState: null
+		};
+		const errors = validateStateObject(sharedSchemaDocumentNode, stateTypeDefinitionNode, existingValue);
+		if (errors.length && syncWithSchema) {
+			const computedFixedState = makeMinimalObjectForStateType({
+				sharedSchemaDocumentNode,
+				stateTypeDefinitionNode,
+				existingValue
+			});
+			if (initialValue !== computedFixedState) return {
+				initialValueErrors: [],
+				fixedState: computedFixedState
+			};
+		}
+		return {
+			initialValueErrors: errors,
+			fixedState: null
+		};
+	}, [
+		sharedSchemaSdl,
+		initialValue,
+		syncWithSchema,
+		scope,
+		modelName
+	]);
+	useEffect(() => {
+		if (fixedState && !hasSyncedRef.current) {
+			hasSyncedRef.current = true;
+			setInitialState(fixedState, scope);
+		} else if (!fixedState) hasSyncedRef.current = false;
+	}, [
+		fixedState,
+		setInitialState,
+		scope
+	]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "grid grid-cols-2 gap-4",
+		children: [/* @__PURE__ */ jsxs("div", { children: [
+			/* @__PURE__ */ jsxs("h3", {
+				className: "mb-2 text-lg text-foreground capitalize",
+				children: [scope, " state schema *"]
+			}),
+			/* @__PURE__ */ jsxs(Button, {
+				onClick: handleToggleStandardLib,
+				className: "mb-2 flex w-fit items-center gap-2",
+				children: [
+					showStandardLib ? "Hide" : "Show",
+					" standard library",
+					/* @__PURE__ */ jsx("svg", {
+						className: twMerge("inline-block transition-transform", showStandardLib ? "rotate-180" : "rotate-0"),
+						xmlns: "http://www.w3.org/2000/svg",
+						width: "24",
+						height: "24",
+						viewBox: "0 0 24 24",
+						fill: "currentColor",
+						children: /* @__PURE__ */ jsx("path", {
+							d: "M11.9883 6.01172C11.4363 6.01172 10.9883 6.45972 10.9883 7.01172V13.0117H6.98828L11.9883 18.0117L16.9883 13.0117H12.9883V7.01172C12.9883 6.45972 12.5403 6.01172 11.9883 6.01172Z",
+							fill: "currentColor"
+						})
+					})
+				]
+			}),
+			/* @__PURE__ */ jsxs(Suspense, { children: [
+				showStandardLib && /* @__PURE__ */ jsx(GraphqlEditor, {
+					doc: typeDefsDoc,
+					readonly: true
+				}),
+				/* @__PURE__ */ jsx(GraphqlEditor, {
+					doc: stateSchema,
+					updateDocumentInModel: handleSchemaUpdate,
+					customLinter
+				}),
+				schemaErrors.length > 0 && /* @__PURE__ */ jsx("p", {
+					className: "mt-2 text-sm text-destructive",
+					children: schemaErrors[0].message
+				})
+			] })
+		] }), /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex flex-col items-end",
+			children: [/* @__PURE__ */ jsxs("h3", {
+				className: "mb-2 text-right text-lg text-foreground capitalize",
+				children: [scope, " state initial value *"]
+			}), /* @__PURE__ */ jsxs("label", {
+				className: "mb-2 flex w-fit items-center gap-2 rounded-md border border-border bg-background p-2 text-sm font-medium whitespace-nowrap text-foreground transition-colors hover:hover-effect focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:outline-none",
+				children: [
+					/* @__PURE__ */ jsx("input", {
+						type: "checkbox",
+						className: "",
+						value: syncWithSchema.toString(),
+						onChange: (e) => {
+							setSyncWithSchema(e.currentTarget.value === "true" ? true : false);
+						}
+					}),
+					"Sync with schema",
+					" ",
+					/* @__PURE__ */ jsx("svg", {
+						className: "inline-block",
+						xmlns: "http://www.w3.org/2000/svg",
+						width: "16",
+						height: "16",
+						viewBox: "0 0 16 16",
+						fill: "none",
+						children: /* @__PURE__ */ jsx("path", {
+							d: "M8.00521 1.99219C6.63588 1.99219 5.32788 2.45152 4.27588 3.28419C3.98721 3.51219 3.94321 3.93285 4.17188 4.22151C4.40054 4.51018 4.82055 4.55418 5.10921 4.32552C5.92721 3.67819 6.93921 3.32552 8.00521 3.32552C10.5825 3.32552 12.6719 5.41485 12.6719 7.99218H11.3385L13.3385 10.6588L15.3385 7.99218H14.0052C14.0052 4.67818 11.3192 1.99219 8.00521 1.99219ZM2.67188 5.32552L0.671875 7.99218H2.00521C2.00521 11.3062 4.69121 13.9922 8.00521 13.9922C9.37521 13.9922 10.6825 13.5335 11.7345 12.7002C12.0232 12.4722 12.0672 12.0515 11.8385 11.7628C11.6099 11.4742 11.1899 11.4302 10.9012 11.6588C10.0825 12.3068 9.07188 12.6588 8.00521 12.6588C5.42788 12.6588 3.33854 10.5695 3.33854 7.99218H4.67188L2.67188 5.32552Z",
+							fill: "currentColor"
+						})
+					})
+				]
+			})]
+		}), /* @__PURE__ */ jsxs(Suspense, { children: [/* @__PURE__ */ jsx(JSONEditor, {
+			doc: initialValue,
+			updateDocumentInModel: handleInitialStateUpdate
+		}), initialValueErrors.map((error, index) => /* @__PURE__ */ jsx("p", {
+			className: "mt-2 text-sm text-destructive",
+			children: error instanceof StateValidationError ? /* @__PURE__ */ jsx(StateValidationErrorMessage, { error }) : error.message
+		}, index))] })] })]
+	});
+}
+function StateSchemas({ modelName, globalStateSchema, localStateSchema, globalStateInitialValue, localStateInitialValue, setStateSchema, setInitialState, currentScope, onScopeChange }) {
+	const handleAddLocalState = useCallback(() => {
+		setStateSchema(makeInitialSchemaDoc(modelName, "local"), "local");
+		setInitialState("", "local");
+	}, [
+		modelName,
+		setStateSchema,
+		setInitialState
+	]);
+	return /* @__PURE__ */ jsxs(Tabs, {
+		className: "pb-8",
+		activationMode: "manual",
+		value: currentScope,
+		onValueChange: (value) => onScopeChange(value),
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: "my-6",
+				children: /* @__PURE__ */ jsxs(TabsList, {
+					className: "mx-auto flex max-w-sm",
+					children: [/* @__PURE__ */ jsx(TabsTrigger, {
+						value: "global",
+						children: "Global"
+					}), /* @__PURE__ */ jsx(TabsTrigger, {
+						value: "local",
+						children: "Local"
+					})]
+				})
+			}),
+			/* @__PURE__ */ jsx(TabsContent, {
+				value: "global",
+				tabIndex: -1,
+				children: /* @__PURE__ */ jsx(StateEditor, {
+					modelName,
+					stateSchema: globalStateSchema,
+					initialValue: globalStateInitialValue,
+					setStateSchema,
+					setInitialState,
+					scope: "global"
+				})
+			}),
+			/* @__PURE__ */ jsx(TabsContent, {
+				value: "local",
+				tabIndex: -1,
+				children: !localStateSchema ? /* @__PURE__ */ jsxs("div", {
+					className: "",
+					children: [/* @__PURE__ */ jsx("h3", {
+						className: "mb-2 text-lg text-foreground capitalize",
+						children: "local state schema *"
+					}), /* @__PURE__ */ jsx(Button, {
+						onClick: handleAddLocalState,
+						children: "Add local state"
+					})]
+				}) : /* @__PURE__ */ jsx(StateEditor, {
+					modelName,
+					stateSchema: localStateSchema,
+					initialValue: localStateInitialValue,
+					setStateSchema,
+					setInitialState,
+					scope: "local"
+				})
+			})
+		]
+	});
+}
+//#endregion
+export { StateSchemas as default };
+
+//# sourceMappingURL=state-schemas-DuA5rB1e.js.map