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

package/dist/{trees/tree-node/tree-node.types.d.ts → state-and-nav/tree/tree.types.d.ts}

@@ -25,7 +25,7 @@ declare const treeNodeBrand: unique symbol;
  * @remarks
  *
  * `TreeNode` is intentionally opaque. Callers may hold, compare by reference,
- * pass, store, and return nodes, but should use {@link TreeNodeApi} operations
+ * pass, store, and return nodes, but should use {@link TreeMethods} operations
  * to create, inspect, and update them.
  *
  * In particular, callers do not depend on:
@@ -111,14 +111,14 @@ export type TreeNodeKind = 'leaf' | 'unloaded-branch' | 'loaded-branch';
  *
  * @remarks
  *
- * `TreeNodeMatch` provides exhaustive pattern matching over the semantic state
- * of a node. It is the preferred operation when behavior differs between
- * leaves, unloaded branches, and loaded branches:
+ * `MatchByKind` provides exhaustive pattern matching over the node's semantic
+ * state. It is the preferred operation when behavior differs between leaves,
+ * unloaded branches, and loaded branches:
  *
  * - `leaf` receives no `children`, because a leaf cannot have children;
  * - `unloadedBranch` receives no `children`, because its children are not loaded;
- * - `loadedBranch` receives an iterable of loaded direct child nodes. No
- *   iteration-order guarantee is made.
+ * - `loadedBranch` receives an iterable of loaded direct child nodes in
+ *    child order.
  *
  * Every handler must return the same `Result` type.
  *
@@ -129,7 +129,7 @@ export type TreeNodeKind = 'leaf' | 'unloaded-branch' | 'loaded-branch';
  * @example
  *
  * ```ts
- * const label = api.match(node, {
+ * const label = api.matchByKind(node, {
  *   leaf: ({ value }) => value.label,
  *
  *   unloadedBranch: ({ value }) => `${value.label} (loading…)`,
@@ -146,7 +146,7 @@ export type TreeNodeKind = 'leaf' | 'unloaded-branch' | 'loaded-branch';
  * });
  * ```
  */
