dirvi-lib 0.1.0 → 0.3.0

package/dist/domain/cursor.d.ts

@@ -0,0 +1,17 @@
+import { UnixEntryName, UnixEntryPath } from './unix-entry.js';
+import { DisplayRow } from './display-row.js';
+export type Cursor = {
+    kind: 'entry';
+    parentPath: UnixEntryPath;
+    entryName: UnixEntryName;
+} | {
+    kind: 'fold';
+    parentPath: UnixEntryPath;
+};
+export declare const Cursor: {
+    equal(left: Cursor, right: Cursor): boolean;
+    matchesDisplayRow(cursor: Cursor, row: DisplayRow): boolean;
+    fromDisplayRow(row: DisplayRow): Cursor;
+    getPath(cursor: Cursor): UnixEntryPath | undefined;
+};
+//# sourceMappingURL=cursor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/domain/cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,MAAM,MAAM,MAAM,GACd;IACE,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,aAAa,CAAC;IAC1B,SAAS,EAAE,aAAa,CAAC;CAC1B,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,CAAC;CAC3B,CAAC;AAEN,eAAO,MAAM,MAAM;gBACL,MAAM,SAAS,MAAM,GAAG,OAAO;8BAgBjB,MAAM,OAAO,UAAU,GAAG,OAAO;wBAevC,UAAU,GAAG,MAAM;oBAevB,MAAM,GAAG,aAAa,GAAG,SAAS;CAOnD,CAAC"}

package/dist/domain/cursor.js

@@ -0,0 +1,44 @@
+import { UnixEntryPath } from './unix-entry.js';
+export const Cursor = {
+    equal(left, right) {
+        if (left.kind !== right.kind) {
+            return false;
+        }
+        if (!UnixEntryPath.equal(left.parentPath, right.parentPath)) {
+            return false;
+        }
+        if (left.kind === 'entry' && right.kind === 'entry') {
+            return left.entryName === right.entryName;
+        }
+        return true;
+    },
+    matchesDisplayRow(cursor, row) {
+        if (cursor.kind === 'entry' && row.kind === 'entry') {
+            return (UnixEntryPath.equal(cursor.parentPath, row.parentPath) &&
+                cursor.entryName === row.entry.name);
+        }
+        if (cursor.kind === 'fold' && row.kind === 'fold') {
+            return UnixEntryPath.equal(cursor.parentPath, row.parentPath);
+        }
+        return false;
+    },
+    fromDisplayRow(row) {
+        if (row.kind === 'entry') {
+            return {
+                kind: 'entry',
+                parentPath: row.parentPath,
+                entryName: row.entry.name,
+            };
+        }
+        return {
+            kind: 'fold',
+            parentPath: row.parentPath,
+        };
+    },
+    getPath(cursor) {
+        if (cursor.kind === 'fold') {
+            return undefined;
+        }
+        return [...cursor.parentPath, cursor.entryName];
+    },
+};

package/dist/domain/display-row.d.ts

@@ -1,7 +1,5 @@
-import type { UnixEntry, UnixEntryName } from './unix-entry.js';
+import { UnixEntry, UnixEntryName, UnixEntryPath } from './unix-entry.js';
 import type { UnixPath } from './unix-path.js';
