dirvi-lib 0.7.1 → 0.8.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export * from './tree-surfer-ui/application/user-input-to-intent.js';
 export * from './tree-surfer-ui/application/intent-to-effect.js';
 export * from './tree-surfer-ui/domain/effect.js';
-export * from './tree-surfer-ui/domain/input-state.js';
+export * from './tree-surfer-ui/domain/input-mode-state.js';
 export * from './tree-surfer-ui/domain/intent.js';
 export * from './tree-surfer-ui/domain/user-input.js';
 export * from './tree-surfer/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sDAAsD,CAAC;AACrE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AAEtD,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sDAAsD,CAAC;AACrE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mCAAmC,CAAC;AAClD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AAEtD,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,7 +1,7 @@
 export * from './tree-surfer-ui/application/user-input-to-intent.js';
 export * from './tree-surfer-ui/application/intent-to-effect.js';
 export * from './tree-surfer-ui/domain/effect.js';
-export * from './tree-surfer-ui/domain/input-state.js';
+export * from './tree-surfer-ui/domain/input-mode-state.js';
 export * from './tree-surfer-ui/domain/intent.js';
 export * from './tree-surfer-ui/domain/user-input.js';
 export * from './tree-surfer/index.js';

package/dist/tree-surfer/cursor.d.ts

@@ -1,32 +1,58 @@
 import { z } from 'zod';
-export declare const CursorKind: {
-    readonly Entry: "entry";
-    readonly Fold: "fold";
-};
-export type CursorKind = (typeof CursorKind)[keyof typeof CursorKind];
-export type CursorEntry<Id> = {
-    kind: typeof CursorKind.Entry;
-    parentPath: readonly Id[];
-    entryId: Id;
-};
-export type CursorFold<Id> = {
-    kind: typeof CursorKind.Fold;
-    parentPath: readonly Id[];
-};
-export type Cursor<Id> = CursorEntry<Id> | CursorFold<Id>;
-export declare function createCursorSchema<IdSchema extends z.ZodTypeAny>(idSchema: IdSchema): z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"entry">;
-    parentPath: z.ZodArray<IdSchema>;
-    entryId: IdSchema;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"fold">;
-    parentPath: z.ZodArray<IdSchema>;
-}, z.core.$strip>], "kind">;
+/**
+ * A root-relative path identifying the current tree position.
+ *
+ * The empty path identifies the tree root. A non-empty path identifies a
+ * descendant by following child IDs from the root.
+ *
+ * For example, given:
+ *
+ * ```
+ * root
+ * └── src
+ *     └── main.ts
+ * ```
+ *
+ * the cursors are:
+ *
+ * ```ts
+ * []                    // root
+ * ['src']               // src
+ * ['src', 'main.ts']    // main.ts
+ * ```
+ *
+ * @typeParam Id - The type of node IDs.
+ */
+export type Cursor<Id> = readonly Id[];
+/**
+ * Creates a schema for root-relative tree cursors.
+ *
+ * The schema validates the IDs in the path, but does not verify that the path
+ * exists in a particular tree.
+ */
+export declare function createCursorSchema<IdSchema extends z.ZodTypeAny>(idSchema: IdSchema): z.ZodArray<IdSchema>;
+/**
+ * Operations for comparing and inspecting root-relative tree cursors.
+ *
+ * @typeParam Id - The type of node IDs.
+ */
 export type CursorApi<Id> = {
-    isEntry(cursor: Cursor<Id>): cursor is CursorEntry<Id>;
-    isFold(cursor: Cursor<Id>): cursor is CursorFold<Id>;
+    /**
+     * Tests whether two cursors identify the same tree position.
+     */
     equal(left: Cursor<Id>, right: Cursor<Id>): boolean;
-    getPath(cursor: Cursor<Id>): Id[] | undefined;
+    /**
+     * Returns a mutable copy of the cursor path.
+     *
+     * The empty path identifies the tree root.
+     */
+    getPath(cursor: Cursor<Id>): Id[];
+    /**
+     * Tests whether the cursor is within the subtree at `entryPath`.
+     *
+     * The subtree includes the node at `entryPath` itself. Therefore, equal
+     * paths return `true`, and an empty `entryPath` contains every cursor.
+     */
     cursorBelongsToSubtree(cursor: Cursor<Id>, entryPath: readonly Id[]): boolean;
 };
 export declare function createCursorApi<Id>(): CursorApi<Id>;

