@voidhash/mimic 0.0.2 → 0.0.3

package/dist/primitives/Tree.mjs

@@ -0,0 +1,574 @@
+import { _defineProperty } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/defineProperty.mjs";
+import { _objectSpread2 } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.mjs";
+import { ValidationError, applyDefaults, runValidators } from "./shared.mjs";
+import { make } from "../OperationDefinition.mjs";
+import { isPrefix, pathsEqual, pathsOverlap } from "../OperationPath.mjs";
+import { fromDefinition } from "../Operation.mjs";
+import { base62CharSet, generateKeyBetween } from "../FractionalIndex.mjs";
+import { Effect, Schema } from "effect";
+
+//#region src/primitives/Tree.ts
+/**
+* Helper to get children sorted by position
+*/
+const getOrderedChildren = (nodes, parentId) => {
+	return [...nodes].filter((n) => n.parentId === parentId).sort((a, b) => a.pos < b.pos ? -1 : a.pos > b.pos ? 1 : 0);
+};
+/**
+* Get all descendant IDs of a node (recursive)
+*/
+const getDescendantIds = (nodes, nodeId) => {
+	const children = nodes.filter((n) => n.parentId === nodeId);
+	const descendantIds = [];
+	for (const child of children) {
+		descendantIds.push(child.id);
+		descendantIds.push(...getDescendantIds(nodes, child.id));
+	}
+	return descendantIds;
+};
+/**
+* Check if moving a node to a new parent would create a cycle
+*/
+const wouldCreateCycle = (nodes, nodeId, newParentId) => {
+	if (newParentId === null) return false;
+	if (newParentId === nodeId) return true;
+	return getDescendantIds(nodes, nodeId).includes(newParentId);
+};
+/**
+* Generate a fractional position between two positions
+*/
+const generateTreePosBetween = (left, right) => {
+	const charSet = base62CharSet();
+	return Effect.runSync(generateKeyBetween(left, right, charSet));
+};
+var TreePrimitive = class TreePrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "TreePrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_nodeTypeRegistry", void 0);
+		_defineProperty(this, "_opDefinitions", {
+			set: make({
+				kind: "tree.set",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			insert: make({
+				kind: "tree.insert",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			remove: make({
+				kind: "tree.remove",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			}),
+			move: make({
+				kind: "tree.move",
+				payload: Schema.Unknown,
+				target: Schema.Unknown,
+				apply: (payload) => payload
+			})
+		});
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const getCurrentState = () => {
+					const state = env.getState(operationPath);
+					return state !== null && state !== void 0 ? state : [];
+				};
+				const getParentType = (parentId) => {
+					var _parent$type;
+					if (parentId === null) return null;
+					const parent = getCurrentState().find((n) => n.id === parentId);
+					return (_parent$type = parent === null || parent === void 0 ? void 0 : parent.type) !== null && _parent$type !== void 0 ? _parent$type : null;
+				};
+				const createNodeProxy = (nodeState) => {
+					return {
+						id: nodeState.id,
+						type: nodeState.type,
+						is: (nodeType) => {
+							return nodeState.type === nodeType.type;
+						},
+						as: (nodeType) => {
+							if (nodeState.type !== nodeType.type) throw new ValidationError(`Node is of type "${nodeState.type}", not "${nodeType.type}"`);
+							const nodePath = operationPath.append(nodeState.id);
+							const dataProxy = nodeType.data._internal.createProxy(env, nodePath);
+							return {
+								id: nodeState.id,
+								type: nodeType.type,
+								data: dataProxy,
+								get: () => nodeState,
+								update: (value) => {
+									dataProxy.update(value);
+								}
+							};
+						},
+						get: () => nodeState
+					};
+				};
+				const buildSnapshot = (nodeId, nodes) => {
+					const node = nodes.find((n) => n.id === nodeId);
+					if (!node) return void 0;
+					const childNodes = getOrderedChildren(nodes, nodeId);
+					const children = [];
+					for (const child of childNodes) {
+						const childSnapshot = buildSnapshot(child.id, nodes);
+						if (childSnapshot) children.push(childSnapshot);
+					}
+					return _objectSpread2(_objectSpread2({
+						id: node.id,
+						type: node.type
+					}, node.data), {}, { children });
+				};
+				return {
+					get: () => {
+						return getCurrentState();
+					},
+					set: (nodes) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, nodes));
+					},
+					root: () => {
+						return getCurrentState().find((n) => n.parentId === null);
+					},
+					children: (parentId) => {
+						return getOrderedChildren(getCurrentState(), parentId);
+					},
+					node: (id) => {
+						const nodeState = getCurrentState().find((n) => n.id === id);
+						if (!nodeState) return void 0;
+						return createNodeProxy(nodeState);
+					},
+					insertFirst: (parentId, nodeType, data) => {
+						const state = getCurrentState();
+						const siblings = getOrderedChildren(state, parentId);
+						const pos = generateTreePosBetween(null, siblings.length > 0 ? siblings[0].pos : null);
+						const id = env.generateId();
+						if (parentId !== null && !state.find((n) => n.id === parentId)) throw new ValidationError(`Parent node not found: ${parentId}`);
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						if (parentId === null && state.some((n) => n.parentId === null)) throw new ValidationError("Tree already has a root node");
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						return id;
+					},
+					insertLast: (parentId, nodeType, data) => {
+						const state = getCurrentState();
+						const siblings = getOrderedChildren(state, parentId);
+						const pos = generateTreePosBetween(siblings.length > 0 ? siblings[siblings.length - 1].pos : null, null);
+						const id = env.generateId();
+						if (parentId !== null && !state.find((n) => n.id === parentId)) throw new ValidationError(`Parent node not found: ${parentId}`);
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						if (parentId === null && state.some((n) => n.parentId === null)) throw new ValidationError("Tree already has a root node");
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						return id;
+					},
+					insertAt: (parentId, index, nodeType, data) => {
+						const state = getCurrentState();
+						const siblings = getOrderedChildren(state, parentId);
+						const clampedIndex = Math.max(0, Math.min(index, siblings.length));
+						const pos = generateTreePosBetween(clampedIndex > 0 && siblings[clampedIndex - 1] ? siblings[clampedIndex - 1].pos : null, clampedIndex < siblings.length && siblings[clampedIndex] ? siblings[clampedIndex].pos : null);
+						const id = env.generateId();
+						if (parentId !== null && !state.find((n) => n.id === parentId)) throw new ValidationError(`Parent node not found: ${parentId}`);
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						if (parentId === null && state.some((n) => n.parentId === null)) throw new ValidationError("Tree already has a root node");
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						return id;
+					},
+					insertAfter: (siblingId, nodeType, data) => {
+						var _nextSibling$pos;
+						const state = getCurrentState();
+						const sibling = state.find((n) => n.id === siblingId);
+						if (!sibling) throw new ValidationError(`Sibling node not found: ${siblingId}`);
+						const parentId = sibling.parentId;
+						const siblings = getOrderedChildren(state, parentId);
+						const nextSibling = siblings[siblings.findIndex((n) => n.id === siblingId) + 1];
+						const pos = generateTreePosBetween(sibling.pos, (_nextSibling$pos = nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.pos) !== null && _nextSibling$pos !== void 0 ? _nextSibling$pos : null);
+						const id = env.generateId();
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						return id;
+					},
+					insertBefore: (siblingId, nodeType, data) => {
+						var _prevSibling$pos;
+						const state = getCurrentState();
+						const sibling = state.find((n) => n.id === siblingId);
+						if (!sibling) throw new ValidationError(`Sibling node not found: ${siblingId}`);
+						const parentId = sibling.parentId;
+						const siblings = getOrderedChildren(state, parentId);
+						const prevSibling = siblings[siblings.findIndex((n) => n.id === siblingId) - 1];
+						const pos = generateTreePosBetween((_prevSibling$pos = prevSibling === null || prevSibling === void 0 ? void 0 : prevSibling.pos) !== null && _prevSibling$pos !== void 0 ? _prevSibling$pos : null, sibling.pos);
+						const id = env.generateId();
+						const parentType = getParentType(parentId);
+						this._validateChildType(parentType, nodeType.type);
+						const mergedData = applyDefaults(nodeType.data, data);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.insert, {
+							id,
+							type: nodeType.type,
+							parentId,
+							pos,
+							data: mergedData
+						}));
+						return id;
+					},
+					remove: (id) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.remove, { id }));
+					},
+					move: (nodeId, newParentId, toIndex) => {
+						var _state$find$type, _state$find;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (newParentId !== null && !state.find((n) => n.id === newParentId)) throw new ValidationError(`Parent node not found: ${newParentId}`);
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type = (_state$find = state.find((n) => n.id === newParentId)) === null || _state$find === void 0 ? void 0 : _state$find.type) !== null && _state$find$type !== void 0 ? _state$find$type : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const clampedIndex = Math.max(0, Math.min(toIndex, siblings.length));
+						const pos = generateTreePosBetween(clampedIndex > 0 && siblings[clampedIndex - 1] ? siblings[clampedIndex - 1].pos : null, clampedIndex < siblings.length && siblings[clampedIndex] ? siblings[clampedIndex].pos : null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					moveAfter: (nodeId, siblingId) => {
+						var _state$find$type2, _state$find2, _nextSibling$pos2;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						const sibling = state.find((n) => n.id === siblingId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (!sibling) throw new ValidationError(`Sibling node not found: ${siblingId}`);
+						const newParentId = sibling.parentId;
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type2 = (_state$find2 = state.find((n) => n.id === newParentId)) === null || _state$find2 === void 0 ? void 0 : _state$find2.type) !== null && _state$find$type2 !== void 0 ? _state$find$type2 : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const nextSibling = siblings[siblings.findIndex((n) => n.id === siblingId) + 1];
+						const pos = generateTreePosBetween(sibling.pos, (_nextSibling$pos2 = nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.pos) !== null && _nextSibling$pos2 !== void 0 ? _nextSibling$pos2 : null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					moveBefore: (nodeId, siblingId) => {
+						var _state$find$type3, _state$find3, _prevSibling$pos2;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						const sibling = state.find((n) => n.id === siblingId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (!sibling) throw new ValidationError(`Sibling node not found: ${siblingId}`);
+						const newParentId = sibling.parentId;
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type3 = (_state$find3 = state.find((n) => n.id === newParentId)) === null || _state$find3 === void 0 ? void 0 : _state$find3.type) !== null && _state$find$type3 !== void 0 ? _state$find$type3 : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const prevSibling = siblings[siblings.findIndex((n) => n.id === siblingId) - 1];
+						const pos = generateTreePosBetween((_prevSibling$pos2 = prevSibling === null || prevSibling === void 0 ? void 0 : prevSibling.pos) !== null && _prevSibling$pos2 !== void 0 ? _prevSibling$pos2 : null, sibling.pos);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					moveToFirst: (nodeId, newParentId) => {
+						var _state$find$type4, _state$find4;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (newParentId !== null && !state.find((n) => n.id === newParentId)) throw new ValidationError(`Parent node not found: ${newParentId}`);
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type4 = (_state$find4 = state.find((n) => n.id === newParentId)) === null || _state$find4 === void 0 ? void 0 : _state$find4.type) !== null && _state$find$type4 !== void 0 ? _state$find$type4 : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const pos = generateTreePosBetween(null, siblings.length > 0 ? siblings[0].pos : null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					moveToLast: (nodeId, newParentId) => {
+						var _state$find$type5, _state$find5;
+						const state = getCurrentState();
+						const node = state.find((n) => n.id === nodeId);
+						if (!node) throw new ValidationError(`Node not found: ${nodeId}`);
+						if (newParentId !== null && !state.find((n) => n.id === newParentId)) throw new ValidationError(`Parent node not found: ${newParentId}`);
+						if (wouldCreateCycle(state, nodeId, newParentId)) throw new ValidationError("Move would create a cycle in the tree");
+						const newParentType = newParentId === null ? null : (_state$find$type5 = (_state$find5 = state.find((n) => n.id === newParentId)) === null || _state$find5 === void 0 ? void 0 : _state$find5.type) !== null && _state$find$type5 !== void 0 ? _state$find$type5 : null;
+						this._validateChildType(newParentType, node.type);
+						if (node.parentId === null && newParentId !== null) throw new ValidationError("Cannot move root node to have a parent");
+						const siblings = getOrderedChildren(state, newParentId).filter((n) => n.id !== nodeId);
+						const pos = generateTreePosBetween(siblings.length > 0 ? siblings[siblings.length - 1].pos : null, null);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.move, {
+							id: nodeId,
+							parentId: newParentId,
+							pos
+						}));
+					},
+					at: (id, nodeType) => {
+						const node = getCurrentState().find((n) => n.id === id);
+						if (!node) throw new ValidationError(`Node not found: ${id}`);
+						if (node.type !== nodeType.type) throw new ValidationError(`Node is of type "${node.type}", not "${nodeType.type}"`);
+						const nodePath = operationPath.append(id);
+						return nodeType.data._internal.createProxy(env, nodePath);
+					},
+					updateAt: (id, nodeType, value) => {
+						const node = getCurrentState().find((n) => n.id === id);
+						if (!node) throw new ValidationError(`Node not found: ${id}`);
+						if (node.type !== nodeType.type) throw new ValidationError(`Node is of type "${node.type}", not "${nodeType.type}"`);
+						const nodePath = operationPath.append(id);
+						nodeType.data._internal.createProxy(env, nodePath).update(value);
+					},
+					toSnapshot: () => {
+						const state = getCurrentState();
+						const rootNode = state.find((n) => n.parentId === null);
+						if (!rootNode) return void 0;
+						return buildSnapshot(rootNode.id, state);
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				const path = operation.path;
+				const tokens = path.toTokens().filter((t) => t !== "");
+				const currentState = state !== null && state !== void 0 ? state : [];
+				let newState;
+				if (tokens.length === 0) switch (operation.kind) {
+					case "tree.set": {
+						const payload = operation.payload;
+						if (!globalThis.Array.isArray(payload)) throw new ValidationError(`TreePrimitive.set requires an array payload`);
+						newState = payload;
+						break;
+					}
+					case "tree.insert": {
+						const { id, type, parentId, pos, data } = operation.payload;
+						newState = [...currentState, {
+							id,
+							type,
+							parentId,
+							pos,
+							data
+						}];
+						break;
+					}
+					case "tree.remove": {
+						const { id } = operation.payload;
+						const descendantIds = getDescendantIds(currentState, id);
+						const idsToRemove = new Set([id, ...descendantIds]);
+						newState = currentState.filter((node) => !idsToRemove.has(node.id));
+						break;
+					}
+					case "tree.move": {
+						const { id, parentId, pos } = operation.payload;
+						newState = currentState.map((node) => node.id === id ? _objectSpread2(_objectSpread2({}, node), {}, {
+							parentId,
+							pos
+						}) : node);
+						break;
+					}
+					default: throw new ValidationError(`TreePrimitive cannot apply operation of kind: ${operation.kind}`);
+				}
+				else {
+					const nodeId = tokens[0];
+					const nodeIndex = currentState.findIndex((node$1) => node$1.id === nodeId);
+					if (nodeIndex === -1) throw new ValidationError(`Tree node not found with ID: ${nodeId}`);
+					const node = currentState[nodeIndex];
+					const nodeTypePrimitive = this._getNodeTypePrimitive(node.type);
+					const remainingPath = path.shift();
+					const nodeOperation = _objectSpread2(_objectSpread2({}, operation), {}, { path: remainingPath });
+					const newData = nodeTypePrimitive.data._internal.applyOperation(node.data, nodeOperation);
+					const mutableState = [...currentState];
+					mutableState[nodeIndex] = _objectSpread2(_objectSpread2({}, node), {}, { data: newData });
+					newState = mutableState;
+				}
+				runValidators(newState, this._schema.validators);
+				return newState;
+			},
+			getInitialState: () => {
+				var _rootNodeType$data$_i;
+				if (this._schema.defaultValue !== void 0) return this._schema.defaultValue;
+				const rootNodeType = this._schema.root;
+				const rootData = (_rootNodeType$data$_i = rootNodeType.data._internal.getInitialState()) !== null && _rootNodeType$data$_i !== void 0 ? _rootNodeType$data$_i : {};
+				const rootId = crypto.randomUUID();
+				const rootPos = generateTreePosBetween(null, null);
+				return [{
+					id: rootId,
+					type: rootNodeType.type,
+					parentId: null,
+					pos: rootPos,
+					data: rootData
+				}];
+			},
+			transformOperation: (clientOp, serverOp) => {
+				const clientPath = clientOp.path;
+				const serverPath = serverOp.path;
+				if (!pathsOverlap(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "tree.remove") {
+					const removedId = serverOp.payload.id;
+					const clientTokens$1 = clientPath.toTokens().filter((t) => t !== "");
+					const serverTokens$1 = serverPath.toTokens().filter((t) => t !== "");
+					if (clientOp.kind === "tree.move") {
+						const movePayload = clientOp.payload;
+						if (movePayload.id === removedId || movePayload.parentId === removedId) return { type: "noop" };
+					}
+					if (clientOp.kind === "tree.insert") {
+						if (clientOp.payload.parentId === removedId) return { type: "noop" };
+					}
+					if (clientTokens$1.length > serverTokens$1.length) {
+						if (clientTokens$1[serverTokens$1.length] === removedId) return { type: "noop" };
+					}
+				}
+				if (serverOp.kind === "tree.insert" && clientOp.kind === "tree.insert") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "tree.move" && clientOp.kind === "tree.move") {
+					if (serverOp.payload.id === clientOp.payload.id) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					return {
+						type: "transformed",
+						operation: clientOp
+					};
+				}
+				if (pathsEqual(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverOp.kind === "tree.set" && isPrefix(serverPath, clientPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+				const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+				if (clientTokens.length > 0 && serverTokens.length > 0) {
+					if (clientTokens[0] !== serverTokens[0]) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					return {
+						type: "transformed",
+						operation: clientOp
+					};
+				}
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this tree as required */
+	required() {
+		return new TreePrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this tree */
+	default(defaultValue) {
+		return new TreePrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the root node type */
+	get root() {
+		return this._schema.root;
+	}
+	/** Add a custom validation rule */
+	refine(fn, message) {
+		return new TreePrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { validators: [...this._schema.validators, {
+			validate: fn,
+			message
+		}] }));
+	}
+	/**
+	* Build a registry of all node types reachable from root
+	*/
+	_buildNodeTypeRegistry() {
+		if (this._nodeTypeRegistry !== void 0) return this._nodeTypeRegistry;
+		const registry = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (node) => {
+			if (visited.has(node.type)) return;
+			visited.add(node.type);
+			registry.set(node.type, node);
+			for (const child of node.children) visit(child);
+		};
+		visit(this._schema.root);
+		this._nodeTypeRegistry = registry;
+		return registry;
+	}
+	/**
+	* Get a node type primitive by its type string
+	*/
+	_getNodeTypePrimitive(type) {
+		const nodeType = this._buildNodeTypeRegistry().get(type);
+		if (!nodeType) throw new ValidationError(`Unknown node type: ${type}`);
+		return nodeType;
+	}
+	/**
+	* Validate that a node type can be a child of a parent node type
+	*/
+	_validateChildType(parentType, childType) {
+		if (parentType === null) {
+			if (childType !== this._schema.root.type) throw new ValidationError(`Root node must be of type "${this._schema.root.type}", got "${childType}"`);
+			return;
+		}
+		const parentNodePrimitive = this._getNodeTypePrimitive(parentType);
+		if (!parentNodePrimitive.isChildAllowed(childType)) throw new ValidationError(`Node type "${childType}" is not allowed as a child of "${parentType}". Allowed types: ${parentNodePrimitive.children.map((c) => c.type).join(", ") || "none"}`);
+	}
+};
+/** Creates a new TreePrimitive with the given root node type */
+const Tree = (options) => new TreePrimitive({
+	required: false,
+	defaultValue: void 0,
+	root: options.root,
+	validators: []
+});
+
+//#endregion
+export { Tree, TreePrimitive };
+//# sourceMappingURL=Tree.mjs.map