@voidhash/mimic 0.0.2 → 0.0.3

package/dist/index.d.cts

@@ -1,419 +1,12 @@
-import { $ as InferState, A as InferLazyProxy, B as ArraySnapshot, C as TreeNodeSelfType, D as InferUnionSnapshot, E as ScalarPrimitive, F as ArrayElementSetInput, G as StructProxy, H as ArrayUpdateInput, I as ArrayEntry, J as AnyPrimitive, K as StructSetInput, L as ArrayEntrySnapshot, M as InferLazySnapshot, N as InferLazyState, O as InferUnionState, P as InferLazyUpdateInput, Q as InferSnapshot, R as ArrayProxy, S as TreeNodeSelf, T as InferEitherState, U as InferStructSnapshot, V as ArrayState, W as InferStructState, X as InferProxy, Y as HasDefault, Z as InferSetInput, _ as InferTreeNodeDataState, _t as OperationPath_d_exports, a as TreeNodeSnapshot, at as Optional, b as TreeNodeConfig, c as TreePrimitive, ct as Validator, d as TreeState, dt as ProxyEnvironment_d_exports, et as InferUpdateInput, f as TreeUpdateInput, g as InferTreeNodeChildren, gt as Operation_d_exports, h as AnyTreeNodePrimitive, ht as Operation, i as TreeNodeProxyBase, it as NeedsValue, j as InferLazySetInput, k as UnionVariants, l as TreeProxy, m as TypedTreeNodeState, mt as Transaction_d_exports, n as InferTreeSnapshot, nt as IsRequired, o as TreeNodeState, ot as Primitive, p as TypedNodeProxy, pt as Transaction, q as StructUpdateValue, r as TreeNodeDataSetInput, rt as MaybeUndefined, s as TreeNodeUpdateValue, st as PrimitiveInternal, t as Primitive_d_exports, tt as IsDefined, u as TreeSetInput, ut as Transform_d_exports, v as InferTreeNodeType, vt as __export, w as InferEitherSnapshot, x as TreeNodePrimitive, y as TreeNodeChildrenInput, z as ArraySetInput } from "./Primitive-awpEjnKL.cjs";
-import { i as Presence_d_exports } from "./Presence-DKKP4v5X.cjs";
-import { Schema } from "effect";
-
-//#region src/Document.d.ts
-declare namespace Document_d_exports {
-  export { Document, DocumentOptions, NestedTransactionError, OperationError, make };
-}
-/**
- * Error thrown when attempting to start a nested transaction.
- */
-declare class NestedTransactionError extends Error {
-  readonly _tag = "NestedTransactionError";
-  constructor();
-}
-/**
- * Error thrown when an operation fails to apply.
- */
-declare class OperationError extends Error {
-  readonly _tag = "OperationError";
-  constructor(message: string);
-}
-/**
- * A Document manages state for a primitive-based schema with transaction support.
- */
-interface Document<TSchema extends AnyPrimitive> {
-  /** The schema defining this document's structure */
-  readonly schema: TSchema;
-  /** Root proxy for accessing and modifying document data */
-  readonly root: InferProxy<TSchema>;
-  /** Returns the current document state */
-  get(): InferState<TSchema> | undefined;
-  /**
-   * Returns a readonly snapshot of the entire document state for rendering.
-   * The snapshot is a type-safe, readonly structure where:
-   * - Required fields and fields with defaults are guaranteed to be defined
-   * - Optional fields may be undefined
-   */
-  toSnapshot(): InferSnapshot<TSchema>;
-  /**
-   * Runs a function within a transaction.
-   * All operations are collected and applied atomically.
-   * If the function throws, all changes are rolled back.
-   * @returns The return value of the function
-   */
-  transaction<R>(fn: (root: InferProxy<TSchema>) => R): R;
-  /**
-   * Applies external operations (e.g., from server/peers) to the document.
-   * These operations are NOT added to pending operations.
-   */
-  apply(ops: ReadonlyArray<Operation<any, any, any>>): void;
-  /**
-   * Returns pending local operations as a Transaction and clears the buffer.
-   */
-  flush(): Transaction;
-}
-interface DocumentOptions<TSchema extends AnyPrimitive> {
-  /** Initial state for the document */
-  readonly initial?: InferState<TSchema>;
-}
-/**
- * Creates a new Document for the given schema.
- */
-declare const make: <TSchema extends AnyPrimitive>(schema: TSchema, options?: DocumentOptions<TSchema>) => Document<TSchema>;
-declare namespace EffectSchema_d_exports {
-  export { ToSetSchema, ToTreeNodeSetSchema, ToTreeNodeUpdateSchema, ToUpdateSchema, TreeNodeStateSchema, toSetSchema, toUpdateSchema };
-}
-/**
- * Infer the Effect.Schema type for a primitive's set input.
- */
-type ToSetSchema<T extends AnyPrimitive> = Schema.Schema<InferSetInput<T>>;
-/**
- * Infer the Effect.Schema type for a primitive's update input.
- */
-type ToUpdateSchema<T extends AnyPrimitive> = Schema.Schema<InferUpdateInput<T>>;
-/**
- * Type for TreeNode set schema - uses the node's data set input type
- */
-type ToTreeNodeSetSchema<T extends AnyTreeNodePrimitive> = Schema.Schema<InferSetInput<T["data"]>>;
-/**
- * Type for TreeNode update schema - uses the node's data update input type
- */
-type ToTreeNodeUpdateSchema<T extends AnyTreeNodePrimitive> = Schema.Schema<InferUpdateInput<T["data"]>>;
-/**
- * Schema for a tree node state (flat storage format).
- */
-declare const TreeNodeStateSchema: Schema.Struct<{
-  id: typeof Schema.String;
-  type: typeof Schema.String;
-  parentId: Schema.NullOr<typeof Schema.String>;
-  pos: typeof Schema.String;
-  data: typeof Schema.Unknown;
-}>;
-/**
- * Convert a Mimic primitive to an Effect.Schema for set operations.
- *
- * The resulting schema:
- * - For structs: required fields (required=true, no default) are non-optional, others are optional
- * - For arrays: uses the element's set schema
- * - For unions: creates a Schema.Union of variant schemas
- * - For TreeNode: delegates to the node's data struct schema
- * - For Tree: returns Schema.Array of TreeNodeState
- *
- * @example
- * ```typescript
- * const UserSchema = Primitive.Struct({
- *   name: Primitive.String().required(),
- *   age: Primitive.Number().default(0),
- *   email: Primitive.String(),
- * });
- *
- * const SetSchema = toSetSchema(UserSchema);
- * // { name: string, age?: number, email?: string }
- * ```
- */
-declare function toSetSchema<T extends AnyPrimitive>(primitive: T): ToSetSchema<T>;
-declare function toSetSchema<T extends AnyTreeNodePrimitive>(primitive: T): ToTreeNodeSetSchema<T>;
-/**
- * Convert a Mimic primitive to an Effect.Schema for update operations.
- *
- * The resulting schema:
- * - For structs: all fields are optional (partial updates)
- * - For unions: all variant fields are optional
- * - For TreeNode: delegates to the node's data struct update schema
- * - For simple primitives: same as set schema
- *
- * @example
- * ```typescript
- * const UserSchema = Primitive.Struct({
- *   name: Primitive.String().required(),
- *   age: Primitive.Number().default(0),
- *   email: Primitive.String(),
- * });
- *
- * const UpdateSchema = toUpdateSchema(UserSchema);
- * // { name?: string, age?: string, email?: string }
- * ```
- */
-declare function toUpdateSchema<T extends AnyPrimitive>(primitive: T): ToUpdateSchema<T>;
-declare function toUpdateSchema<T extends AnyTreeNodePrimitive>(primitive: T): ToTreeNodeUpdateSchema<T>;
-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 };
-}
-declare namespace tree_helpers_d_exports {
-  export { FlattenedNode, NodeSearchResult, ParentSearchResult, TraverseOptions, buildNodeTypeMap, canAddChildType, findNode, findNodeById, findNodeWithPath, findNodes, flattenTree, getAllNodeTypes, getAllowedChildTypes, getAllowedChildTypesForNode, getAncestors, getDescendants, getNodeDepth, getNodePrimitive, getNodeTypeByName, getParent, getSiblings, getSubtree, isAncestorOf, isChildTypeAllowed, mapTree, traverse };
-}
-/**
- * Result of finding a node with path information.
- */
-interface NodeSearchResult<TNode extends AnyTreeNodePrimitive> {
-  readonly node: TreeNodeSnapshot<TNode>;
-  readonly path: readonly string[];
-  readonly depth: number;
-}
-/**
- * Result of finding a parent node.
- */
-interface ParentSearchResult<TNode extends AnyTreeNodePrimitive> {
-  readonly parent: TreeNodeSnapshot<TNode>;
-  readonly childIndex: number;
-}
-/**
- * Flattened node with parent information.
- */
-interface FlattenedNode<TNode extends AnyTreeNodePrimitive> {
-  readonly node: TreeNodeSnapshot<TNode>;
-  readonly parentId: string | null;
-  readonly depth: number;
-}
-/**
- * Options for tree traversal.
- */
-interface TraverseOptions {
-  readonly order?: "pre" | "post";
-}
-/**
- * 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
- */
-declare function findNodeById<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, id: string): TreeNodeSnapshot<TNode> | undefined;
-/**
- * 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
- */
-declare function findNodeWithPath<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, id: string): NodeSearchResult<TNode> | undefined;
-/**
- * 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
- */
-declare function getParent<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, nodeId: string): ParentSearchResult<TNode> | undefined;
-/**
- * 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
- */
-declare function getSubtree<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, nodeId: string): TreeNodeSnapshot<TNode> | undefined;
-/**
- * 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
- */
-declare function getAncestors<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, nodeId: string): readonly TreeNodeSnapshot<TNode>[];
-/**
- * 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
- */
-declare function getDescendants<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, nodeId?: string): readonly TreeNodeSnapshot<TNode>[];
-/**
- * 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
- */
-declare function getSiblings<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, nodeId: string, includeSelf?: boolean): readonly TreeNodeSnapshot<TNode>[];
-/**
- * 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
- */
-declare function findNode<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, predicate: (node: TreeNodeSnapshot<TNode>) => boolean): TreeNodeSnapshot<TNode> | undefined;
-/**
- * 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
- */
-declare function findNodes<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, predicate: (node: TreeNodeSnapshot<TNode>) => boolean): readonly TreeNodeSnapshot<TNode>[];
-/**
- * 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
- */
-declare function getNodeDepth<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, nodeId: string): number;
-/**
- * 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
- */
-declare function isAncestorOf<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, ancestorId: string, descendantId: string): boolean;
-/**
- * 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')
- */
-declare function traverse<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined, visitor: (node: TreeNodeSnapshot<TNode>, depth: number) => void | false, options?: TraverseOptions): void;
-/**
- * Flatten the tree into an array with parent information.
- *
- * @param snapshot - The root tree snapshot
- * @returns Array of { node, parentId, depth } objects
- */
-declare function flattenTree<TNode extends AnyTreeNodePrimitive>(snapshot: TreeNodeSnapshot<TNode> | undefined): readonly FlattenedNode<TNode>[];
-/**
- * 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
- */
-declare function mapTree<TNode extends AnyTreeNodePrimitive, R>(snapshot: TreeNodeSnapshot<TNode> | undefined, mapper: (node: TreeNodeSnapshot<TNode>, depth: number) => R): {
-  value: R;
-  children: ReturnType<typeof mapTree<TNode, R>>[];
-} | undefined;
-/**
- * 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
- * ```
- */
-declare function buildNodeTypeMap<TRoot extends AnyTreeNodePrimitive>(tree: TreePrimitive<TRoot>): Map<string, AnyTreeNodePrimitive>;
-/**
- * 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
- * ```
- */
-declare function getNodePrimitive<TRoot extends AnyTreeNodePrimitive>(tree: TreePrimitive<TRoot>, snapshot: TreeNodeSnapshot<AnyTreeNodePrimitive>): AnyTreeNodePrimitive | undefined;
-/**
- * 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
- * ```
- */
-declare function getAllowedChildTypesForNode<TRoot extends AnyTreeNodePrimitive>(tree: TreePrimitive<TRoot>, snapshot: TreeNodeSnapshot<AnyTreeNodePrimitive>): readonly AnyTreeNodePrimitive[];
-/**
- * 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
- * ```
- */
-declare function canAddChildType<TRoot extends AnyTreeNodePrimitive>(tree: TreePrimitive<TRoot>, parentSnapshot: TreeNodeSnapshot<AnyTreeNodePrimitive>, childTypeName: string): boolean;
-/**
- * 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
- * ```
- */
-declare function getAllowedChildTypes<TNode extends AnyTreeNodePrimitive>(nodeType: TNode): readonly AnyTreeNodePrimitive[];
-/**
- * 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
- * ```
- */
-declare function getAllNodeTypes<TRoot extends AnyTreeNodePrimitive>(tree: TreePrimitive<TRoot>): readonly AnyTreeNodePrimitive[];
-/**
- * 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
- * ```
- */
-declare function getNodeTypeByName<TRoot extends AnyTreeNodePrimitive>(tree: TreePrimitive<TRoot>, typeName: string): AnyTreeNodePrimitive | undefined;
-/**
- * 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
- * ```
- */
-declare function isChildTypeAllowed(parentType: AnyTreeNodePrimitive, childTypeName: string): boolean;
-//#endregion
-export { Document_d_exports as Document, EffectSchema_d_exports as EffectSchema, Operation_d_exports as Operation, OperationPath_d_exports as OperationPath, Presence_d_exports as Presence, type Primitive_d_exports as Primitive, ProxyEnvironment_d_exports as ProxyEnvironment, Transaction_d_exports as Transaction, Transform_d_exports as Transform, tree_helpers_d_exports as TreeHelpers, index_d_exports as Types };
-//# sourceMappingURL=index.d.cts.map
+import { Presence_d_exports } from "./Presence.cjs";
+import { OperationPath_d_exports } from "./OperationPath.cjs";
+import { Operation_d_exports } from "./Operation.cjs";
+import { Transaction_d_exports } from "./Transaction.cjs";
+import { ProxyEnvironment_d_exports } from "./ProxyEnvironment.cjs";
+import { Transform_d_exports } from "./Transform.cjs";
+import { Primitive_d_exports } from "./Primitive.cjs";
+import { Document_d_exports } from "./Document.cjs";
+import { EffectSchema_d_exports } from "./EffectSchema.cjs";
+import { index_d_exports } from "./types/index.cjs";
+import { tree_helpers_d_exports } from "./utils/tree-helpers.cjs";
+export { Document_d_exports as Document, EffectSchema_d_exports as EffectSchema, Operation_d_exports as Operation, OperationPath_d_exports as OperationPath, Presence_d_exports as Presence, Primitive_d_exports as Primitive, ProxyEnvironment_d_exports as ProxyEnvironment, Transaction_d_exports as Transaction, Transform_d_exports as Transform, tree_helpers_d_exports as TreeHelpers, index_d_exports as Types };