@ssebastien/tcmd 0.1.3 → 0.1.7

package/src/js/tcmd/core/os.js

@@ -14,6 +14,13 @@
 // - `edit(path)`: Promise<void> - $EDITOR (or vi)
 // - `run(command, options)`: Promise<void> - `$SHELL -c command` in
 //   `options.cwd`
+// - `copy(text)`: boolean - best-effort clipboard write. The TUI sends OSC 52
+//   through the renderer; the browser and desktop webview use the Clipboard
+//   API. False when the host has no clipboard.
+// - `canEdit`: boolean - whether `edit` can launch an editor at all. A host
+//   without one (the web's null adapter) sets it false, so Enter on a file
+//   falls back to the fullscreen inspector instead of erroring (see
+//   `core/commands#pane.enter`).
 
 // `node:child_process` is imported lazily: only `createNodeOs` needs it, so
 // bundles that use the null adapter (the web view, tests) never pull in a Node
@@ -29,9 +36,14 @@ function loadChildProcess() {
 
 // Function: createNodeOs
 // Node/Bun-backed host adapter. `suspend`/`resume` are optional hooks the TUI
-// uses to release and restore the terminal around interactive commands.
-function createNodeOs({ suspend, resume } = {}) {
+// uses to release and restore the terminal around interactive commands;
+// `copy` is the TUI's OSC 52 hook (`renderer.copyToClipboardOSC52`).
+function createNodeOs({ suspend, resume, copy } = {}) {
 	return {
+		canEdit: true,
+		copy(text) {
+			return Boolean(copy?.(`${text ?? ""}`))
+		},
 		async open(path) {
 			await openWith(path, openerCandidates())
 		},
@@ -48,14 +60,28 @@ function createNodeOs({ suspend, resume } = {}) {
 	}
 }
 
+// Function: copyToBrowserClipboard
+// Best-effort clipboard write for a browser or desktop webview. The write is
+// asynchronous but fire-and-forget; a refused write (no permission, no user
+// gesture) leaves the clipboard untouched.
+function copyToBrowserClipboard(text) {
+	const clipboard = globalThis.navigator?.clipboard
+	if (!clipboard?.writeText) return false
+	void clipboard.writeText(`${text ?? ""}`).catch(() => {})
+	return true
+}
+
 // Function: createNullOs
 // Host adapter for environments without a shell (web): every operation fails
 // with a clear message, which the dispatch path reports in the command bar.
+// Clipboard access is the exception: the browser has one.
 function createNullOs() {
 	const unsupported = (name) => async () => {
 		throw new Error(`${name} is not available in this environment`)
 	}
 	return {
+		canEdit: false,
+		copy: (text) => copyToBrowserClipboard(text),
 		open: unsupported("open"),
 		edit: unsupported("edit"),
 		run: unsupported("run"),
@@ -123,6 +149,6 @@ async function runDetached(command, args) {
 	})
 }
 
-export { createNodeOs, createNullOs }
+export { copyToBrowserClipboard, createNodeOs, createNullOs }
 
 // EOF

package/src/js/tcmd/core/pane.js

@@ -6,8 +6,11 @@
 // Module: tcmd/core/pane
 // A Pane is one column with a single directory: it owns that directory and
 // proxies its cells (path, entries, cursor, marks, disk, …) as pane-level
-// cells, so views and commands address the pane directly. Navigation is async
-// and updates the directory's `rawEntries` in place.
+// cells, so views and commands address the pane directly. Navigation reads the
+// target first and commits atomically (see `core/directory#read`), so the pane
+// keeps showing its current listing until the replacement is ready. The pane
+// also owns its navigation history (back/forward snapshots of the view), which
+// the session drives to restore position, selection and focus.
 
 import { cell } from "select/state/cells"
 import { createDirectory } from "./directory.js"
@@ -22,6 +25,23 @@ const PANE_BUFFERS = { left: "A", right: "B" }
 // destination (DST).
 const PANE_LABELS = { left: "SRC", right: "DST" }
 
+// Function: currentPaneId
+// The id of the pane that owns the current directory: the focused pane while
+// focus is on source/destination, the anchor pane otherwise.
+function currentPaneId(session) {
+	return session.currentId?.value ?? session.active?.value ?? "left"
+}
+
+// Function: currentPane
+// The pane that owns the current directory: the focused pane while focus is
+// on source/destination, the anchor pane while it is on an auxiliary column
+// (see `core/session`). Path-changing commands — open, up, history,
+// breadcrumbs, relative arguments — target it; only cursor movement follows
+// the focused column. `core/commands` keeps `pane()` for the latter.
+function currentPane(session) {
+	return session.panes[currentPaneId(session)] ?? session.panes.left
+}
+
 // Function: createPane
 // Creates a pane bound to a filesystem adapter at `path`.
 //
@@ -31,10 +51,10 @@ const PANE_LABELS = { left: "SRC", right: "DST" }
 // await pane.refresh()
 // pane.entries.value // sorted, filtered FileEntry[]
 // ```
-function createPane({ fs, path: initialPath } = {}) {
+function createPane({ fs, path: initialPath, context, watch } = {}) {
 	const pane = {}
 	pane.fs = fs
-	pane.directory = createDirectory({ fs, path: initialPath })
+	pane.directory = createDirectory({ fs, path: initialPath, context, watch })
 
 	// Proxy cells mirror the directory, so views address the pane uniformly.
 	const dir = pane.directory
@@ -46,29 +66,34 @@ function createPane({ fs, path: initialPath } = {}) {
 	pane.sort = dir.sort
 	pane.entries = dir.entries
 	pane.cursor = dir.cursor
-	pane.cursorStat = dir.cursorStat
 	pane.marked = dir.marked
 	pane.disk = dir.disk
 	pane.segments = dir.segments
+	pane.history = dir.history
+	pane.autoRefresh = dir.autoRefresh
 
 	// Function: current
 	// The pane's directory.
 	pane.current = () => pane.directory
 
 	// Function: refresh / navigate / up / open / back / forward /
-	// currentEntry / toggleMark / clearFilter — delegate to the directory.
+	// currentEntry / toggleMark / setFilter / clearFilter — delegate to the
+	// directory.
 	pane.refresh = () => pane.directory.refresh()
-	pane.navigate = (path) => pane.directory.navigate(path)
+	pane.setAutoRefresh = (enabled) => pane.directory.setAutoRefresh(enabled)
+	pane.navigate = (path, options) => pane.directory.navigate(path, options)
 	pane.up = () => pane.directory.up()
 	pane.open = () => pane.directory.open()
 	pane.back = () => pane.directory.back()
 	pane.forward = () => pane.directory.forward()
 	pane.currentEntry = () => pane.directory.currentEntry()
 	pane.toggleMark = () => pane.directory.toggleMark()
+	pane.setFilter = (query) => pane.directory.setFilter(query)
 	pane.clearFilter = () => pane.directory.clearFilter()
+	pane.setContext = (context) => pane.directory.setContext(context)
 	pane.dispose = () => pane.directory.dispose()
 
 	return pane
 }
 
-export { PANE_BUFFERS, PANE_LABELS, createPane }
+export { PANE_BUFFERS, PANE_LABELS, createPane, currentPane, currentPaneId }