@ssebastien/tcmd 0.1.4 → 0.1.7

package/src/js/tcmd/core/picker.js

@@ -0,0 +1,156 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-22
+
+// Module: tcmd/core/picker
+// The command panel's file picker: the private pane the panel browses while a
+// `dest`/`path` argument is being filled. The picker owns its editable path
+// text, the directory that text resolves against, the visible listing and the
+// queue that keeps fast typing from landing an older navigation after a newer
+// one. State cells live on the session (see `core/session`); this module holds
+// the path rules and the row shaping so `core/panel` stays about argument
+// binding.
+
+import { basename, join, normalize, parent } from "./path.js"
+
+// Function: pickerAbsolutePath
+// Resolves the picker's editable path text: `~`, an absolute path, or a path
+// relative to `base` (the directory the picker was opened from).
+function pickerAbsolutePath(text, base = "/", home = "/") {
+	const raw = `${text ?? ""}`
+	if (!raw) return normalize(base || "/")
+	if (raw === "~") return normalize(home || "/")
+	if (raw.startsWith("~/")) return join(home, raw.slice(2))
+	if (raw.startsWith("/")) return normalize(raw)
+	return join(base || "/", raw)
+}
+
+// Function: pickerDirectoryText
+// The path input's display form: a trailing slash marks a directory, so typing
+// after it starts a child name (the same affordance a shell prompt gives).
+function pickerDirectoryText(path) {
+	const normalized = normalize(path)
+	return normalized === "/" ? "/" : `${normalized}/`
+}
+
+// Function: resolvePickerPath
+// Interprets the editable path text as `{ directory, query }`: an existing
+// directory lists its contents, an existing file keeps its parent listing with
+// the file as the filter, and a missing path walks up to the closest existing
+// directory while the dropped segment becomes the filter. This is what makes
+// typing `/home/do` show the matching entries under `/home`.
+async function resolvePickerPath(fs, text, base = "/", home = "/") {
+	const raw = `${text ?? ""}`
+	const absolute = pickerAbsolutePath(raw, base, home)
+	const stats = await fs.stat(absolute)
+	if (stats?.isDir) return { directory: absolute, query: "" }
+	if (stats) return { directory: parent(absolute) ?? "/", query: basename(absolute) }
+
+	const trailing = raw.endsWith("/")
+	let directory = trailing ? absolute : parent(absolute) ?? "/"
+	const rest = trailing ? [] : [basename(absolute)]
+	while (directory !== "/") {
+		if ((await fs.stat(directory))?.isDir) break
+		rest.unshift(basename(directory))
+		directory = parent(directory) ?? "/"
+	}
+	return { directory, query: rest[0] ?? "" }
+}
+
+// Function: pickerVisibleEntries
+// The entries the picker lists for a mode: a destination picker lists
+// directories only, so every row is a valid choice; a file/any picker keeps the
+// listing intact, where a directory row descends.
+function pickerVisibleEntries(entries, mode) {
+	return mode === "dir" ? (entries ?? []).filter((entry) => entry.isDir) : entries ?? []
+}
+
+// Function: pickerRowList
+// Flattens the picker's visible listing into the rows the picker renders. The
+// `..` parent navigation row stays at the top when filtering and is omitted at
+// the filesystem root; entry rows keep the listing details (size, mode, link
+// target) so they render exactly like a file panel.
+function pickerRowList(entries, path) {
+	const rows = []
+	const parentPath = parent(path)
+	if (parentPath) {
+		rows.push({
+			type: "parent",
+			key: `parent:${path}`,
+			name: "..",
+			path: parentPath,
+			isDir: true,
+			isSymlink: false,
+			isDevice: false,
+			isParent: true,
+			target: null,
+			size: 0,
+			mode: 0,
+			ext: null,
+		})
+	}
+	for (const entry of entries ?? []) {
+		rows.push({ ...entry, type: "entry", key: entry.path })
+	}
+	return rows
+}
+
+// Function: createPickerPathQueue
+// Creates the picker's path-resolution queue for one session. `invalidate`
+// drops any queued work before an explicit navigation or close; `schedule`
+// resolves one path text and applies the resulting directory and filter. Work
+// is serialized so fast typing cannot land an older navigation after a newer
+// one, and a token drops every intermediate keystroke.
+function createPickerPathQueue(session) {
+	let version = 0
+	let queue = Promise.resolve()
+	return {
+		invalidate() {
+			version += 1
+		},
+		schedule(text) {
+			if (!session.pickerOpen.value) return
+			const token = ++version
+			queue = queue
+				.then(async () => {
+					if (token !== version || !session.pickerOpen.value) return
+					const base = session.pickerBasePath.value || session.pickerPane.path.value || "/"
+					const { directory, query } = await resolvePickerPath(
+						session.fs,
+						text,
+						base,
+						session.fs.home?.() ?? "/",
+					)
+					if (token !== version || session.pickerPathText.value !== text) return
+					if (session.pickerPane.path.value !== directory) {
+						await session.pickerPane.navigate(directory, { record: false })
+					}
+					if (token !== version || session.pickerPathText.value !== text) return
+					session.pickerQuery.set(query)
+					const rows = session.pickerRows.value
+					const firstMatch = query ? rows.findIndex((row) => row.type === "entry") : 0
+					session.panelRowIndex.set(firstMatch >= 0 ? firstMatch : 0)
+				})
+				.catch((error) => {
+					// Keep the queue alive after an unreadable path; the picker
+					// keeps the last listing and the command bar reports what
+					// failed.
+					if (token === version) {
+						session.notice?.set({ kind: "warning", text: `${error?.message ?? error}` })
+					}
+				})
+		},
+	}
+}
+
+export {
+	createPickerPathQueue,
+	pickerAbsolutePath,
+	pickerDirectoryText,
+	pickerRowList,
+	pickerVisibleEntries,
+	resolvePickerPath,
+}
+
+// EOF

