@danypops/pi-lector 0.13.7 → 0.13.9

package/extension/src/editor/explorer-component.ts

@@ -9,7 +9,14 @@ import type { EditorTheme } from "./editor-theme.ts";
 import type { ExplorerDiff, ExplorerEntry } from "./explorer-diff.ts";
 import { diffExplorerLines, formatExplorerLine, parseExplorerLine } from "./explorer-diff.ts";
 
-export type ExplorerResult = { kind: "quit" } | { kind: "open-file"; absolutePath: string };
+/** Restores one Workspace's directory and active entry when its Explorer becomes visible again. */
+export interface ExplorerViewState {
+	readonly relativePath: string;
+	readonly selectedEntryName?: string;
+}
+
+/** Reports why the Explorer closed plus its latest restorable location when the host supports view-state persistence. */
+export type ExplorerResult = { kind: "quit"; viewState?: ExplorerViewState } | { kind: "open-file"; absolutePath: string; viewState?: ExplorerViewState };
 
 /** Joins a directory-relative name onto `directory` ("" means the resolved root itself). */
 export function joinExplorerPath(directory: string, name: string): string {
@@ -51,12 +58,19 @@ export class ExplorerComponent implements Component {
 	private statusMessage = "";
 	private confirming: PendingConfirmation | undefined;
 
-	constructor(tui: TUI, theme: EditorTheme, session: DirectoryExplorerSession, initialRelativePath: string, done: (result: ExplorerResult) => void) {
+	constructor(
+		tui: TUI,
+		theme: EditorTheme,
+		session: DirectoryExplorerSession,
+		initialRelativePath: string,
+		done: (result: ExplorerResult) => void,
+		initialSelectedEntryName?: string,
+	) {
 		this.tui = tui;
 		this.theme = theme;
 		this.session = session;
 		this.done = done;
-		this.pending = this.loadDirectory(initialRelativePath).catch((error: unknown) => this.reportError(error));
+		this.pending = this.loadDirectory(initialRelativePath, initialSelectedEntryName).catch((error: unknown) => this.reportError(error));
 	}
 
 	private pending: Promise<void> = Promise.resolve();
@@ -111,13 +125,20 @@ export class ExplorerComponent implements Component {
 		this.tui.requestRender();
 	}
 
-	private async loadDirectory(relativePath: string): Promise<void> {
+	private async loadDirectory(relativePath: string, selectedEntryName?: string): Promise<void> {
 		const listing = await this.session.listDirectory(relativePath);
 		this.currentPath = relativePath;
 		this.nextId = 1;
 		this.entries = listing.entries.map((entry) => ({ id: this.nextId++, name: entry.name, kind: entry.kind }));
 		const text = this.entries.length > 0 ? this.entries.map((entry) => formatExplorerLine(entry)).join("\n") : "";
 		this.state = new EditorState(text);
+		const selectedIndex = selectedEntryName === undefined ? -1 : this.entries.findIndex((entry) => entry.name === selectedEntryName);
+		const selectedEntry = selectedIndex >= 0 ? this.entries[selectedIndex] : undefined;
+		if (selectedEntry) {
+			this.state.cursorLine = selectedIndex + 1;
+			this.state.cursorCharacter = `${selectedEntry.id} `.length + 1;
+			this.scrollToKeepCursorVisible();
+		}
 		this.confirming = undefined;
 		this.statusMessage = "";
 		this.tui.requestRender();
@@ -133,12 +154,17 @@ export class ExplorerComponent implements Component {
 			await this.loadDirectory(joinExplorerPath(this.currentPath, entry.name));
 			return;
 		}
-		this.done({ kind: "open-file", absolutePath: join(this.session.root, joinExplorerPath(this.currentPath, entry.name)) });
+		this.done({
+			kind: "open-file",
+			absolutePath: join(this.session.root, joinExplorerPath(this.currentPath, entry.name)),
+			viewState: { relativePath: this.currentPath, selectedEntryName: entry.name },
+		});
 	}
 
 	private async navigateToParent(): Promise<void> {
 		if (this.currentPath === "") return; // already at the resolved root -- v1 never widens scope above it
-		await this.loadDirectory(parentExplorerPath(this.currentPath));
+		const childName = posix.basename(this.currentPath);
+		await this.loadDirectory(parentExplorerPath(this.currentPath), childName);
 	}
 
 	private async performAction(action: EditorAction): Promise<void> {
@@ -149,14 +175,14 @@ export class ExplorerComponent implements Component {
 				this.state.dirty = false;
 				if (diffs.length === 0) {
 					this.statusMessage = "no changes";
-					if (action.kind === "save-and-quit") this.done({ kind: "quit" });
+					if (action.kind === "save-and-quit") this.done({ kind: "quit", viewState: this.viewState() });
 					return;
 				}
 				this.confirming = { diffs, andQuit: action.kind === "save-and-quit" };
 				return;
 			}
 			case "quit":
-				this.done({ kind: "quit" });
+				this.done({ kind: "quit", viewState: this.viewState() });
 				return;
 			case "hover":
 				this.statusMessage = "hover is not applicable in the file explorer";
@@ -186,13 +212,19 @@ export class ExplorerComponent implements Component {
 			return;
 		}
 		if (andQuit) {
-			this.done({ kind: "quit" });
+			this.done({ kind: "quit", viewState: this.viewState() });
 			return;
 		}
 		await this.loadDirectory(this.currentPath);
 		this.statusMessage = "applied";
 	}
 
+	private viewState(): ExplorerViewState {
+		const parsed = parseExplorerLine(this.state.currentLineText);
+		const entry = !parsed || parsed.id === null ? undefined : this.entries.find((candidate) => candidate.id === parsed.id);
+		return entry ? { relativePath: this.currentPath, selectedEntryName: entry.name } : { relativePath: this.currentPath };
+	}
+
 	private scrollToKeepCursorVisible(): void {
 		const viewportHeight = Math.max(1, this.tui.terminal.rows - 2);
 		if (this.state.cursorLine < this.scrollTop) this.scrollTop = this.state.cursorLine;

package/extension/src/editor/explorer-flow.ts

@@ -1,10 +1,10 @@
-import { dirname, relative } from "node:path";
+import { basename, dirname, relative } from "node:path";
 import type { DirectoryExplorerSession } from "./directory-explorer-operations.ts";
-import type { ExplorerResult } from "./explorer-component.ts";
+import type { ExplorerResult, ExplorerViewState } from "./explorer-component.ts";
 
 export interface ExplorerFlowHost {
-	/** Shows the explorer at `relativePath` (root-relative, "" for the resolved root) and resolves once the user quits or opens a file. */
-	showExplorer(session: DirectoryExplorerSession, relativePath: string): Promise<ExplorerResult>;
+	/** Shows the explorer at `relativePath` (root-relative, "" for the resolved root), optionally revealing one active entry, and resolves once the user quits or opens a file. */
+	showExplorer(session: DirectoryExplorerSession, relativePath: string, selectedEntryName?: string): Promise<ExplorerResult>;
 	/** Shows the real file editor for `absolutePath` and resolves once the user quits it. */
 	showEditor(absolutePath: string): Promise<void>;
 }
@@ -14,14 +14,21 @@ export interface ExplorerFlowHost {
  * the explorer -- at the directory the opened file lives in, not the resolved root -- once that
  * editor quits, rather than closing the whole session after the first file opened.
  */
-export async function runExplorerFlow(session: DirectoryExplorerSession, host: ExplorerFlowHost): Promise<void> {
-	let relativePath = "";
+export async function runExplorerFlow(
+	session: DirectoryExplorerSession,
+	host: ExplorerFlowHost,
+	initialViewState: ExplorerViewState = { relativePath: "" },
+): Promise<ExplorerViewState> {
+	let viewState = initialViewState;
 	for (;;) {
-		const result = await host.showExplorer(session, relativePath);
-		if (result.kind === "quit") return;
+		const result = await host.showExplorer(session, viewState.relativePath, viewState.selectedEntryName);
+		if (result.kind === "quit") return result.viewState ?? viewState;
 
 		await host.showEditor(result.absolutePath);
 		// path.relative(root, root) is "" directly, matching ExplorerComponent's own root-relative convention -- no "." case to normalize.
-		relativePath = relative(session.root, dirname(result.absolutePath));
+		viewState = result.viewState ?? {
+			relativePath: relative(session.root, dirname(result.absolutePath)),
+			selectedEntryName: basename(result.absolutePath),
+		};
 	}
 }

package/extension/src/editor/index.ts

@@ -31,7 +31,7 @@
 export type { DirectoryExplorerSession } from "./directory-explorer-operations.ts";
 export { type EditorAction, type EditorMode, EditorState } from "./editor-state.ts";
 export type { EditorTheme } from "./editor-theme.ts";
-export { ExplorerComponent, type ExplorerResult, joinExplorerPath } from "./explorer-component.ts";
+export { ExplorerComponent, type ExplorerResult, type ExplorerViewState, joinExplorerPath } from "./explorer-component.ts";
 // runExplorerFlow is pure orchestration over the two interfaces above (browse, open a file into
 // the real editor, return to the explorer at that file's own directory once it quits) -- exported
 // for the same reason ExplorerComponent/DirectoryExplorerSession are: any real host can drive this

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.13.7",
+	"version": "0.13.9",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",