@revisium/schema-toolkit-ui 0.2.0 → 0.2.2

package/dist/index.cjs

@@ -44,7 +44,6 @@ let _chakra_ui_react_menu = require("@chakra-ui/react/menu");
 let react_icons_lu = require("react-icons/lu");
 let _atlaskit_drag_and_drop_adapter_element = require("@atlaskit/drag-and-drop/adapter/element");
 let _chakra_ui_react_dialog = require("@chakra-ui/react/dialog");
-let _revisium_formula = require("@revisium/formula");
 
 //#region src/schema-editor/model/state/TreeState.ts
 var TreeState = class {
@@ -1409,6 +1408,7 @@ var CollapseManager = class {
 var KeyboardNavigation = class {
 	_mode = "TREE_NAV";
 	_skipNextEscape = false;
+	_suppressNextReturnFocus = false;
 	_containerRef = null;
 	_disposers = [];
 	constructor(_treeState, _navigator, _accessors) {
@@ -1425,7 +1425,8 @@ var KeyboardNavigation = class {
 			if (!isFocused && wasFocused) {
 				this._mode = "TREE_NAV";
 				this._skipNextEscape = true;
-				this.deferReturnFocus();
+				if (this._suppressNextReturnFocus) this._suppressNextReturnFocus = false;
+				else this.deferReturnFocus();
 			}
 		}));
 	}
@@ -1506,10 +1507,12 @@ var KeyboardNavigation = class {
 		const target = event.target;
 		if (!(target instanceof HTMLElement)) return;
 		if (this._containerRef?.contains(target)) {
+			this._suppressNextReturnFocus = true;
 			if (!target.closest("[data-node-id]")) this._treeState.setActiveNodeId(null);
 			return;
 		}
-		if (!target.closest("[role=\"menu\"], [role=\"listbox\"], [role=\"dialog\"]")) this._treeState.setActiveNodeId(null);
+		if (target.closest("[role=\"menu\"], [role=\"listbox\"], [role=\"dialog\"]")) this._suppressNextReturnFocus = true;
+		else this._treeState.setActiveNodeId(null);
 	};
 	handleEditEnter() {
 		this.insertField();
@@ -3215,11 +3218,13 @@ const DescriptionSubmenu = (0, mobx_react_lite.observer)(({ accessor, dataTestId
 				onKeyDown: stopPropagation,
 				onKeyUp: stopPropagation,
 				rows: 3,
-				autoFocus: true,
-				onFocus: (e) => {
-					const len = e.currentTarget.value.length;
-					e.currentTarget.setSelectionRange(len, len);
-				},
+				ref: (0, react.useCallback)((el) => {
+					if (el) requestAnimationFrame(() => {
+						el.focus({ preventScroll: true });
+						const len = el.value.length;
+						el.setSelectionRange(len, len);
+					});
+				}, []),
 				"data-testid": `${dataTestId}-description-input`
 			})
 		}) }) })]
@@ -3274,11 +3279,13 @@ const FormulaInput = (0, mobx_react_lite.observer)(({ accessor, dataTestId }) =>
 			onChange: handleChange,
 			onKeyDown: stopPropagation,
 			onKeyUp: stopPropagation,
-			autoFocus: true,
-			onFocus: (e) => {
-				const len = e.currentTarget.value.length;
-				e.currentTarget.setSelectionRange(len, len);
-			},
+			ref: (0, react.useCallback)((el) => {
+				if (el) requestAnimationFrame(() => {
+					el.focus({ preventScroll: true });
+					const len = el.value.length;
+					el.setSelectionRange(len, len);
+				});
+			}, []),
 			rows: 2,
 			borderColor: hasError ? "red.300" : void 0,
 			"data-testid": `${dataTestId}-formula-input`
@@ -3405,7 +3412,11 @@ const DefaultValueSubmenu = (0, mobx_react_lite.observer)(({ accessor, dataTestI
 				onBlur: handleBlur,
 				onKeyDown: stopPropagation,
 				onKeyUp: stopPropagation,
-				autoFocus: true,
+				ref: (0, react.useCallback)((el) => {
+					if (el) requestAnimationFrame(() => {
+						el.focus({ preventScroll: true });
+					});
+				}, []),
 				"data-testid": `${dataTestId}-default-input`
 			})
 		}) }) })]
@@ -4602,1512 +4613,13 @@ const UpdatingSchemaEditor = (0, mobx_react_lite.observer)(({ vm }) => {
 });
 
 //#endregion
