@ssebastien/tcmd 0.1.4 → 0.1.7

package/src/js/tcmd/core/concurrency.js

@@ -0,0 +1,59 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-18
+
+// Module: tcmd/core/concurrency
+// Bounded async helpers. Both filesystem adapters list a directory by statting
+// every entry; doing that one await at a time starves the host's threadpool, so
+// each issues a bounded window of requests concurrently instead. `mapLimit`
+// bounds one pass; `createLimiter` bounds a recursive walk, where the fan-out
+// at each level would otherwise multiply. Pure, so the browser bundle can share
+// them with the Node adapter.
+
+// Function: mapLimit
+// `map` over `items` with at most `limit` mappers in flight, preserving order.
+async function mapLimit(items, limit, mapper) {
+	const result = new Array(items.length)
+	let next = 0
+	const worker = async () => {
+		while (next < items.length) {
+			const index = next++
+			result[index] = await mapper(items[index], index)
+		}
+	}
+	const workers = []
+	for (let i = 0; i < Math.min(limit, items.length); i++) workers.push(worker())
+	await Promise.all(workers)
+	return result
+}
+
+// Function: createLimiter
+// Wraps calls so at most `limit` run concurrently, queueing the rest. Unlike
+// `mapLimit`, every call shares one global slot, so a recursive walk can bound
+// its total in-flight work rather than multiplying the limit per level.
+function createLimiter(limit) {
+	let active = 0
+	const queue = []
+	const pump = () => {
+		if (active >= limit || queue.length === 0) return
+		active += 1
+		const { fn, resolve, reject } = queue.shift()
+		Promise.resolve()
+			.then(fn)
+			.then(resolve, reject)
+			.finally(() => {
+				active -= 1
+				pump()
+			})
+	}
+	return (fn) =>
+		new Promise((resolve, reject) => {
+			queue.push({ fn, resolve, reject })
+			pump()
+		})
+}
+
+export { createLimiter, mapLimit }
+
+// EOF

package/src/js/tcmd/core/decompress.js

@@ -0,0 +1,117 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-20
+
+// Module: tcmd/core/decompress
+// Head decompression for compressed previews. `core/session` reads a bounded
+// run of the file's raw bytes through the filesystem adapter and hands it here;
+// the result is the leading decompressed text (never more than the requested
+// budget), which the preview treats exactly like a plain text head.
+//
+// Gzip uses the platform's `DecompressionStream` (Bun and every browser ship
+// it). Bzip2 has no such primitive, so the vendored decoder does the work; its
+// output is a binary string that is decoded as UTF-8 here.
+
+import { bzip2 } from "../vendor/bzip2.js"
+import { PREVIEW_BYTES } from "./preview.js"
+
+// Constant: BZIP2_BLOCK_BYTES
+// A bzip2 stream decodes one block at a time and cannot emit anything until
+// the whole block is in hand. Block size 9 holds at most 900 kB, so reading
+// this much compressed data always covers the first block (plus its header).
+const BZIP2_BLOCK_BYTES = 1024 * 1024
+
+// Function: compressedBytes
+// How many raw bytes the adapter should read for a compression format: gzip
+// can be streamed and a preview-sized run is plenty; bzip2 needs its first
+// whole block.
+function compressedBytes(compression) {
+	return compression === "bzip2" ? BZIP2_BLOCK_BYTES : PREVIEW_BYTES
+}
+
+// Function: decompressHead
+// Leading `maxBytes` of decompressed text for `compression` ("gzip" or
+// "bzip2"). Throws on a corrupt or unsupported stream; callers fall back to a
+// metadata card.
+async function decompressHead(bytes, compression, maxBytes = PREVIEW_BYTES) {
+	if (compression === "gzip") return gunzipHead(bytes, maxBytes)
+	if (compression === "bzip2") return bunzip2Head(bytes, maxBytes)
+	throw new Error(`unsupported compression: ${compression}`)
+}
+
+// Function: gunzipHead
+// Streams gzip members and stops at `maxBytes` of output. A truncated head is
+// fine: the reader is cancelled once the budget is spent or the input ends.
+async function gunzipHead(bytes, maxBytes) {
+	const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"))
+	const reader = stream.getReader()
+	const chunks = []
+	let length = 0
+	try {
+		while (length < maxBytes) {
+			const { value, done } = await reader.read()
+			if (done) break
+			if (!value?.length) continue
+			chunks.push(value)
+			length += value.length
+		}
+	} finally {
+		await reader.cancel().catch(() => {})
+	}
+	return decodeBytes(chunks, maxBytes)
+}
+
+// Function: bunzip2Head
+// Decodes blocks until `maxBytes` of output or the stream terminator. The
+// decoder yields one byte per char code, so the collected string is converted
+// back to bytes before UTF-8 decoding.
+function bunzip2Head(bytes, maxBytes) {
+	let chunks
+	try {
+		const bits = bzip2.array(bytes)
+		const size = bzip2.header(bits)
+		chunks = []
+		let length = 0
+		while (length < maxBytes) {
+			const chunk = bzip2.decompress(bits, size, maxBytes - length)
+			if (chunk === -1) break
+			chunks.push(chunk)
+			length += chunk.length
+		}
+	} catch (error) {
+		// The vendored decoder throws bare strings.
+		throw error instanceof Error ? error : new Error(`${error}`)
+	}
+	return decodeBytes(chunks.map(byteString), maxBytes)
+}
+
+// Function: byteString
+// The vendored decoder's char codes are bytes, not text.
+function byteString(text) {
+	const bytes = new Uint8Array(text.length)
+	for (let i = 0; i < text.length; i++) bytes[i] = text.charCodeAt(i) & 0xff
+	return bytes
+}
+
+// Function: decodeBytes
+// Concatenates the chunks (bounded to `maxBytes`) and decodes them as UTF-8.
+function decodeBytes(chunks, maxBytes) {
+	const total = Math.min(
+		chunks.reduce((size, chunk) => size + chunk.length, 0),
+		maxBytes,
+	)
+	const bytes = new Uint8Array(total)
+	let offset = 0
+	for (const chunk of chunks) {
+		if (offset >= total) break
+		const take = Math.min(chunk.length, total - offset)
+		bytes.set(chunk.subarray(0, take), offset)
+		offset += take
+	}
+	return new TextDecoder().decode(bytes)
+}
+
+export { compressedBytes, decompressHead }
+
+// EOF

