@voidhash/mimic 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -2522,5 +2522,447 @@ function toUpdateSchema(primitive) {
 }
 
 //#endregion
-export { Document_exports as Document, EffectSchema_exports as EffectSchema, Operation_exports as Operation, OperationPath_exports as OperationPath, Presence_exports as Presence, Primitive_exports as Primitive, ProxyEnvironment_exports as ProxyEnvironment, Transaction_exports as Transaction, Transform_exports as Transform };
+//#region src/types/index.ts
+var types_exports = /* @__PURE__ */ __export({
+	TreeNodePrimitive: () => TreeNodePrimitive,
+	TreeNodeSelf: () => TreeNodeSelf
+});
+
+//#endregion
+//#region src/utils/tree-helpers.ts
+var tree_helpers_exports = /* @__PURE__ */ __export({
+	buildNodeTypeMap: () => buildNodeTypeMap,
+	canAddChildType: () => canAddChildType,
+	findNode: () => findNode,
+	findNodeById: () => findNodeById,
+	findNodeWithPath: () => findNodeWithPath,
+	findNodes: () => findNodes,
+	flattenTree: () => flattenTree,
+	getAllNodeTypes: () => getAllNodeTypes,
+	getAllowedChildTypes: () => getAllowedChildTypes,
+	getAllowedChildTypesForNode: () => getAllowedChildTypesForNode,
+	getAncestors: () => getAncestors,
+	getDescendants: () => getDescendants,
+	getNodeDepth: () => getNodeDepth,
+	getNodePrimitive: () => getNodePrimitive,
+	getNodeTypeByName: () => getNodeTypeByName,
+	getParent: () => getParent,
+	getSiblings: () => getSiblings,
+	getSubtree: () => getSubtree,
+	isAncestorOf: () => isAncestorOf,
+	isChildTypeAllowed: () => isChildTypeAllowed,
+	mapTree: () => mapTree,
+	traverse: () => traverse
+});
+/**
+* Find a node by ID in a tree snapshot.
+*
+* @param snapshot - The root tree snapshot
+* @param id - The node ID to find
+* @returns The node snapshot if found, undefined otherwise
+*/
+function findNodeById(snapshot, id) {
+	if (!snapshot) return void 0;
+	if (snapshot.id === id) return snapshot;
+	for (const child of snapshot.children) {
+		const found = findNodeById(child, id);
+		if (found) return found;
+	}
+}
+/**
+* Find a node by ID with full path information.
+*
+* @param snapshot - The root tree snapshot
+* @param id - The node ID to find
+* @returns NodeSearchResult with node, path, and depth, or undefined if not found
+*/
+function findNodeWithPath(snapshot, id) {
+	if (!snapshot) return void 0;
+	const search = (node, currentPath, depth) => {
+		const path = [...currentPath, node.id];
+		if (node.id === id) return {
+			node,
+			path,
+			depth
+		};
+		for (const child of node.children) {
+			const result = search(child, path, depth + 1);
+			if (result) return result;
+		}
+	};
+	return search(snapshot, [], 0);
+}
+/**
+* Get the parent node of a given node ID.
+*
+* @param snapshot - The root tree snapshot
+* @param nodeId - The ID of the node whose parent we want
+* @returns ParentSearchResult with parent node and child index, or undefined
+*/
+function getParent(snapshot, nodeId) {
+	if (!snapshot) return void 0;
+	for (let i = 0; i < snapshot.children.length; i++) {
+		const child = snapshot.children[i];
+		if (child && child.id === nodeId) return {
+			parent: snapshot,
+			childIndex: i
+		};
+	}
+	for (const child of snapshot.children) {
+		const result = getParent(child, nodeId);
+		if (result) return result;
+	}
+}
+/**
+* Get a subtree rooted at a specific node ID.
+*
+* @param snapshot - The root tree snapshot
+* @param nodeId - The ID of the node to use as new root
+* @returns The subtree snapshot, or undefined if node not found
+*/
+function getSubtree(snapshot, nodeId) {
+	return findNodeById(snapshot, nodeId);
+}
+/**
+* Get all ancestor nodes from a node up to the root.
+*
+* @param snapshot - The root tree snapshot
+* @param nodeId - The ID of the node
+* @returns Array of ancestor snapshots from immediate parent to root, or empty array
+*/
+function getAncestors(snapshot, nodeId) {
+	if (!snapshot) return [];
+	const result = findNodeWithPath(snapshot, nodeId);
+	if (!result || result.path.length <= 1) return [];
+	const ancestorIds = result.path.slice(0, -1);
+	const ancestors = [];
+	for (let i = ancestorIds.length - 1; i >= 0; i--) {
+		const id = ancestorIds[i];
+		if (id) {
+			const ancestor = findNodeById(snapshot, id);
+			if (ancestor) ancestors.push(ancestor);
+		}
+	}
+	return ancestors;
+}
+/**
+* Get all descendant nodes of a given node (flat array).
+*
+* @param snapshot - The root tree snapshot
+* @param nodeId - The ID of the node (if undefined, returns all descendants of root)
+* @returns Flat array of all descendant node snapshots
+*/
+function getDescendants(snapshot, nodeId) {
+	if (!snapshot) return [];
+	const startNode = nodeId ? findNodeById(snapshot, nodeId) : snapshot;
+	if (!startNode) return [];
+	const descendants = [];
+	const collect = (node) => {
+		for (const child of node.children) {
+			descendants.push(child);
+			collect(child);
+		}
+	};
+	collect(startNode);
+	return descendants;
+}
+/**
+* Get siblings of a node (nodes with the same parent).
+*
+* @param snapshot - The root tree snapshot
+* @param nodeId - The ID of the node
+* @param includeSelf - Whether to include the node itself (default: false)
+* @returns Array of sibling snapshots
+*/
+function getSiblings(snapshot, nodeId, includeSelf = false) {
+	if (!snapshot) return [];
+	const parentResult = getParent(snapshot, nodeId);
+	if (!parentResult) return [];
+	const siblings = parentResult.parent.children;
+	if (includeSelf) return siblings;
+	return siblings.filter((s) => s.id !== nodeId);
+}
+/**
+* Find the first node matching a predicate.
+*
+* @param snapshot - The root tree snapshot
+* @param predicate - Function to test each node
+* @returns First matching node snapshot, or undefined
+*/
+function findNode(snapshot, predicate) {
+	if (!snapshot) return void 0;
+	if (predicate(snapshot)) return snapshot;
+	for (const child of snapshot.children) {
+		const found = findNode(child, predicate);
+		if (found) return found;
+	}
+}
+/**
+* Find all nodes matching a predicate.
+*
+* @param snapshot - The root tree snapshot
+* @param predicate - Function to test each node
+* @returns Array of matching node snapshots
+*/
+function findNodes(snapshot, predicate) {
+	if (!snapshot) return [];
+	const results = [];
+	const search = (node) => {
+		if (predicate(node)) results.push(node);
+		for (const child of node.children) search(child);
+	};
+	search(snapshot);
+	return results;
+}
+/**
+* Get the depth of a specific node (0 = root).
+*
+* @param snapshot - The root tree snapshot
+* @param nodeId - The ID of the node
+* @returns The depth, or -1 if not found
+*/
+function getNodeDepth(snapshot, nodeId) {
+	if (!snapshot) return -1;
+	const result = findNodeWithPath(snapshot, nodeId);
+	return result ? result.depth : -1;
+}
+/**
+* Check if one node is an ancestor of another.
+*
+* @param snapshot - The root tree snapshot
+* @param ancestorId - Potential ancestor node ID
+* @param descendantId - Potential descendant node ID
+* @returns true if ancestorId is an ancestor of descendantId
+*/
+function isAncestorOf(snapshot, ancestorId, descendantId) {
+	if (!snapshot) return false;
+	const result = findNodeWithPath(snapshot, descendantId);
+	if (!result) return false;
+	return result.path.slice(0, -1).includes(ancestorId);
+}
+/**
+* Traverse the tree and call a visitor function for each node.
+* Return false from visitor to stop traversal.
+*
+* @param snapshot - The root tree snapshot
+* @param visitor - Function called for each node (return false to stop)
+* @param options - Traversal options (order: 'pre' | 'post')
+*/
+function traverse(snapshot, visitor, options = {}) {
+	if (!snapshot) return;
+	const { order = "pre" } = options;
+	const visit = (node, depth) => {
+		if (order === "pre") {
+			if (visitor(node, depth) === false) return false;
+		}
+		for (const child of node.children) if (!visit(child, depth + 1)) return false;
+		if (order === "post") {
+			if (visitor(node, depth) === false) return false;
+		}
+		return true;
+	};
+	visit(snapshot, 0);
+}
+/**
+* Flatten the tree into an array with parent information.
+*
+* @param snapshot - The root tree snapshot
+* @returns Array of { node, parentId, depth } objects
+*/
+function flattenTree(snapshot) {
+	if (!snapshot) return [];
+	const result = [];
+	const flatten = (node, parentId, depth) => {
+		result.push({
+			node,
+			parentId,
+			depth
+		});
+		for (const child of node.children) flatten(child, node.id, depth + 1);
+	};
+	flatten(snapshot, null, 0);
+	return result;
+}
+/**
+* Map over all nodes in the tree, transforming each node's data.
+* Preserves tree structure while transforming node content.
+*
+* @param snapshot - The root tree snapshot
+* @param mapper - Function to transform each node
+* @returns New tree structure with transformed nodes, or undefined
+*/
+function mapTree(snapshot, mapper) {
+	if (!snapshot) return void 0;
+	const map = (node, depth) => {
+		return {
+			value: mapper(node, depth),
+			children: node.children.map((child) => map(child, depth + 1))
+		};
+	};
+	return map(snapshot, 0);
+}
+/**
+* Build a lookup map from node type strings to their TreeNodePrimitive definitions.
+* Useful for resolving snapshot node types back to their schema definitions.
+*
+* @param tree - The TreePrimitive to analyze
+* @returns Map from type string to TreeNodePrimitive
+*
+* @example
+* ```ts
+* const typeMap = buildNodeTypeMap(fileTree);
+* const folderPrimitive = typeMap.get("folder"); // FolderNode
+* ```
+*/
+function buildNodeTypeMap(tree) {
+	const map = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (visited.has(node.type)) return;
+		visited.add(node.type);
+		map.set(node.type, node);
+		for (const child of node.children) visit(child);
+	};
+	visit(tree.root);
+	return map;
+}
+/**
+* Get the TreeNodePrimitive definition for a snapshot node.
+* Requires the tree schema to resolve the type string to its primitive.
+*
+* @param tree - The TreePrimitive schema
+* @param snapshot - The node snapshot to get the primitive for
+* @returns The TreeNodePrimitive, or undefined if not found
+*
+* @example
+* ```ts
+* const node = findNodeById(treeSnapshot, "some-id");
+* const primitive = getNodePrimitive(fileTree, node);
+* // primitive is FolderNode or FileNode depending on node.type
+* ```
+*/
+function getNodePrimitive(tree, snapshot) {
+	return getNodeTypeByName(tree, snapshot.type);
+}
+/**
+* Get the allowed child types for a snapshot node.
+* Combines schema lookup with the node's allowed children.
+*
+* @param tree - The TreePrimitive schema
+* @param snapshot - The node snapshot to get allowed children for
+* @returns Array of allowed child TreeNodePrimitives, or empty array if not found
+*
+* @example
+* ```ts
+* const node = findNodeById(treeSnapshot, "folder-id");
+* const allowedChildren = getAllowedChildTypesForNode(fileTree, node);
+* // Returns [FolderNode, FileNode] if the folder can contain both
+* ```
+*/
+function getAllowedChildTypesForNode(tree, snapshot) {
+	const primitive = getNodePrimitive(tree, snapshot);
+	if (!primitive) return [];
+	return primitive.children;
+}
+/**
+* Check if a child type is allowed for a specific snapshot node.
+*
+* @param tree - The TreePrimitive schema
+* @param parentSnapshot - The parent node snapshot
+* @param childTypeName - The type string of the potential child
+* @returns true if the child type is allowed
+*
+* @example
+* ```ts
+* const folder = findNodeById(treeSnapshot, "folder-id");
+* canAddChildType(fileTree, folder, "file"); // true
+* canAddChildType(fileTree, folder, "unknown"); // false
+* ```
+*/
+function canAddChildType(tree, parentSnapshot, childTypeName) {
+	const primitive = getNodePrimitive(tree, parentSnapshot);
+	if (!primitive) return false;
+	return primitive.isChildAllowed(childTypeName);
+}
+/**
+* Get all allowed child node types for a specific node type.
+*
+* @param nodeType - The TreeNodePrimitive to get children for
+* @returns Array of allowed child TreeNodePrimitives
+*
+* @example
+* ```ts
+* const FolderNode = TreeNode("folder", { ... });
+* const FileNode = TreeNode("file", { ... });
+*
+* // Get allowed children for FolderNode
+* const allowedChildren = getAllowedChildTypes(FolderNode);
+* // Returns [FolderNode, FileNode] if folder can contain both
+* ```
+*/
+function getAllowedChildTypes(nodeType) {
+	return nodeType.children;
+}
+/**
+* Get all unique node types reachable in a tree schema.
+* Recursively traverses the tree structure starting from the root.
+*
+* @param tree - The TreePrimitive to analyze
+* @returns Array of all unique TreeNodePrimitives in the tree schema
+*
+* @example
+* ```ts
+* const fileTree = Tree({ root: FolderNode });
+* const allNodeTypes = getAllNodeTypes(fileTree);
+* // Returns [FolderNode, FileNode] - all possible node types
+* ```
+*/
+function getAllNodeTypes(tree) {
+	const visited = /* @__PURE__ */ new Set();
+	const result = [];
+	const visit = (node) => {
+		if (visited.has(node.type)) return;
+		visited.add(node.type);
+		result.push(node);
+		for (const child of node.children) visit(child);
+	};
+	visit(tree.root);
+	return result;
+}
+/**
+* Get the node type primitive by its type string from a tree schema.
+*
+* @param tree - The TreePrimitive to search
+* @param typeName - The type string to find (e.g., "folder", "file")
+* @returns The matching TreeNodePrimitive, or undefined if not found
+*
+* @example
+* ```ts
+* const fileTree = Tree({ root: FolderNode });
+* const folderType = getNodeTypeByName(fileTree, "folder");
+* // Returns FolderNode
+* ```
+*/
+function getNodeTypeByName(tree, typeName) {
+	return getAllNodeTypes(tree).find((node) => node.type === typeName);
+}
+/**
+* Check if a child type is allowed under a parent type.
+*
+* @param parentType - The parent TreeNodePrimitive
+* @param childTypeName - The type string of the potential child
+* @returns true if the child type is allowed
+*
+* @example
+* ```ts
+* isChildTypeAllowed(FolderNode, "file"); // true if folder can contain files
+* isChildTypeAllowed(FileNode, "folder"); // false - files can't have children
+* ```
+*/
+function isChildTypeAllowed(parentType, childTypeName) {
+	return parentType.isChildAllowed(childTypeName);
+}
+
+//#endregion
+export { Document_exports as Document, EffectSchema_exports as EffectSchema, Operation_exports as Operation, OperationPath_exports as OperationPath, Presence_exports as Presence, Primitive_exports as Primitive, ProxyEnvironment_exports as ProxyEnvironment, Transaction_exports as Transaction, Transform_exports as Transform, tree_helpers_exports as TreeHelpers, types_exports as Types };
 //# sourceMappingURL=index.mjs.map