package/src/js/tcmd/core/preview.js

@@ -0,0 +1,102 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-16
+
+// Module: tcmd/core/preview
+// Preview classification and payload helpers, shared by the session's preview
+// effect and by the commands that need to know how an entry previews — Enter
+// opens a text file in `$EDITOR` and everything else in the fullscreen
+// inspector (see `core/commands`). Pure and renderer-free: `previewKind` maps
+// a resolved extension to a preview kind, `previewSource` resolves what a
+// symlink previews *through* (and what a compressed file decompresses *to*),
+// and `hasBinaryByte` is the content sniff that turns a text head into a
+// metadata card.
+
+import { basename, extname } from "./path.js"
+
+// Constant: PREVIEW_BYTES / SNIFF_BYTES
+// Bytes of a text file the inspector reads for its inline body — the head
+// budget every filesystem adapter defaults to — and the shorter opening run
+// `hasBinaryByte` sniffs to call a body binary.
+const PREVIEW_BYTES = 65536
+const SNIFF_BYTES = 2048
+
+// Constant: IMAGE_EXTS / MEDIA_EXTS
+// Extensions with a dedicated (non-text) preview: they render as a metadata
+// card, never as an editable text body.
+const IMAGE_EXTS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "svg"]
+const MEDIA_EXTS = ["mp3", "wav", "ogg", "flac", "mp4", "webm", "mkv", "mov", "pdf"]
+
+// Constant: COMPRESSION_EXTS
+// Single-file compression formats the inspector decompresses before sniffing
+// the body. The compressed entry keeps its own extension in the header; the
+// name inside (`notes.txt` in `notes.txt.gz`) supplies the kind, the syntax
+// filetype and the badge's inner label.
+const COMPRESSION_EXTS = new Map([
+	["gz", "gzip"],
+	["bz2", "bzip2"],
+])
+
+// Function: compressionOf
+// Decompressor for a resolved extension ("gzip"/"bzip2"), or null when the
+// entry is not compressed.
+function compressionOf(ext) {
+	return ext ? COMPRESSION_EXTS.get(ext) ?? null : null
+}
+
+// Function: previewKind
+// Preview classification for a resolved file extension; directories are not
+// previewed (the caller passes their `null` ext). Takes the extension rather
+// than the entry so a symlink classifies as what it points at.
+function previewKind(ext) {
+	if (ext && IMAGE_EXTS.includes(ext)) return "image"
+	if (ext && MEDIA_EXTS.includes(ext)) return "media"
+	return "text"
+}
+
+// Function: hasBinaryByte
+// Content sniff: a text file's head carries no control byte in its opening
+// run, so a hit here means the body is binary and previews as a card.
+function hasBinaryByte(text) {
+	for (let i = 0; i < SNIFF_BYTES && i < text.length; i++) {
+		const code = text.charCodeAt(i)
+		if (code < 9 || (code > 13 && code < 32)) return true
+	}
+	return false
+}
+
+// Function: previewSource
+// What the preview renders *through* a symlink, and what a compressed file
+// decompresses to: `title` names the traversal (`notes -> ../real/notes`) so
+// it is visible in the header; `ext` is the entry's (target's) own extension;
+// `innerName`/`innerExt` strip a `.gz`/`.bz2` suffix so `notes.txt.gz`
+// previews with the kind, filetype and badge of `notes.txt`; `compression` is
+// the decompressor the session applies, or null. Plain entries pass through
+// with `innerName === name` and `innerExt === ext`.
+function previewSource(entry) {
+	const target = entry?.isSymlink && entry.target ? `${entry.target}` : null
+	const name = target ? basename(target) : basename(entry?.path ?? "")
+	const ext = extname(name) ?? entry?.ext ?? null
+	const compression = compressionOf(ext)
+	const innerName = compression ? name.slice(0, name.lastIndexOf(".")) : name
+	const innerExt = compression ? extname(innerName) : ext
+	return {
+		title: target ? `${basename(entry.path)} -> ${target}` : name,
+		ext,
+		innerName,
+		innerExt,
+		compression,
+	}
+}
+
+export {
+	compressionOf,
+	hasBinaryByte,
+	PREVIEW_BYTES,
+	previewKind,
+	previewSource,
+	SNIFF_BYTES,
+}
+
+// EOF