dirvi-lib 0.11.0-beta.1 → 0.11.0-beta.13

package/dist/trees/nav-node/nav-node.impl.js

@@ -1,223 +0,0 @@
-/**
- * Creates operations for projecting an opaque tree into a navigation model.
- *
- * Navigation ordering is intentionally a UI concern. The underlying TreeNode
- * API need not promise a particular child-storage representation or ordering.
- */
-export function createNavNodeApi(treeNodeApi, foldsApi, cursorApi, options) {
-    function entryIsBranch(entry) {
-        return 'children' in entry;
-    }
-    function compareTreeNodes(left, right) {
-        return options.compareEntries({
-            id: treeNodeApi.id(left),
-            value: treeNodeApi.value(left),
-        }, {
-            id: treeNodeApi.id(right),
-            value: treeNodeApi.value(right),
-        });
-    }
-    /**
-     * Projects loaded children into navigation entries.
-     *
-     * Folded source entries are omitted from `entries` and represented in the
-     * synthetic `folded` row instead.
-     */
-    function createNavNode(entries, foldRoot, parentPath) {
-        const visibleEntries = [];
-        const foldedEntries = [];
-        /*
-         * Navigation owns presentation order, so materialize and sort the child
-         * iterable before projecting it.
-         */
-        const orderedEntries = [...entries].sort(compareTreeNodes);
-        for (const entry of orderedEntries) {
-            const entryId = treeNodeApi.id(entry);
-            const entryPath = [...parentPath, entryId];
-            const isFolded = foldsApi.isEntryHiddenAtPath(foldRoot, parentPath, entryId);
-            const navigationEntry = createNavEntry(entry, foldRoot, entryPath);
-            if (isFolded) {
-                foldedEntries.push(navigationEntry);
-            }
-            else {
-                visibleEntries.push(navigationEntry);
-            }
-        }
-        return {
-            entries: visibleEntries,
-            /*
-             * Fold state may contain entries that are not currently available in the
-             * loaded source tree. Do not render an empty synthetic row for them.
-             */
-            folded: foldedEntries.length === 0
-                ? null
-                : {
-                    entries: foldedEntries,
-                },
-        };
-    }
-    function createNavEntry(entry, foldRoot, entryPath) {
-        return treeNodeApi.match(entry, {
-            leaf: ({ id }) => ({
-                id,
-            }),
-            unloadedBranch: ({ id }) => ({
-                id,
-                children: null,
-            }),
-            loadedBranch: ({ id, children }) => ({
-                id,
-                children: createNavNode(children, foldRoot, entryPath),
-            }),
-        });
-    }
-    function createRootNavBranch(root, foldRoot) {
-        return treeNodeApi.match(root, {
-            leaf: () => undefined,
-            unloadedBranch: ({ id }) => ({
-                id,
-                children: null,
-            }),
-            loadedBranch: ({ id, children }) => ({
-                id,
-                children: createNavNode(children, foldRoot, []),
-            }),
-        });
-    }
-    function rootCursors(rootNode) {
-        if (rootNode.children === null) {
-            return [[]];
-        }
-        return [[], ...cursorsInNode(rootNode.children, [])];
-    }
-    function cursorsInNode(node, parentPath) {
-        const cursors = [];
-        for (const entry of node.entries) {
-            const entryPath = [...parentPath, entry.id];
-            cursors.push(entryPath);
-            if (!entryIsBranch(entry) || entry.children === null) {
-                continue;
-            }
-            cursors.push(...cursorsInNode(entry.children, entryPath));
-        }
-        return cursors;
-    }
-    const navNodeApi = {
-        entryIsBranch,
-        from(root, foldRoot) {
-            return createRootNavBranch(root, foldRoot);
-        },
-        getNodeAtPath(navigation, path) {
-            const [currentId, ...remainingPath] = path;
-            /*
-             * An empty path identifies the current navigation node.
-             */
-            if (currentId === undefined) {
-                return navigation;
-            }
-            const entry = navigation.entries.find((candidate) => candidate.id === currentId);
-            if (entry === undefined || !entryIsBranch(entry)) {
-                return undefined;
-            }
-            /*
-             * A null value represents a source branch whose children are not loaded.
-             */
-            if (entry.children === null) {
-                return undefined;
-            }
-            return navNodeApi.getNodeAtPath(entry.children, remainingPath);
-        },
-        getEntryAtPath(navigation, path) {
-            const [currentId, ...remainingPath] = path;
-            /*
-             * A NavNode does not itself correspond to a NavEntry. Therefore [] does
-             * not resolve to an entry.
-             */
-            if (currentId === undefined) {
-                return undefined;
-            }
-            const entry = navigation.entries.find((candidate) => candidate.id === currentId);
-            if (entry === undefined) {
-                return undefined;
-            }
-            if (remainingPath.length === 0) {
-                return entry;
-            }
-            if (!entryIsBranch(entry) || entry.children === null) {
-                return undefined;
-            }
-            return navNodeApi.getEntryAtPath(entry.children, remainingPath);
-        },
-        nextCursor(rootNode, cursor) {
-            const cursors = rootCursors(rootNode);
-            const currentIndex = cursors.findIndex((candidate) => cursorApi.equal(candidate, cursor));
-            if (currentIndex === -1 || currentIndex === cursors.length - 1) {
-                return undefined;
-            }
-            return cursors[currentIndex + 1];
-        },
-        previousCursor(rootNode, cursor) {
-            const cursors = rootCursors(rootNode);
-            const currentIndex = cursors.findIndex((candidate) => cursorApi.equal(candidate, cursor));
-            if (currentIndex <= 0) {
-                return undefined;
-            }
-            return cursors[currentIndex - 1];
-        },
-        cursorAfterFold(rootNode, cursor) {
-            // Folding root disallowed
-            if (cursor.length === 0) {
-                return undefined;
-            }
-            const cursors = rootCursors(rootNode);
-            const currentIndex = cursors.findIndex((candidate) => cursorApi.equal(candidate, cursor));
-            if (currentIndex === -1) {
-                return undefined;
-            }
-            // If the last entry, then cursor should go to previous entry
-            // This works to go to the root when the last entry in the root is folded.
-            if (currentIndex + 1 === cursors.length) {
-                return cursors[currentIndex - 1];
-            }
-            for (let index = currentIndex + 1; index < cursors.length; index += 1) {
-                const candidate = cursors[index];
-                if (candidate === undefined) {
-                    continue;
-                }
-                // Skip any entries that are children of the entry about to be folded
-                if (cursorApi.cursorBelongsToSubtree(candidate, cursor)) {
-                    continue;
-                }
-                return candidate;
-            }
-        },
-        parentCursor(_navigation, cursor) {
-            if (cursor.length === 0) {
-                return undefined;
-            }
-            return cursor.slice(0, -1);
-        },
-        cursors(navigation, parentPath = []) {
-            return cursorsInNode(navigation, parentPath);
-        },
-        visibleLeavesPaths(navigation, parentPath = []) {
-            const paths = [];
-            for (const entry of navigation.entries) {
-                const entryPath = [...parentPath, entry.id];
-                if (!entryIsBranch(entry)) {
-                    paths.push(entryPath);
-                    continue;
-                }
-                /*
-                 * A null value means the source branch is not loaded/opened. It has no
-                 * currently visible descendants.
-                 */
-                if (entry.children !== null) {
-                    paths.push(...navNodeApi.visibleLeavesPaths(entry.children, entryPath));
-                }
-            }
-            return paths;
-        },
-    };
-    return navNodeApi;
-}