-export type TreeNodeMatch<Id extends SerializableKey, Value, Result> = Readonly<{
+export type MatchByKind<Id extends SerializableKey, Value, Result> = Readonly<{
     leaf: (node: Readonly<{
         id: Id;
         value: Value;
@@ -168,12 +168,16 @@ export type TreeNodeMatch<Id extends SerializableKey, Value, Result> = Readonly<
  *
  * A `TreeNodeApi` is specialized to one ID type and one application-value
  * type. It owns the structural tree rules: leaf/branch state, child loading
- * state, sibling-ID uniqueness, and immutable ancestor reconstruction.
+ * state, child order, sibling-ID uniqueness, and immutable ancestor
+ * reconstruction.
  *
- * Child collections are unordered. Although operations expose children as
- * `Iterable` values, callers must not rely on iteration order being stable,
- * meaningful, or related to insertion order. The implementation may use an
- * array, map, set, indexed store, or another representation internally.
+ * Loaded children form an ordered sequence. Construction and child-replacement
+ * operations preserve the supplied iterable's iteration order. Inspection
+ * operations expose children in that order, and model conversion preserves it.
+ * Replacing a descendant retains its position among siblings.
+ *
+ * The backing representation is private; these ordering guarantees do not
+ * require callers to depend on a particular storage structure.
  *
  * Tree nodes are plain immutable values at runtime. Update operations do not
  * mutate supplied nodes or their loaded child collections. When an update
@@ -191,19 +195,19 @@ export type TreeNodeMatch<Id extends SerializableKey, Value, Result> = Readonly<
  *
  * the root is addressed by `[]`, and `child` is addressed by `['child']`.
  *
- * Paths cannot pass through leaves or closed branches. A closed branch may be
- * selected as the final node in a path, but its unloaded descendants cannot be
- * addressed.
+ * Paths cannot pass through leaves or unloaded branches. An unloaded branch may
+ * be selected as the final node in a path, but its unloaded descendants cannot
+ * be addressed.
  *
  * @typeParam Id - The type used to identify nodes among siblings.
  * @typeParam Value - The application-specific value stored at each node.
  */
-export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
+export type TreeMethods<Id extends SerializableKey, Value> = Readonly<{
     /**
      * Creates a leaf node.
      *
      * A leaf cannot contain children. To convert an existing node to a leaf while
-     * retaining its ID and value, use {@link TreeNodeApi.toLeaf}.
+     * retaining its ID and value, use {@link TreeMethods.toLeaf}.
      *
      * @param id - The ID that identifies this node among its siblings.
      * @param value - Application-owned data stored on the node.
@@ -219,7 +223,13 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
      */
     createUnloadedBranch(id: Id, value: Value): TreeNode<Id, Value>;
     /**
-     * Creates a branch with a loaded child collection.
+     * Creates a branch with an ordered, loaded child collection.
+     *
+     * Children are copied in the supplied iterable's iteration order. Subsequent
+     * changes to the supplied collection do not affect the created branch.
+     *
+     * Direct siblings must have unique IDs. Returns `undefined` if the supplied
+     * children contain duplicate sibling IDs.
      *
      * An empty child collection creates a loaded branch with no current children;
      * it does not create a leaf.
@@ -245,7 +255,7 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
     /**
      * Returns the semantic kind of a node.
      *
-     * Prefer {@link TreeNodeApi.match} when behavior differs by node kind and all
+     * Prefer {@link TreeMethods.matchByKind} when behavior differs by node kind and all
      * three variants must be handled.
      *
      * @param node - The node to inspect.
@@ -256,24 +266,24 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
      * Inspects a node by handling its semantic state exhaustively.
      *
      * @param node - The node to inspect.
-     * @param handlers - Case handlers for leaf, closed-branch, and open-branch
+     * @param handlers - Case handlers for leaf, and unloaded/loaded branch
      * states.
      * @returns The value returned by the selected case handler.
      */
-    match<Result>(node: TreeNode<Id, Value>, handlers: TreeNodeMatch<Id, Value, Result>): Result;
+    matchByKind<Result>(node: TreeNode<Id, Value>, handlers: MatchByKind<Id, Value, Result>): Result;
     /**
-     * Returns the loaded direct children of a loaded branch.
+     * Returns the loaded direct children of a loaded branch in child order.
      *
-     * The returned child nodes are existing values, not defensive clones. No
-     * iteration-order guarantee is made.
+     * The returned iterable is reusable. Its child nodes are existing values,
+     * not defensive clones.
      *
      * Returns `undefined` when `node` is a leaf or an unloaded branch. Use
-     * {@link TreeNodeApi.kind} or {@link TreeNodeApi.match} when those cases need
+     * {@link TreeMethods.kind} or {@link TreeMethods.matchByKind} when those cases need
      * to be distinguished.
      *
      * @param node - The node whose direct children to inspect.
      * @returns An iterable of loaded direct children, or `undefined` when children
-     * are unavailable because `node` is a leaf or closed branch.
+     * are unavailable because `node` is a leaf or unloaded branch.
      */
     getLoadedChildren(node: TreeNode<Id, Value>): Iterable<TreeNode<Id, Value>> | undefined;
     /**
@@ -284,16 +294,16 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
      *
      * @param node - The node whose loaded direct children to search.
      * @param id - The sibling ID to find.
-     * @returns The existing matching child, or `undefined` when `node` is not an
-     * open branch or does not have a direct child with `id`.
+     * @returns The existing matching child, or `undefined` when `node` is not a
+     * loaded branch or does not have a direct child with `id`.
      */
     findChildById(node: TreeNode<Id, Value>, id: Id): TreeNode<Id, Value> | undefined;
     /**
      * Returns an equivalent node with replacement application data.
      *
      * The returned node retains the original node's ID, semantic child state,
-     * and when applicable, existing child-node references. The supplied node is
-     * not mutated.
+     * and when applicable, child order and existing child-node references.
+     * The supplied node is not mutated.
      *
      * @param node - The node to update.
      * @param value - Replacement application-owned data.
@@ -317,17 +327,18 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
      * Any currently loaded child collection is discarded.
      *
      * @param node - The node to convert.
-     * @returns A closed branch with the source node's ID and value.
+     * @returns An unloaded branch with the source node's ID and value.
      */
     toUnloadedBranch(node: TreeNode<Id, Value>): TreeNode<Id, Value>;
     /**
-     * Converts a node to an open branch with replacement loaded children.
+     * Converts a node to a loaded branch with replacement children.
      *
      * The returned node retains the source node's ID and application value.
      * Any previous child state is replaced.
      *
-     * Child collections are unordered. Callers must not rely on the iteration order
-     * of the supplied children being retained or exposed by the resulting node.
+     * Children are copied in the supplied iterable's iteration order. That order
+     * becomes the replacement child order. Subsequent changes to the supplied
+     * collection do not affect the returned node.
      *
      * Direct siblings must have unique IDs. If two or more supplied children have
      * the same ID, no replacement node is created and this method returns
@@ -338,8 +349,8 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
      * @param node - The node to convert or update.
      * @param children - Replacement loaded direct children. Their IDs must be
      * unique among direct siblings.
-     * @returns An open branch with the source node's ID and value, or `undefined`
-     * when `children` contains duplicate sibling IDs.
+     * @returns A loaded branch with the source node's ID and value, or
+     * `undefined` when `children` contains duplicate sibling IDs.
      */
     withLoadedChildren(node: TreeNode<Id, Value>, children: Iterable<TreeNode<Id, Value>>): TreeNode<Id, Value> | undefined;
     /**
@@ -361,7 +372,7 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
      * selected node is supplied as the existing node value and is not cloned.
      *
      * An empty path selects `root`. Resolution fails when a path refers to a
-     * missing child or attempts to pass through a leaf or a closed branch.
+     * missing child or attempts to pass through a leaf or an unloaded branch.
      *
      * @param root - The root node relative to which `path` is interpreted.
      * @param path - A sibling-ID path relative to `root`.
@@ -373,40 +384,49 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
     /**
      * Immutably replaces the node addressed by a path relative to `root`.
      *
-     * The modifier runs only after the complete path has been resolved. Returning
-     * `undefined` aborts the operation and causes this method to return
+     * The update callback runs only after the complete path has been resolved.
+     * Returning `undefined` aborts the operation and causes this method to return
      * `undefined`.
      *
      * An empty path selects `root`. When a descendant is replaced, replacement
      * nodes are created only along the path from `root` to that descendant. Nodes
      * outside that path retain their original object identity.
      *
-     * The modifier may return a node with a different ID. If it does, the
+     * The `update` may return a node with a different ID. If it does, the
      * replacement is subsequently addressed by its new ID rather than the old
-     * path segment.
+     * path segment. The replacement retains the original node's position among
+     * siblings, and all other siblings retain their relative order.
      *
      * The update also fails when the replacement node's ID duplicates the ID of
-     * one of its new siblings. This can occur when `modifier` returns a node with
+     * one of its new siblings. This can occur when `update` returns a node with
      * a different ID.
      *
      * @param root - The root node relative to which `path` is interpreted.
      * @param path - A sibling-ID path relative to `root`.
      * @param update - Produces a replacement node, or `undefined` to abort.
      * @returns A replacement root, or `undefined` when the path cannot be
-     *  resolved, `modifier` aborts, or the replacement would create duplicate
+     *  resolved, `update` aborts, or the replacement would create duplicate
      *  sibling IDs.
      */
     updateAtPath(root: TreeNode<Id, Value>, path: readonly Id[], update: (node: TreeNode<Id, Value>) => TreeNode<Id, Value> | undefined): TreeNode<Id, Value> | undefined;
     /**
      * Converts an opaque runtime node into a public structural model.
      *
-     * The returned model is a fresh recursive snapshot. It is suitable for
-     * serialization when `Id` and `Value` are serializable.
+     * Creates fresh model objects and child arrays recursively, preserving child
+     * order at every loaded branch. Application-owned values are retained by
+     * reference, not cloned; callers must treat those values as immutable.
+     *
+     * The model is suitable for JSON serialization when `Id` and `Value` are
+     * JSON-serializable.
      */
     toModel(node: TreeNode<Id, Value>): TreeNodeModel<Id, Value>;
     /**
      * Constructs an opaque tree from a public structural model.
      *
+     * Creates new runtime nodes and child collections, preserving child order
+     * at every loaded branch. Application-owned values are retained by reference,
+     * not cloned.
+     *
      * Returns `undefined` if any loaded child collection contains duplicate
      * sibling IDs.
      *
@@ -416,4 +436,4 @@ export type TreeNodeApi<Id extends SerializableKey, Value> = Readonly<{
     fromModel(model: TreeNodeModel<Id, Value>): TreeNode<Id, Value> | undefined;
 }>;
 export {};
-//# sourceMappingURL=tree-node.types.d.ts.map
+//# sourceMappingURL=tree.types.d.ts.map

package/dist/state-and-nav/tree/tree.types.d.ts.map

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

package/dist/state-and-nav/tree/tree.types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirvi-lib",
-  "version": "0.11.0-beta.1",
+  "version": "0.11.0-beta.13",
   "description": "Dependency for dirvi.",
   "license": "LGPL-3.0-or-later",
   "type": "module",
@@ -10,7 +10,8 @@
     "dist"
   ],
   "dependencies": {
-    "zod": "^4.4.3"
+    "zod": "^4.4.3",
+    "dirvi-apis": "0.11.0-beta.13"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/dist/app/app-api.d.ts

@@ -1,74 +0,0 @@
-import type { ViewApi } from './view-api.js';
-import type { CursorApi, FoldsApi, NavNodeApi, SerializableKey, State, StateApi, TreeNode, TreeNodeApi } from '../trees/index.js';
-/**
- * Application-specific tree dependencies and operations.
- *
- * This is currently migrated through the generic TreeNode and State APIs.
- * Navigation-specific APIs remain outside this type until NavNodeApi has been
- * migrated from the old structural TreeNode API.
- *
- * @typeParam Id - The sibling-unique tree-node ID type.
- * @typeParam Value - Application-owned data stored in each tree node.
- * @typeParam ViewKey - The key used to identify view implementations.
- */
-export type AppApi<Id extends SerializableKey, Value, ViewKey = string> = Readonly<{
-    /**
-     * Name used to distinguish the application, for example `posix` for a
-     * POSIX-directory application.
-     */
-    appId: string;
-    /**
-     * Name used to distinguish a particular application instance.
-     */
-    name: string;
-    /**
-     * ID used for the application's root node.
-     */
-    rootId: Id;
-    /**
-     * Loads direct children for the branch addressed by `path`.
-     *
-     * Returned nodes must be opaque tree values created or decoded through this
-     * application's TreeNodeApi specialization.
-     */
-    loadBranches: (path: readonly Id[]) => Promise<readonly TreeNode<Id, Value>[]>;
-    /**
-     * Creates the application's root node.
-     *
-     * Invariant: the returned node is an open branch. That invariant is checked
-     * when an initial State is created.
-     */
-    createRoot: () => Promise<TreeNode<Id, Value>>;
-    /**
-     * Subscribes to external data changes that require tree state to be loaded
-     * again.
-     *
-     * Returns an unsubscribe function.
-     */
-    subscribeToResync: (listener: () => void) => () => void;
-    /**
-     * Generic structural operations for this application's buffer tree.
-     */
-    treeNodeApi: TreeNodeApi<Id, Value>;
-    /**
-     * Semantic fold-state operations.
-     *
-     * This remains temporarily available while FoldNode itself is migrated.
-     */
-    foldsApi: FoldsApi<Id>;
-    cursorApi: CursorApi<Id>;
-    stateApi: StateApi<Id, Value>;
-    /**
-     * UI navigation projection and cursor-navigation operations.
-     */
-    navNodeApi: NavNodeApi<Id, Value>;
-    viewKey: ViewKey;
-    viewApi: ViewApi<State<Id, Value>, ViewKey>;
-}>;
-export type AppStateApis<Id extends SerializableKey, Value> = Readonly<{
-    treeNodeApi: TreeNodeApi<Id, Value>;
-    cursorApi: CursorApi<Id>;
-    stateApi: StateApi<Id, Value>;
-}>;
-export declare function createAppStateApis<Id extends SerializableKey, Value>(): AppStateApis<Id, Value>;
-//# sourceMappingURL=app-api.d.ts.map

package/dist/app/app-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-api.d.ts","sourceRoot":"","sources":["../../src/app/app-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EACR,UAAU,EACV,eAAe,EACf,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAO3B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,MAAM,CAChB,EAAE,SAAS,eAAe,EAC1B,KAAK,EACL,OAAO,GAAG,MAAM,IACd,QAAQ,CAAC;IACX;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,EAAE,EAAE,CAAC;IAEX;;;;;OAKG;IACH,YAAY,EAAE,CACZ,IAAI,EAAE,SAAS,EAAE,EAAE,KAChB,OAAO,CAAC,SAAS,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;IAE7C;;;;;OAKG;IACH,UAAU,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;IAE/C;;;;;OAKG;IACH,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAExD;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAEpC;;;;OAIG;IACH,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEvB,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;IAEzB,QAAQ,EAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAE9B;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAElC,OAAO,EAAE,OAAO,CAAC;IAEjB,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;CAC7C,CAAC,CAAC;AAEH,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,QAAQ,CAAC;IACrE,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IACpC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;CAC/B,CAAC,CAAC;AAEH,wBAAgB,kBAAkB,CAChC,EAAE,SAAS,eAAe,EAC1B,KAAK,KACF,YAAY,CAAC,EAAE,EAAE,KAAK,CAAC,CAU3B"}

package/dist/app/app-api.js

@@ -1,11 +0,0 @@
-import { createCursorApi, createStateApi, createTreeNodeApi, } from '../trees/index.js';
-export function createAppStateApis() {
-    const treeNodeApi = createTreeNodeApi();
-    const cursorApi = createCursorApi();
-    const stateApi = createStateApi(treeNodeApi, cursorApi);
-    return {
-        treeNodeApi,
-        cursorApi,
-        stateApi,
-    };
-}

package/dist/input/application/parse-command.d.ts

@@ -1,14 +0,0 @@
-import type { SerializableKey } from '../../trees/index.js';
-import type { Effect } from '../domain/index.js';
-/**
- * Parses a command-line command into an application effect.
- *
- * Command parsing is independent of the concrete tree-node value type, but the
- * generic parameters allow its result to compose with the application's
- * Effect<Id, Value> pipeline.
- *
- * @typeParam Id - The sibling-unique tree-node ID type.
- * @typeParam Value - Application-owned data stored in each tree node.
- */
-export declare function parseCommand<Id extends SerializableKey, Value>(commandLine: string): Effect<Id, Value> | undefined;
-//# sourceMappingURL=parse-command.d.ts.map

package/dist/input/application/parse-command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-command.d.ts","sourceRoot":"","sources":["../../../src/input/application/parse-command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AA8GjD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,EAC5D,WAAW,EAAE,MAAM,GAClB,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,GAAG,SAAS,CAyD/B"}

package/dist/trees/cursor.d.ts

@@ -1,59 +0,0 @@
-import { z } from 'zod';
-/**
- * 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> = {
-    /**
-     * Tests whether two cursors identify the same tree position.
-     */
-    equal(left: Cursor<Id>, right: Cursor<Id>): boolean;
-    /**
-     * 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>;
-//# sourceMappingURL=cursor.d.ts.map

package/dist/trees/cursor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/trees/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/trees/cursor.js

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-/**
- * 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) {
-    return z.array(idSchema);
-}
-export function createCursorApi() {
-    return {
-        equal(left, right) {
-            return idPathEqual(left, right);
-        },
-        getPath(cursor) {
-            return [...cursor];
-        },
-        cursorBelongsToSubtree(cursor, entryPath) {
-            return isPathPrefix(entryPath, cursor);
-        },
-    };
-}
-/**
- * Returns true when both root-relative paths contain the same IDs in the same
- * order.
- */
-function idPathEqual(left, right) {
-    if (left.length !== right.length) {
-        return false;
-    }
-    for (let index = 0; index < left.length; index += 1) {
-        if (left[index] !== right[index]) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Returns true when `prefix` is a prefix of `path`.
- *
- * Equal paths are included. An empty prefix is therefore a prefix of every
- * path.
- */
-function isPathPrefix(prefix, path) {
-    if (prefix.length > path.length) {
-        return false;
-    }
-    for (let index = 0; index < prefix.length; index += 1) {
-        if (prefix[index] !== path[index]) {
-            return false;
-        }
-    }
-    return true;
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"fold-node.impl.d.ts","sourceRoot":"","sources":["../../../../src/trees/fold-node/deprecated/fold-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,WAAW,EACX,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,SAAS,eAAe,EAC9D,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC,GAC3B,eAAe,CAAC,EAAE,CAAC,CA0WrB"}

package/dist/trees/fold-node/deprecated/fold-node.test.d.ts.map

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"fold-node.types.d.ts","sourceRoot":"","sources":["../../../../src/trees/fold-node/deprecated/fold-node.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAElC;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,EAAE,SAAS,eAAe,IAAI,QAAQ,CAAC;IAC/D,cAAc,EAAE,SAAS,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;CACzC,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,EAAE,SAAS,eAAe,IAAI,QAAQ,CACzD,EAAE,EACF,aAAa,CAAC,EAAE,CAAC,CAClB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,SAAS,eAAe,IAAI,WAAW,CAC/D,EAAE,EACF,aAAa,CAAC,EAAE,CAAC,CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,eAAe,CAAC,EAAE,SAAS,eAAe,IAAI;IACxD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,EAAE,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEtC;;;;;;;;;;;;;;OAcG;IACH,sBAAsB,CACpB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,EACnB,OAAO,EAAE,EAAE,GACV,OAAO,CAAC;IAEX;;;;OAIG;IACH,mBAAmB,CACjB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,GAClB,EAAE,EAAE,GAAG,SAAS,CAAC;IAEpB;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAAoB,CAClB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,EACnB,OAAO,EAAE,EAAE,GACV,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAE5B;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAAuB,CACrB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,EACnB,OAAO,EAAE,EAAE,GACV,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAE5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,wBAAwB,CACtB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,GAClB,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CAC7B,CAAC"}

package/dist/trees/fold-node/fold-node.impl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fold-node.impl.d.ts","sourceRoot":"","sources":["../../../src/trees/fold-node/fold-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAEf,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAM/B,OAAO,KAAK,EAIV,QAAQ,EACT,MAAM,sBAAsB,CAAC;AAE9B;;GAEG;AACH,KAAK,cAAc,CAAC,EAAE,SAAS,eAAe,IAAI,SAAS,EAAE,EAAE,CAAC;AA0ChE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,SAAS,eAAe,EACvD,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,cAAc,CAAC,EAAE,CAAC,CAAC,GAC/C,QAAQ,CAAC,EAAE,CAAC,CA8nBd"}

package/dist/trees/fold-node/fold-node.model.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fold-node.model.d.ts","sourceRoot":"","sources":["../../../src/trees/fold-node/fold-node.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAY7D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,aAAa,CAAC,EAAE,SAAS,eAAe,IAAI,QAAQ,CAAC;IAC/D;;OAEG;IACH,EAAE,EAAE,EAAE,CAAC;IAEP;;;;;OAKG;IACH,cAAc,EAAE,SAAS,EAAE,EAAE,CAAC;IAE9B;;;;OAIG;IACH,QAAQ,EAAE,SAAS,aAAa,CAAC,EAAE,CAAC,EAAE,CAAC;CACxC,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,SAAS,eAAe,EAClE,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,GACtB,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,CA0B9B;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,EAAE,SAAS,eAAe,IAAI,QAAQ,CAAC;IAC/D;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,IAAI,EAAE,aAAa,CAAC,EAAE,CAAC,CAAC;CACzB,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,EAAE,SAAS,eAAe,IAAI,QAAQ,CAAC;IAC5D,KAAK,EAAE,SAAS,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;CACtE,CAAC,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,SAAS,eAAe,EAC/D,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,GACtB,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAmB3B"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/trees/fold-node/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}

package/dist/trees/index.d.ts

@@ -1,9 +0,0 @@
-export * from './fold-node/index.js';
-export * from './nav-node/nav-node.impl.js';
-export * from './nav-node/nav-node.types.js';
-export * from './tree-node/index.js';
-export * from './cursor.js';
-export * from './state/state.impl.js';
-export * from './state/state.schemas.js';
-export * from './state/state.types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/trees/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trees/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AAErC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAE7C,cAAc,sBAAsB,CAAC;AAErC,cAAc,aAAa,CAAC;AAE5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}

package/dist/trees/index.js

@@ -1,8 +0,0 @@
-export * from './fold-node/index.js';
-export * from './nav-node/nav-node.impl.js';
-export * from './nav-node/nav-node.types.js';
-export * from './tree-node/index.js';
-export * from './cursor.js';
-export * from './state/state.impl.js';
-export * from './state/state.schemas.js';
-export * from './state/state.types.js';

package/dist/trees/nav-node/nav-node.impl.d.ts

@@ -1,29 +0,0 @@
-import type { SerializableKey, TreeNodeApi } from '../tree-node/index.js';
-import type { FoldsApi } from '../fold-node/index.js';
-import type { CursorApi } from '../cursor.js';
-import type { NavNodeApi } from './nav-node.types.js';
-export type NavEntryComparator<Id extends SerializableKey, Value> = (left: Readonly<{
-    id: Id;
-    value: Value;
-}>, right: Readonly<{
-    id: Id;
-    value: Value;
-}>) => number;
-export type CreateNavNodeApiOptions<Id extends SerializableKey, Value> = Readonly<{
-    /**
-     * Defines display and cursor-navigation order among sibling entries.
-     *
-     * For deterministic navigation, this should define a total order for
-     * distinct sibling entries. If two entries compare equal, their order falls
-     * back to the source TreeNode child iteration order.
-     */
-    compareEntries: NavEntryComparator<Id, Value>;
-}>;
-/**
- * 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 declare function createNavNodeApi<Id extends SerializableKey, Value>(treeNodeApi: TreeNodeApi<Id, Value>, foldsApi: FoldsApi<Id>, cursorApi: CursorApi<Id>, options: CreateNavNodeApiOptions<Id, Value>): NavNodeApi<Id, Value>;
-//# sourceMappingURL=nav-node.impl.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"nav-node.impl.d.ts","sourceRoot":"","sources":["../../../src/trees/nav-node/nav-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAEf,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAS,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAU,SAAS,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAIV,UAAU,EACX,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,kBAAkB,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,CAClE,IAAI,EAAE,QAAQ,CAAC;IACb,EAAE,EAAE,EAAE,CAAC;IACP,KAAK,EAAE,KAAK,CAAC;CACd,CAAC,EACF,KAAK,EAAE,QAAQ,CAAC;IACd,EAAE,EAAE,EAAE,CAAC;IACP,KAAK,EAAE,KAAK,CAAC;CACd,CAAC,KACC,MAAM,CAAC;AAEZ,MAAM,MAAM,uBAAuB,CACjC,EAAE,SAAS,eAAe,EAC1B,KAAK,IACH,QAAQ,CAAC;IACX;;;;;;OAMG;IACH,cAAc,EAAE,kBAAkB,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;CAC/C,CAAC,CAAC;AAEH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,EAChE,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,KAAK,CAAC,EACnC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,EACxB,OAAO,EAAE,uBAAuB,CAAC,EAAE,EAAE,KAAK,CAAC,GAC1C,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,CA8UvB"}