-//#region src/value-model/node/BaseValueNode.ts
-let nodeIdCounter = 0;
-function generateNodeId() {
-	return `node-${++nodeIdCounter}`;
-}
-var BaseValueNode = class {
-	id;
-	schema;
-	_parent = null;
-	_name;
-	constructor(id, name, schema) {
-		this.id = id ?? generateNodeId();
-		this._name = name;
-		this.schema = schema;
-	}
-	get parent() {
-		return this._parent;
-	}
-	set parent(value) {
-		this._parent = value;
-	}
-	get name() {
-		return this._name;
-	}
-	isObject() {
-		return false;
-	}
-	isArray() {
-		return false;
-	}
-	isPrimitive() {
-		return false;
-	}
-	get errors() {
-		return [];
-	}
-	get warnings() {
-		return [];
-	}
-	get isValid() {
-		return this.errors.length === 0;
-	}
-	get hasWarnings() {
-		return this.warnings.length > 0;
-	}
-};
-
-//#endregion
-//#region src/value-model/node/BasePrimitiveValueNode.ts
-var BasePrimitiveValueNode = class extends BaseValueNode {
-	_value;
-	_baseValue;
-	_formulaWarning = null;
-	constructor(id, name, schema, value, defaultValue) {
-		super(id, name, schema);
-		const initialValue = value ?? schema.default ?? defaultValue;
-		this._value = initialValue;
-		this._baseValue = initialValue;
-	}
-	initObservable() {
-		(0, mobx.makeObservable)(this, {
-			_value: mobx.observable,
-			_baseValue: mobx.observable,
-			_formulaWarning: mobx.observable,
-			value: mobx.computed,
-			baseValue: mobx.computed,
-			isDirty: mobx.computed,
-			errors: mobx.computed,
-			warnings: mobx.computed,
-			setValue: mobx.action,
-			setFormulaWarning: mobx.action,
-			commit: mobx.action,
-			revert: mobx.action
-		});
-	}
-	get value() {
-		return this._value;
-	}
-	set value(newValue) {
-		if (this.isReadOnly) throw new Error(`Cannot set value on read-only field: ${this.name}`);
-		this._value = newValue;
-	}
-	get baseValue() {
-		return this._baseValue;
-	}
-	get isDirty() {
-		return this._value !== this._baseValue;
-	}
-	get formula() {
-		const xFormula = this.schema["x-formula"];
-		if (xFormula) return {
-			expression: xFormula.expression,
-			version: xFormula.version
-		};
-	}
-	get formulaWarning() {
-		return this._formulaWarning;
-	}
-	get isReadOnly() {
-		return this.schema.readOnly === true || this.formula !== void 0;
-	}
-	getPlainValue() {
-		return this._value;
-	}
-	setValue(value, options) {
-		if (this.isReadOnly && !options?.internal) throw new Error(`Cannot set value on read-only field: ${this.name}`);
-		this._value = this.coerceValue(value);
-	}
-	setFormulaWarning(warning) {
-		this._formulaWarning = warning;
-	}
-	commit() {
-		this._baseValue = this._value;
-	}
-	revert() {
-		this._value = this._baseValue;
-	}
-	isPrimitive() {
-		return true;
-	}
-	get errors() {
-		return this.computeErrors();
-	}
-	computeErrors() {
-		return [];
-	}
-	get warnings() {
-		if (!this._formulaWarning) return [];
-		return [{
-			severity: "warning",
-			type: this._formulaWarning.type,
-			message: this._formulaWarning.message,
-			path: this.name,
-			params: {
-				expression: this._formulaWarning.expression,
-				computedValue: this._formulaWarning.computedValue
-			}
-		}];
-	}
-};
-
-//#endregion
-//#region src/value-model/core/types.ts
-let ValueType = /* @__PURE__ */ function(ValueType) {
-	ValueType["String"] = "string";
-	ValueType["Number"] = "number";
-	ValueType["Boolean"] = "boolean";
-	ValueType["Object"] = "object";
-	ValueType["Array"] = "array";
-	ValueType["Ref"] = "ref";
-	return ValueType;
-}({});
-
-//#endregion
-//#region src/value-model/node/StringValueNode.ts
-var StringValueNode = class extends BasePrimitiveValueNode {
-	type = ValueType.String;
-	constructor(id, name, schema, value) {
-		super(id, name, schema, value, "");
-		this.initObservable();
-	}
-	get defaultValue() {
-		return this.schema.default ?? "";
-	}
-	coerceValue(value) {
-		if (typeof value === "string") return value;
-		if (value === null || value === void 0) return "";
-		return String(value);
-	}
-	computeErrors() {
-		const errors = [];
-		this.validateRequired(errors);
-		this.validateForeignKey(errors);
-		this.validateMinLength(errors);
-		this.validateMaxLength(errors);
-		this.validatePattern(errors);
-		this.validateEnum(errors);
-		return errors;
-	}
-	validateRequired(errors) {
-		if (this.schema.required && this._value === "") errors.push({
-			severity: "error",
-			type: "required",
-			message: "Field is required",
-			path: this.name
-		});
-	}
-	validateForeignKey(errors) {
-		const foreignKey = this.schema.foreignKey;
-		if (foreignKey && this._value === "") errors.push({
-			severity: "error",
-			type: "foreignKey",
-			message: `Reference to ${foreignKey} is required`,
-			path: this.name,
-			params: { table: foreignKey }
-		});
-	}
-	validateMinLength(errors) {
-		const minLength = this.schema.minLength;
-		if (minLength !== void 0 && this._value.length > 0 && this._value.length < minLength) errors.push({
-			severity: "error",
-			type: "minLength",
-			message: `Minimum length is ${minLength}`,
-			path: this.name,
-			params: {
-				min: minLength,
-				actual: this._value.length
-			}
-		});
-	}
-	validateMaxLength(errors) {
-		const maxLength = this.schema.maxLength;
-		if (maxLength !== void 0 && this._value.length > maxLength) errors.push({
-			severity: "error",
-			type: "maxLength",
-			message: `Maximum length is ${maxLength}`,
-			path: this.name,
-			params: {
-				max: maxLength,
-				actual: this._value.length
-			}
-		});
-	}
-	validatePattern(errors) {
-		const pattern = this.schema.pattern;
-		if (!pattern || this._value.length === 0) return;
-		try {
-			if (!new RegExp(pattern).test(this._value)) errors.push({
-				severity: "error",
-				type: "pattern",
-				message: "Value does not match pattern",
-				path: this.name,
-				params: { pattern }
-			});
-		} catch {
-			errors.push({
-				severity: "error",
-				type: "invalidPattern",
-				message: "Invalid regex pattern in schema",
-				path: this.name,
-				params: { pattern }
-			});
-		}
-	}
-	validateEnum(errors) {
-		const enumValues = this.schema.enum;
-		if (enumValues && enumValues.length > 0 && !enumValues.includes(this._value)) errors.push({
-			severity: "error",
-			type: "enum",
-			message: "Value is not in allowed list",
-			path: this.name,
-			params: {
-				allowed: enumValues,
-				actual: this._value
-			}
-		});
-	}
-};
-
-//#endregion
-//#region src/value-model/node/NumberValueNode.ts
-var NumberValueNode = class extends BasePrimitiveValueNode {
-	type = ValueType.Number;
-	constructor(id, name, schema, value) {
-		super(id, name, schema, value, 0);
-		this.initObservable();
-	}
-	get defaultValue() {
-		return this.schema.default ?? 0;
-	}
-	coerceValue(value) {
-		if (typeof value === "number") return value;
-		return Number(value) || 0;
-	}
-	computeErrors() {
-		const errors = [];
-		const minimum = this.schema.minimum;
-		if (minimum !== void 0 && this._value < minimum) errors.push({
-			severity: "error",
-			type: "min",
-			message: `Value must be at least ${minimum}`,
-			path: this.name,
-			params: {
-				min: minimum,
-				actual: this._value
-			}
-		});
-		const maximum = this.schema.maximum;
-		if (maximum !== void 0 && this._value > maximum) errors.push({
-			severity: "error",
-			type: "max",
-			message: `Value must be at most ${maximum}`,
-			path: this.name,
-			params: {
-				max: maximum,
-				actual: this._value
-			}
-		});
-		const enumValues = this.schema.enum;
-		if (enumValues && enumValues.length > 0 && !enumValues.includes(this._value)) errors.push({
-			severity: "error",
-			type: "enum",
-			message: "Value is not in allowed list",
-			path: this.name,
-			params: {
-				allowed: enumValues,
-				actual: this._value
-			}
-		});
-		return errors;
-	}
-};
-
-//#endregion
-//#region src/value-model/node/BooleanValueNode.ts
-var BooleanValueNode = class extends BasePrimitiveValueNode {
-	type = ValueType.Boolean;
-	constructor(id, name, schema, value) {
-		super(id, name, schema, value, false);
-		this.initObservable();
-	}
-	get defaultValue() {
-		return this.schema.default ?? false;
-	}
-	coerceValue(value) {
-		if (typeof value === "boolean") return value;
-		return Boolean(value);
-	}
-};
-
-//#endregion
-//#region src/value-model/node/ObjectValueNode.ts
-var ObjectValueNode = class extends BaseValueNode {
-	type = ValueType.Object;
-	_children = /* @__PURE__ */ new Map();
-	_baseChildren = /* @__PURE__ */ new Map();
-	constructor(id, name, schema, children) {
-		super(id, name, schema);
-		if (children) for (const child of children) {
-			this._children.set(child.name, child);
-			child.parent = this;
-		}
-		this._baseChildren = new Map(this._children);
-		(0, mobx.makeObservable)(this, {
-			_children: mobx.observable,
-			_baseChildren: mobx.observable,
-			value: mobx.computed,
-			children: mobx.computed,
-			isDirty: mobx.computed,
-			errors: mobx.computed,
-			warnings: mobx.computed,
-			addChild: mobx.action,
-			removeChild: mobx.action,
-			commit: mobx.action,
-			revert: mobx.action
-		});
-	}
-	get value() {
-		return Object.fromEntries(this._children);
-	}
-	get children() {
-		return Array.from(this._children.values());
-	}
-	getPlainValue() {
-		const result = {};
-		for (const [key, node] of this._children) result[key] = node.getPlainValue();
-		return result;
-	}
-	child(name) {
-		return this._children.get(name);
-	}
-	hasChild(name) {
-		return this._children.has(name);
-	}
-	addChild(node) {
-		const existing = this._children.get(node.name);
-		if (existing) existing.parent = null;
-		node.parent = this;
-		this._children.set(node.name, node);
-	}
-	removeChild(name) {
-		const node = this._children.get(name);
-		if (node) {
-			node.parent = null;
-			this._children.delete(name);
-		}
-	}
-	get isDirty() {
-		if (this._children.size !== this._baseChildren.size) return true;
-		for (const [key, child] of this._children) if (this._baseChildren.get(key) !== child) return true;
-		for (const child of this._children.values()) if ("isDirty" in child && child.isDirty) return true;
-		return false;
-	}
-	commit() {
-		this._baseChildren = new Map(this._children);
-		for (const child of this._children.values()) if ("commit" in child && typeof child.commit === "function") child.commit();
-	}
-	revert() {
-		for (const child of this._children.values()) child.parent = null;
-		this._children = new Map(this._baseChildren);
-		for (const child of this._children.values()) {
-			child.parent = this;
-			if ("revert" in child && typeof child.revert === "function") child.revert();
-		}
-	}
-	isObject() {
-		return true;
-	}
-	get errors() {
-		const errors = [];
-		for (const child of this._children.values()) errors.push(...child.errors);
-		return errors;
-	}
-	get warnings() {
-		const warnings = [];
-		for (const child of this._children.values()) warnings.push(...child.warnings);
-		return warnings;
-	}
-};
-
-//#endregion
-//#region src/value-model/node/ArrayValueNode.ts
-var ArrayValueNode = class extends BaseValueNode {
-	type = ValueType.Array;
-	_items = [];
-	_baseItems = [];
-	_nodeFactory = null;
-	constructor(id, name, schema, items) {
-		super(id, name, schema);
-		if (items) for (const item of items) {
-			item.parent = this;
-			this._items.push(item);
-		}
-		this._baseItems = [...this._items];
-		(0, mobx.makeObservable)(this, {
-			_items: mobx.observable,
-			_baseItems: mobx.observable,
-			value: mobx.computed,
-			length: mobx.computed,
-			isDirty: mobx.computed,
-			errors: mobx.computed,
-			warnings: mobx.computed,
-			push: mobx.action,
-			insertAt: mobx.action,
-			removeAt: mobx.action,
-			move: mobx.action,
-			replaceAt: mobx.action,
-			clear: mobx.action,
-			commit: mobx.action,
-			revert: mobx.action,
-			pushValue: mobx.action,
-			insertValueAt: mobx.action
-		});
-	}
-	get value() {
-		return this._items;
-	}
-	get length() {
-		return this._items.length;
-	}
-	getPlainValue() {
-		return this._items.map((item) => item.getPlainValue());
-	}
-	at(index) {
-		if (index < 0) return this._items[this._items.length + index];
-		return this._items[index];
-	}
-	push(node) {
-		node.parent = this;
-		this._items.push(node);
-	}
-	insertAt(index, node) {
-		if (index < 0 || index > this._items.length) throw new Error(`Index out of bounds: ${index}`);
-		node.parent = this;
-		this._items.splice(index, 0, node);
-	}
-	removeAt(index) {
-		if (index < 0 || index >= this._items.length) throw new Error(`Index out of bounds: ${index}`);
-		const removed = this._items.splice(index, 1)[0];
-		if (removed) removed.parent = null;
-	}
-	move(fromIndex, toIndex) {
-		if (fromIndex < 0 || fromIndex >= this._items.length) throw new Error(`Source index out of bounds: ${fromIndex}`);
-		if (toIndex < 0 || toIndex >= this._items.length) throw new Error(`Target index out of bounds: ${toIndex}`);
-		if (fromIndex === toIndex) return;
-		const [item] = this._items.splice(fromIndex, 1);
-		if (item) this._items.splice(toIndex, 0, item);
-	}
-	replaceAt(index, node) {
-		if (index < 0 || index >= this._items.length) throw new Error(`Index out of bounds: ${index}`);
-		const oldNode = this._items[index];
-		if (oldNode) oldNode.parent = null;
-		node.parent = this;
-		this._items[index] = node;
-	}
-	clear() {
-		for (const item of this._items) item.parent = null;
-		this._items.length = 0;
-	}
-	setNodeFactory(factory) {
-		this._nodeFactory = factory;
-	}
-	pushValue(value) {
-		const node = this.createItemNode(this._items.length, value);
-		this.push(node);
-	}
-	insertValueAt(index, value) {
-		const node = this.createItemNode(index, value);
-		this.insertAt(index, node);
-	}
-	createItemNode(index, value) {
-		if (!this._nodeFactory) throw new Error("NodeFactory not set");
-		const itemSchema = this.schema.items;
-		if (!itemSchema) throw new Error("No items schema");
-		const itemValue = value === void 0 ? itemSchema.default : value;
-		const node = this._nodeFactory.create(String(index), itemSchema, itemValue);
-		this.propagateFactory(node);
-		return node;
-	}
-	propagateFactory(node) {
-		if (!this._nodeFactory) return;
-		if (node.isArray()) {
-			node.setNodeFactory(this._nodeFactory);
-			for (const item of node.value) this.propagateFactory(item);
-		} else if (node.isObject()) for (const child of node.children) this.propagateFactory(child);
-	}
-	get isDirty() {
-		if (this._items.length !== this._baseItems.length) return true;
-		for (let i = 0; i < this._items.length; i++) if (this._items[i] !== this._baseItems[i]) return true;
-		for (const item of this._items) if ("isDirty" in item && item.isDirty) return true;
-		return false;
-	}
-	commit() {
-		this._baseItems = [...this._items];
-		for (const item of this._items) if ("commit" in item && typeof item.commit === "function") item.commit();
-	}
-	revert() {
-		for (const item of this._items) item.parent = null;
-		this._items = [...this._baseItems];
-		for (const item of this._items) {
-			item.parent = this;
-			if ("revert" in item && typeof item.revert === "function") item.revert();
-		}
-	}
-	isArray() {
-		return true;
-	}
-	get errors() {
-		const errors = [];
-		for (const item of this._items) errors.push(...item.errors);
-		return errors;
-	}
-	get warnings() {
-		const warnings = [];
-		for (const item of this._items) warnings.push(...item.warnings);
-		return warnings;
-	}
-};
-
-//#endregion
-//#region src/value-model/node/NodeFactory.ts
-var NodeFactoryRegistry = class {
-	factories = /* @__PURE__ */ new Map();
-	register(schemaType, factory) {
-		this.factories.set(schemaType, factory);
-		return this;
-	}
-	get(schemaType) {
-		return this.factories.get(schemaType);
-	}
-	has(schemaType) {
-		return this.factories.has(schemaType);
-	}
-};
-var NodeFactory = class {
-	constructor(registry) {
-		this.registry = registry;
-	}
-	create(name, schema, value, id) {
-		const schemaType = schema.type ?? "object";
-		const factory = this.registry.get(schemaType);
-		if (!factory) throw new Error(`Unknown schema type: ${schemaType}`);
-		return factory(name, schema, value, id);
-	}
-	createTree(schema, value) {
-		return this.create("", schema, value);
-	}
-};
-const stringFactory = (name, schema, value, id) => {
-	return new StringValueNode(id, name, schema, value);
-};
-const numberFactory = (name, schema, value, id) => {
-	return new NumberValueNode(id, name, schema, value);
-};
-const booleanFactory = (name, schema, value, id) => {
-	return new BooleanValueNode(id, name, schema, value);
-};
-function createObjectFactory(nodeFactory) {
-	return (name, schema, value, id) => {
-		const objValue = value ?? {};
-		const children = [];
-		const properties = schema.properties ?? {};
-		for (const [propName, propSchema] of Object.entries(properties)) {
-			const propValue = objValue[propName];
-			const childNode = nodeFactory.create(propName, propSchema, propValue);
-			children.push(childNode);
-		}
-		return new ObjectValueNode(id, name, schema, children);
-	};
-}
-function createArrayFactory(nodeFactory) {
-	return (name, schema, value, id) => {
-		const arrValue = value ?? [];
-		const itemSchema = schema.items ?? { type: "string" };
-		const items = [];
-		for (let i = 0; i < arrValue.length; i++) {
-			const itemValue = arrValue[i];
-			const itemNode = nodeFactory.create(String(i), itemSchema, itemValue);
-			items.push(itemNode);
-		}
-		return new ArrayValueNode(id, name, schema, items);
-	};
-}
-function createDefaultRegistry() {
-	const registry = new NodeFactoryRegistry();
-	registry.register("string", stringFactory);
-	registry.register("number", numberFactory);
-	registry.register("boolean", booleanFactory);
-	return registry;
-}
-function createNodeFactory() {
-	const registry = createDefaultRegistry();
-	const factory = new NodeFactory(registry);
-	registry.register("object", createObjectFactory(factory));
-	registry.register("array", createArrayFactory(factory));
-	return factory;
-}
-
-//#endregion
-//#region src/value-model/core/Path.ts
-var Path = class Path {
-	constructor(_segments) {
-		this._segments = _segments;
-	}
-	static empty() {
-		return new Path([]);
-	}
-	static INDEX_REGEX = /^\[(\d+)\]/;
-	static PROP_REGEX = /^\.?([a-zA-Z_]\w*)/;
-	static fromString(path) {
-		if (!path || path === "") return Path.empty();
-		const segments = [];
-		let current = path;
-		while (current.length > 0) {
-			const indexMatch = Path.INDEX_REGEX.exec(current);
-			if (indexMatch?.[1] !== void 0) {
-				segments.push({
-					type: "index",
-					index: Number.parseInt(indexMatch[1], 10)
-				});
-				current = current.slice(indexMatch[0].length);
-				continue;
-			}
-			if (current.startsWith("[*]")) {
-				segments.push({ type: "items" });
-				current = current.slice(3);
-				continue;
-			}
-			const propMatch = Path.PROP_REGEX.exec(current);
-			if (propMatch?.[1] !== void 0) {
-				segments.push({
-					type: "property",
-					name: propMatch[1]
-				});
-				current = current.slice(propMatch[0].length);
-				continue;
-			}
-			throw new Error(`Invalid path segment: ${current}`);
-		}
-		return new Path(segments);
-	}
-	static fromSegments(segments) {
-		return new Path([...segments]);
-	}
-	segments() {
-		return this._segments;
-	}
-	isEmpty() {
-		return this._segments.length === 0;
-	}
-	length() {
-		return this._segments.length;
-	}
-	first() {
-		return this._segments[0];
-	}
-	last() {
-		return this._segments.at(-1);
-	}
-	parent() {
-		if (this._segments.length === 0) return this;
-		return new Path(this._segments.slice(0, -1));
-	}
-	child(name) {
-		return new Path([...this._segments, {
-			type: "property",
-			name
-		}]);
-	}
-	childIndex(index) {
-		return new Path([...this._segments, {
-			type: "index",
-			index
-		}]);
-	}
-	childItems() {
-		return new Path([...this._segments, { type: "items" }]);
-	}
-	isChildOf(parent) {
-		if (parent._segments.length >= this._segments.length) return false;
-		for (let i = 0; i < parent._segments.length; i++) {
-			const parentSeg = parent._segments[i];
-			const thisSeg = this._segments[i];
-			if (!parentSeg || !thisSeg || !this.segmentEquals(parentSeg, thisSeg)) return false;
-		}
-		return true;
-	}
-	equals(other) {
-		if (this._segments.length !== other._segments.length) return false;
-		for (let i = 0; i < this._segments.length; i++) {
-			const thisSeg = this._segments[i];
-			const otherSeg = other._segments[i];
-			if (!thisSeg || !otherSeg || !this.segmentEquals(thisSeg, otherSeg)) return false;
-		}
-		return true;
-	}
-	asSimple() {
-		let result = "";
-		for (const segment of this._segments) if (segment.type === "property") {
-			if (result.length > 0) result += ".";
-			result += segment.name;
-		} else if (segment.type === "index") result += `[${segment.index}]`;
-		else if (segment.type === "items") result += "[*]";
-		return result;
-	}
-	asJsonPointer() {
-		if (this._segments.length === 0) return "";
-		let result = "";
-		for (const segment of this._segments) if (segment.type === "property") result += "/" + segment.name;
-		else if (segment.type === "index") result += "/" + segment.index;
-		else if (segment.type === "items") result += "/-";
-		return result;
-	}
-	segmentEquals(a, b) {
-		if (a.type !== b.type) return false;
-		if (a.type === "property" && b.type === "property") return a.name === b.name;
-		if (a.type === "index" && b.type === "index") return a.index === b.index;
-		return true;
-	}
-};
-
-//#endregion
-//#region src/value-model/tree/TreeIndex.ts
-var TreeIndex = class {
-	nodesById = /* @__PURE__ */ new Map();
-	pathCache = /* @__PURE__ */ new Map();
-	constructor(root) {
-		this.root = root;
-		this.rebuild();
-	}
-	nodeById(id) {
-		const node = this.nodesById.get(id);
-		if (node) return node;
-		this.rebuild();
-		return this.nodesById.get(id);
-	}
-	pathOf(node) {
-		if (this.isInsideArray(node)) return this.computePath(node);
-		const cached = this.pathCache.get(node.id);
-		if (cached) return cached;
-		const path = this.computePath(node);
-		this.pathCache.set(node.id, path);
-		return path;
-	}
-	isInsideArray(node) {
-		let current = node.parent;
-		while (current) {
-			if (current.isArray()) return true;
-			current = current.parent;
-		}
-		return false;
-	}
-	rebuild() {
-		this.nodesById.clear();
-		this.pathCache.clear();
-		this.indexNode(this.root);
-	}
-	registerNode(node) {
-		this.indexNode(node);
-	}
-	invalidatePathsUnder(node) {
-		this.pathCache.delete(node.id);
-		this.invalidateChildPaths(node);
-	}
-	indexNode(node) {
-		this.nodesById.set(node.id, node);
-		if (node.isObject()) for (const child of node.children) this.indexNode(child);
-		else if (node.isArray()) for (const item of node.value) this.indexNode(item);
-	}
-	computePath(node) {
-		const segments = [];
-		let current = node;
-		while (current?.parent) {
-			const parent = current.parent;
-			if (parent.isObject()) segments.unshift({
-				type: "property",
-				name: current.name
-			});
-			else if (parent.isArray()) {
-				const index = parent.value.indexOf(current);
-				if (index >= 0) segments.unshift({
-					type: "index",
-					index
-				});
-			}
-			current = parent;
-		}
-		return Path.fromSegments(segments);
-	}
-	invalidateChildPaths(node) {
-		if (node.isObject()) for (const child of node.children) {
-			this.pathCache.delete(child.id);
-			this.invalidateChildPaths(child);
-		}
-		else if (node.isArray()) for (const item of node.value) {
-			this.pathCache.delete(item.id);
-			this.invalidateChildPaths(item);
-		}
-	}
-};
-
-//#endregion
-//#region src/value-model/tree/ChangeTracker.ts
-var ChangeTracker = class {
-	_changes = [];
-	get changes() {
-		return this._changes;
-	}
-	get hasChanges() {
-		return this._changes.length > 0;
-	}
-	track(change) {
-		this._changes.push(change);
-	}
-	clear() {
-		this._changes = [];
-	}
-	toPatches() {
-		const patches = [];
-		for (const change of this._changes) {
-			const patch = this.changeToPatches(change);
-			patches.push(...patch);
-		}
-		return patches;
-	}
-	changeToPatches(change) {
-		const path = change.path.asJsonPointer();
-		switch (change.type) {
-			case "setValue": return [{
-				op: "replace",
-				path,
-				value: change.value
-			}];
-			case "addProperty": return [{
-				op: "add",
-				path,
-				value: change.value
-			}];
-			case "removeProperty": return [{
-				op: "remove",
-				path
-			}];
-			case "arrayPush": return [{
-				op: "add",
-				path: `${path}/-`,
-				value: change.value
-			}];
-			case "arrayInsert": return [{
-				op: "add",
-				path: `${path}/${change.index}`,
-				value: change.value
-			}];
-			case "arrayRemove": return [{
-				op: "remove",
-				path: `${path}/${change.index}`
-			}];
-			case "arrayMove": {
-				const fromIndex = change.fromIndex ?? 0;
-				const toIndex = change.toIndex ?? 0;
-				return [{
-					op: "move",
-					from: `${path}/${fromIndex}`,
-					path: `${path}/${toIndex}`
-				}];
-			}
-			case "arrayReplace": return [{
-				op: "replace",
-				path: `${path}/${change.index}`,
-				value: change.value
-			}];
-			case "arrayClear": return [{
-				op: "replace",
-				path,
-				value: []
-			}];
-			default: return [];
-		}
-	}
-};
-
-//#endregion
-//#region src/value-model/tree/ValueTree.ts
-var ValueTree = class {
-	index;
-	changeTracker;
-	_formulaEngine = null;
-	constructor(_root) {
-		this._root = _root;
-		this.index = new TreeIndex(_root);
-		this.changeTracker = new ChangeTracker();
-		(0, mobx.makeObservable)(this, {
-			allErrors: mobx.computed,
-			allWarnings: mobx.computed,
-			allDiagnostics: mobx.computed,
-			isValid: mobx.computed,
-			hasDiagnostics: mobx.computed,
-			isDirty: mobx.computed,
-			commit: mobx.action,
-			revert: mobx.action
-		});
-	}
-	get root() {
-		return this._root;
-	}
-	nodeById(id) {
-		return this.index.nodeById(id);
-	}
-	get(path) {
-		return this.getByPath(Path.fromString(path));
-	}
-	getByPath(path) {
-		if (path.isEmpty()) return this._root;
-		let current = this._root;
-		for (const segment of path.segments()) {
-			if (!current) return;
-			current = this.resolveSegment(current, segment);
-		}
-		return current;
-	}
-	resolveSegment(node, segment) {
-		if (segment.type === "property" && node.isObject()) return node.child(segment.name);
-		if (segment.type === "index" && node.isArray()) return node.at(segment.index);
-	}
-	pathOf(nodeOrId) {
-		const node = typeof nodeOrId === "string" ? this.nodeById(nodeOrId) : nodeOrId;
-		if (!node) return Path.empty();
-		return this.index.pathOf(node);
-	}
-	get allErrors() {
-		return this._root.errors;
-	}
-	get allWarnings() {
-		return this._root.warnings;
-	}
-	get allDiagnostics() {
-		return [...this.allErrors, ...this.allWarnings];
-	}
-	get isValid() {
-		return this.allErrors.length === 0;
-	}
-	get hasDiagnostics() {
-		return this.allDiagnostics.length > 0;
-	}
-	get errorsByPath() {
-		const map = /* @__PURE__ */ new Map();
-		for (const error of this.allErrors) {
-			const list = map.get(error.path) ?? [];
-			list.push(error);
-			map.set(error.path, list);
-		}
-		return map;
-	}
-	getValue(path) {
-		return this.get(path)?.getPlainValue();
-	}
-	setValue(path, value) {
-		const parsedPath = Path.fromString(path);
-		const node = this.getByPath(parsedPath);
-		if (!node) throw new Error(`Path not found: ${path}`);
-		if (!node.isPrimitive()) throw new Error(`Cannot set value on non-primitive node: ${path}`);
-		const oldValue = node.value;
-		node.setValue(value);
-		this.changeTracker.track({
-			type: "setValue",
-			path: parsedPath,
-			value,
-			oldValue
-		});
-	}
-	getPlainValue() {
-		return this._root.getPlainValue();
-	}
-	get changes() {
-		return this.changeTracker.changes;
-	}
-	get hasChanges() {
-		return this.changeTracker.hasChanges;
-	}
-	clearChanges() {
-		this.changeTracker.clear();
-	}
-	getPatches() {
-		return this.changeTracker.toPatches();
-	}
-	trackChange(change) {
-		this.changeTracker.track(change);
-	}
-	rebuildIndex() {
-		this.index.rebuild();
-	}
-	invalidatePathsUnder(node) {
-		this.index.invalidatePathsUnder(node);
-	}
-	get isDirty() {
-		const root = this._root;
-		if ("isDirty" in root) return root.isDirty;
-		return false;
-	}
-	commit() {
-		const root = this._root;
-		if ("commit" in root && typeof root.commit === "function") root.commit();
-		this.changeTracker.clear();
-	}
-	revert() {
-		const root = this._root;
-		if ("revert" in root && typeof root.revert === "function") root.revert();
-		this.changeTracker.clear();
-	}
-	setFormulaEngine(engine) {
-		this._formulaEngine = engine;
-	}
-	get formulaEngine() {
-		return this._formulaEngine;
-	}
-	dispose() {
-		this._formulaEngine?.dispose();
-		this._formulaEngine = null;
-	}
-};
-
-//#endregion
-//#region src/value-model/formula/FormulaCollector.ts
-const INDEX_REGEX = /^\[(-?\d+)\]/;
-const PROP_REGEX = /^\.?([a-zA-Z_]\w*)/;
-var FormulaCollector = class {
-	root = null;
-	collect(root) {
-		this.root = root;
-		const formulas = [];
-		this.traverse(root, {
-			parent: null,
-			arrayLevels: []
-		}, formulas);
-		return formulas;
-	}
-	traverse(node, context, formulas) {
-		if (node.isPrimitive()) this.collectPrimitive(node, context, formulas);
-		else if (node.isObject()) for (const child of node.children) this.traverse(child, {
-			...context,
-			parent: node
-		}, formulas);
-		else if (node.isArray()) for (let i = 0; i < node.length; i++) {
-			const item = node.at(i);
-			if (item) this.traverse(item, {
-				...context,
-				arrayLevels: [...context.arrayLevels, {
-					array: node,
-					index: i
-				}]
-			}, formulas);
-		}
-	}
-	collectPrimitive(node, context, formulas) {
-		const formula = node.formula;
-		if (!formula) return;
-		const rawDependencies = this.extractDependencies(formula.expression);
-		const dependencyNodes = this.resolveDependencies(rawDependencies, node, context);
-		formulas.push({
-			node,
-			expression: formula.expression,
-			parent: context.parent,
-			dependencyNodes,
-			arrayLevels: context.arrayLevels
-		});
-	}
-	extractDependencies(expression) {
-		try {
-			return (0, _revisium_formula.parseExpression)(expression).dependencies;
-		} catch {
-			return [];
-		}
-	}
-	resolveDependencies(rawDeps, formulaNode, context) {
-		const nodes = [];
-		for (const dep of rawDeps) {
-			const node = this.resolveOneDependency(dep, formulaNode, context);
-			if (node) this.collectPrimitiveNodes(node, nodes);
-		}
-		return nodes;
-	}
-	collectPrimitiveNodes(node, result) {
-		if (node.isPrimitive()) result.push(node);
-		else if (node.isArray()) for (let i = 0; i < node.length; i++) {
-			const item = node.at(i);
-			if (item) this.collectPrimitiveNodes(item, result);
-		}
-		else if (node.isObject()) for (const child of node.children) this.collectPrimitiveNodes(child, result);
-	}
-	resolveOneDependency(dep, _formulaNode, context) {
-		if (dep.startsWith("/")) return this.resolveFromRoot(dep.slice(1));
-		if (dep.startsWith("../")) return this.resolveRelative(dep, context);
-		if (context.parent) return this.resolveFromNode(context.parent, dep);
-		return this.resolveFromRoot(dep);
-	}
-	resolveFromRoot(pathStr) {
-		if (!this.root) return null;
-		return this.resolveFromNode(this.root, pathStr);
-	}
-	resolveFromNode(startNode, pathStr) {
-		const segments = this.parsePathSegments(pathStr);
-		let current = startNode;
-		for (const segment of segments) {
-			if (!current) return null;
-			if (segment.type === "property") if (current.isObject()) current = current.children.find((c) => c.name === segment.name) ?? null;
-			else return null;
-			else if (segment.type === "index") if (current.isArray()) current = current.at(segment.index) ?? null;
-			else return null;
-		}
-		return current;
-	}
-	resolveRelative(dep, context) {
-		let upLevels = 0;
-		let remaining = dep;
-		while (remaining.startsWith("../")) {
-			upLevels++;
-			remaining = remaining.slice(3);
-		}
-		let current = context.parent;
-		for (let i = 0; i < upLevels && current; i++) {
-			current = this.findParent(current);
-			if (current?.isArray()) current = this.findParent(current);
-		}
-		if (!current) return null;
-		if (remaining) return this.resolveFromNode(current, remaining);
-		return current;
-	}
-	findParent(node) {
-		if (!this.root || node === this.root) return null;
-		return this.findParentRecursive(this.root, node);
-	}
-	findParentRecursive(current, target) {
-		const children = this.getChildNodes(current);
-		for (const child of children) {
-			if (child === target) return current;
-			const found = this.findParentRecursive(child, target);
-			if (found) return found;
-		}
-		return null;
-	}
-	getChildNodes(node) {
-		if (node.isObject()) return [...node.children];
-		if (node.isArray()) {
-			const items = [];
-			for (let i = 0; i < node.length; i++) {
-				const item = node.at(i);
-				if (item) items.push(item);
-			}
-			return items;
-		}
-		return [];
-	}
-	parsePathSegments(pathStr) {
-		const segments = [];
-		let current = pathStr;
-		while (current.length > 0) {
-			const indexMatch = INDEX_REGEX.exec(current);
-			if (indexMatch?.[1]) {
-				segments.push({
-					type: "index",
-					index: Number.parseInt(indexMatch[1], 10)
-				});
-				current = current.slice(indexMatch[0].length);
-				continue;
-			}
-			const propMatch = PROP_REGEX.exec(current);
-			if (propMatch?.[1]) {
-				segments.push({
-					type: "property",
-					name: propMatch[1]
-				});
-				current = current.slice(propMatch[0].length);
-				continue;
-			}
-			break;
-		}
-		return segments;
-	}
-};
-
-//#endregion
-//#region src/value-model/formula/DependencyGraph.ts
-var DependencyGraph = class {
-	buildDependencyMap(formulas) {
-		const map = /* @__PURE__ */ new Map();
-		for (const field of formulas) for (const depNode of field.dependencyNodes) {
-			let depSet = map.get(depNode);
-			if (!depSet) {
-				depSet = /* @__PURE__ */ new Set();
-				map.set(depNode, depSet);
-			}
-			depSet.add(field);
-		}
-		return map;
-	}
-	buildEvaluationOrder(formulas) {
-		const formulaNodes = new Set(formulas.map((f) => f.node));
-		const visited = /* @__PURE__ */ new Set();
-		const order = [];
-		const formulaByNode = /* @__PURE__ */ new Map();
-		for (const field of formulas) formulaByNode.set(field.node, field);
-		const visit = (field, stack) => {
-			if (visited.has(field.node)) return;
-			if (stack.has(field.node)) return;
-			stack.add(field.node);
-			for (const depNode of field.dependencyNodes) if (formulaNodes.has(depNode)) {
-				const depFormula = formulaByNode.get(depNode);
-				if (depFormula) visit(depFormula, stack);
-			}
-			stack.delete(field.node);
-			visited.add(field.node);
-			order.push(field);
-		};
-		for (const field of formulas) visit(field, /* @__PURE__ */ new Set());
-		return order;
-	}
-	getAffectedFormulas(changedNode, dependencyMap, evaluationOrder) {
-		const affected = /* @__PURE__ */ new Set();
-		const queue = [changedNode];
-		while (queue.length > 0) {
-			const current = queue.shift();
-			if (!current) continue;
-			const dependents = dependencyMap.get(current);
-			if (dependents) {
-				for (const field of dependents) if (!affected.has(field)) {
-					affected.add(field);
-					queue.push(field.node);
-				}
-			}
-		}
-		return evaluationOrder.filter((field) => affected.has(field));
-	}
-};
-
-//#endregion
-//#region src/value-model/formula/FormulaEvaluator.ts
-var FormulaEvaluator = class {
-	constructor(tree, options = {}) {
-		this.tree = tree;
-		this.options = options;
-	}
-	evaluate(field) {
-		try {
-			const context = this.buildContext(field);
-			const result = (0, _revisium_formula.evaluateWithContext)(field.expression, context);
-			this.setNodeValue(field, result);
-			this.checkForWarnings(field, result);
-		} catch (error) {
-			this.handleError(field, error);
-		}
-	}
-	evaluateAll(fields) {
-		for (const field of fields) this.evaluate(field);
-	}
-	buildContext(field) {
-		const context = { rootData: this.tree.getPlainValue() };
-		if (field.parent) {
-			const itemData = this.getPlainObjectValue(field.parent);
-			if (itemData) context.itemData = itemData;
-		}
-		if (field.arrayLevels.length > 0) context.arrayContext = { levels: this.buildArrayLevels(field) };
-		return context;
-	}
-	buildArrayLevels(field) {
-		const levels = [];
-		for (let i = field.arrayLevels.length - 1; i >= 0; i--) {
-			const level = field.arrayLevels[i];
-			if (!level) continue;
-			const { array, index } = level;
-			levels.push({
-				index,
-				length: array.length,
-				prev: this.getPrevItemValue(array, index),
-				next: this.getNextItemValue(array, index)
-			});
-		}
-		return levels;
-	}
-	getPrevItemValue(array, index) {
-		if (index <= 0) return null;
-		const prevItem = array.at(index - 1);
-		return prevItem ? this.getPlainNodeValue(prevItem) : null;
-	}
-	getNextItemValue(array, index) {
-		if (index >= array.length - 1) return null;
-		const nextItem = array.at(index + 1);
-		return nextItem ? this.getPlainNodeValue(nextItem) : null;
-	}
-	getPlainObjectValue(node) {
-		const result = {};
-		for (const child of node.children) result[child.name] = this.getPlainNodeValue(child);
-		return result;
-	}
-	getPlainNodeValue(node) {
-		if (node.isPrimitive()) return node.value;
-		if (node.isObject()) return this.getPlainObjectValue(node);
-		if (node.isArray()) {
-			const result = [];
-			for (let i = 0; i < node.length; i++) {
-				const item = node.at(i);
-				if (item) result.push(this.getPlainNodeValue(item));
-			}
-			return result;
-		}
-		return null;
-	}
-	setNodeValue(field, result) {
-		const { node } = field;
-		const defaultValue = node.defaultValue;
-		if (result === null || result === void 0) {
-			node.setValue(defaultValue, { internal: true });
-			return;
-		}
-		if (typeof result === "number" && (Number.isNaN(result) || !Number.isFinite(result))) {
-			node.setValue(defaultValue, { internal: true });
-			return;
-		}
-		node.setValue(result, { internal: true });
-	}
-	checkForWarnings(field, result) {
-		const { node } = field;
-		if (typeof result === "number") {
-			if (Number.isNaN(result)) {
-				node.setFormulaWarning({
-					type: "nan",
-					message: "Formula result is NaN",
-					expression: field.expression,
-					computedValue: result
-				});
-				return;
-			}
-			if (!Number.isFinite(result)) {
-				node.setFormulaWarning({
-					type: "infinity",
-					message: "Formula result is Infinity",
-					expression: field.expression,
-					computedValue: result
-				});
-				return;
-			}
-		}
-		node.setFormulaWarning(null);
-	}
-	handleError(field, error) {
-		const { node } = field;
-		node.setValue(node.defaultValue, { internal: true });
-		node.setFormulaWarning({
-			type: "runtime-error",
-			message: error.message,
-			expression: field.expression,
-			computedValue: void 0
-		});
-		if (this.options.onError) this.options.onError(node, error);
-	}
-};
-
-//#endregion
-//#region src/value-model/formula/FormulaEngine.ts
-var FormulaEngine = class {
-	collector;
-	graph;
-	evaluator;
-	formulas = [];
-	dependencyMap = /* @__PURE__ */ new Map();
-	evaluationOrder = [];
-	disposers = [];
-	constructor(tree, options = {}) {
-		this.tree = tree;
-		this.collector = new FormulaCollector();
-		this.graph = new DependencyGraph();
-		this.evaluator = new FormulaEvaluator(tree, options);
-		this.initialize();
-	}
-	reinitialize() {
-		this.disposeReactions();
-		this.initialize();
-	}
-	dispose() {
-		this.disposeReactions();
-		this.formulas = [];
-		this.dependencyMap = /* @__PURE__ */ new Map();
-		this.evaluationOrder = [];
-	}
-	getFormulas() {
-		return this.formulas;
-	}
-	getEvaluationOrder() {
-		return this.evaluationOrder;
-	}
-	initialize() {
-		this.formulas = this.collector.collect(this.tree.root);
-		this.dependencyMap = this.graph.buildDependencyMap(this.formulas);
-		this.evaluationOrder = this.graph.buildEvaluationOrder(this.formulas);
-		this.evaluateAll();
-		this.setupReactions();
-	}
-	evaluateAll() {
-		(0, mobx.runInAction)(() => {
-			for (const field of this.evaluationOrder) this.evaluator.evaluate(field);
-		});
-	}
-	setupReactions() {
-		const watchedNodes = /* @__PURE__ */ new Set();
-		for (const [depNode] of this.dependencyMap) {
-			if (watchedNodes.has(depNode)) continue;
-			watchedNodes.add(depNode);
-			const disposer = (0, mobx.reaction)(() => depNode.value, () => this.handleDependencyChange(depNode));
-			this.disposers.push(disposer);
-		}
-		this.setupArrayReactions(this.tree.root);
-	}
-	setupArrayReactions(node) {
-		if (node.isArray()) {
-			const disposer = (0, mobx.reaction)(() => node.length, () => this.handleStructureChange());
-			this.disposers.push(disposer);
-			for (const item of node.value) this.setupArrayReactions(item);
-		} else if (node.isObject()) for (const child of node.children) this.setupArrayReactions(child);
-	}
-	handleDependencyChange(changedNode) {
-		const affected = this.graph.getAffectedFormulas(changedNode, this.dependencyMap, this.evaluationOrder);
-		(0, mobx.runInAction)(() => {
-			for (const field of affected) this.evaluator.evaluate(field);
-		});
-	}
-	handleStructureChange() {
-		this.reinitialize();
-	}
-	disposeReactions() {
-		for (const disposer of this.disposers) disposer();
-		this.disposers = [];
-	}
-};
-
-//#endregion
-//#region src/value-model/factory.ts
-function createValueModel(schema, initialValue, options) {
-	const nodeFactory = options?.nodeFactory ?? createNodeFactory();
-	const rootNode = nodeFactory.createTree(schema, initialValue);
-	propagateFactoryToArrays(rootNode, nodeFactory);
-	const tree = new ValueTree(rootNode);
-	if (options?.formulaEngine !== false) {
-		const engine = new FormulaEngine(tree, typeof options?.formulaEngine === "object" ? options.formulaEngine : {});
-		tree.setFormulaEngine(engine);
-	}
-	return tree;
-}
-function propagateFactoryToArrays(node, factory) {
-	if (node.isArray()) {
-		node.setNodeFactory(factory);
-		for (const item of node.value) propagateFactoryToArrays(item, factory);
-	} else if (node.isObject()) for (const child of node.children) propagateFactoryToArrays(child, factory);
-}
-function createEmptyValueModel(schema, options) {
-	return createValueModel(schema, void 0, options);
-}
-
-//#endregion
-exports.ArrayValueNode = ArrayValueNode;
 exports.BackButton = BackButton;