package/dist/trees/nav-node/nav-node.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nav-node.types.d.ts","sourceRoot":"","sources":["../../../src/trees/nav-node/nav-node.types.ts"],"names":[],"mappings":"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"}

package/dist/trees/state/state.impl.d.ts

@@ -1,8 +0,0 @@
-import type { SerializableKey, TreeNodeApi } from '../tree-node/index.js';
-import type { CursorApi } from '../cursor.js';
-import type { StateApi } from './state.types.js';
-/**
- * Creates operations for navigating and resynchronizing tree-surfer state.
- */
-export declare function createStateApi<Id extends SerializableKey, Value>(treeNodeApi: TreeNodeApi<Id, Value>, cursorApi: CursorApi<Id>): StateApi<Id, Value>;
-//# sourceMappingURL=state.impl.d.ts.map

package/dist/trees/state/state.impl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.impl.d.ts","sourceRoot":"","sources":["../../../src/trees/state/state.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAEf,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAU,SAAS,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAS,MAAM,kBAAkB,CAAC;AAMxD;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,EAC9D,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,KAAK,CAAC,EACnC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,GACvB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,CA4LrB"}

package/dist/trees/state/state.schemas.d.ts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-import type { Cursor } from '../cursor.js';
-import type { FoldsModel } from '../fold-node/index.js';
-import type { SerializableKey, TreeNodeModel } from '../tree-node/index.js';
-/**
- * Serializable persistence/interchange model for tree-surfer state.
- *
- * This is intentionally distinct from runtime `State`: its root and folds use
- * public structural models, while runtime state holds opaque TreeNode and
- * Folds values.
- */
-export type StateModel<Id extends SerializableKey, Value> = Readonly<{
-    root: TreeNodeModel<Id, Value>;
-    folds: FoldsModel<Id>;
-    cursor: Cursor<Id>;
-}>;
-/**
- * Creates a schema for the serializable StateModel DTO.
- *
- * This validates only the persistence representation. Applications must decode
- * the validated root and folds models through their specialized TreeNodeApi and
- * FoldsApi before constructing opaque runtime State.
- */
-export declare function createStateModelSchema<Id extends SerializableKey, Value>(rootSchema: z.ZodType<TreeNodeModel<Id, Value>>, foldsSchema: z.ZodType<FoldsModel<Id>>, cursorSchema: z.ZodType<Cursor<Id>>): z.ZodType<StateModel<Id, Value>>;
-//# sourceMappingURL=state.schemas.d.ts.map

