@voidhash/mimic 0.0.1 → 0.0.3

package/dist/types/index.cjs

@@ -0,0 +1,16 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_TreeNode = require('../primitives/TreeNode.cjs');
+
+//#region src/types/index.ts
+var types_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	TreeNodePrimitive: () => require_TreeNode.TreeNodePrimitive,
+	TreeNodeSelf: () => require_TreeNode.TreeNodeSelf
+});
+
+//#endregion
+Object.defineProperty(exports, 'types_exports', {
+  enumerable: true,
+  get: function () {
+    return types_exports;
+  }
+});

package/dist/types/index.d.cts

@@ -0,0 +1,16 @@
+import { AnyPrimitive, HasDefault, InferProxy, InferSetInput, InferSnapshot, InferState, InferUpdateInput, IsDefined, IsRequired, MaybeUndefined, NeedsValue, Optional, Primitive, PrimitiveInternal, Validator } from "../primitives/shared.cjs";
+import { InferStructSnapshot, InferStructState, StructProxy, StructSetInput, StructUpdateValue } from "../primitives/Struct.cjs";
+import { ArrayElementSetInput, ArrayEntry, ArrayEntrySnapshot, ArrayProxy, ArraySetInput, ArraySnapshot, ArrayState, ArrayUpdateInput } from "../primitives/Array.cjs";
+import { InferLazyProxy, InferLazySetInput, InferLazySnapshot, InferLazyState, InferLazyUpdateInput } from "../primitives/Lazy.cjs";
+import { InferUnionSnapshot, InferUnionState, UnionVariants } from "../primitives/Union.cjs";
+import { InferEitherSnapshot, InferEitherState, ScalarPrimitive } from "../primitives/Either.cjs";
+import { AnyTreeNodePrimitive, InferTreeNodeChildren, InferTreeNodeDataState, InferTreeNodeType, TreeNodeChildrenInput, TreeNodeConfig, TreeNodePrimitive, TreeNodeSelf, TreeNodeSelfType } from "../primitives/TreeNode.cjs";
+import { InferTreeSnapshot, TreeNodeDataSetInput, TreeNodeProxyBase, TreeNodeSnapshot, TreeNodeState, TreeNodeUpdateValue, TreeProxy, TreeSetInput, TreeState, TreeUpdateInput, TypedNodeProxy, TypedTreeNodeState } from "../primitives/Tree.cjs";
+
+//#region src/types/index.d.ts
+declare namespace index_d_exports {
+  export { AnyPrimitive, AnyTreeNodePrimitive, ArrayElementSetInput, ArrayEntry, ArrayEntrySnapshot, ArrayProxy, ArraySetInput, ArraySnapshot, ArrayState, ArrayUpdateInput, HasDefault, InferEitherSnapshot, InferEitherState, InferLazyProxy, InferLazySetInput, InferLazySnapshot, InferLazyState, InferLazyUpdateInput, InferProxy, InferSetInput, InferSnapshot, InferState, InferStructSnapshot, InferStructState, InferTreeNodeChildren, InferTreeNodeDataState, InferTreeNodeType, InferTreeSnapshot, InferUnionSnapshot, InferUnionState, InferUpdateInput, IsDefined, IsRequired, MaybeUndefined, NeedsValue, Optional, Primitive, PrimitiveInternal, ScalarPrimitive, StructProxy, StructSetInput, StructUpdateValue, TreeNodeChildrenInput, TreeNodeConfig, TreeNodeDataSetInput, TreeNodePrimitive, TreeNodeProxyBase, TreeNodeSelf, TreeNodeSelfType, TreeNodeSnapshot, TreeNodeState, TreeNodeUpdateValue, TreeProxy, TreeSetInput, TreeState, TreeUpdateInput, TypedNodeProxy, TypedTreeNodeState, UnionVariants, Validator };
+}
+//#endregion
+export { index_d_exports };
+//# sourceMappingURL=index.d.cts.map

