@voidhash/mimic 0.0.2 → 0.0.3

package/dist/utils/tree-helpers.mjs

@@ -0,0 +1,439 @@
+import { __export } from "../_virtual/rolldown_runtime.mjs";
+
+//#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 { tree_helpers_exports };
+//# sourceMappingURL=tree-helpers.mjs.map

package/dist/utils/tree-helpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-helpers.mjs","names":["ancestors: TreeNodeSnapshot<TNode>[]","descendants: TreeNodeSnapshot<TNode>[]","results: TreeNodeSnapshot<TNode>[]","result: FlattenedNode<TNode>[]","result: AnyTreeNodePrimitive[]"],"sources":["../../src/utils/tree-helpers.ts"],"sourcesContent":["/**\n * Tree snapshot utility functions.\n *\n * Standalone helpers for traversing and querying tree snapshots.\n * All functions handle undefined snapshots gracefully.\n *\n * @since 0.0.1\n */\n\nimport type { TreeNodeSnapshot, TreePrimitive } from \"../primitives/Tree.js\";\nimport type { AnyTreeNodePrimitive } from \"../primitives/TreeNode.js\";\n\n// =============================================================================\n// Result Types\n// =============================================================================\n\n/**\n * Result of finding a node with path information.\n */\nexport interface NodeSearchResult<TNode extends AnyTreeNodePrimitive> {\n  readonly node: TreeNodeSnapshot<TNode>;\n  readonly path: readonly string[]; // Array of node IDs from root to this node\n  readonly depth: number;\n}\n\n/**\n * Result of finding a parent node.\n */\nexport interface ParentSearchResult<TNode extends AnyTreeNodePrimitive> {\n  readonly parent: TreeNodeSnapshot<TNode>;\n  readonly childIndex: number; // Index of the target node in parent's children\n}\n\n/**\n * Flattened node with parent information.\n */\nexport interface FlattenedNode<TNode extends AnyTreeNodePrimitive> {\n  readonly node: TreeNodeSnapshot<TNode>;\n  readonly parentId: string | null;\n  readonly depth: number;\n}\n\n/**\n * Options for tree traversal.\n */\nexport interface TraverseOptions {\n  readonly order?: \"pre\" | \"post\";\n}\n\n// =============================================================================\n// Core Functions\n// =============================================================================\n\n/**\n * Find a node by ID in a tree snapshot.\n *\n * @param snapshot - The root tree snapshot\n * @param id - The node ID to find\n * @returns The node snapshot if found, undefined otherwise\n */\nexport function findNodeById<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  id: string\n): TreeNodeSnapshot<TNode> | undefined {\n  if (!snapshot) return undefined;\n  if (snapshot.id === id) return snapshot;\n\n  for (const child of snapshot.children) {\n    const found = findNodeById(child as TreeNodeSnapshot<TNode>, id);\n    if (found) return found;\n  }\n\n  return undefined;\n}\n\n/**\n * Find a node by ID with full path information.\n *\n * @param snapshot - The root tree snapshot\n * @param id - The node ID to find\n * @returns NodeSearchResult with node, path, and depth, or undefined if not found\n */\nexport function findNodeWithPath<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  id: string\n): NodeSearchResult<TNode> | undefined {\n  if (!snapshot) return undefined;\n\n  const search = (\n    node: TreeNodeSnapshot<TNode>,\n    currentPath: string[],\n    depth: number\n  ): NodeSearchResult<TNode> | undefined => {\n    const path = [...currentPath, node.id];\n\n    if (node.id === id) {\n      return { node, path, depth };\n    }\n\n    for (const child of node.children) {\n      const result = search(child as TreeNodeSnapshot<TNode>, path, depth + 1);\n      if (result) return result;\n    }\n\n    return undefined;\n  };\n\n  return search(snapshot, [], 0);\n}\n\n/**\n * Get the parent node of a given node ID.\n *\n * @param snapshot - The root tree snapshot\n * @param nodeId - The ID of the node whose parent we want\n * @returns ParentSearchResult with parent node and child index, or undefined\n */\nexport function getParent<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  nodeId: string\n): ParentSearchResult<TNode> | undefined {\n  if (!snapshot) return undefined;\n\n  // Check if any direct child is the target\n  for (let i = 0; i < snapshot.children.length; i++) {\n    const child = snapshot.children[i];\n    if (child && child.id === nodeId) {\n      return {\n        parent: snapshot,\n        childIndex: i,\n      };\n    }\n  }\n\n  // Recursively search children\n  for (const child of snapshot.children) {\n    const result = getParent(child as TreeNodeSnapshot<TNode>, nodeId);\n    if (result) return result;\n  }\n\n  return undefined;\n}\n\n/**\n * Get a subtree rooted at a specific node ID.\n *\n * @param snapshot - The root tree snapshot\n * @param nodeId - The ID of the node to use as new root\n * @returns The subtree snapshot, or undefined if node not found\n */\nexport function getSubtree<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  nodeId: string\n): TreeNodeSnapshot<TNode> | undefined {\n  return findNodeById(snapshot, nodeId);\n}\n\n/**\n * Get all ancestor nodes from a node up to the root.\n *\n * @param snapshot - The root tree snapshot\n * @param nodeId - The ID of the node\n * @returns Array of ancestor snapshots from immediate parent to root, or empty array\n */\nexport function getAncestors<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  nodeId: string\n): readonly TreeNodeSnapshot<TNode>[] {\n  if (!snapshot) return [];\n\n  const result = findNodeWithPath(snapshot, nodeId);\n  if (!result || result.path.length <= 1) return [];\n\n  // Path includes the node itself, so we need all nodes except the last one\n  const ancestorIds = result.path.slice(0, -1);\n  const ancestors: TreeNodeSnapshot<TNode>[] = [];\n\n  // Collect ancestors in reverse order (parent first, root last)\n  for (let i = ancestorIds.length - 1; i >= 0; i--) {\n    const id = ancestorIds[i];\n    if (id) {\n      const ancestor = findNodeById(snapshot, id);\n      if (ancestor) {\n        ancestors.push(ancestor);\n      }\n    }\n  }\n\n  return ancestors;\n}\n\n/**\n * Get all descendant nodes of a given node (flat array).\n *\n * @param snapshot - The root tree snapshot\n * @param nodeId - The ID of the node (if undefined, returns all descendants of root)\n * @returns Flat array of all descendant node snapshots\n */\nexport function getDescendants<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  nodeId?: string\n): readonly TreeNodeSnapshot<TNode>[] {\n  if (!snapshot) return [];\n\n  const startNode = nodeId ? findNodeById(snapshot, nodeId) : snapshot;\n  if (!startNode) return [];\n\n  const descendants: TreeNodeSnapshot<TNode>[] = [];\n\n  const collect = (node: TreeNodeSnapshot<TNode>) => {\n    for (const child of node.children) {\n      descendants.push(child as TreeNodeSnapshot<TNode>);\n      collect(child as TreeNodeSnapshot<TNode>);\n    }\n  };\n\n  collect(startNode);\n  return descendants;\n}\n\n/**\n * Get siblings of a node (nodes with the same parent).\n *\n * @param snapshot - The root tree snapshot\n * @param nodeId - The ID of the node\n * @param includeSelf - Whether to include the node itself (default: false)\n * @returns Array of sibling snapshots\n */\nexport function getSiblings<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  nodeId: string,\n  includeSelf: boolean = false\n): readonly TreeNodeSnapshot<TNode>[] {\n  if (!snapshot) return [];\n\n  const parentResult = getParent(snapshot, nodeId);\n\n  // If no parent, this is the root - root has no siblings\n  if (!parentResult) return [];\n\n  const siblings = parentResult.parent.children as readonly TreeNodeSnapshot<TNode>[];\n\n  if (includeSelf) {\n    return siblings;\n  }\n\n  return siblings.filter((s) => s.id !== nodeId);\n}\n\n// =============================================================================\n// Query Functions\n// =============================================================================\n\n/**\n * Find the first node matching a predicate.\n *\n * @param snapshot - The root tree snapshot\n * @param predicate - Function to test each node\n * @returns First matching node snapshot, or undefined\n */\nexport function findNode<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  predicate: (node: TreeNodeSnapshot<TNode>) => boolean\n): TreeNodeSnapshot<TNode> | undefined {\n  if (!snapshot) return undefined;\n\n  if (predicate(snapshot)) return snapshot;\n\n  for (const child of snapshot.children) {\n    const found = findNode(child as TreeNodeSnapshot<TNode>, predicate);\n    if (found) return found;\n  }\n\n  return undefined;\n}\n\n/**\n * Find all nodes matching a predicate.\n *\n * @param snapshot - The root tree snapshot\n * @param predicate - Function to test each node\n * @returns Array of matching node snapshots\n */\nexport function findNodes<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  predicate: (node: TreeNodeSnapshot<TNode>) => boolean\n): readonly TreeNodeSnapshot<TNode>[] {\n  if (!snapshot) return [];\n\n  const results: TreeNodeSnapshot<TNode>[] = [];\n\n  const search = (node: TreeNodeSnapshot<TNode>) => {\n    if (predicate(node)) {\n      results.push(node);\n    }\n    for (const child of node.children) {\n      search(child as TreeNodeSnapshot<TNode>);\n    }\n  };\n\n  search(snapshot);\n  return results;\n}\n\n/**\n * Get the depth of a specific node (0 = root).\n *\n * @param snapshot - The root tree snapshot\n * @param nodeId - The ID of the node\n * @returns The depth, or -1 if not found\n */\nexport function getNodeDepth<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  nodeId: string\n): number {\n  if (!snapshot) return -1;\n\n  const result = findNodeWithPath(snapshot, nodeId);\n  return result ? result.depth : -1;\n}\n\n/**\n * Check if one node is an ancestor of another.\n *\n * @param snapshot - The root tree snapshot\n * @param ancestorId - Potential ancestor node ID\n * @param descendantId - Potential descendant node ID\n * @returns true if ancestorId is an ancestor of descendantId\n */\nexport function isAncestorOf<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  ancestorId: string,\n  descendantId: string\n): boolean {\n  if (!snapshot) return false;\n\n  const result = findNodeWithPath(snapshot, descendantId);\n  if (!result) return false;\n\n  // Check if ancestorId is in the path (excluding the descendant itself)\n  return result.path.slice(0, -1).includes(ancestorId);\n}\n\n// =============================================================================\n// Traversal Functions\n// =============================================================================\n\n/**\n * Traverse the tree and call a visitor function for each node.\n * Return false from visitor to stop traversal.\n *\n * @param snapshot - The root tree snapshot\n * @param visitor - Function called for each node (return false to stop)\n * @param options - Traversal options (order: 'pre' | 'post')\n */\nexport function traverse<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  visitor: (node: TreeNodeSnapshot<TNode>, depth: number) => void | false,\n  options: TraverseOptions = {}\n): void {\n  if (!snapshot) return;\n\n  const { order = \"pre\" } = options;\n\n  const visit = (node: TreeNodeSnapshot<TNode>, depth: number): boolean => {\n    if (order === \"pre\") {\n      const result = visitor(node, depth);\n      if (result === false) return false;\n    }\n\n    for (const child of node.children) {\n      const shouldContinue = visit(child as TreeNodeSnapshot<TNode>, depth + 1);\n      if (!shouldContinue) return false;\n    }\n\n    if (order === \"post\") {\n      const result = visitor(node, depth);\n      if (result === false) return false;\n    }\n\n    return true;\n  };\n\n  visit(snapshot, 0);\n}\n\n/**\n * Flatten the tree into an array with parent information.\n *\n * @param snapshot - The root tree snapshot\n * @returns Array of { node, parentId, depth } objects\n */\nexport function flattenTree<TNode extends AnyTreeNodePrimitive>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined\n): readonly FlattenedNode<TNode>[] {\n  if (!snapshot) return [];\n\n  const result: FlattenedNode<TNode>[] = [];\n\n  const flatten = (\n    node: TreeNodeSnapshot<TNode>,\n    parentId: string | null,\n    depth: number\n  ) => {\n    result.push({ node, parentId, depth });\n\n    for (const child of node.children) {\n      flatten(child as TreeNodeSnapshot<TNode>, node.id, depth + 1);\n    }\n  };\n\n  flatten(snapshot, null, 0);\n  return result;\n}\n\n/**\n * Map over all nodes in the tree, transforming each node's data.\n * Preserves tree structure while transforming node content.\n *\n * @param snapshot - The root tree snapshot\n * @param mapper - Function to transform each node\n * @returns New tree structure with transformed nodes, or undefined\n */\nexport function mapTree<TNode extends AnyTreeNodePrimitive, R>(\n  snapshot: TreeNodeSnapshot<TNode> | undefined,\n  mapper: (node: TreeNodeSnapshot<TNode>, depth: number) => R\n): { value: R; children: ReturnType<typeof mapTree<TNode, R>>[] } | undefined {\n  if (!snapshot) return undefined;\n\n  const map = (\n    node: TreeNodeSnapshot<TNode>,\n    depth: number\n  ): { value: R; children: ReturnType<typeof mapTree<TNode, R>>[] } => {\n    const value = mapper(node, depth);\n    const children = node.children.map((child) =>\n      map(child as TreeNodeSnapshot<TNode>, depth + 1)\n    );\n    return { value, children };\n  };\n\n  return map(snapshot, 0);\n}\n\n// =============================================================================\n// Schema Functions (work with TreeNodePrimitive, not snapshots)\n// =============================================================================\n\n/**\n * Build a lookup map from node type strings to their TreeNodePrimitive definitions.\n * Useful for resolving snapshot node types back to their schema definitions.\n *\n * @param tree - The TreePrimitive to analyze\n * @returns Map from type string to TreeNodePrimitive\n *\n * @example\n * ```ts\n * const typeMap = buildNodeTypeMap(fileTree);\n * const folderPrimitive = typeMap.get(\"folder\"); // FolderNode\n * ```\n */\nexport function buildNodeTypeMap<TRoot extends AnyTreeNodePrimitive>(\n  tree: TreePrimitive<TRoot>\n): Map<string, AnyTreeNodePrimitive> {\n  const map = new Map<string, AnyTreeNodePrimitive>();\n  const visited = new Set<string>();\n\n  const visit = (node: AnyTreeNodePrimitive) => {\n    if (visited.has(node.type)) return;\n    visited.add(node.type);\n    map.set(node.type, node);\n\n    for (const child of node.children) {\n      visit(child);\n    }\n  };\n\n  visit(tree.root);\n  return map;\n}\n\n/**\n * Get the TreeNodePrimitive definition for a snapshot node.\n * Requires the tree schema to resolve the type string to its primitive.\n *\n * @param tree - The TreePrimitive schema\n * @param snapshot - The node snapshot to get the primitive for\n * @returns The TreeNodePrimitive, or undefined if not found\n *\n * @example\n * ```ts\n * const node = findNodeById(treeSnapshot, \"some-id\");\n * const primitive = getNodePrimitive(fileTree, node);\n * // primitive is FolderNode or FileNode depending on node.type\n * ```\n */\nexport function getNodePrimitive<TRoot extends AnyTreeNodePrimitive>(\n  tree: TreePrimitive<TRoot>,\n  snapshot: TreeNodeSnapshot<AnyTreeNodePrimitive>\n): AnyTreeNodePrimitive | undefined {\n  return getNodeTypeByName(tree, snapshot.type);\n}\n\n/**\n * Get the allowed child types for a snapshot node.\n * Combines schema lookup with the node's allowed children.\n *\n * @param tree - The TreePrimitive schema\n * @param snapshot - The node snapshot to get allowed children for\n * @returns Array of allowed child TreeNodePrimitives, or empty array if not found\n *\n * @example\n * ```ts\n * const node = findNodeById(treeSnapshot, \"folder-id\");\n * const allowedChildren = getAllowedChildTypesForNode(fileTree, node);\n * // Returns [FolderNode, FileNode] if the folder can contain both\n * ```\n */\nexport function getAllowedChildTypesForNode<TRoot extends AnyTreeNodePrimitive>(\n  tree: TreePrimitive<TRoot>,\n  snapshot: TreeNodeSnapshot<AnyTreeNodePrimitive>\n): readonly AnyTreeNodePrimitive[] {\n  const primitive = getNodePrimitive(tree, snapshot);\n  if (!primitive) return [];\n  return primitive.children;\n}\n\n/**\n * Check if a child type is allowed for a specific snapshot node.\n *\n * @param tree - The TreePrimitive schema\n * @param parentSnapshot - The parent node snapshot\n * @param childTypeName - The type string of the potential child\n * @returns true if the child type is allowed\n *\n * @example\n * ```ts\n * const folder = findNodeById(treeSnapshot, \"folder-id\");\n * canAddChildType(fileTree, folder, \"file\"); // true\n * canAddChildType(fileTree, folder, \"unknown\"); // false\n * ```\n */\nexport function canAddChildType<TRoot extends AnyTreeNodePrimitive>(\n  tree: TreePrimitive<TRoot>,\n  parentSnapshot: TreeNodeSnapshot<AnyTreeNodePrimitive>,\n  childTypeName: string\n): boolean {\n  const primitive = getNodePrimitive(tree, parentSnapshot);\n  if (!primitive) return false;\n  return primitive.isChildAllowed(childTypeName);\n}\n\n/**\n * Get all allowed child node types for a specific node type.\n *\n * @param nodeType - The TreeNodePrimitive to get children for\n * @returns Array of allowed child TreeNodePrimitives\n *\n * @example\n * ```ts\n * const FolderNode = TreeNode(\"folder\", { ... });\n * const FileNode = TreeNode(\"file\", { ... });\n *\n * // Get allowed children for FolderNode\n * const allowedChildren = getAllowedChildTypes(FolderNode);\n * // Returns [FolderNode, FileNode] if folder can contain both\n * ```\n */\nexport function getAllowedChildTypes<TNode extends AnyTreeNodePrimitive>(\n  nodeType: TNode\n): readonly AnyTreeNodePrimitive[] {\n  return nodeType.children;\n}\n\n/**\n * Get all unique node types reachable in a tree schema.\n * Recursively traverses the tree structure starting from the root.\n *\n * @param tree - The TreePrimitive to analyze\n * @returns Array of all unique TreeNodePrimitives in the tree schema\n *\n * @example\n * ```ts\n * const fileTree = Tree({ root: FolderNode });\n * const allNodeTypes = getAllNodeTypes(fileTree);\n * // Returns [FolderNode, FileNode] - all possible node types\n * ```\n */\nexport function getAllNodeTypes<TRoot extends AnyTreeNodePrimitive>(\n  tree: TreePrimitive<TRoot>\n): readonly AnyTreeNodePrimitive[] {\n  const visited = new Set<string>();\n  const result: AnyTreeNodePrimitive[] = [];\n\n  const visit = (node: AnyTreeNodePrimitive) => {\n    if (visited.has(node.type)) return;\n    visited.add(node.type);\n    result.push(node);\n\n    for (const child of node.children) {\n      visit(child);\n    }\n  };\n\n  visit(tree.root);\n  return result;\n}\n\n/**\n * Get the node type primitive by its type string from a tree schema.\n *\n * @param tree - The TreePrimitive to search\n * @param typeName - The type string to find (e.g., \"folder\", \"file\")\n * @returns The matching TreeNodePrimitive, or undefined if not found\n *\n * @example\n * ```ts\n * const fileTree = Tree({ root: FolderNode });\n * const folderType = getNodeTypeByName(fileTree, \"folder\");\n * // Returns FolderNode\n * ```\n */\nexport function getNodeTypeByName<TRoot extends AnyTreeNodePrimitive>(\n  tree: TreePrimitive<TRoot>,\n  typeName: string\n): AnyTreeNodePrimitive | undefined {\n  const allTypes = getAllNodeTypes(tree);\n  return allTypes.find((node) => node.type === typeName);\n}\n\n/**\n * Check if a child type is allowed under a parent type.\n *\n * @param parentType - The parent TreeNodePrimitive\n * @param childTypeName - The type string of the potential child\n * @returns true if the child type is allowed\n *\n * @example\n * ```ts\n * isChildTypeAllowed(FolderNode, \"file\"); // true if folder can contain files\n * isChildTypeAllowed(FileNode, \"folder\"); // false - files can't have children\n * ```\n */\nexport function isChildTypeAllowed(\n  parentType: AnyTreeNodePrimitive,\n  childTypeName: string\n): boolean {\n  return parentType.isChildAllowed(childTypeName);\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidhash/mimic",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "type": "module",
   "repository": {
     "type": "git",
@@ -31,7 +31,7 @@
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@voidhash/tsconfig": "0.0.2"
+    "@voidhash/tsconfig": "0.0.3"
   },
   "peerDependencies": {
     "effect": "^3.19.12"

package/tsdown.config.ts

@@ -9,7 +9,7 @@ export default defineConfig({
 		sourcemap: true,
 		tsconfig: "./tsconfig.build.json",
 	},
-	// unbundle: true,
+	unbundle: true,
 	format: ["cjs", "esm"],
 	outExtensions: (ctx) => ({
 		dts: ctx.format === "cjs" ? ".d.cts" : ".d.mts",