package/src/js/tcmd/core/directory.js

@@ -20,17 +20,23 @@ import { viewEntries } from "./entries.js"
 import { createHistory } from "./history.js"
 import { clampCursor, currentEntry, indexOfPath, toggleMark } from "./selection.js"
 import { SEP, parent as parentPath, split, prefix } from "./path.js"
+import { createPathWatcher } from "./watch.js"
 
 // Function: createDirectory
 // Creates the directory state for one pane, bound to a filesystem adapter.
 //
+// Options:
+// - `watch`: true (default) auto-refreshes when the displayed directory
+//   changes; false disables it; an object forwards `{ delay, interval }` to
+//   `core/watch` (tests use a short delay).
+//
 // Example:
 // ```javascript
 // const dir = createDirectory({ fs: createNodeFs(), path: "/home" })
 // await dir.refresh()
 // dir.entries.value // sorted, filtered FileEntry[]
 // ```
-function createDirectory({ fs, path: initialPath, context: initialContext }) {
+function createDirectory({ fs, path: initialPath, context: initialContext, watch = true }) {
 	const dir = { fs }
 	dir.path = cell(initialPath)
 	dir.rawEntries = cell([])
@@ -70,6 +76,40 @@ function createDirectory({ fs, path: initialPath, context: initialContext }) {
 	// was last selected there.
 	const cursorMemory = new Map()
 	let readToken = 0
+	// Auto-refresh: one watcher on the displayed path. It is re-armed after a
+	// move commits and released on dispose. A change notification during a
+	// *move* is ignored — the read in flight is already producing the next
+	// listing, and refreshing the path being left would race its token. During
+	// a plain refresh a notification may supersede it: the newer read carries
+	// the newest change, so no event is ever lost to a slow listing.
+	const watchOptions = watch === false ? null : watch === true || watch == null ? {} : watch
+	// Whether this directory currently watches its path. The session pauses
+	// columns the view does not show, so a hidden pane does not keep polling
+	// the filesystem (or hold a desktop RPC watcher) for nothing.
+	dir.autoRefresh = cell(Boolean(watchOptions))
+	let watchedPath = null
+	let stopWatcher = null
+	let moving = false
+	const stopWatching = () => {
+		stopWatcher?.()
+		stopWatcher = null
+		watchedPath = null
+	}
+	const watchCurrentPath = () => {
+		if (!watchOptions || !dir.autoRefresh.value || watchedPath === dir.path.value) return
+		stopWatching()
+		const path = dir.path.value
+		watchedPath = path
+		stopWatcher = createPathWatcher(
+			fs,
+			path,
+			() => {
+				if (moving || watchedPath !== dir.path.value) return
+				void dir.refresh()
+			},
+			watchOptions,
+		)
+	}
 
 	// Function: setContext
 	// Replaces the owner context captured into history entries.
@@ -95,6 +135,12 @@ function createDirectory({ fs, path: initialPath, context: initialContext }) {
 		{ move = false, record = false, cursorPath = null, restore = null } = {},
 	) => {
 		const token = ++readToken
+		const isMove = move || Boolean(restore)
+		// A refresh keeps the same entry selected when entries are inserted or
+		// removed above it; the raw cursor index alone would drift, which
+		// matters once refreshes happen behind the user's back.
+		const keepPath = !isMove ? (dir.currentEntry()?.path ?? null) : null
+		if (isMove) moving = true
 		batch(() => {
 			dir.loading.set(true)
 			dir.error.set(null)
@@ -102,7 +148,6 @@ function createDirectory({ fs, path: initialPath, context: initialContext }) {
 		try {
 			const raw = await fs.readDir(path)
 			if (token !== readToken) return
-			const isMove = move || Boolean(restore)
 			const filter = restore ? restore.filter : isMove ? "" : dir.filter.value
 			const entries = viewEntries(raw, filter, dir.sort.value)
 			let cursor
@@ -112,8 +157,9 @@ function createDirectory({ fs, path: initialPath, context: initialContext }) {
 				const remembered = isMove && path !== dir.path.value
 					? (cursorMemory.get(path) ?? 0)
 					: dir.cursor.value
+				const kept = keepPath ? indexOfPath(entries, keepPath) : -1
 				const selected = cursorPath ? indexOfPath(entries, cursorPath) : -1
-				cursor = clampCursor(selected >= 0 ? selected : remembered, entries.length)
+				cursor = clampCursor(kept >= 0 ? kept : selected >= 0 ? selected : remembered, entries.length)
 			}
 			// A move that rewrites the filter sets the cursor it computed; no
 			// watcher intervenes (the filter cell is written directly, not
@@ -139,6 +185,7 @@ function createDirectory({ fs, path: initialPath, context: initialContext }) {
 				dir.cursor.set(cursor)
 				dir.loading.set(false)
 			})
+			watchCurrentPath()
 			if (record) {
 				const entry = { path, filter: "", cursor, marks: new Set(), context: contextGet() }
 				// Re-navigating to the current path updates the entry instead of
@@ -151,7 +198,10 @@ function createDirectory({ fs, path: initialPath, context: initialContext }) {
 		} catch (error) {
 			if (token === readToken) dir.error.set(`${error?.message ?? error}`)
 		} finally {
-			if (token === readToken) dir.loading.set(false)
+			if (token === readToken) {
+				moving = false
+				dir.loading.set(false)
+			}
 		}
 	}
 
@@ -159,6 +209,26 @@ function createDirectory({ fs, path: initialPath, context: initialContext }) {
 	// Re-reads the displayed directory, preserving filter, marks and cursor.
 	dir.refresh = () => read(dir.path.value)
 
+	// Function: setAutoRefresh
+	// Pauses or resumes the path watcher. Resuming re-reads the listing: it
+	// may have changed while the column was hidden and unwatched. A no-op for
+	// a directory created with `watch: false`, and while a move is in flight
+	// (that read already produces the next listing and re-arms the watcher).
+	dir.setAutoRefresh = (enabled) => {
+		if (!watchOptions) return
+		const next = enabled !== false
+		if (dir.autoRefresh.value === next) return
+		dir.autoRefresh.set(next)
+		if (!next) {
+			stopWatching()
+			return
+		}
+		if (!moving) {
+			watchCurrentPath()
+			void dir.refresh()
+		}
+	}
+
 	// Function: navigate
 	// Moves the directory to `path` (resetting filter and marks, restoring the
 	// cursor remembered for `path`), records the step in the history and reads
@@ -233,11 +303,17 @@ function createDirectory({ fs, path: initialPath, context: initialContext }) {
 	})
 
 	// Function: dispose
-	// Cancels any in-flight read so a late listing can no longer publish.
+	// Cancels any in-flight read so a late listing can no longer publish, and
+	// releases the path watcher.
 	dir.dispose = () => {
 		readToken += 1
+		stopWatching()
 	}
 
+	// Start watching the opening directory; a later move re-arms the watcher
+	// on its target (see `read`).
+	watchCurrentPath()
+
 	return dir
 }
 

package/src/js/tcmd/core/format.js

@@ -0,0 +1,36 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-31
+
+// Module: tcmd/core/format
+// Domain-level formatting of byte sizes and filesystem capacity. These live in
+// core, not components, because operations report sizes too (`stat`, `du`,
+// `df`); the component formatters re-export them so every renderer and every
+// operation shares one wording.
+
+// Function: formatSize
+// Human-readable byte size, e.g. "512B", "2.0K", "3.8M".
+function formatSize(bytes) {
+	const value = Number(bytes ?? 0)
+	if (value < 1024) return `${value}B`
+	const units = ["K", "M", "G", "T"]
+	let size = value / 1024
+	let unit = 0
+	while (size >= 1024 && unit < units.length - 1) {
+		size /= 1024
+		unit++
+	}
+	return `${size >= 100 ? Math.round(size) : size.toFixed(1)}${units[unit]}`
+}
+
+// Function: formatDisk
+// Compact free/total disk line, e.g. "12G free of 256G".
+function formatDisk(disk) {
+	if (!disk) return ""
+	return `${formatSize(disk.free)} free of ${formatSize(disk.total)}`
+}
+
+export { formatDisk, formatSize }
+
+// EOF