@voidhash/mimic 0.0.1-alpha.9 → 0.0.2

package/dist/index.cjs

@@ -2349,6 +2349,619 @@ var Primitive_exports = /* @__PURE__ */ require_Document.__export({
 //#region src/Transform.ts
 var Transform_exports = {};
 
+//#endregion
+//#region src/EffectSchema.ts
+/**
+* Effect.Schema utilities for converting Mimic primitives to Effect.Schema schemas.
+* 
+* @since 0.0.1
+*/
+var EffectSchema_exports = /* @__PURE__ */ require_Document.__export({
+	TreeNodeStateSchema: () => TreeNodeStateSchema,
+	toSetSchema: () => toSetSchema,
+	toUpdateSchema: () => toUpdateSchema
+});
+/**
+* Schema for a tree node state (flat storage format).
+*/
+const TreeNodeStateSchema = effect.Schema.Struct({
+	id: effect.Schema.String,
+	type: effect.Schema.String,
+	parentId: effect.Schema.NullOr(effect.Schema.String),
+	pos: effect.Schema.String,
+	data: effect.Schema.Unknown
+});
+/**
+* Check if a field is required for set operations.
+* A field is required if: TRequired is true AND THasDefault is false.
+* 
+* We determine this by checking the primitive's schema properties.
+*/
+function isRequiredForSet(primitive) {
+	const schema = primitive._schema;
+	if (!schema) return false;
+	return schema.required === true && schema.defaultValue === void 0;
+}
+/**
+* Get the base Effect.Schema for a primitive type (without optional wrapper).
+*/
+function getBaseSchema(primitive) {
+	switch (primitive._tag) {
+		case "StringPrimitive": return effect.Schema.String;
+		case "NumberPrimitive": return effect.Schema.Number;
+		case "BooleanPrimitive": return effect.Schema.Boolean;
+		case "LiteralPrimitive": {
+			var _schema$literal, _schema;
+			const literalPrimitive = primitive;
+			const literalValue = (_schema$literal = (_schema = literalPrimitive._schema) === null || _schema === void 0 ? void 0 : _schema.literal) !== null && _schema$literal !== void 0 ? _schema$literal : literalPrimitive.literal;
+			return effect.Schema.Literal(literalValue);
+		}
+		case "StructPrimitive": return buildStructSetSchema(primitive);
+		case "ArrayPrimitive": {
+			const elementSchema = buildElementSetSchema(primitive.element);
+			return effect.Schema.Array(elementSchema);
+		}
+		case "UnionPrimitive": return buildUnionSetSchema(primitive);
+		case "EitherPrimitive": return buildEitherSchema(primitive);
+		case "LazyPrimitive": {
+			var _resolve, _resolve2;
+			const lazyPrimitive = primitive;
+			return getBaseSchema((_resolve = (_resolve2 = lazyPrimitive._resolve) === null || _resolve2 === void 0 ? void 0 : _resolve2.call(lazyPrimitive)) !== null && _resolve !== void 0 ? _resolve : lazyPrimitive._thunk());
+		}
+		case "TreeNodePrimitive": return buildStructSetSchema(primitive.data);
+		case "TreePrimitive": return effect.Schema.Array(TreeNodeStateSchema);
+		default: return effect.Schema.Unknown;
+	}
+}
+/**
+* Build the set schema for a struct primitive.
+* Required fields (required=true, no default) are non-optional.
+* Other fields are wrapped with Schema.optional.
+*/
+function buildStructSetSchema(structPrimitive) {
+	const fields = structPrimitive.fields;
+	const schemaFields = {};
+	for (const key in fields) {
+		const fieldPrimitive = fields[key];
+		const baseSchema = getBaseSchema(fieldPrimitive);
+		if (isRequiredForSet(fieldPrimitive)) schemaFields[key] = baseSchema;
+		else schemaFields[key] = effect.Schema.optional(baseSchema);
+	}
+	return effect.Schema.Struct(schemaFields);
+}
+/**
+* Build the update schema for a struct primitive.
+* All fields are optional for partial updates.
+*/
+function buildStructUpdateSchema(structPrimitive) {
+	const fields = structPrimitive.fields;
+	const schemaFields = {};
+	for (const key in fields) {
+		const fieldPrimitive = fields[key];
+		let fieldSchema;
+		if (fieldPrimitive._tag === "StructPrimitive") fieldSchema = buildStructUpdateSchema(fieldPrimitive);
+		else fieldSchema = getBaseSchema(fieldPrimitive);
+		schemaFields[key] = effect.Schema.optional(fieldSchema);
+	}
+	return effect.Schema.Struct(schemaFields);
+}
+/**
+* Build the set schema for an array element.
+* For struct elements, uses the struct's set input schema.
+*/
+function buildElementSetSchema(elementPrimitive) {
+	if (elementPrimitive._tag === "StructPrimitive") return buildStructSetSchema(elementPrimitive);
+	return getBaseSchema(elementPrimitive);
+}
+/**
+* Build the set schema for a union primitive.
+* Creates a Schema.Union of all variant schemas.
+*/
+function buildUnionSetSchema(unionPrimitive) {
+	const variants = unionPrimitive.variants;
+	const variantSchemas = [];
+	for (const key in variants) {
+		const variantPrimitive = variants[key];
+		variantSchemas.push(buildStructSetSchema(variantPrimitive));
+	}
+	if (variantSchemas.length === 0) return effect.Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return effect.Schema.Union(...variantSchemas);
+}
+/**
+* Build the schema for an either primitive.
+* Creates a Schema.Union of all scalar variant types.
+*/
+function buildEitherSchema(eitherPrimitive) {
+	const variants = eitherPrimitive.variants;
+	const variantSchemas = [];
+	for (const variant of variants) variantSchemas.push(getBaseSchema(variant));
+	if (variantSchemas.length === 0) return effect.Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return effect.Schema.Union(...variantSchemas);
+}
+/**
+* Build the update schema for a union primitive.
+* Creates a Schema.Union of all variant update schemas.
+*/
+function buildUnionUpdateSchema(unionPrimitive) {
+	const variants = unionPrimitive.variants;
+	const variantSchemas = [];
+	for (const key in variants) {
+		const variantPrimitive = variants[key];
+		variantSchemas.push(buildStructUpdateSchema(variantPrimitive));
+	}
+	if (variantSchemas.length === 0) return effect.Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return effect.Schema.Union(...variantSchemas);
+}
+/**
+* Get the update schema for a primitive.
+* For structs, all fields are optional (partial updates).
+* For simple primitives, same as set schema.
+*/
+function getUpdateSchema(primitive) {
+	switch (primitive._tag) {
+		case "StructPrimitive": return buildStructUpdateSchema(primitive);
+		case "UnionPrimitive": return buildUnionUpdateSchema(primitive);
+		case "TreeNodePrimitive": return buildStructUpdateSchema(primitive.data);
+		case "LazyPrimitive": {
+			var _resolve3, _resolve4;
+			const lazyPrimitive = primitive;
+			return getUpdateSchema((_resolve3 = (_resolve4 = lazyPrimitive._resolve) === null || _resolve4 === void 0 ? void 0 : _resolve4.call(lazyPrimitive)) !== null && _resolve3 !== void 0 ? _resolve3 : lazyPrimitive._thunk());
+		}
+		default: return getBaseSchema(primitive);
+	}
+}
+function toSetSchema(primitive) {
+	return getBaseSchema(primitive);
+}
+function toUpdateSchema(primitive) {
+	return getUpdateSchema(primitive);
+}
+
+//#endregion
+//#region src/types/index.ts
+var types_exports = /* @__PURE__ */ require_Document.__export({
+	TreeNodePrimitive: () => TreeNodePrimitive,
+	TreeNodeSelf: () => TreeNodeSelf
+});
+
+//#endregion
+//#region src/utils/tree-helpers.ts
+var tree_helpers_exports = /* @__PURE__ */ require_Document.__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, 'Document', {
   enumerable: true,
@@ -2356,6 +2969,12 @@ Object.defineProperty(exports, 'Document', {
     return require_Document.Document_exports;
   }
 });
+Object.defineProperty(exports, 'EffectSchema', {
+  enumerable: true,
+  get: function () {
+    return EffectSchema_exports;
+  }
+});
 Object.defineProperty(exports, 'Operation', {
   enumerable: true,
   get: function () {
@@ -2397,4 +3016,16 @@ Object.defineProperty(exports, 'Transform', {
   get: function () {
     return Transform_exports;
   }
+});
+Object.defineProperty(exports, 'TreeHelpers', {
+  enumerable: true,
+  get: function () {
+    return tree_helpers_exports;
+  }
+});
+Object.defineProperty(exports, 'Types', {
+  enumerable: true,
+  get: function () {
+    return types_exports;
+  }
 });