dirvi-lib 0.7.0 → 0.8.0

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

@@ -1,33 +1,98 @@
 import * as fc from 'fast-check';
 import type { TreeNode } from './tree-node.types.js';
-type Id = string;
-export declare const idArb: fc.Arbitrary<string>;
-export type StringNode = TreeNode<Id, StringNode>;
-type PathEntry = {
-    path: string[];
+/**
+ * The ID type used by the generated test trees.
+ *
+ * Short strings keep generated counterexamples readable.
+ */
+type TestNodeId = string;
+/**
+ * Generates valid string IDs for test nodes. Note that the API just does
+ * comparisons on the IDs so we can safely restrict to any subset.
+ */
+export declare const testIdArb: fc.Arbitrary<string>;
+/**
+ * Tree node whose IDs are strings, without additional domain properties.
+ */
+export type StringNode = TreeNode<TestNodeId, StringNode>;
+type Path = TestNodeId[];
+type NodeAtPath = {
+    path: Path;
     node: StringNode;
 };
-type GeneratedNode = {
+type NodeWithReachableNodes = {
     node: StringNode;
-    pathEntries: PathEntry[];
+    reachableNodes: NodeAtPath[];
 };
-export declare const generatedNodeArb: fc.Arbitrary<GeneratedNode>;
-export declare const generatedNodesArrayArb: fc.Arbitrary<GeneratedNode[]>;
-export declare const forestAndPathsArb: fc.Arbitrary<{
-    entries: any[];
-    pathEntries: PathEntry[];
+/**
+ * Generates a leaf node.
+ */
+export declare const generatedLeafNodeArb: fc.Arbitrary<NodeWithReachableNodes>;
+/**
+ * Generates a closed branch.
+ */
+export declare const generatedClosedBranchNodeArb: fc.Arbitrary<NodeWithReachableNodes>;
+/**
+ * Generates a leaf, an open branch, or a closed branch.
+ *
+ * Open branches have unique child IDs. Root IDs are made unique separately
+ * when generating a forest.
+ *
+ * The weighted choice gives recursive open branches a geometric dropoff.
+ */
+export declare const generatedNodeArb: fc.Arbitrary<NodeWithReachableNodes>;
+/**
+ * Generates an array of generated nodes with unique sibling IDs.
+ *
+ * The result is suitable for use as the loaded children of an open branch.
+ */
+export declare const generatedNodesArrayArb: fc.Arbitrary<NodeWithReachableNodes[]>;
+/**
+ * An array of root-level nodes and all paths that can be resolved through
+ * those nodes.
+ *
+ * Paths through closed branches stop at the closed branch because its
+ * descendants are not loaded.
+ */
+export declare const nodeAndPathsArb: fc.Arbitrary<{
+    root: any;
+    pathEntries: NodeAtPath[];
 }>;
-export declare const forestAndPathAndExpectedArb: fc.Arbitrary<{
-    entries: any[];
-    path: string[];
+/**
+ * Generates root-level nodes and a path to one of their reachable nodes.
+ *
+ * Every generated path is valid for `getAtPath`; unreachable paths are not
+ * included.
+ */
+export declare const nodeAndPathAndExpectedArb: fc.Arbitrary<{
+    root: any;
+    path: Path;
     expected: any;
 }>;
+/**
+ * Generates root-level nodes and a path to one of their branch nodes.
+ *
+ * Both open and closed branches are included. A path to a closed branch is
+ * valid, but a path through a closed branch cannot reach any descendants.
+ */
 export declare const nodesArrayAndBranchPathArb: fc.Arbitrary<{
-    entries: any[];
-    path: string[];
+    root: any;
+    path: Path;
     expected: any;
 }>;
+/**
+ * Generates a new array of loaded child nodes.
+ *
+ * The generated nodes have unique IDs, making the result suitable for use as
+ * the children of an open branch.
+ */
 export declare const newBranchesArb: fc.Arbitrary<any[]>;
+/**
+ * Generates either a new array of loaded child nodes or `null`.
+ *
+ * An array represents an open branch, including an open branch with no
+ * children. `null` represents a closed branch.
+ */
 export declare const newBranchesOrNullArb: fc.Arbitrary<any[] | null>;
 export {};
 //# sourceMappingURL=tree-node.arb.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tree-node.arb.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.arb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,KAAK,EAAE,GAAG,MAAM,CAAC;AAEjB,eAAO,MAAM,KAAK,sBAGhB,CAAC;AAGH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC,CAAC;AAElD,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,SAAS,EAAE,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC,SAAS,CAAC,aAAa,CA8DnD,CAAC;AAEP,eAAO,MAAM,sBAAsB,+BAIjC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;EAK7B,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;EAQrC,CAAC;AAEJ,eAAO,MAAM,0BAA0B;;;;EAYpC,CAAC;AAEJ,eAAO,MAAM,cAAc,qBAE1B,CAAC;AAEF,eAAO,MAAM,oBAAoB,4BAA8C,CAAC"}
+{"version":3,"file":"tree-node.arb.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.arb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;GAIG;AACH,KAAK,UAAU,GAAG,MAAM,CAAC;AASzB;;;GAGG;AACH,eAAO,MAAM,SAAS,sBAIpB,CAAC;AAEH;;GAEG;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAC1D,KAAK,IAAI,GAAG,UAAU,EAAE,CAAC;AAEzB,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,UAAU,EAAE,CAAC;CAC9B,CAAC;AAqEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,sCAEhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B,sCAExC,CAAC;AAaF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC,SAAS,CAAC,sBAAsB,CA0C5D,CAAC;AAEP;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,wCAIjC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;EAK3B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;;EAQnC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;EAYpC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,cAAc,qBAE1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,4BAGhC,CAAC"}

package/dist/tree-surfer/tree-node/tree-node.arb.debug.test.d.ts

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

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

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

package/dist/tree-surfer/tree-node/tree-node.arb.debug.test.js

@@ -0,0 +1,34 @@
+import { describe, it } from 'vitest';
+import * as fc from 'fast-check';
+import { generatedNodeArb, generatedNodesArrayArb, } from './tree-node.arb.js';
+/**
+ * Used for looking at the tree distributions generated by the arbs.
+ */
+describe('print generated tree node arbitraries', () => {
+    it.only('generated nodes', () => {
+        const samples = fc.sample(generatedNodeArb, {
+            numRuns: 10,
+            seed: 12345,
+        });
+        for (const [index, generated] of samples.entries()) {
+            console.log(`\n--- node ${index + 1} ---`);
+            console.dir(generated.node, {
+                depth: Infinity,
+                colors: false,
+            });
+        }
+    });
+    it.only('generated root-level node arrays', () => {
+        const samples = fc.sample(generatedNodesArrayArb, {
+            numRuns: 5,
+            seed: 12345,
+        });
+        for (const [index, generatedNodes] of samples.entries()) {
+            console.log(`\n--- root array ${index + 1} ---`);
+            console.dir(generatedNodes.map(({ node }) => node), {
+                depth: Infinity,
+                colors: false,
+            });
+        }
+    });
+});

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

@@ -1,80 +1,188 @@
 import * as fc from 'fast-check';
-export const idArb = fc.string({
+/**
+ * Characters used by readable generated node IDs.
+ */
+const smallLetterCharacters = Array.from('abcdefghijklmnopqrstuvwxyz');
+/**
+ * Generates valid string IDs for test nodes. Note that the API just does
+ * comparisons on the IDs so we can safely restrict to any subset.
+ */
+export const testIdArb = fc.string({
+    unit: fc.constantFrom(...smallLetterCharacters),
     minLength: 1,
     maxLength: 8,
 });
-export const generatedNodeArb = fc.letrec((tie) => ({
-    node: fc.oneof(idArb.map((id) => {
-        const node = { id: id };
-        return {
-            node,
-            pathEntries: [
-                {
-                    path: [id],
-                    node,
-                },
-            ],
-        };
-    }), fc
-        .tuple(idArb, fc.oneof(fc.constant(null), fc.uniqueArray(tie('node'), {
+/**
+ * Generates the metadata for a leaf node.
+ *
+ * @param id - The ID assigned to the leaf.
+ * @returns The leaf and the path that resolves to it.
+ */
+const generatedLeafNodeWithReachableNodes = (id) => {
+    const node = { id };
+    return {
+        node,
+        reachableNodes: [{ path: [], node }],
+    };
+};
+/**
+ * Generates the metadata for a closed branch.
+ *
+ * A closed branch contributes no descendant paths because its children are not
+ * loaded.
+ *
+ * @param id - The ID assigned to the branch.
+ * @returns The closed branch and the path that resolves to it.
+ */
+const generatedClosedBranchWithReachableNodes = (id) => {
+    const node = {
+        id,
+        children: null,
+    };
+    return {
+        node,
+        reachableNodes: [{ path: [], node }],
+    };
+};
+/**
+ * Generates the metadata for an open branch and its descendants.
+ *
+ * @param id - The ID assigned to the branch.
+ * @param children - The generated children of the branch.
+ * @returns The open branch and paths to the branch and all its descendants.
+ */
+const generatedOpenBranchWithReachableNodes = (id, children) => {
+    const node = {
+        id,
+        children: children.map(({ node }) => node),
+    };
+    const descendantNodes = children.flatMap(({ node: child, reachableNodes }) => reachableNodes.map(({ path, node }) => ({
+        path: [child.id, ...path],
+        node,
+    })));
+    return {
+        node,
+        reachableNodes: [{ path: [], node }, ...descendantNodes],
+    };
+};
+/**
+ * Generates a leaf node.
+ */
+export const generatedLeafNodeArb = testIdArb.map(generatedLeafNodeWithReachableNodes);
+/**
+ * Generates a closed branch.
+ */
+export const generatedClosedBranchNodeArb = testIdArb.map(generatedClosedBranchWithReachableNodes);
+/**
+ * Generates a leaf or a closed branch.
+ *
+ * These node types terminate a generated path because they have no reachable
+ * descendants.
+ */
+const generatedTerminalNodeArb = fc.oneof(generatedLeafNodeArb, generatedClosedBranchNodeArb);
+/**
+ * Generates a leaf, an open branch, or a closed branch.
+ *
+ * Open branches have unique child IDs. Root IDs are made unique separately
+ * when generating a forest.
+ *
+ * The weighted choice gives recursive open branches a geometric dropoff.
+ */
+export const generatedNodeArb = fc.letrec((tie) => {
+    const generatedChildNodeArb = tie('node');
+    /**
+     * Generates the loaded children of an open branch.
+     *
+     * Sibling IDs must be unique so that child lookup is unambiguous. The
+     * maximum length also limits the branching factor of recursive examples.
+     */
+    const generatedOpenChildrenArb = fc.uniqueArray(generatedChildNodeArb, {
         minLength: 0,
+        maxLength: 4,
         size: 'medium',
-        // @ts-ignore
-        selector: (generated) => generated.node.id,
-    })))
-        .map(([id, children]) => {
-        const node = {
-            id,
-            children: 
-            // @ts-ignore
-            children === null ? null : children.map((child) => child.node),
-        };
-        const descendantPathEntries = children === null
-            ? []
-            : children.flatMap((child) => 
-            // @ts-ignore
-            child.pathEntries.map(({ path, node }) => ({
-                path: [id, ...path],
-                node,
-            })));
-        return {
-            node,
-            pathEntries: [
-                {
-                    path: [id],
-                    node,
-                },
-                ...descendantPathEntries,
-            ],
-        };
-    })),
-})).node;
+        selector: ({ node }) => node.id,
+    });
+    /**
+     * Generates an open branch and its reachable descendants.
+     */
+    const generatedOpenBranchNodeArb = fc
+        .tuple(testIdArb, generatedOpenChildrenArb)
+        .map(([id, children]) => generatedOpenBranchWithReachableNodes(id, children));
+    return {
+        node: fc
+            .integer({
+            min: 0,
+            max: 9999,
+        })
+            .chain((choice) => 
+        // 5046 works for getAtPath tests, but too heavy for modifyAtPath tests
+        choice >= 5050
+            ? generatedOpenBranchNodeArb
+            : generatedTerminalNodeArb),
+    };
+}).node;
+/**
+ * Generates an array of generated nodes with unique sibling IDs.
+ *
+ * The result is suitable for use as the loaded children of an open branch.
+ */
 export const generatedNodesArrayArb = fc.uniqueArray(generatedNodeArb, {
     minLength: 0,
     size: 'small',
     selector: (generated) => generated.node.id,
 });
-export const forestAndPathsArb = generatedNodesArrayArb.map((generatedNodes) => ({
-    entries: generatedNodes.map((generated) => generated.node),
-    pathEntries: generatedNodes.flatMap((generated) => generated.pathEntries),
+/**
+ * An array of root-level nodes and all paths that can be resolved through
+ * those nodes.
+ *
+ * Paths through closed branches stop at the closed branch because its
+ * descendants are not loaded.
+ */
+export const nodeAndPathsArb = generatedNodeArb.map(({ node: root, reachableNodes }) => ({
+    root,
+    pathEntries: reachableNodes,
 }));
-export const forestAndPathAndExpectedArb = forestAndPathsArb
+/**
+ * Generates root-level nodes and a path to one of their reachable nodes.
+ *
+ * Every generated path is valid for `getAtPath`; unreachable paths are not
+ * included.
+ */
+export const nodeAndPathAndExpectedArb = nodeAndPathsArb
     .filter(({ pathEntries }) => pathEntries.length > 0)
-    .chain(({ entries, pathEntries }) => fc.constantFrom(...pathEntries).map(({ path, node }) => ({
-    entries,
+    .chain(({ root, pathEntries }) => fc.constantFrom(...pathEntries).map(({ path, node }) => ({
+    root,
     path,
     expected: node,
 })));
-export const nodesArrayAndBranchPathArb = forestAndPathsArb
-    .map(({ entries, pathEntries }) => ({
-    entries,
+/**
+ * Generates root-level nodes and a path to one of their branch nodes.
+ *
+ * Both open and closed branches are included. A path to a closed branch is
+ * valid, but a path through a closed branch cannot reach any descendants.
+ */
+export const nodesArrayAndBranchPathArb = nodeAndPathsArb
+    .map(({ root, pathEntries }) => ({
+    root,
     branchPathEntries: pathEntries.filter(({ node }) => 'children' in node),
 }))
     .filter(({ branchPathEntries }) => branchPathEntries.length > 0)
-    .chain(({ entries, branchPathEntries }) => fc.constantFrom(...branchPathEntries).map(({ path, node }) => ({
-    entries,
+    .chain(({ root, branchPathEntries }) => fc.constantFrom(...branchPathEntries).map(({ path, node }) => ({
+    root,
     path,
     expected: node,
 })));
+/**
+ * Generates a new array of loaded child nodes.
+ *
+ * The generated nodes have unique IDs, making the result suitable for use as
+ * the children of an open branch.
+ */
 export const newBranchesArb = generatedNodesArrayArb.map((generatedNodes) => generatedNodes.map(({ node }) => node));
+/**
+ * Generates either a new array of loaded child nodes or `null`.
+ *
+ * An array represents an open branch, including an open branch with no
+ * children. `null` represents a closed branch.
+ */
 export const newBranchesOrNullArb = fc.oneof(newBranchesArb, fc.constant(null));

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

@@ -10,5 +10,5 @@ import type { SerializableKey, TreeNode, TreeNodeApi } from './tree-node.types.j
  * Node IDs are compared using JavaScript value equality. Sibling IDs
  * should be unique.
  */
-export declare function createTreeNodeApi<Id extends SerializableKey, ChildNode extends TreeNode<Id, ChildNode>>(): TreeNodeApi<Id, ChildNode>;
+export declare function createTreeNodeApi<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(): TreeNodeApi<Id, Node>;
 //# sourceMappingURL=tree-node.impl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tree-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,eAAe,EACf,QAAQ,EACR,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,SAAS,SAAS,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC,KACtC,WAAW,CAAC,EAAE,EAAE,SAAS,CAAC,CA0G9B"}
+{"version":3,"file":"tree-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,eAAe,EACf,QAAQ,EACR,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,KAC5B,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAqGzB"}

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

@@ -11,7 +11,6 @@
  */
 export function createTreeNodeApi() {
     const treeNodeApi = {
-        // Type Narrowers:
         isLeaf(node) {
             return !('children' in node);
         },
@@ -30,60 +29,54 @@ export function createTreeNodeApi() {
         getChildById(node, id) {
             return node.children.find((child) => child.id === id);
         },
-        getAtPath(entries, path, selector) {
-            if (path.length === 0) {
-                return undefined;
-            }
-            // Accumulator
-            let node = entries.find((candidate) => candidate.id === path[0]);
-            for (let index = 1; node !== undefined && index < path.length; index += 1) {
-                if (treeNodeApi.isOpenBranch(node)) {
-                    node = treeNodeApi.getChildById(node, path[index]);
+        getAtPath(root, path, selector) {
+            let node = root;
+            for (const id of path) {
+                if (!treeNodeApi.isBranch(node) || !treeNodeApi.isOpenBranch(node)) {
+                    return undefined;
                 }
-                else {
-                    node = undefined;
+                const child = treeNodeApi.getChildById(node, id);
+                if (child === undefined) {
+                    return undefined;
                 }
+                node = child;
             }
-            return node === undefined ? undefined : selector(node);
+            return selector(node);
         },
-        modifyAtPath(entries, path, modifier) {
+        modifyAtPath(root, path, modifier) {
             if (path.length === 0) {
-                return undefined;
+                return modifier(root);
             }
-            // Only cloned arrays/nodes are modified below.
-            const updatedEntries = [...entries];
-            let currentEntries = updatedEntries;
-            for (let index = 0; index < path.length; index += 1) {
-                const id = path[index];
-                const childIndex = currentEntries.findIndex((candidate) => candidate.id === id);
-                if (childIndex === -1) {
-                    return undefined;
-                }
-                const child = currentEntries[childIndex];
-                if (index === path.length - 1) {
-                    const replacement = modifier(child);
-                    if (replacement === undefined) {
-                        return undefined;
-                    }
-                    currentEntries[childIndex] = replacement;
-                    return updatedEntries;
-                }
-                if (!treeNodeApi.isBranch(child) || !treeNodeApi.isOpenBranch(child)) {
-                    // The path cannot continue through a leaf or closed branch.
-                    return undefined;
-                }
-                // Clone the child array before modifying it.
-                const updatedChildren = [...treeNodeApi.getChildren(child)];
-                // Clone the ancestor node and attach the cloned child array.
-                currentEntries[childIndex] = {
-                    ...child,
-                    children: updatedChildren,
-                };
-                // Continue traversal through the cloned children.
-                currentEntries = updatedChildren;
-            }
-            return undefined;
+            return modifyChildAtPath(root, path, modifier);
         },
     };
+    function modifyChildAtPath(node, path, modifier) {
+        const childId = path[0];
+        if (childId === undefined ||
+            !treeNodeApi.isBranch(node) ||
+            !treeNodeApi.isOpenBranch(node)) {
+            return undefined;
+        }
+        const childIndex = node.children.findIndex((child) => child.id === childId);
+        if (childIndex === -1) {
+            return undefined;
+        }
+        const child = node.children[childIndex];
+        if (child === undefined) {
+            return undefined;
+        }
+        const updatedChild = path.length === 1
+            ? modifier(child)
+            : modifyChildAtPath(child, path.slice(1), modifier);
+        if (updatedChild === undefined) {
+            return undefined;
+        }
+        const children = [...node.children];
+        children[childIndex] = updatedChild;
+        return {
+            ...node,
+            children,
+        };
+    }
     return treeNodeApi;
 }

package/dist/tree-surfer/tree-node/tree-node.schemas.d.ts

@@ -16,7 +16,7 @@ export declare const serializableKeySchema: z.ZodUnion<readonly [z.ZodString, z.
  *
  * The concrete application can extend these schemas with additional fields.
  */
-export declare function createTreeNodeSchemas<Id extends SerializableKey, ChildNode extends TreeNode<Id, ChildNode>>(idSchema: z.ZodType<Id>, childSchema: z.ZodType<ChildNode>): {
+export declare function createTreeNodeSchemas<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(idSchema: z.ZodType<Id>, nodeSchema: z.ZodType<Node>): {
     leafSchema: z.ZodObject<{
         id: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
     }, z.core.$strip>;
@@ -26,7 +26,7 @@ export declare function createTreeNodeSchemas<Id extends SerializableKey, ChildN
     }, z.core.$strip>;
     openBranchSchema: z.ZodObject<{
         id: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
-        children: z.ZodArray<z.ZodType<ChildNode, unknown, z.core.$ZodTypeInternals<ChildNode, unknown>>>;
+        children: z.ZodArray<z.ZodType<Node, unknown, z.core.$ZodTypeInternals<Node, unknown>>>;
     }, z.core.$strip>;
 };
 //# sourceMappingURL=tree-node.schemas.d.ts.map

package/dist/tree-surfer/tree-node/tree-node.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree-node.schemas.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEjE;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,iDAA6C,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,SAAS,eAAe,EAC1B,SAAS,SAAS,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC,EACzC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;;;;;;;;;;;;EAoB3D"}
+{"version":3,"file":"tree-node.schemas.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEjE;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,iDAA6C,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;EAoBrD"}

package/dist/tree-surfer/tree-node/tree-node.schemas.js

@@ -15,7 +15,7 @@ export const serializableKeySchema = z.union([z.string(), z.number().finite()]);
  *
  * The concrete application can extend these schemas with additional fields.
  */
-export function createTreeNodeSchemas(idSchema, childSchema) {
+export function createTreeNodeSchemas(idSchema, nodeSchema) {
     const leafSchema = z.object({
         id: idSchema,
     });
@@ -25,7 +25,7 @@ export function createTreeNodeSchemas(idSchema, childSchema) {
     });
     const openBranchSchema = z.object({
         id: idSchema,
-        children: z.array(childSchema),
+        children: z.array(nodeSchema),
     });
     return {
         leafSchema,