package/dist/types/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":""}

package/dist/types/index.d.mts

@@ -0,0 +1,16 @@
+import { AnyPrimitive, HasDefault, InferProxy, InferSetInput, InferSnapshot, InferState, InferUpdateInput, IsDefined, IsRequired, MaybeUndefined, NeedsValue, Optional, Primitive, PrimitiveInternal, Validator } from "../primitives/shared.mjs";
+import { InferStructSnapshot, InferStructState, StructProxy, StructSetInput, StructUpdateValue } from "../primitives/Struct.mjs";
+import { ArrayElementSetInput, ArrayEntry, ArrayEntrySnapshot, ArrayProxy, ArraySetInput, ArraySnapshot, ArrayState, ArrayUpdateInput } from "../primitives/Array.mjs";
+import { InferLazyProxy, InferLazySetInput, InferLazySnapshot, InferLazyState, InferLazyUpdateInput } from "../primitives/Lazy.mjs";
+import { InferUnionSnapshot, InferUnionState, UnionVariants } from "../primitives/Union.mjs";
+import { InferEitherSnapshot, InferEitherState, ScalarPrimitive } from "../primitives/Either.mjs";
+import { AnyTreeNodePrimitive, InferTreeNodeChildren, InferTreeNodeDataState, InferTreeNodeType, TreeNodeChildrenInput, TreeNodeConfig, TreeNodePrimitive, TreeNodeSelf, TreeNodeSelfType } from "../primitives/TreeNode.mjs";
+import { InferTreeSnapshot, TreeNodeDataSetInput, TreeNodeProxyBase, TreeNodeSnapshot, TreeNodeState, TreeNodeUpdateValue, TreeProxy, TreeSetInput, TreeState, TreeUpdateInput, TypedNodeProxy, TypedTreeNodeState } from "../primitives/Tree.mjs";
+
+//#region src/types/index.d.ts
+declare namespace index_d_exports {
+  export { AnyPrimitive, AnyTreeNodePrimitive, ArrayElementSetInput, ArrayEntry, ArrayEntrySnapshot, ArrayProxy, ArraySetInput, ArraySnapshot, ArrayState, ArrayUpdateInput, HasDefault, InferEitherSnapshot, InferEitherState, InferLazyProxy, InferLazySetInput, InferLazySnapshot, InferLazyState, InferLazyUpdateInput, InferProxy, InferSetInput, InferSnapshot, InferState, InferStructSnapshot, InferStructState, InferTreeNodeChildren, InferTreeNodeDataState, InferTreeNodeType, InferTreeSnapshot, InferUnionSnapshot, InferUnionState, InferUpdateInput, IsDefined, IsRequired, MaybeUndefined, NeedsValue, Optional, Primitive, PrimitiveInternal, ScalarPrimitive, StructProxy, StructSetInput, StructUpdateValue, TreeNodeChildrenInput, TreeNodeConfig, TreeNodeDataSetInput, TreeNodePrimitive, TreeNodeProxyBase, TreeNodeSelf, TreeNodeSelfType, TreeNodeSnapshot, TreeNodeState, TreeNodeUpdateValue, TreeProxy, TreeSetInput, TreeState, TreeUpdateInput, TypedNodeProxy, TypedTreeNodeState, UnionVariants, Validator };
+}
+//#endregion
+export { index_d_exports };
+//# sourceMappingURL=index.d.mts.map

package/dist/types/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":""}

package/dist/types/index.mjs

@@ -0,0 +1,12 @@
+import { __export } from "../_virtual/rolldown_runtime.mjs";
+import { TreeNodePrimitive, TreeNodeSelf } from "../primitives/TreeNode.mjs";
+
+//#region src/types/index.ts
+var types_exports = /* @__PURE__ */ __export({
+	TreeNodePrimitive: () => TreeNodePrimitive,
+	TreeNodeSelf: () => TreeNodeSelf
+});
+
+//#endregion
+export { types_exports };
+//# sourceMappingURL=index.mjs.map