-exports.BooleanValueNode = BooleanValueNode;
 exports.CloseButton = CloseButton;
 exports.ContentEditable = ContentEditable;
 exports.CopyButton = CopyButton;
 exports.CreateButton = CreateButton;
 exports.CreatingEditorVM = CreatingEditorVM;
 exports.CreatingSchemaEditor = CreatingSchemaEditor;
-exports.FormulaEngine = FormulaEngine;
 exports.GrayButton = GrayButton;
 exports.JsonCard = JsonCard;
 Object.defineProperty(exports, 'JsonSchemaTypeName', {
@@ -6116,20 +4628,27 @@ Object.defineProperty(exports, 'JsonSchemaTypeName', {
     return _revisium_schema_toolkit.JsonSchemaTypeName;
   }
 });
-exports.NumberValueNode = NumberValueNode;
-exports.ObjectValueNode = ObjectValueNode;
 exports.SchemaEditorCore = SchemaEditorCore;
 exports.SchemaTypeIds = SchemaTypeIds;
 exports.SettingsButton = SettingsButton;
-exports.StringValueNode = StringValueNode;
 exports.Tooltip = Tooltip;
 exports.UpdatingEditorVM = UpdatingEditorVM;
 exports.UpdatingSchemaEditor = UpdatingSchemaEditor;
-exports.ValueTree = ValueTree;
 exports.ViewerSwitcher = ViewerSwitcher;
 exports.ViewerSwitcherMode = ViewerSwitcherMode;
-exports.createEmptyValueModel = createEmptyValueModel;
-exports.createValueModel = createValueModel;
+Object.defineProperty(exports, 'createRowModel', {
+  enumerable: true,
+  get: function () {
+    return _revisium_schema_toolkit.createRowModel;
+  }
+});
+Object.defineProperty(exports, 'createTableModel', {
+  enumerable: true,
+  get: function () {
+    return _revisium_schema_toolkit.createTableModel;
+  }
+});
+exports.ensureReactivityProvider = ensureReactivityProvider;
 exports.getLabelByRef = getLabelByRef;
 exports.typeMenuGroups = typeMenuGroups;
 exports.useContentEditable = useContentEditable;