dirvi-lib 0.2.0 → 0.4.0

package/dist/domain/navigation-node.js

@@ -0,0 +1,210 @@
+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,CAAC"}

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

@@ -2,17 +2,43 @@ import { z } from 'zod';
 import { UnixPath } from './unix-path.js';
 export declare const UnixEntryNameSchema: z.ZodString;
 export type UnixEntryName = z.output<typeof UnixEntryNameSchema>;
-export declare function entryNamesEqual(left: UnixEntryName[], right: UnixEntryName[]): boolean;
-export type UnixEntry = {
-    kind: 'file';
-    name: UnixEntryName;
-} | {
-    kind: 'symlink';
-    name: UnixEntryName;
-    target: UnixPath;
-} | {
-    kind: 'directory';
-    name: UnixEntryName;
-    entries?: UnixEntry[];
+export declare function entryNamesEqual(
+  left: UnixEntryName[],
+  right: UnixEntryName[],
+): boolean;
+export type UnixEntry =
+  | {
+      kind: 'file';
+      name: UnixEntryName;
+    }
+  | {
+      kind: 'symlink';
+      name: UnixEntryName;
+      target: UnixPath;
+    }
+  | {
+      kind: 'directory';
+      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[];
 };
-//# sourceMappingURL=unix-entry.d.ts.map
+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;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;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;+BAI9B,aAAa,QAAQ,aAAa,GAAG,OAAO;CAOxE,CAAC"}

package/dist/domain/unix-entry.js

@@ -1,15 +1,108 @@
 import { z } from 'zod';
 // UNIX ENTRY
 export const UnixEntryNameSchema = z
-    .string()
-    .min(1)
-    .refine((value) => !value.includes('/'), {
+  .string()
+  .min(1)
+  .refine((value) => !value.includes('/'), {
     message: "Entry name must not contain '/'",
-})
-    .refine((value) => value !== '.' && value !== '..', {
+  })
+  .refine((value) => value !== '.' && value !== '..', {
     message: "Entry name cannot be '.' or '..'",
-});
+  });
 export function entryNamesEqual(left, right) {
-    return (left.length === right.length &&
-        left.every((name, index) => name === right[index]));
+  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/unix-path.d.ts

@@ -3,4 +3,4 @@ export declare const UnixPathSchema: z.ZodString;
 export type UnixPath = z.output<typeof UnixPathSchema>;
 export declare const UnixAbsolutePathSchema: z.ZodString;
 export type UnixAbsolutePath = z.output<typeof UnixAbsolutePathSchema>;
-//# sourceMappingURL=unix-path.d.ts.map
+//# sourceMappingURL=unix-path.d.ts.map

package/dist/domain/unix-path.js

@@ -1,11 +1,14 @@
 import { z } from 'zod';
 // UNIX PATHS
 export const UnixPathSchema = z
-    .string()
-    .min(1)
-    .refine((value) => !value.includes('\0'), {
+  .string()
+  .min(1)
+  .refine((value) => !value.includes('\0'), {
     message: 'Unix paths must not contain null bytes',
-});
-export const UnixAbsolutePathSchema = UnixPathSchema.refine((value) => value.startsWith('/'), {
+  });
+export const UnixAbsolutePathSchema = UnixPathSchema.refine(
+  (value) => value.startsWith('/'),
+  {
     message: 'Path must be an absolute Unix path',
-});
+  },
+);

package/dist/domain/user-input.d.ts

@@ -0,0 +1,27 @@
+export type UserInput =
+  | {
+      userInputType: 'character';
+      string: string;
+    }
+  | {
+      userInputType: 'enter';
+    }
+  | {
+      userInputType: 'backspace';
+    }
+  | {
+      userInputType: 'esc';
+    }
+  | {
+      userInputType: 'rightArrow';
+    }
+  | {
+      userInputType: 'leftArrow';
+    }
+  | {
+      userInputType: 'downArrow';
+    }
+  | {
+      userInputType: 'upArrow';
+    };
+//# sourceMappingURL=user-input.d.ts.map

package/dist/domain/user-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-input.d.ts","sourceRoot":"","sources":["../../src/domain/user-input.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GACjB;IACE,aAAa,EAAE,WAAW,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IACE,aAAa,EAAE,OAAO,CAAC;CACxB,GACD;IACE,aAAa,EAAE,WAAW,CAAC;CAC5B,GACD;IACE,aAAa,EAAE,KAAK,CAAC;CACtB,GACD;IACE,aAAa,EAAE,YAAY,CAAC;CAC7B,GACD;IACE,aAAa,EAAE,WAAW,CAAC;CAC5B,GACD;IACE,aAAa,EAAE,WAAW,CAAC;CAC5B,GACD;IACE,aAAa,EAAE,SAAS,CAAC;CAC1B,CAAC"}

package/dist/domain/user-input.js

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

package/dist/index.d.ts

@@ -1,7 +1,15 @@
+export * from './application/user-input-to-intent.js';
+export * from './application/intent-to-effect.js';
+export * from './domain/cursor.js';
 export * from './domain/display-row.js';
+export * from './domain/effect.js';
+export * from './domain/fold-node.js';
+export * from './domain/input-state.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 './domain/user-input.js';
 export * from './infrastructure/get-cwd.js';
 export * from './infrastructure/get-dir-lazy-entries.js';
-//# sourceMappingURL=index.d.ts.map
+//# 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,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAElD,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC"}

package/dist/index.js

@@ -1,6 +1,14 @@
+export * from './application/user-input-to-intent.js';
+export * from './application/intent-to-effect.js';
+export * from './domain/cursor.js';
 export * from './domain/display-row.js';
+export * from './domain/effect.js';
+export * from './domain/fold-node.js';
+export * from './domain/input-state.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 './domain/user-input.js';
 export * from './infrastructure/get-cwd.js';
 export * from './infrastructure/get-dir-lazy-entries.js';

package/dist/infrastructure/get-cwd.d.ts

@@ -1,3 +1,3 @@
 import type { UnixAbsolutePath } from '../domain/unix-path.js';
 export declare function getCwdAbsPath(): UnixAbsolutePath;
-//# sourceMappingURL=get-cwd.d.ts.map
+//# sourceMappingURL=get-cwd.d.ts.map

package/dist/infrastructure/get-cwd.js

@@ -1,13 +1,15 @@
 import { UnixAbsolutePathSchema } from '../domain/unix-path.js';
 export function getCwdAbsPath() {
-    const currentWorkingDirectory = process.cwd();
-    const result = UnixAbsolutePathSchema.safeParse(currentWorkingDirectory);
-    if (!result.success) {
-        const details = result.error.issues
-            .map((issue) => issue.message)
-            .join('; ');
-        throw new Error(`Bad path for current working directory ` +
-            `"${currentWorkingDirectory}": ${details}`);
-    }
-    return result.data;
+  const currentWorkingDirectory = process.cwd();
+  const result = UnixAbsolutePathSchema.safeParse(currentWorkingDirectory);
+  if (!result.success) {
+    const details = result.error.issues
+      .map((issue) => issue.message)
+      .join('; ');
+    throw new Error(
+      `Bad path for current working directory ` +
+        `"${currentWorkingDirectory}": ${details}`,
+    );
+  }
+  return result.data;
 }

package/dist/infrastructure/get-dir-lazy-entries.d.ts

@@ -1,4 +1,6 @@
 import type { UnixAbsolutePath } from '../domain/unix-path.js';
 import type { UnixEntry } from '../domain/unix-entry.js';
-export declare function getDirLazyEntries(address: UnixAbsolutePath): Promise<UnixEntry[]>;
-//# sourceMappingURL=get-dir-lazy-entries.d.ts.map
+export declare function getDirLazyEntries(
+  address: UnixAbsolutePath,
+): Promise<UnixEntry[]>;
+//# sourceMappingURL=get-dir-lazy-entries.d.ts.map

package/dist/infrastructure/get-dir-lazy-entries.js

@@ -3,32 +3,38 @@ import { join } from 'node:path';
 import { UnixPathSchema } from '../domain/unix-path.js';
 import { UnixEntryNameSchema } from '../domain/unix-entry.js';
 export async function getDirLazyEntries(address) {
-    const directoryEntries = await readdir(address, {
-        withFileTypes: true,
-    });
-    return Promise.all(directoryEntries.map(async (directoryEntry) => {
-        const name = UnixEntryNameSchema.parse(directoryEntry.name);
-        if (directoryEntry.isSymbolicLink()) {
-            const target = UnixPathSchema.parse(await readlink(join(address, directoryEntry.name)));
-            return {
-                kind: 'symlink',
-                name,
-                target,
-            };
-        }
-        if (directoryEntry.isDirectory()) {
-            return {
-                kind: 'directory',
-                name,
-                // Deliberately omitted: this directory has not been expanded.
-            };
-        }
-        if (directoryEntry.isFile()) {
-            return {
-                kind: 'file',
-                name,
-            };
-        }
-        throw new Error(`Unsupported filesystem entry "${join(address, directoryEntry.name)}"`);
-    }));
+  const directoryEntries = await readdir(address, {
+    withFileTypes: true,
+  });
+  return Promise.all(
+    directoryEntries.map(async (directoryEntry) => {
+      const name = UnixEntryNameSchema.parse(directoryEntry.name);
+      if (directoryEntry.isSymbolicLink()) {
+        const target = UnixPathSchema.parse(
+          await readlink(join(address, directoryEntry.name)),
+        );
+        return {
+          kind: 'symlink',
+          name,
+          target,
+        };
+      }
+      if (directoryEntry.isDirectory()) {
+        return {
+          kind: 'directory',
+          name,
+          // Deliberately omitted: this directory has not been expanded.
+        };
+      }
+      if (directoryEntry.isFile()) {
+        return {
+          kind: 'file',
+          name,
+        };
+      }
+      throw new Error(
+        `Unsupported filesystem entry "${join(address, directoryEntry.name)}"`,
+      );
+    }),
+  );
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "dirvi-lib",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Dependency for dirvi apps.",
   "license": "LGPL-3.0-or-later",
   "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
@@ -17,6 +18,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "format": "prettier . --write"
   }
 }