package/dist/tree-surfer/cursor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;CAGb,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEtE,MAAM,MAAM,WAAW,CAAC,EAAE,IAAI;IAC5B,IAAI,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAC9B,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;IAC1B,OAAO,EAAE,EAAE,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,UAAU,CAAC,EAAE,IAAI;IAC3B,IAAI,EAAE,OAAO,UAAU,CAAC,IAAI,CAAC;IAC7B,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,EAAE,IAAI,WAAW,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC;AAE1D,wBAAgB,kBAAkB,CAAC,QAAQ,SAAS,CAAC,CAAC,UAAU,EAC9D,QAAQ,EAAE,QAAQ;;;;;;;4BAgBnB;AAED,MAAM,MAAM,SAAS,CAAC,EAAE,IAAI;IAC1B,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;IAEvD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IAErD,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAEpD,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,GAAG,SAAS,CAAC;IAE9C,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC;CAC/E,CAAC;AAEF,wBAAgB,eAAe,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC,CA0CnD"}
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,MAAM,CAAC,EAAE,IAAI,SAAS,EAAE,EAAE,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,SAAS,CAAC,CAAC,UAAU,EAC9D,QAAQ,EAAE,QAAQ,wBAGnB;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,EAAE,IAAI;IAC1B;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAEpD;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC;IAElC;;;;;OAKG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC;CAC/E,CAAC;AAEF,wBAAgB,eAAe,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC,CAcnD"}

package/dist/tree-surfer/cursor.js

@@ -1,57 +1,29 @@
 import { z } from 'zod';