-export type EntryPath = UnixEntryName[];
-export declare function pathsEqual(left: EntryPath, right: EntryPath): boolean;
 export type DisplayEntry = {
     kind: 'file';
     name: UnixEntryName;
@@ -13,15 +11,19 @@ export type DisplayEntry = {
     kind: 'directory';
     name: UnixEntryName;
 };
-export declare function unixEntryToDisplayEntry(entry: UnixEntry): DisplayEntry;
+export declare const DisplayEntry: {
+    fromUnixEntry(entry: UnixEntry): DisplayEntry;
+};
 export type DisplayRow = {
     kind: 'entry';
-    parentPath: EntryPath;
+    parentPath: UnixEntryPath;
     entry: DisplayEntry;
 } | {
     kind: 'fold';
-    parentPath: EntryPath;
+    parentPath: UnixEntryPath;
     entryNames: UnixEntryName[];
 };
-export declare function rowsEqual(firstRow: DisplayRow, secondRow: DisplayRow): boolean;
+export declare const DisplayRow: {
+    equal(firstRow: DisplayRow, secondRow: DisplayRow): boolean;
+};
 //# sourceMappingURL=display-row.d.ts.map

package/dist/domain/display-row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"display-row.d.ts","sourceRoot":"","sources":["../../src/domain/display-row.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,SAAS,GAAG,aAAa,EAAE,CAAC;AAExC,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAErE;AAED,MAAM,MAAM,YAAY,GACpB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;CACrB,CAAC;AAEN,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,GAAG,YAAY,CAStE;AAED,MAAM,MAAM,UAAU,GAClB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,SAAS,CAAC;IACtB,KAAK,EAAE,YAAY,CAAC;CACrB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,CAAC;IACtB,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B,CAAC;AAEN,wBAAgB,SAAS,CACvB,QAAQ,EAAE,UAAU,EACpB,SAAS,EAAE,UAAU,GACpB,OAAO,CAoBT"}
+{"version":3,"file":"display-row.d.ts","sourceRoot":"","sources":["../../src/domain/display-row.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,YAAY,GACpB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;CACrB,CAAC;AAEN,eAAO,MAAM,YAAY;yBACF,SAAS,GAAG,YAAY;CAU9C,CAAA;AAED,MAAM,MAAM,UAAU,GAClB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,aAAa,CAAC;IAC1B,KAAK,EAAE,YAAY,CAAC;CACrB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,CAAC;IAC1B,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B,CAAC;AAEN,eAAO,MAAM,UAAU;oBACL,UAAU,aAAa,UAAU,GAAG,OAAO;CAqB5D,CAAC"}

package/dist/domain/display-row.js

@@ -1,27 +1,29 @@
+import { UnixEntryPath } from './unix-entry.js';
 import { entryNamesEqual } from './unix-entry.js';
-export function pathsEqual(left, right) {
-    return entryNamesEqual(left, right);
-}
-export function unixEntryToDisplayEntry(entry) {
-    if (entry.kind === 'directory') {
-        return {
-            kind: 'directory',
-            name: entry.name,
-        };
+export const DisplayEntry = {
+    fromUnixEntry(entry) {
+        if (entry.kind === 'directory') {
+            return {
+                kind: 'directory',
+                name: entry.name,
+            };
+        }
+        return entry;
     }
-    return entry;
-}
-export function rowsEqual(firstRow, secondRow) {
-    if (firstRow.kind !== secondRow.kind) {
+};
+export const DisplayRow = {
+    equal(firstRow, secondRow) {
+        if (firstRow.kind !== secondRow.kind) {
+            return false;
+        }
+        if (firstRow.kind === 'fold' && secondRow.kind === 'fold') {
+            return (UnixEntryPath.equal(firstRow.parentPath, secondRow.parentPath) &&
+                entryNamesEqual(firstRow.entryNames, secondRow.entryNames));
+        }
+        if (firstRow.kind === 'entry' && secondRow.kind === 'entry') {
+            return (UnixEntryPath.equal(firstRow.parentPath, secondRow.parentPath) &&
+                firstRow.entry.name === secondRow.entry.name);
+        }
         return false;
-    }
-    if (firstRow.kind === 'fold' && secondRow.kind === 'fold') {
-        return (pathsEqual(firstRow.parentPath, secondRow.parentPath) &&
-            entryNamesEqual(firstRow.entryNames, secondRow.entryNames));
-    }
-    if (firstRow.kind === 'entry' && secondRow.kind === 'entry') {
-        return (pathsEqual(firstRow.parentPath, secondRow.parentPath) &&
-            firstRow.entry.name === secondRow.entry.name);
-    }
-    return false;
-}
+    },
+};

package/dist/domain/fold-node.d.ts

@@ -0,0 +1,17 @@
+import { UnixEntry, UnixEntryName, UnixEntryPath } from './unix-entry.js';
+export type FoldNode = {
+    children: Record<UnixEntryName, FoldNode>;
+    folds: UnixEntryName[];
+};
+export declare const FoldNode: {
+    getAtPath(rootNode: FoldNode, path: UnixEntryPath): FoldNode | undefined;
+    getIfEntryFolded(node: FoldNode | undefined, entry: UnixEntry): boolean;
+    modifyAtPath(rootNode: FoldNode, path: UnixEntryName[], modifier: (targetNode: FoldNode) => FoldNode): FoldNode;
+    addFoldedEntry(node: FoldNode, entry: UnixEntry): FoldNode;
+    addFoldedEntryAtPath(rootNode: FoldNode, path: UnixEntryName[], entry: UnixEntry): FoldNode;
+    createEmpty(): FoldNode;
+    setFoldedEntries(node: FoldNode, entries: UnixEntry[]): FoldNode;
+    removeFoldedEntry(node: FoldNode, entry: UnixEntry): FoldNode;
+    clearFoldedEntries(node: FoldNode): FoldNode;
+};
+//# sourceMappingURL=fold-node.d.ts.map

package/dist/domain/fold-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold-node.d.ts","sourceRoot":"","sources":["../../src/domain/fold-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE1E,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC1C,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB,CAAC;AAEF,eAAO,MAAM,QAAQ;wBAEC,QAAQ,QAAQ,aAAa,GAAG,QAAQ,GAAG,SAAS;2BAgBjD,QAAQ,GAAG,SAAS,SAAS,SAAS,GAAG,OAAO;2BAM3D,QAAQ,QACZ,aAAa,EAAE,YACX,CAAC,UAAU,EAAE,QAAQ,KAAK,QAAQ,GAC3C,QAAQ;yBAwBU,QAAQ,SAAS,SAAS,GAAG,QAAQ;mCAU9C,QAAQ,QACZ,aAAa,EAAE,SACd,SAAS,GACf,QAAQ;mBAMI,QAAQ;2BAOA,QAAQ,WAAW,SAAS,EAAE,GAAG,QAAQ;4BAOxC,QAAQ,SAAS,SAAS,GAAG,QAAQ;6BAWpC,QAAQ,GAAG,QAAQ;CAO7C,CAAC"}

package/dist/domain/fold-node.js

@@ -0,0 +1,81 @@
+export const FoldNode = {
+    // Query-Like
+    getAtPath(rootNode, path) {
+        const [currentName, ...remainingPath] = path;
+        if (currentName === undefined) {
+            return rootNode;
+        }
+        const childNode = rootNode.children[currentName];
+        if (childNode === undefined) {
+            return undefined;
+        }
+        return FoldNode.getAtPath(childNode, remainingPath);
+    },
+    getIfEntryFolded(node, entry) {
+        return node !== undefined && hasFoldedEntryNamed(node, entry.name);
+    },
+    // Command/Modifer-Like
+    modifyAtPath(rootNode, path, modifier) {
+        const [currentName, ...remainingPath] = path;
+        // Base case
+        if (currentName === undefined) {
+            return modifier(rootNode);
+        }
+        // Create childNode to create path in tree to the needed node
+        const childNode = rootNode.children[currentName] ?? FoldNode.createEmpty();
+        return {
+            ...rootNode,
+            children: {
+                ...rootNode.children,
+                [currentName]: FoldNode.modifyAtPath(childNode, remainingPath, modifier),
+            },
+        };
+    },
+    addFoldedEntry(node, entry) {
+        // Avoid duplicates
+        if (hasFoldedEntryNamed(node, entry.name)) {
+            return node;
+        }
+        return setFoldedEntriesNamed(node, [...node.folds, entry.name]);
+    },
+    addFoldedEntryAtPath(rootNode, path, entry) {
+        return FoldNode.modifyAtPath(rootNode, path, (node) => FoldNode.addFoldedEntry(node, entry));
+    },
+    createEmpty() {
+        return {
+            children: Object.create(null),
+            folds: [],
+        };
+    },
+    setFoldedEntries(node, entries) {
+        return setFoldedEntriesNamed(node, entries.map((entry) => entry.name));
+    },
+    removeFoldedEntry(node, entry) {
+        if (!hasFoldedEntryNamed(node, entry.name)) {
+            return node;
+        }
+        return setFoldedEntriesNamed(node, node.folds.filter((entryName) => entryName !== entry.name));
+    },
+    clearFoldedEntries(node) {
+        if (node.folds.length === 0) {
+            return node;
+        }
+        return setFoldedEntriesNamed(node, []);
+    },
+};
+// PRIVATE HELPERS
+// Queries
+function hasFoldedEntryNamed(node, entryName) {
+    return node.folds.includes(entryName);
+}
+function uniqueEntryNames(entryNames) {
+    return [...new Set(entryNames)];
+}
+// Adding
+function setFoldedEntriesNamed(node, entryNames) {
+    const uniqueNames = uniqueEntryNames(entryNames);
+    return {
+        ...node,
+        folds: uniqueNames,
+    };
+}

package/dist/domain/fold.d.ts

@@ -0,0 +1,10 @@
+import type { UnixEntryName } from './unix-entry.js';
+export type FoldNode = {
+    children: Record<UnixEntryName, FoldNode>;
+    folds: UnixEntryName[];
+};
+export declare const FoldNode: {
+    createEmpty(): FoldNode;
+    updateAtPath(rootNode: FoldNode, path: UnixEntryName[], update: (targetNode: FoldNode) => FoldNode): FoldNode;
+};
+//# sourceMappingURL=fold.d.ts.map

package/dist/domain/fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/domain/fold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC1C,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB,CAAC;AAEF,eAAO,MAAM,QAAQ;mBACJ,QAAQ;2BAQX,QAAQ,QACZ,aAAa,EAAE,UACb,CAAC,UAAU,EAAE,QAAQ,KAAK,QAAQ,GACzC,QAAQ;CAmBZ,CAAC"}

package/dist/domain/fold.js

@@ -0,0 +1,24 @@
+export const FoldNode = {
+    createEmpty() {
+        return {
+            children: Object.create(null),
+            folds: [],
+        };
+    },
+    updateAtPath(rootNode, path, update) {
+        const [currentName, ...remainingPath] = path;
+        // Base case
+        if (currentName === undefined) {
+            return update(rootNode);
+        }
+        // Create childNode to create path in tree to the needed node
+        const childNode = rootNode.children[currentName] ?? FoldNode.createEmpty();
+        return {
+            ...rootNode,
+            children: {
+                ...rootNode.children,
+                [currentName]: FoldNode.updateAtPath(childNode, remainingPath, update),
+            },
+        };
+    }
+};

package/dist/domain/navigation-entry.d.ts

@@ -0,0 +1,23 @@
+import { UnixEntryName } from './unix-entry.js';
+import { UnixPath } from './unix-path.js';
+import { State } from './state.js';
+export type NavigationEntry = {
+    kind: 'file';
+    name: UnixEntryName;
+} | {
+    kind: 'symlink';
+    name: UnixEntryName;
+    target: UnixPath;
+} | {
+    kind: 'directory';
+    name: UnixEntryName;
+    node?: NavigationNode;
+};
+export type NavigationNode = {
+    entries: NavigationEntry[];
+    foldedEntries: NavigationEntry[];
+};
+export declare const NavigationNode: {
+    derive(state: State): NavigationNode;
+};
+//# sourceMappingURL=navigation-entry.d.ts.map

package/dist/domain/navigation-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-entry.d.ts","sourceRoot":"","sources":["../../src/domain/navigation-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGnC,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAEN,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,cAAc;kBACX,KAAK,GAAG,cAAc;CAGrC,CAAC"}

package/dist/domain/navigation-entry.js

@@ -0,0 +1,52 @@
+export const NavigationNode = {
+    derive(state) {
+        return deriveNode(state.buffer.entries, state.folds);
+    },
+};
+function deriveNode(entries, foldNode) {
+    if (entries === undefined) {
+        return {
+            entries: [],
+            foldedEntries: [],
+        };
+    }
+    const foldedNames = new Set(foldNode?.folds ?? []);
+    const visibleEntries = [];
+    const foldedEntries = [];
+    for (const entry of entries) {
+        const navigationEntry = deriveEntry(entry, foldNode?.children[entry.name]);
+        if (foldedNames.has(entry.name)) {
+            foldedEntries.push(navigationEntry);
+        }
+        else {
+            visibleEntries.push(navigationEntry);
+        }
+    }
+    return {
+        entries: visibleEntries,
+        foldedEntries,
+    };
+}
+function deriveEntry(entry, foldNode) {
+    switch (entry.kind) {
+        case 'file':
+            return {
+                kind: 'file',
+                name: entry.name,
+            };
+        case 'symlink':
+            return {
+                kind: 'symlink',
+                name: entry.name,
+                target: entry.target,
+            };
+        case 'directory':
+            return {
+                kind: 'directory',
+                name: entry.name,
+                node: entry.entries === undefined
+                    ? undefined
+                    : deriveNode(entry.entries, foldNode),
+            };
+    }
+}

package/dist/domain/navigation-node.d.ts

@@ -0,0 +1,43 @@
+import { UnixEntry, UnixEntryName, UnixEntryPath } from './unix-entry.js';
+import { UnixPath } from './unix-path.js';
+import { FoldNode } from './fold-node.js';
+import { Cursor } from './cursor.js';
+export type NavigationEntry = {
+    kind: 'file';
+    name: UnixEntryName;
+} | {
+    kind: 'symlink';
+    name: UnixEntryName;
+    target: UnixPath;
+} | {
+    /**
+     * Undefined node means the directory has not been loaded.
+     */
+    kind: 'directory';
+    name: UnixEntryName;
+    node?: NavigationNode;
+};
+/**
+ * A directory as navigated: list of visible entries and folded entries.
+ */
+export type NavigationNode = {
+    /**
+     * Currently visible entries.
+     */
+    entries: NavigationEntry[];
+    /**
+     * Currently loaded entries hidden by this directory's fold.
+     */
+    foldedEntries: NavigationEntry[];
+};
+export declare const NavigationNode: {
+    from(entries: UnixEntry[] | undefined, foldNode: FoldNode | undefined): NavigationNode;
+    getNodeAtPath(navigation: NavigationNode, path: UnixEntryPath): NavigationNode | undefined;
+    getEntryAtPath(navigation: NavigationNode, path: UnixEntryPath): NavigationEntry | undefined;
+    nextCursor(rootNode: NavigationNode, cursor: Cursor): Cursor | undefined;
+    previousCursor(rootNode: NavigationNode, cursor: Cursor): Cursor | undefined;
+    cursorAfterFold(rootNode: NavigationNode, cursor: Cursor): Cursor | undefined;
+    parentCursor(navigation: NavigationNode, cursor: Cursor): Cursor | undefined;
+    visibleFilesPaths(navigation: NavigationNode, parentPath?: UnixEntryPath): UnixEntryPath[];
+};
+//# sourceMappingURL=navigation-node.d.ts.map

package/dist/domain/navigation-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-node.d.ts","sourceRoot":"","sources":["../../src/domain/navigation-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAEN;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,OAAO,EAAE,eAAe,EAAE,CAAC;IAE3B;;OAEG;IACH,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,cAAc;kBAEd,SAAS,EAAE,GAAG,SAAS,YACtB,QAAQ,GAAG,SAAS,GAC7B,cAAc;8BA4DH,cAAc,QACpB,aAAa,GAClB,cAAc,GAAG,SAAS;+BAyBf,cAAc,QACpB,aAAa,GAClB,eAAe,GAAG,SAAS;yBA0BT,cAAc,UAAU,MAAM,GAAG,MAAM,GAAG,SAAS;6BAc/C,cAAc,UAAU,MAAM,GAAG,MAAM,GAAG,SAAS;8BAehE,cAAc,UAChB,MAAM,GACb,MAAM,GAAG,SAAS;6BAsCI,cAAc,UAAU,MAAM,GAAG,MAAM,GAAG,SAAS;kCA6B9D,cAAc,eACd,aAAa,GACxB,aAAa,EAAE;CA2BnB,CAAC"}

package/dist/domain/navigation-node.js

@@ -0,0 +1,198 @@
+import { UnixEntryPath } from './unix-entry.js';
+import { Cursor } from './cursor.js';
+export const NavigationNode = {
+    from(entries, foldNode) {
+        if (entries === undefined) {
+            return {
+                entries: [],
+                foldedEntries: [],
+            };
+        }
+        const foldedNames = new Set(foldNode?.folds ?? []);
+        const visibleEntries = [];
+        const foldedEntries = [];
+        for (const entry of entries) {
+            let navigationEntry;
+            switch (entry.kind) {
+                case 'file':
+                    navigationEntry = {
+                        kind: 'file',
+                        name: entry.name,
+                    };
+                    break;
+                case 'symlink':
+                    navigationEntry = {
+                        kind: 'symlink',
+                        name: entry.name,
+                        target: entry.target,
+                    };
+                    break;
+                case 'directory': {
+                    const childFoldNode = foldNode?.children[entry.name];
+                    navigationEntry = {
+                        kind: 'directory',
+                        name: entry.name,
+                        node: entry.entries === undefined
+                            ? undefined
+                            : NavigationNode.from(entry.entries, childFoldNode),
+                    };
+                    break;
+                }
+            }
+            if (foldedNames.has(entry.name)) {
+                foldedEntries.push(navigationEntry);
+            }
+            else {
+                visibleEntries.push(navigationEntry);
+            }
+        }
+        return {
+            entries: visibleEntries,
+            foldedEntries,
+        };
+    },
+    getNodeAtPath(navigation, path) {
+        const [currentName, ...remainingPath] = path;
+        // An empty path identifies the current node.
+        if (currentName === undefined) {
+            return navigation;
+        }
+        const entry = [...navigation.entries, ...navigation.foldedEntries].find((candidate) => candidate.name === currentName);
+        if (entry === undefined || entry.kind !== 'directory') {
+            return undefined;
+        }
+        // The directory has not been loaded/opened.
+        if (entry.node === undefined) {
+            return undefined;
+        }
+        return NavigationNode.getNodeAtPath(entry.node, remainingPath);
+    },
+    getEntryAtPath(navigation, path) {
+        const [currentName, ...remainingPath] = path;
+        if (currentName === undefined) {
+            return undefined;
+        }
+        const entry = [...navigation.entries, ...navigation.foldedEntries].find((candidate) => candidate.name === currentName);
+        if (entry === undefined) {
+            return undefined;
+        }
+        if (remainingPath.length === 0) {
+            return entry;
+        }
+        if (entry.kind !== 'directory' || entry.node === undefined) {
+            return undefined;
+        }
+        return NavigationNode.getEntryAtPath(entry.node, remainingPath);
+    },
+    nextCursor(rootNode, cursor) {
+        const cursors = cursorsInNode(rootNode, []);
+        const currentIndex = cursors.findIndex((candidate) => Cursor.equal(candidate, cursor));
+        if (currentIndex === -1 || currentIndex === cursors.length - 1) {
+            return undefined;
+        }
+        return cursors[currentIndex + 1];
+    },
+    previousCursor(rootNode, cursor) {
+        const cursors = cursorsInNode(rootNode, []);
+        const currentIndex = cursors.findIndex((candidate) => Cursor.equal(candidate, cursor));
+        if (currentIndex <= 0) {
+            return undefined;
+        }
+        return cursors[currentIndex - 1];
+    },
+    cursorAfterFold(rootNode, cursor) {
+        if (cursor.kind === 'fold') {
+            return undefined;
+        }
+        const cursors = cursorsInNode(rootNode, []);
+        const currentIndex = cursors.findIndex((candidate) => Cursor.equal(candidate, cursor));
+        if (currentIndex === -1) {
+            return undefined;
+        }
+        const foldedPath = [...cursor.parentPath, cursor.entryName];
+        for (let index = currentIndex + 1; index < cursors.length; index += 1) {
+            const candidate = cursors[index];
+            if (candidate === undefined) {
+                continue;
+            }
+            if (cursorBelongsToSubtree(candidate, foldedPath)) {
+                continue;
+            }
+            return candidate;
+        }
+        // The fold row will be created at the end of this directory.
+        return {
+            kind: 'fold',
+            parentPath: cursor.parentPath,
+        };
+    },
+    parentCursor(navigation, cursor) {
+        const parentPath = cursor.parentPath;
+        // The cursor is already in the root directory.
+        if (parentPath.length === 0) {
+            return undefined;
+        }
+        const entryName = parentPath.at(-1);
+        if (entryName === undefined) {
+            return undefined;
+        }
+        const containingPath = parentPath.slice(0, -1);
+        const entry = NavigationNode.getEntryAtPath(navigation, parentPath);
+        if (entry === undefined || entry.kind !== 'directory') {
+            return undefined;
+        }
+        return {
+            kind: 'entry',
+            parentPath: containingPath,
+            entryName,
+        };
+    },
+    visibleFilesPaths(navigation, parentPath = []) {
+        const paths = [];
+        for (const entry of navigation.entries) {
+            const entryPath = [...parentPath, entry.name];
+            switch (entry.kind) {
+                case 'file':
+                    paths.push(entryPath);
+                    break;
+                case 'symlink':
+                    // Do not recurse through symlinks.
+                    break;
+                case 'directory':
+                    if (entry.node !== undefined) {
+                        paths.push(...NavigationNode.visibleFilesPaths(entry.node, entryPath));
+                    }
+                    break;
+            }
+        }
+        return paths;
+    },
+};
+function cursorsInNode(node, parentPath) {
+    const cursors = [];
+    for (const entry of node.entries) {
+        cursors.push({
+            kind: 'entry',
+            parentPath,
+            entryName: entry.name,
+        });
+        if (entry.kind !== 'directory' || entry.node === undefined) {
+            continue;
+        }
+        cursors.push(...cursorsInNode(entry.node, [...parentPath, entry.name]));
+    }
+    if (node.foldedEntries.length > 0) {
+        cursors.push({
+            kind: 'fold',
+            parentPath,
+        });
+    }
+    return cursors;
+}
+function cursorBelongsToSubtree(cursor, entryPath) {
+    if (cursor.kind === 'fold') {
+        return UnixEntryPath.isStrictPathPrefix(entryPath, cursor.parentPath);
+    }
+    const cursorPath = [...cursor.parentPath, cursor.entryName];
+    return UnixEntryPath.isStrictPathPrefix(entryPath, cursorPath);
+}

package/dist/domain/state.d.ts

@@ -0,0 +1,12 @@
+import { UnixEntry } from './unix-entry.js';
+import type { FoldNode } from './fold-node.js';
+import { Cursor } from './cursor.js';
+export type State = {
+    buffer: UnixEntry[];
+    folds: FoldNode;
+    cursor: Cursor;
+};
+export declare const View: {
+    getEntryAtCursor(view: State): UnixEntry | undefined;
+};
+//# sourceMappingURL=state.d.ts.map

package/dist/domain/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/domain/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,MAAM,KAAK,GAAG;IAClB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,IAAI;2BACQ,KAAK,GAAG,SAAS,GAAG,SAAS;CAUrD,CAAA"}

package/dist/domain/state.js

@@ -0,0 +1,12 @@
+import { UnixEntry } from './unix-entry.js';
+import { Cursor } from './cursor.js';
+export const View = {
+    getEntryAtCursor(view) {
+        const path = Cursor.getPath(view.cursor);
+        // Nothing on folds
+        if (path === undefined) {
+            return undefined;
+        }
+        return UnixEntry.getEntryAtPath(view.buffer, path);
+    }
+};

package/dist/domain/unix-entry.d.ts

@@ -15,4 +15,14 @@ export type UnixEntry = {
     name: UnixEntryName;
     entries?: UnixEntry[];
 };
+export declare const UnixEntry: {
+    getEntryAtPath(entries: UnixEntry[], path: UnixEntryPath): UnixEntry | undefined;
+    getEntriesAtPath(entries: UnixEntry[], path: UnixEntryPath): UnixEntry[] | undefined;
+    setEntriesAtPath(entries: UnixEntry[], path: UnixEntryPath, newEntries: UnixEntry[] | undefined): UnixEntry[];
+};
+export type UnixEntryPath = UnixEntryName[];
+export declare const UnixEntryPath: {
+    equal(left: UnixEntryPath, right: UnixEntryPath): boolean;
+    isStrictPathPrefix(prefix: UnixEntryPath, path: UnixEntryPath): boolean;
+};
 //# sourceMappingURL=unix-entry.d.ts.map

package/dist/domain/unix-entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unix-entry.d.ts","sourceRoot":"","sources":["../../src/domain/unix-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG1C,eAAO,MAAM,mBAAmB,aAQ5B,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEjE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EAAE,EACrB,KAAK,EAAE,aAAa,EAAE,GACrB,OAAO,CAKT;AAED,MAAM,MAAM,SAAS,GACjB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IAEpB,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;CACvB,CAAC"}
+{"version":3,"file":"unix-entry.d.ts","sourceRoot":"","sources":["../../src/domain/unix-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI1C,eAAO,MAAM,mBAAmB,aAQ5B,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEjE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EAAE,EACrB,KAAK,EAAE,aAAa,EAAE,GACrB,OAAO,CAKT;AAED,MAAM,MAAM,SAAS,GACjB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IAEpB,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;CACvB,CAAC;AAEN,eAAO,MAAM,SAAS;4BAGT,SAAS,EAAE,QACd,aAAa,GAClB,SAAS,GAAG,SAAS;8BA6Bb,SAAS,EAAE,QACd,aAAa,GAClB,SAAS,EAAE,GAAG,SAAS;8BAgBf,SAAS,EAAE,QACd,aAAa,cACP,SAAS,EAAE,GAAG,SAAS,GAClC,SAAS,EAAE;CAyDf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,aAAa,EAAE,CAAC;AAE5C,eAAO,MAAM,aAAa;gBACZ,aAAa,SAAS,aAAa,GAAG,OAAO;+BAK/C,aAAa,QACf,aAAa,GAClB,OAAO;CAOX,CAAA"}

package/dist/domain/unix-entry.js

@@ -13,3 +13,84 @@ export function entryNamesEqual(left, right) {
     return (left.length === right.length &&
         left.every((name, index) => name === right[index]));
 }
+export const UnixEntry = {
+    // Query-Like
+    getEntryAtPath(entries, path) {
+        if (path.length === 0) {
+            return undefined;
+        }
+        let entry;
+        for (const [index, name] of path.entries()) {
+            entry = entries.find((candidate) => candidate.name === name);
+            if (entry === undefined) {
+                return undefined;
+            }
+            if (index === path.length - 1) {
+                return entry;
+            }
+            if (entry.kind !== 'directory' || entry.entries === undefined) {
+                return undefined;
+            }
+            entries = entry.entries;
+        }
+        return undefined;
+    },
+    getEntriesAtPath(entries, path) {
+        if (path.length === 0) {
+            return entries;
+        }
+        const entry = UnixEntry.getEntryAtPath(entries, path);
+        if (entry?.kind !== 'directory') {
+            return undefined;
+        }
+        return entry.entries;
+    },
+    // Command/Modifer-Like
+    setEntriesAtPath(entries, path, newEntries) {
+        const [currentName, ...remainingPath] = path;
+        if (currentName === undefined) {
+            throw new Error('Cannot update directory entries with an empty path');
+        }
+        let found = false;
+        const updatedEntries = entries.map((entry) => {
+            if (entry.name !== currentName) {
+                return entry;
+            }
+            found = true;
+            if (remainingPath.length === 0) {
+                if (entry.kind !== 'directory') {
+                    throw new Error(`Cannot update entries for non-directory entry "${entry.name}"`);
+                }
+                return {
+                    ...entry,
+                    entries: newEntries,
+                };
+            }
+            if (entry.kind !== 'directory') {
+                throw new Error(`Cannot descend through non-directory entry "${entry.name}"`);
+            }
+            if (entry.entries === undefined) {
+                throw new Error(`Cannot descend into unexpanded directory "${entry.name}"`);
+            }
+            return {
+                ...entry,
+                entries: UnixEntry.setEntriesAtPath(entry.entries, remainingPath, newEntries),
+            };
+        });
+        if (!found) {
+            throw new Error(`Directory path does not contain entry "${currentName}"`);
+        }
+        return updatedEntries;
+    },
+};
+export const UnixEntryPath = {
+    equal(left, right) {
+        return entryNamesEqual(left, right);
+    },
+    isStrictPathPrefix(prefix, path) {
+        if (path.length <= prefix.length) {
+            return false;
+        }
+        return prefix.every((name, index) => path[index] === name);
+    }
+};

package/dist/domain/view.d.ts

@@ -1,11 +1,6 @@
-import { UnixEntry, UnixEntryName } from './unix-entry.js';
-import { DisplayRow } from './display-row.js';
-export type FoldNode = {
-    children: Record<UnixEntryName, FoldNode>;
-    folds: UnixEntryName[];
-};
-export declare function createEmptyFoldNode(): FoldNode;
-export type Cursor = DisplayRow;
+import { UnixEntry } from './unix-entry.js';
+import type { FoldNode } from './fold-node.js';
+import { Cursor } from './cursor.js';
 export type DirectoryBuffer = {
     entries: UnixEntry[];
 };
@@ -14,4 +9,7 @@ export type View = {
     folds: FoldNode;
     cursor: Cursor;
 };
+export declare const View: {
+    getEntryAtCursor(view: View): UnixEntry | undefined;
+};
 //# sourceMappingURL=view.d.ts.map

package/dist/domain/view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../src/domain/view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC1C,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB,CAAC;AAEF,wBAAgB,mBAAmB,IAAI,QAAQ,CAK9C;AAED,MAAM,MAAM,MAAM,GAAG,UAAU,CAAC;AAEhC,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,SAAS,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../src/domain/view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,SAAS,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,IAAI;2BACQ,IAAI,GAAG,SAAS,GAAG,SAAS;CAUpD,CAAA"}

package/dist/domain/view.js

@@ -1,6 +1,12 @@
-export function createEmptyFoldNode() {
-    return {
-        children: Object.create(null),
-        folds: [],
-    };
-}
+import { UnixEntry } from './unix-entry.js';
+import { Cursor } from './cursor.js';
+export const View = {
+    getEntryAtCursor(view) {
+        const path = Cursor.getPath(view.cursor);
+        // Nothing on folds
+        if (path === undefined) {
+            return undefined;
+        }
+        return UnixEntry.getEntryAtPath(view.buffer.entries, path);
+    }
+};

package/dist/index.d.ts

@@ -1,7 +1,10 @@
+export * from './domain/cursor.js';
 export * from './domain/display-row.js';
+export * from './domain/fold-node.js';
+export * from './domain/navigation-node.js';
+export * from './domain/state.js';
 export * from './domain/unix-entry.js';
 export * from './domain/unix-path.js';
-export * from './domain/view.js';
 export * from './infrastructure/get-cwd.js';
 export * from './infrastructure/get-dir-lazy-entries.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC"}

package/dist/index.js

@@ -1,6 +1,9 @@
+export * from './domain/cursor.js';
 export * from './domain/display-row.js';
+export * from './domain/fold-node.js';
+export * from './domain/navigation-node.js';
+export * from './domain/state.js';
 export * from './domain/unix-entry.js';
 export * from './domain/unix-path.js';
-export * from './domain/view.js';
 export * from './infrastructure/get-cwd.js';
 export * from './infrastructure/get-dir-lazy-entries.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirvi-lib",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Dependency for dirvi apps.",
   "license": "LGPL-3.0-or-later",
   "type": "module",