package/dist/trees/state/state.schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.schemas.d.ts","sourceRoot":"","sources":["../../../src/trees/state/state.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE5E;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,QAAQ,CAAC;IACnE,IAAI,EAAE,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC/B,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;CACpB,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,EACtE,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,EAC/C,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,EACtC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,GAClC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAQlC"}

package/dist/trees/state/state.schemas.js

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-/**
- * Creates a schema for the serializable StateModel DTO.
- *
- * This validates only the persistence representation. Applications must decode
- * the validated root and folds models through their specialized TreeNodeApi and
- * FoldsApi before constructing opaque runtime State.
- */
-export function createStateModelSchema(rootSchema, foldsSchema, cursorSchema) {
-    return z
-        .object({
-        root: rootSchema,
-        folds: foldsSchema,
-        cursor: cursorSchema,
-    })
-        .strict();
-}

package/dist/trees/state/state.types.d.ts

@@ -1,36 +0,0 @@
-import type { Cursor } from '../cursor.js';
-import type { Folds } from '../fold-node/index.js';
-import type { SerializableKey, TreeNode } from '../tree-node/index.js';
-/**
- * State for navigating a tree and its associated fold-state tree.
- *
- * Invariant: `root` is an open branch.
- *
- * Note: This cannot be represented through a structural intersection because
- * TreeNode is opaque; enforce it when constructing State, using
- * TreeNodeApi.state or TreeNodeApi.getChildren.
- *
- * @typeParam Id - Tree-node sibling ID type.
- * @typeParam Value - Application-owned value stored in every tree node.
- */
-export type State<Id extends SerializableKey, Value> = Readonly<{
-    root: TreeNode<Id, Value>;
-    folds: Folds<Id>;
-    cursor: Cursor<Id>;
-}>;
-export type StateApi<Id extends SerializableKey, Value> = Readonly<{
-    getNodeAtCursor(state: State<Id, Value>): TreeNode<Id, Value> | undefined;
-    /**
-     * Reloads the root's children and all descendant branches that were loaded
-     * in the previous state.
-     *
-     * `loadBranches([])` loads the root's direct children.
-     * `loadBranches(['src'])` loads the children of `src`, where `src` is the
-     * ID of a root child.
-     *
-     * Returned nodes must be valid TreeNode values created or decoded through
-     * the specialized TreeNodeApi for `Id` and `Value`.
-     */
-    resync(oldState: State<Id, Value>, loadBranches: (path: readonly Id[]) => Promise<readonly TreeNode<Id, Value>[]>): Promise<State<Id, Value>>;
-}>;
-//# sourceMappingURL=state.types.d.ts.map