package/dist/types/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":["/**\n * Consolidated type inference utilities for all primitives.\n *\n * This module re-exports all inference types from a single location\n * for convenient access across the mimic package.\n *\n * @since 0.0.1\n */\n\n// =============================================================================\n// Core Inference Types (from shared.ts)\n// =============================================================================\n\nexport type {\n  // Core primitive types\n  Primitive,\n  AnyPrimitive,\n  PrimitiveInternal,\n\n  // State and proxy inference\n  InferState,\n  InferProxy,\n\n  // Input inference\n  InferSetInput,\n  InferUpdateInput,\n\n  // Snapshot inference\n  InferSnapshot,\n\n  // Required/default status inference\n  HasDefault,\n  IsDefined,\n  IsRequired,\n\n  // Utility types\n  MaybeUndefined,\n  NeedsValue,\n  Optional,\n\n  // Validator type\n  Validator,\n} from \"../primitives/shared.js\";\n\n// =============================================================================\n// Struct Inference Types\n// =============================================================================\n\nexport type {\n  InferStructState,\n  InferStructSnapshot,\n  StructSetInput,\n  StructUpdateValue,\n  StructProxy,\n} from \"../primitives/Struct.js\";\n\n// =============================================================================\n// Array Inference Types\n// =============================================================================\n\nexport type {\n  ArrayState,\n  ArraySnapshot,\n  ArrayEntrySnapshot,\n  ArrayEntry,\n  ArraySetInput,\n  ArrayUpdateInput,\n  ArrayElementSetInput,\n  ArrayProxy,\n} from \"../primitives/Array.js\";\n\n// =============================================================================\n// Tree Inference Types\n// =============================================================================\n\nexport type {\n  TreeState,\n  TreeNodeState,\n  TypedTreeNodeState,\n  TreeNodeSnapshot,\n  InferTreeSnapshot,\n  TreeSetInput,\n  TreeUpdateInput,\n  TreeNodeUpdateValue,\n  TreeNodeDataSetInput,\n  TreeProxy,\n  TypedNodeProxy,\n  TreeNodeProxyBase,\n} from \"../primitives/Tree.js\";\n\n// =============================================================================\n// TreeNode Inference Types\n// =============================================================================\n\nexport type {\n  AnyTreeNodePrimitive,\n  InferTreeNodeDataState,\n  InferTreeNodeType,\n  InferTreeNodeChildren,\n  TreeNodeSelfType,\n  TreeNodeConfig,\n  TreeNodeChildrenInput,\n} from \"../primitives/TreeNode.js\";\n\nexport { TreeNodePrimitive, TreeNodeSelf } from \"../primitives/TreeNode.js\";\n\n// =============================================================================\n// Union Inference Types\n// =============================================================================\n\nexport type {\n  InferUnionState,\n  InferUnionSnapshot,\n  UnionVariants,\n} from \"../primitives/Union.js\";\n\n// =============================================================================\n// Either Inference Types\n// =============================================================================\n\nexport type {\n  InferEitherState,\n  InferEitherSnapshot,\n  ScalarPrimitive,\n} from \"../primitives/Either.js\";\n\n// =============================================================================\n// Lazy Inference Types\n// =============================================================================\n\nexport type {\n  InferLazyState,\n  InferLazyProxy,\n  InferLazySnapshot,\n  InferLazySetInput,\n  InferLazyUpdateInput,\n} from \"../primitives/Lazy.js\";\n"],"mappings":""}

package/dist/utils/tree-helpers.cjs

@@ -0,0 +1,443 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+
+//#region src/utils/tree-helpers.ts
+var tree_helpers_exports = /* @__PURE__ */ require_rolldown_runtime.__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
+Object.defineProperty(exports, 'tree_helpers_exports', {
+  enumerable: true,
+  get: function () {
+    return tree_helpers_exports;
+  }
+});