-export const CursorKind = {
-    Entry: 'entry',
-    Fold: 'fold',
-};
+/**
+ * Creates a schema for root-relative tree cursors.
+ *
+ * The schema validates the IDs in the path, but does not verify that the path
+ * exists in a particular tree.
+ */
 export function createCursorSchema(idSchema) {
-    const parentPathSchema = z.array(idSchema);
-    return z.discriminatedUnion('kind', [
-        z.object({
-            kind: z.literal(CursorKind.Entry),
-            parentPath: parentPathSchema,
-            entryId: idSchema,
-        }),
-        z.object({
-            kind: z.literal(CursorKind.Fold),
-            parentPath: parentPathSchema,
-        }),
-    ]);
+    return z.array(idSchema);
 }
 export function createCursorApi() {
-    const cursorApi = {
-        isEntry(cursor) {
-            return cursor.kind === CursorKind.Entry;
-        },
-        isFold(cursor) {
-            return cursor.kind === CursorKind.Fold;
-        },
+    return {
         equal(left, right) {
-            if (!idPathEqual(left.parentPath, right.parentPath)) {
-                return false;
-            }
-            if (cursorApi.isFold(left)) {
-                return cursorApi.isFold(right);
-            }
-            return cursorApi.isEntry(right) && left.entryId === right.entryId;
+            return idPathEqual(left, right);
         },
         getPath(cursor) {
-            if (cursorApi.isFold(cursor)) {
-                return undefined;
-            }
-            return [...cursor.parentPath, cursor.entryId];
+            return [...cursor];
         },
         cursorBelongsToSubtree(cursor, entryPath) {
-            if (cursorApi.isFold(cursor)) {
-                return isStrictPathPrefix(entryPath, cursor.parentPath);
-            }
-            const cursorPath = [...cursor.parentPath, cursor.entryId];
-            return isStrictPathPrefix(entryPath, cursorPath);
+            return isPathPrefix(entryPath, cursor);
         },
     };
-    return cursorApi;
 }
 /**
- * Returns true when both paths contain the same IDs in the same order.
+ * Returns true when both root-relative paths contain the same IDs in the same
+ * order.
  */
 function idPathEqual(left, right) {
     if (left.length !== right.length) {
@@ -65,10 +37,13 @@ function idPathEqual(left, right) {
     return true;
 }
 /**
- * Returns true when `prefix` is a strict prefix of `path`.
+ * Returns true when `prefix` is a prefix of `path`.
+ *
+ * Equal paths are included. An empty prefix is therefore a prefix of every
+ * path.
  */
-function isStrictPathPrefix(prefix, path) {
-    if (prefix.length >= path.length) {
+function isPathPrefix(prefix, path) {
+    if (prefix.length > path.length) {
         return false;
     }
     for (let index = 0; index < prefix.length; index += 1) {

package/dist/tree-surfer/fold-node/fold-node.arb.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fold-node.arb.d.ts.map

package/dist/tree-surfer/fold-node/fold-node.arb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold-node.arb.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.arb.ts"],"names":[],"mappings":""}

package/dist/tree-surfer/fold-node/fold-node.arb.js

@@ -0,0 +1 @@
+export {};

package/dist/tree-surfer/fold-node/fold-node.impl.d.ts

@@ -1,5 +1,4 @@
-import { FoldNode, FoldNodeApi, FoldNodeService } from './fold-node.types.js';
-import { SerializableKey } from '../tree-node/tree-node.types.js';
-export declare function createFoldNodeApi<Id extends SerializableKey>(): FoldNodeApi<Id>;
-export declare function createFoldNodeService<Id extends SerializableKey>(foldNodeApi: FoldNodeApi<Id>, createChild: (id: Id) => FoldNode<Id>): FoldNodeService<Id>;
+import type { FoldNodeApi, FoldNodeService } from './fold-node.types.js';
+import type { SerializableKey } from '../tree-node/tree-node.types.js';
+export declare function createFoldNodeService<Id extends SerializableKey>(foldNodeApi: FoldNodeApi<Id>): FoldNodeService<Id>;
 //# sourceMappingURL=fold-node.impl.d.ts.map

package/dist/tree-surfer/fold-node/fold-node.impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.impl.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EACR,WAAW,EAEX,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,KACvB,WAAW,CAAC,EAAE,CAAC,CAiCnB;AAED,wBAAgB,qBAAqB,CAAC,EAAE,SAAS,eAAe,EAC9D,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC,EAC5B,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,QAAQ,CAAC,EAAE,CAAC,GACpC,eAAe,CAAC,EAAE,CAAC,CAiLrB"}
+{"version":3,"file":"fold-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,WAAW,EACX,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAgBvE,wBAAgB,qBAAqB,CAAC,EAAE,SAAS,eAAe,EAC9D,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC,GAC3B,eAAe,CAAC,EAAE,CAAC,CAwNrB"}

package/dist/tree-surfer/fold-node/fold-node.impl.js

@@ -1,110 +1,109 @@
-import { createTreeNodeApi } from '../tree-node/tree-node.impl.js';
-export function createFoldNodeApi() {
-    const treeNodeApi = createTreeNodeApi();
-    return {
-        getChildren(node) {
-            return node.children;
-        },
-        getChildById(node, id) {
-            return node.children.find((child) => child.id === id);
-        },
-        getAtPath(rootNode, path, selector) {
-            return treeNodeApi.getAtPath(rootNode.children, path, selector);
-        },
-        modifyAtPath(rootNode, path, modifier) {
-            const children = treeNodeApi.modifyAtPath(rootNode.children, path, modifier);
-            if (children === undefined) {
-                return undefined;
-            }
-            return {
-                ...rootNode,
-                children,
-            };
-        },
-    };
+function getFoldedChildById(node, id) {
+    return node.foldedChildren.find((child) => child.id === id);
+}
+function hasFoldedChildWithId(node, id) {
+    return getFoldedChildById(node, id) !== undefined;
 }
-export function createFoldNodeService(foldNodeApi, createChild) {
+export function createFoldNodeService(foldNodeApi) {
+    function createEmptyNode(id) {
+        return {
+            id,
+            children: [],
+            foldedChildren: [],
+        };
+    }
     return {
-        createEmptyRoot() {
-            return {
-                children: [],
-                folds: new Set(),
-            };
-        },
+        createEmptyNode,
         getIfEntryFoldedAtPath(rootNode, path, entryId) {
-            if (path.length === 0) {
-                return rootNode.folds.has(entryId);
-            }
             const node = foldNodeApi.getAtPath(rootNode, path, (candidate) => candidate);
-            return node !== undefined && node.folds.has(entryId);
+            return node !== undefined && hasFoldedChildWithId(node, entryId);
+        },
+        foldedEntriesAtPath(rootNode, path) {
+            const node = foldNodeApi.getAtPath(rootNode, path, (candidate) => candidate);
+            return node?.foldedChildren.map((child) => child.id);
         },
         addFoldedEntryAtPath(rootNode, path, entryId) {
-            const ensuredRoot = ensurePath(rootNode, path);
-            if (path.length === 0) {
-                return addFoldedEntry(ensuredRoot, entryId);
+            const rootWithPath = ensurePath(rootNode, path);
+            if (rootWithPath === undefined) {
+                return undefined;
             }
-            return foldNodeApi.modifyAtPath(ensuredRoot, path, (node) => addFoldedEntry(node, entryId));
+            return foldNodeApi.modifyAtPath(rootWithPath, path, (node) => addFoldedEntry(node, entryId));
         },
         removeFoldedEntryAtPath(rootNode, path, entryId) {
-            if (path.length === 0) {
-                return removeFoldedEntry(rootNode, entryId);
-            }
             return foldNodeApi.modifyAtPath(rootNode, path, (node) => removeFoldedEntry(node, entryId));
         },
         clearFoldedEntriesAtPath(rootNode, path) {
-            if (path.length === 0) {
-                return clearFoldedEntries(rootNode);
-            }
-            return foldNodeApi.modifyAtPath(rootNode, path, clearFoldedEntries);
+            return foldNodeApi.modifyAtPath(rootNode, path, (node) => clearFoldedEntries(node));
         },
     };
-    // Helpers:
-    // `Node extends FoldNodeRoot<Id> | FoldNode<Id>` is used to create two
-    // versions of functions: one for the root and one for the children.
-    // "Flat" functions
+    // Node-local operations.
     //
-    // Adds entry name to the given node.
+    // These functions update only the selected node. Path traversal and immutable
+    // ancestor updates are handled by FoldNodeApi.
     function addFoldedEntry(node, entryId) {
-        if (node.folds.has(entryId)) {
+        const existingFoldedChild = getFoldedChildById(node, entryId);
+        if (existingFoldedChild !== undefined) {
             return node;
         }
-        const folds = new Set(node.folds);
-        folds.add(entryId);
+        const childIndex = node.children.findIndex((child) => child.id === entryId);
+        const child = childIndex === -1 ? createEmptyNode(entryId) : node.children[childIndex];
+        const children = childIndex === -1
+            ? node.children
+            : node.children.filter((_, index) => index !== childIndex);
         return {
             ...node,
-            folds,
+            children,
+            foldedChildren: [...node.foldedChildren, child],
         };
     }
     function removeFoldedEntry(node, entryId) {
-        if (!node.folds.has(entryId)) {
+        const foldedChildIndex = node.foldedChildren.findIndex((child) => child.id === entryId);
+        if (foldedChildIndex === -1) {
             return node;
         }
-        const folds = new Set(node.folds);
-        folds.delete(entryId);
+        const foldedChild = node.foldedChildren[foldedChildIndex];
+        const foldedChildren = node.foldedChildren.filter((_, index) => index !== foldedChildIndex);
+        const hasNestedFoldState = foldedChild.children.length > 0 || foldedChild.foldedChildren.length > 0;
         return {
             ...node,
-            folds,
+            children: hasNestedFoldState
+                ? [...node.children, foldedChild]
+                : node.children,
+            foldedChildren,
         };
     }
     function clearFoldedEntries(node) {
-        if (node.folds.size === 0) {
+        if (node.foldedChildren.length === 0) {
             return node;
         }
+        const children = [...node.children];
+        for (const foldedChild of node.foldedChildren) {
+            const hasNestedFoldState = foldedChild.children.length > 0 ||
+                foldedChild.foldedChildren.length > 0;
+            if (hasNestedFoldState) {
+                children.push(foldedChild);
+            }
+        }
         return {
             ...node,
-            folds: new Set(),
+            children,
+            foldedChildren: [],
         };
     }
     /**
      * Ensures that the requested path exists in the fold-state tree.
      *
-     * This creates fold nodes only; it does not modify the buffer tree.
+     * The path is relative to `rootNode`; an empty path selects the root.
+     * This creates fold nodes only and does not modify the buffer tree.
      */
     function ensurePath(rootNode, path) {
         if (path.length === 0) {
             return rootNode;
         }
-        const children = ensureChildPath(rootNode.children, path, 0);
+        const children = ensureChildPath(rootNode, path, 0);
+        if (children === undefined) {
+            return undefined;
+        }
         if (children === rootNode.children) {
             return rootNode;
         }
@@ -113,16 +112,23 @@ export function createFoldNodeService(foldNodeApi, createChild) {
             children,
         };
     }
-    function ensureChildPath(children, path, pathIndex) {
+    function ensureChildPath(parent, path, pathIndex) {
         const id = path[pathIndex];
         if (id === undefined) {
-            return children;
+            return parent.children;
         }
+        if (hasFoldedChildWithId(parent, id)) {
+            return undefined;
+        }
+        const children = parent.children;
         const childIndex = children.findIndex((child) => child.id === id);
-        const child = childIndex === -1 ? createChild(id) : children[childIndex];
+        const child = childIndex === -1 ? createEmptyNode(id) : children[childIndex];
         let updatedChild = child;
         if (pathIndex < path.length - 1) {
-            const updatedChildren = ensureChildPath(child.children, path, pathIndex + 1);
+            const updatedChildren = ensureChildPath(child, path, pathIndex + 1);
+            if (updatedChildren === undefined) {
+                return undefined;
+            }
             if (updatedChildren !== child.children) {
                 updatedChild = {
                     ...child,

package/dist/tree-surfer/fold-node/fold-node.schema.d.ts

@@ -1,8 +1,5 @@
 import { z } from 'zod';
-import type { FoldNode, FoldNodeRoot } from './fold-node.types.js';
+import type { FoldNode } from './fold-node.types.js';
 import { SerializableKey } from '../tree-node/tree-node.types.js';
-export declare function createFoldNodeSchemas<Id extends SerializableKey>(idSchema: z.ZodType<Id>): {
-    foldNodeSchema: z.ZodType<FoldNode<Id>, unknown, z.core.$ZodTypeInternals<FoldNode<Id>, unknown>>;
-    foldNodeRootSchema: z.ZodType<FoldNodeRoot<Id>, unknown, z.core.$ZodTypeInternals<FoldNodeRoot<Id>, unknown>>;
-};
+export declare function createFoldNodeSchemas<Id extends SerializableKey>(idSchema: z.ZodType<Id>): z.ZodType<FoldNode<Id>>;
 //# sourceMappingURL=fold-node.schema.d.ts.map

package/dist/tree-surfer/fold-node/fold-node.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold-node.schema.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,wBAAgB,qBAAqB,CAAC,EAAE,SAAS,eAAe,EAC9D,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;;;EAsBxB"}
+{"version":3,"file":"fold-node.schema.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,wBAAgB,qBAAqB,CAAC,EAAE,SAAS,eAAe,EAC9D,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,GACtB,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAYzB"}

package/dist/tree-surfer/fold-node/fold-node.schema.js

@@ -3,14 +3,7 @@ export function createFoldNodeSchemas(idSchema) {
     const foldNodeSchema = z.lazy(() => z.object({
         id: idSchema,
         children: z.array(foldNodeSchema),
-        folds: z.array(idSchema).transform((ids) => new Set(ids)),
+        foldedChildren: z.array(foldNodeSchema),
     }));
-    const foldNodeRootSchema = z.object({
-        children: z.array(foldNodeSchema),
-        folds: z.array(idSchema).transform((ids) => new Set(ids)),
-    });
-    return {
-        foldNodeSchema,
-        foldNodeRootSchema,
-    };
+    return foldNodeSchema;
 }