package/dist/trees/state/state.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.types.d.ts","sourceRoot":"","sources":["../../../src/trees/state/state.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEvE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,KAAK,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,QAAQ,CAAC;IAC9D,IAAI,EAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC1B,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;CACpB,CAAC,CAAC;AAEH,MAAM,MAAM,QAAQ,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,QAAQ,CAAC;IACjE,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,GAAG,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC;IAE1E;;;;;;;;;;OAUG;IACH,MAAM,CACJ,QAAQ,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,EAC1B,YAAY,EAAE,CACZ,IAAI,EAAE,SAAS,EAAE,EAAE,KAChB,OAAO,CAAC,SAAS,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,CAAC,GAC3C,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;CAC9B,CAAC,CAAC"}

package/dist/trees/tree-node/deprecated/tree-node.arb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-node.arb.d.ts","sourceRoot":"","sources":["../../../../src/trees/tree-node/deprecated/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;AAOzB;;;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;AAuEF;;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,4BAA8C,CAAC"}

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

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

package/dist/trees/tree-node/deprecated/tree-node.impl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-node.impl.d.ts","sourceRoot":"","sources":["../../../../src/trees/tree-node/deprecated/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/trees/tree-node/deprecated/tree-node.schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-node.schemas.d.ts","sourceRoot":"","sources":["../../../../src/trees/tree-node/deprecated/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/trees/tree-node/deprecated/tree-node.test.d.ts.map

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

package/dist/trees/tree-node/deprecated/tree-node.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-node.types.d.ts","sourceRoot":"","sources":["../../../../src/trees/tree-node/deprecated/tree-node.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,QAAQ,CAClB,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B,YAAY,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;AAEhD,+BAA+B;AAC/B,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,eAAe,IAAI;IACrD,EAAE,EAAE,EAAE,CAAC;IACP,QAAQ,CAAC,EAAE,KAAK,CAAC;CAClB,CAAC;AAEF,gEAAgE;AAChE,MAAM,MAAM,cAAc,CACxB,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B,kBAAkB,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,oBAAoB,CAAC,EAAE,CAAC,CAAC;AAE5D,uDAAuD;AACvD,MAAM,MAAM,kBAAkB,CAC5B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B;IACF,EAAE,EAAE,EAAE,CAAC;IACP,QAAQ,EAAE,IAAI,EAAE,CAAC;CAClB,CAAC;AAEF,2DAA2D;AAC3D,MAAM,MAAM,oBAAoB,CAAC,EAAE,SAAS,eAAe,IAAI;IAC7D,EAAE,EAAE,EAAE,CAAC;IACP,QAAQ,EAAE,IAAI,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,WAAW,CACrB,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B;IACF,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IAC9D,cAAc,CACZ,IAAI,EAAE,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,GAC7B,IAAI,IAAI,oBAAoB,CAAC,EAAE,CAAC,CAAC;IACpC,YAAY,CACV,IAAI,EAAE,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,GAC7B,IAAI,IAAI,kBAAkB,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IAExC;;;;;;;;OAQG;IACH,WAAW,CAAC,IAAI,EAAE,kBAAkB,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAEhE;;;;;;OAMG;IACH,YAAY,CAAC,IAAI,EAAE,kBAAkB,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IAE3E;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,MAAM,EACd,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,SAAS,EAAE,EAAE,EACnB,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,GAC/B,MAAM,GAAG,SAAS,CAAC;IAEtB;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CACV,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,SAAS,EAAE,EAAE,EACnB,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,GAAG,SAAS,GACzC,IAAI,GAAG,SAAS,CAAC;CACrB,CAAC"}

package/dist/trees/tree-node/index.d.ts

@@ -1,5 +0,0 @@
-export type * from './tree-node.model.js';
-export { serializableKeySchema, createTreeNodeModelSchema, } from './tree-node.model.js';
-export type * from './tree-node.types.js';
-export { createTreeNodeApi } from './tree-node.impl.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/trees/tree-node/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/trees/tree-node/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,sBAAsB,CAAC;AAC1C,OAAO,EACL,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,mBAAmB,sBAAsB,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/trees/tree-node/index.js

@@ -1,2 +0,0 @@
-export { serializableKeySchema, createTreeNodeModelSchema, } from './tree-node.model.js';
-export { createTreeNodeApi } from './tree-node.impl.js';

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

@@ -1,104 +0,0 @@
-import * as fc from 'fast-check';
-import { TreeNodeModel } from './tree-node.model.js';
-/**
- * The ID and Values types used for the generated test trees.
- *
- * Short strings keep generated counterexamples readable. Values just have to
- * be something easily checked for equality.
- */
-type TestNodeId = string;
-type TestValue = number;
-type TestNodeModel = TreeNodeModel<TestNodeId, TestValue>;
-type ModelAndPath = {
-    path: TestNodeId[];
-    model: TestNodeModel;
-};
-type ModelWithReachableModels = {
-    model: TestNodeModel;
-    /**
-     * Includes this model at `[]` and every descendant reachable through loaded
-     * branches. Descendants behind unloaded branches are intentionally absent.
-     */
-    reachableModels: ModelAndPath[];
-};
-/**
- * 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>;
-/**
- * Generates serializable application values for test nodes.
- */
-export declare const testValueArb: fc.Arbitrary<number>;
-/**
- * Generates a leaf model.
- */
-export declare const generatedLeafModelArb: fc.Arbitrary<ModelWithReachableModels>;
-/**
- * Generates an unloaded-branch model.
- */
-export declare const generatedUnloadedBranchModelArb: fc.Arbitrary<ModelWithReachableModels>;
-/**
- * Generates a leaf, an unloaded branch, or a loaded branch.
- *
- * Loaded 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<ModelWithReachableModels>;
-/**
- * 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<ModelWithReachableModels[]>;
-/**
- * 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: TestNodeModel;
-    pathEntries: ModelAndPath[];
-}>;
-/**
- * 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: TestNodeModel;
-    path: string[];
-    expected: TestNodeModel;
-}>;
-/**
- * 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<{
-    root: TestNodeModel;
-    path: string[];
-    expected: TestNodeModel;
-}>;
-/**
- * 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<TestNodeModel[]>;
-/**
- * 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<TestNodeModel[] | null>;
-export {};
-//# sourceMappingURL=tree-node.arb.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tree-node.arb.d.ts","sourceRoot":"","sources":["../../../src/trees/tree-node/tree-node.arb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAGjC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;;GAKG;AACH,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,SAAS,GAAG,MAAM,CAAC;AAGxB,KAAK,aAAa,GAAG,aAAa,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;AAE1D,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB;;;OAGG;IACH,eAAe,EAAE,YAAY,EAAE,CAAC;CACjC,CAAC;AAOF;;;GAGG;AACH,eAAO,MAAM,SAAS,sBAIpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,sBAGvB,CAAC;AAiEH;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,EAAE,CAAC,SAAS,CAAC,wBAAwB,CAEnB,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,+BAA+B,EAAE,EAAE,CAAC,SAAS,CAAC,wBAAwB,CAGjB,CAAC;AAUnE;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC,SAAS,CAAC,wBAAwB,CAyC3D,CAAC;AAEV;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,0CAIjC,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,+BAE1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,sCAA8C,CAAC"}