flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Collide.js

@@ -0,0 +1,212 @@
+.pragma library
+.import "Format.js" as Format
+.import "Ops.js" as Ops
+.import "Status.js" as Status
+.import "Swap.js" as Swap
+
+// The question a paste or a drop asks before it lands on names that exist, as decisions ui/CollideHost.qml and ui/CollideConfirm.qml wire.
+
+// Whole sentences with "%1" for a value, filled by Format.fill so each translates as one; one per count, because the verb changes with it.
+var WORDS = {
+    existsOne: "%1 already exists in %2",
+    existsMany: "%1 items already exist in %2"
+}
+
+// Left to right, the order h, l and Tab walk.
+var BUTTONS = ["cancel", "skip", "keep", "merge", "replace"]
+var LABELS = { cancel: "Cancel", skip: "Skip", keep: "Keep both", merge: "Merge", replace: "Replace" }
+// Where the card opens, and so what a reflexive Enter takes: the one choice that changes nothing already there.
+var START = "keep"
+var EXPLAIN = "Replaced items go to Trash, and Undo restores them."
+// What a transfer carries when nothing collided: any name that appears after the question is refused.
+var NONE = "refuse"
+var WAITING = "A transfer is already waiting on its question; try again once it is answered."
+
+// One card geometry for CollideConfirm and FatNamesConfirm, so the two cards keep one size.
+var CARD_REFERENCE_BODY = 13
+var CARD_PAD = 16
+var CARD_CONTENT_BASE = 368
+function cardReferenceScale(bodySmall) { return bodySmall / CARD_REFERENCE_BODY }
+function cardPadding(scale) { return Math.round(CARD_PAD * scale) }
+function cardContentWidth(scale, ratio, buttonsWidth) {
+    return Math.max(Math.round(CARD_CONTENT_BASE * scale * ratio), buttonsWidth)
+}
+
+// The folder's own name, which is what the title says; the root has no leaf, so it says itself.
+function folderName(dest) {
+    var path = String(dest || "")
+    var cut = path.lastIndexOf("/")
+    var leaf = cut >= 0 ? path.substring(cut + 1) : path
+    return leaf.length > 0 ? leaf : "/"
+}
+
+// "screenshot.png already exists in Pictures" for one, "3 items already exist in Downloads" for several.
+function title(names, total, dest) {
+    if (total === 1 && names.length > 0)
+        return Format.fill(WORDS.existsOne, names[0].n, folderName(dest))
+    return Format.fill(WORDS.existsMany, Format.count(total), folderName(dest))
+}
+
+// The row under the list, empty when every collision is already on it.
+function more(total, shown) {
+    return total > shown ? "and " + Format.count(total - shown) + " more" : ""
+}
+
+// Only the buttons the card shows take the ring; a hidden Merge never holds it.
+function shownButtons(showMerge) {
+    return showMerge === true ? BUTTONS : BUTTONS.filter(function (b) { return b !== "merge" })
+}
+
+// h and l stop at the ends like TrashConfirm's pair; Tab and Backtab come round. A focus not in order starts from start.
+function walk(order, focus, key, modifiers, start) {
+    var at = order.indexOf(focus)
+    if (at < 0)
+        at = Math.max(0, order.indexOf(start))
+    var last = order.length - 1
+    if (key === Qt.Key_H || key === Qt.Key_Left)
+        return order[Math.max(0, at - 1)]
+    if (key === Qt.Key_L || key === Qt.Key_Right)
+        return order[Math.min(last, at + 1)]
+    // Shift+Tab reaches a Keys handler as Backtab or as Tab with Shift held, depending on the input path.
+    if (key === Qt.Key_Backtab || key === Qt.Key_Tab && (modifiers & Qt.ShiftModifier))
+        return order[(at + last) % order.length]
+    if (key === Qt.Key_Tab)
+        return order[(at + 1) % order.length]
+    return order[at]
+}
+
+function moved(focus, key, showMerge, modifiers) {
+    return walk(shownButtons(showMerge), focus, key, modifiers, START)
+}
+
+function activates(key) {
+    return key === Qt.Key_Return || key === Qt.Key_Enter || key === Qt.Key_Space
+}
+
+// The transfer the card holds, its rows stamped in the numbering they were read in; a menu's is resolved from the menu's own capture.
+function waiting(request, held) {
+    return request.menuId ? request : Swap.named(request, held)
+}
+
+// One question at a time, open or still in flight: a second is refused out loud rather than replacing the first.
+function refusal(opened, pending) {
+    return opened || pending !== null ? WAITING : ""
+}
+
+// A refused question ends the wait the same way an answered one does: the card never opens, so nothing stays waiting.
+function droppedPending(where, input) {
+    return where === "stale" && (input === "collisions" || input === "mergecollisions")
+}
+
+// The question names the same sources the transfer will, in the backend's order: a shelf drag's paths, a menu's selection, paths, rows.
+function question(request, probe, id) {
+    var asked = { c: "collisions", id: id, dest: request.dest }
+    if (request.fat)
+        asked.fat = request.fat
+    if (probe && probe.length > 0)
+        asked.paths = probe
+    else if (request.menuId)
+        asked.menuId = request.menuId
+    else if (request.paths && request.paths.length > 0)
+        asked.paths = request.paths
+    else
+        asked.rows = request.rows || []
+    // Rows are asked about in the numbering the transfer will name, ui/js/Swap.js named().
+    if (asked.rows && request.listing !== undefined)
+        asked.listing = request.listing
+    return asked
+}
+
+// The waiting transfer with the answer on it; the id is what lets the backend cover only the names it listed.
+function transfer(request, choice, id) {
+    return Object.assign({}, request, { collide: choice, collideId: id })
+}
+
+// Paste as links answers on the waiting request like a transfer; rows ride along only when named, so paths-only pastes skip listing checks.
+function link(request, choice, id) {
+    var out = { c: "link", op: request.op, paths: request.paths || [],
+                dest: request.dest, collide: choice, collideId: id }
+    if (request.fat)
+        out.fat = request.fat
+    if (request.rows && request.rows.length > 0) out.rows = request.rows
+    if (request.listing !== undefined) out.listing = request.listing
+    return out
+}
+
+// After Merge, one walk of the sources against the destination, before anything is written.
+function mergeQuestion(request, probe, id) {
+    var asked = { c: "mergecollisions", id: id, dest: request.dest }
+    if (probe && probe.length > 0)
+        asked.paths = probe
+    else if (request.menuId)
+        asked.menuId = request.menuId
+    else if (request.paths && request.paths.length > 0)
+        asked.paths = request.paths
+    else
+        asked.rows = request.rows || []
+    if (asked.rows && request.listing !== undefined)
+        asked.listing = request.listing
+    return asked
+}
+
+// The merge transfer with the second card's answer on it; the id names the walk it answers.
+function mergeTransfer(request, inner, id) {
+    return Object.assign({}, request, { collide: "merge", collideId: id, inner: inner })
+}
+
+// The second card names the folder it merges into: the one merging folder when it was the only
+// name the first card counted, else the destination, which every other name it lists lands in.
+// Sample input: a first card of trip/ alone gives ".../trip"; trip/ beside a.txt gives the destination.
+function mergeDest(request, outerNames, outerTotal) {
+    var folders = (outerNames || []).filter(function (n) { return n.d === true }).map(function (n) { return n.n })
+    if (folders.length === 1 && (outerTotal === undefined || outerTotal === 1))
+        return String(request.dest).replace(/\/$/, "") + "/" + folders[0]
+    return request.dest
+}
+
+// The board's merged line as whole sentences, one per count, joined once; the undo hint stays its suffix.
+var MERGED_ONE = "Merged 1 item into %1"
+var MERGED_MANY = "Merged %1 items into %2"
+var MERGED_KEPT = "%1 kept both"
+var MERGED_FAILED = "%1 failed"
+var MERGED_SKIPPED = "%1 skipped"
+function merged(count, keptBoth, leaf, failed, skipped, cancelled, note) {
+    var segments = [count === 1 ? MERGED_ONE.replace("%1", leaf) : MERGED_MANY.replace("%1", Format.count(count)).replace("%2", leaf)]
+    if (keptBoth > 0) segments.push(MERGED_KEPT.replace("%1", Format.count(keptBoth)))
+    if (failed > 0) segments.push(MERGED_FAILED.replace("%1", Format.count(failed)))
+    if (skipped > 0) segments.push(MERGED_SKIPPED.replace("%1", Format.count(skipped)))
+    if (cancelled) segments.push("cancelled")
+    if (count > 0 && String(note || "").length > 0) segments.push(note)
+    var line = segments.join(" · ")
+    return line + (count > 0 ? Status.undoHint() : "")
+}
+
+// The done line off the transferdone line itself, so a refused merge never mislabels the next copy.
+function doneLine(t, r) {
+    if (r.into && r.into.length > 0)
+        return merged(r.merged || 0, r.keptBoth || 0, r.into, r.failed, r.skipped, r.cancelled, r.note)
+    return Ops.transferDone(t, r.ok, r.failed, r.skipped, r.cancelled, r.durable, r.note)
+}
+
+// Drops callout 3, the FAT names card: every string is one whole sentence with placeholders for its values.
+var FAT_DEFAULT = "rename"
+var FAT_BUTTONS = { cancel: "Cancel", skip: "Skip them", rename: "Rename and copy" }
+var FAT_TITLE_ONE = "1 name cannot exist on %1 (%2)"
+var FAT_TITLE_MANY = "%1 names cannot exist on %2 (%3)"
+var FAT_NOTE = "%1 refuses : ? * \" < > | and trailing dots or spaces."
+// The mount table's own word as the card spells it; vfat could be any FAT width, so it claims none.
+var FAT_FILESYSTEMS = { exfat: "exFAT", vfat: "FAT", fat: "FAT", msdos: "FAT", fat12: "FAT12", fat16: "FAT16", fat32: "FAT32", ntfs: "NTFS", ntfs3: "NTFS" }
+function filesystemLabel(fstype) {
+    return FAT_FILESYSTEMS[String(fstype).toLowerCase()] || String(fstype)
+}
+// One pass over the placeholders, so a value that holds a placeholder or a dollar sign is never read twice.
+function fill(template, values) {
+    return template.replace(/%(\d)/g, function (whole, n) { return values[n - 1] })
+}
+function cardTitle(total, volume, fstype) {
+    var label = filesystemLabel(fstype)
+    return total === 1 ? fill(FAT_TITLE_ONE, [volume, label]) : fill(FAT_TITLE_MANY, [Format.count(total), volume, label])
+}
+function cardNote(fstype) {
+    return fill(FAT_NOTE, [filesystemLabel(fstype)])
+}

package/ui/js/ColumnFit.js

@@ -0,0 +1,28 @@
+.pragma library
+.import "DirSizes.js" as DirSizes
+.import "Format.js" as Format
+
+// The strings an autofit measures, the same ones ui/Row.qml draws.
+// Sample input: ("size", {p: 33188, d: false, s: 18000}) answers "18.0 kB".
+var FIT_KEYS = ["mode", "size", "date", "kind"]
+
+function cellText(key, row, kindNames, dirSize) {
+    if (key === "mode")
+        return Format.permissions(row.p)
+    if (key === "size") {
+        if (Format.isSymlink(row.p))
+            return "link"
+        if (!row.d)
+            return Format.size(row.s)
+        return DirSizes.folderText(dirSize, row)
+    }
+    if (key === "date")
+        return row.m === null ? "--" : Format.date(row.m)
+    var text = (kindNames || [])[row.k]
+    return text !== undefined ? text : ""
+}
+
+// The held index behind one held row, for the dirsize the row would draw.
+function dirSizeFor(state, held, at) {
+    return DirSizes.sizeFor(state, held + at)
+}

package/ui/js/ColumnMenu.js

@@ -0,0 +1,111 @@
+.pragma library
+
+// Neighbour-column background menus: a peek's empty space navigates to its DRAWN directory (parent/ancestor or shownChildPath, never pending childPath) and opens the background menu once its rows land.
+
+// A trailing slash trimmed except at the root itself.
+// Sample input: trimSlash("/home/gm/") is "/home/gm".
+function trimSlash(path) {
+    var text = String(path)
+    return text.length > 1 && text.charAt(text.length - 1) === "/" ? text.substring(0, text.length - 1) : text
+}
+
+// True when two paths name the same directory, trailing slash aside.
+// Sample input: samePath("/a/", "/a") is true.
+function samePath(a, b) {
+    return trimSlash(a) === trimSlash(b)
+}
+
+// "" when a background intent may arm, else the busy reason: rejects before any intent is stored, so a refused open never leaves one behind.
+// Sample input: canArm({listInFlight: true}) is "loading".
+function canArm(pane) {
+    if (!pane)
+        return "no pane"
+    if (pane.listInFlight === true)
+        return "loading"
+    if (pane.trash && (pane.trash.opened === true || pane.trash.confirming === true))
+        return "trash"
+    if (pane.searchMode && pane.searchMode.length > 0)
+        return "search"
+    if (pane.collide && (pane.collide.opened === true || pane.collide.pending !== null))
+        return "collide"
+    if (pane.menuVisible === true)
+        return "menu"
+    if (pane.menuActions && pane.menuActions.opened === true)
+        return "menu"
+    if (pane.renamingIndex >= 0 || pane.renamePending === true)
+        return "rename"
+    if (pane.filterTyping === true)
+        return "filter"
+    if (pane.selectionBand !== null && pane.selectionBand !== undefined)
+        return "band"
+    return ""
+}
+
+// True when the target is already shown: open the menu where it stands, no navigation.
+// Sample input: directOpen("/a", "/a/") is true.
+function directOpen(target, panePath) {
+    return target.length > 0 && samePath(target, panePath)
+}
+
+// True when landed rows may open the deferred menu: the pending target names this listing and it succeeded; empty counts because an empty directory is where the menu matters most, while locked, error and loading drop the intent.
+// Sample input: shouldOpen("/a", "/a", "ready") is true.
+function shouldOpen(panePath, pending, listingState) {
+    if (!pending || pending.length === 0)
+        return false
+    if (!samePath(panePath, pending))
+        return false
+    return listingState === "ready" || listingState === "empty"
+}
+
+// A failed listing drops the deferred menu, so no later rows open it.
+function clearPendingBackground(pane) {
+    if (!pane)
+        return
+    pane.pendingBackground = ""
+    pane.pendingBackgroundAt = null
+}
+
+// The deferred neighbour background, consumed either way so later rows never open it: opens only a successful listing of the drawn target, at the stored point.
+function applyPendingBackground(pane) {
+    if (!pane || !pane.pendingBackground || pane.pendingBackground.length === 0)
+        return
+    var target = pane.pendingBackground
+    var at = pane.pendingBackgroundAt
+    pane.pendingBackground = ""
+    pane.pendingBackgroundAt = null
+    if (!shouldOpen(pane.path, target, pane.listingState))
+        return
+    if (pane.searchMode && pane.searchMode.length > 0)
+        return
+    if (pane.trash && pane.trash.opened)
+        return
+    if (at === null || at === undefined)
+        return
+    pane.openBackgroundMenu(at)
+}
+
+// Routes one neighbour background for the columns view: busy refuses before any intent is stored, the shown folder opens its menu where it stands, and any other target navigates with the menu waiting on its rows. Answers opened, navigating, ignored or refused:<reason>.
+// Sample input: routeBackground({path: "/a"}, "/a", {x: 1}, {openBackground: function () {}}) is "opened".
+function routeBackground(pane, base, scenePoint, menu) {
+    if (!pane || !base || base.length === 0 || !scenePoint)
+        return "ignored"
+    var busy = canArm(pane)
+    if (busy.length > 0) {
+        if (busy === "loading")
+            pane.message("A directory is already loading.", false)
+        return "refused:" + busy
+    }
+    if (directOpen(base, pane.path)) {
+        menu.openBackground(scenePoint)
+        return "opened"
+    }
+    pane.pendingBackground = base
+    pane.pendingBackgroundAt = scenePoint
+    pane.open(base)
+    if (!pane.listInFlight) {
+        pane.pendingBackground = ""
+        pane.pendingBackgroundAt = null
+        return "refused:not-started"
+    }
+    return "navigating"
+}

package/ui/js/Columns.js

@@ -0,0 +1,298 @@
+.pragma library
+
+// Which columns a list row of a given width draws. The name is the one column a file manager
+// cannot do without, so it is the one that never loses: each metadata column drops instead, at
+// the width where keeping it would push the name under its floor. ui/Header.qml and ui/Row.qml
+// both resolve their set here, from the same width, so the header can never head a column the
+// rows below it are not drawing.
+
+// The optional columns, widest first, which is the order they drop in. Kind goes first: the row
+// already marks its kind with a glyph and most names carry the extension, so it is the most
+// redundant column as well as the widest. Mode goes last, because it is the permanent column.
+var DROP_ORDER = ["kind", "date", "size", "mode"]
+
+// The row width each optional column needs before it is drawn, keyed by column. t carries the
+// tokens ui/Theme.qml resolved: rowPaddingX, gap, iconSize, nameMin, and one width per column.
+// A floor includes every column that outlives it, because they drop in order and a wider column
+// never survives a narrower one, which is what makes the four floors nest.
+function floors(t) {
+    // The name's own slot at its floor: the row padding either side, the mark and the gap after it.
+    var running = t.rowPaddingX + t.iconSize + t.gap + t.nameMin + t.rowPaddingX
+    var out = {}
+    for (var i = DROP_ORDER.length - 1; i >= 0; i--) {
+        var key = DROP_ORDER[i]
+        running += t[key] + t.gap
+        out[key] = running
+    }
+    return out
+}
+
+// One boolean per optional column, for a row of this width. hidden is the user's own set (keys
+// "mode"/"size"/"date"/"kind", from qs module ViewState), subtracted from what the width
+// affords: a hidden column never draws, and width still wins over a column the user wants back,
+// so the name cannot be crowded out by a column the pane is too narrow to carry.
+function set(width, t, hidden) {
+    var f = floors(t)
+    var h = {}
+    var list = hidden || []
+    for (var i = 0; i < list.length; i++) h[list[i]] = true
+    return {
+        location: false,
+        mode: width >= f.mode && !h["mode"],
+        size: width >= f.size && !h["size"],
+        date: width >= f.date && !h["date"],
+        kind: width >= f.kind && !h["kind"]
+    }
+}
+
+// DualPane protects its name floor without reserving absent Mode and Kind columns.
+function dualSet(width, t, hidden) {
+    var base = 2 * t.rowPaddingX + t.iconSize + t.gap + t.nameMin
+    var showSize = (hidden || []).indexOf("size") < 0 && width >= base + t.size
+    var showDate = (hidden || []).indexOf("date") < 0
+        && width >= base + (showSize ? t.size : 0) + t.date
+    return {mode: false, kind: false, location: false, size: showSize, date: showDate}
+}
+
+// Recent protects its pane's name floor and reserves every non-hidden metadata width for Location.
+function recentSet(width, t, hidden, dual) {
+    var base = 2 * t.rowPaddingX + t.iconSize + t.gap + t.nameMin
+    var metadataGap = dual ? 0 : t.gap
+    var h = hidden || []
+    var showSize = h.indexOf("size") < 0 && width >= base + t.size + metadataGap
+    var sizeSlot = showSize ? t.size + metadataGap : 0
+    var showDate = h.indexOf("date") < 0 && width >= base + sizeSlot + t.date + metadataGap
+    var locationFloor = base + (h.indexOf("size") < 0 ? t.size + metadataGap : 0)
+        + (h.indexOf("date") < 0 ? t.date + metadataGap : 0) + t.location + t.gap
+    return {mode: false, kind: false,
+        size: showSize,
+        date: showDate,
+        location: width >= locationFloor}
+}
+
+// A peeked reply is keyed by what ordered it, so a stale ancestor column never survives the hidden-last toggle: path plus hidden plus hiddenLast.
+// Sample input: peekKey("/a", true, true) is "/a\n11".
+function peekKey(path, hidden, hiddenLast) {
+    return String(path) + "\n" + (hidden === true ? "1" : "0") + (hiddenLast === true ? "1" : "0")
+}
+
+// The folder's own remembered order a column asks under and its reply echoes: "" for name order, else the key and 1 when descending.
+// Sample input: orderTag("size", true) is "size1", orderTag("", false) is "".
+function orderTag(by, desc) {
+    return by ? String(by) + (desc === true ? "1" : "0") : ""
+}
+
+// The row count and the folder order join the key only for an outstanding ask, so a resize or a re-sort never orphans a stored column.
+// Sample input: sentKey("/a\n00", 35) is "/a\n00\n35", and sentKey("/a\n00", 35, "size1") is "/a\n00\n35\nsize1".
+function sentKey(key, first, order) {
+    return String(key) + "\n" + Math.floor(Number(first)) + (order ? "\n" + String(order) : "")
+}
+
+// An ask this view made and still awaits, counted per sentKey (path, flags, row count, order), so another client's reply never lands in its column and a column re-asked in flight lands both replies.
+// Sample input: trackAsk(trackAsk({}, "/a\n10\n35"), "/a\n10\n35") holds that key twice.
+function trackAsk(pending, key) {
+    var next = {}
+    var src = pending || {}
+    for (var k in src) next[k] = src[k]
+    next[String(key)] = (next[String(key)] || 0) + 1
+    return next
+}
+
+// True only for a reply this view asked for; anything else is another client's.
+// Sample input: hasAsk(trackAsk({}, "/a\n10"), "/a\n10") is true.
+function hasAsk(pending, key) {
+    return ((pending || {})[String(key)] || 0) > 0
+}
+
+// One ask answered or superseded; a new listing drops them all.
+// Sample input: dropAsk(trackAsk({}, "/a\n10"), "/a\n10") holds nothing, and dropAsk of a key asked twice holds it once.
+function dropAsk(pending, key) {
+    var next = {}
+    var want = String(key)
+    var src = pending || {}
+    for (var k in src) {
+        var left = k === want ? src[k] - 1 : src[k]
+        if (left > 0) next[k] = left
+    }
+    return next
+}
+
+// The columns view's count follows the window width, capped by Settings View's limit.
+// Sample input: (899, 5) answers 2.
+var COUNT_4_AT = 1700
+var COUNT_5_AT = 2300
+var COUNT_NARROW_AT = 900
+var COUNT_MIN = 2
+var COUNT_MAX = 5
+// The shipped View limit: a default install holds 3 columns from 900 px up.
+var COUNT_DEFAULT = 3
+
+// A stored number clamps to 2 to 5, anything else reads as the shipped default.
+function cappedLimit(limit) {
+    if (typeof limit !== "number")
+        return COUNT_DEFAULT
+    var n = Math.floor(limit)
+    if (!(n >= COUNT_MIN) && !(n <= COUNT_MAX))
+        return COUNT_DEFAULT
+    if (n < COUNT_MIN)
+        return COUNT_MIN
+    if (n > COUNT_MAX)
+        return COUNT_MAX
+    return n
+}
+
+// One integer for a window of this width; resizing re-lays columns without re-reading.
+function columnCountForWidth(width, limit) {
+    var count = width < COUNT_NARROW_AT ? 2 : width < COUNT_4_AT ? 3
+        : width < COUNT_5_AT ? 4 : 5
+    var cap = cappedLimit(limit)
+    if (count > cap)
+        count = cap
+    if (count < COUNT_MIN)
+        count = COUNT_MIN
+    return count
+}
+
+// Extra columns are ancestors, read with the same viewport-scoped peek as the parent today.
+function ancestorsForCount(count) {
+    var n = Math.floor(Number(count))
+    if (!(n >= COUNT_MIN))
+        return 0
+    return Math.min(n, COUNT_MAX) - 2
+}
+
+// The parent one step up, with a trailing slash trimmed except at the root itself.
+// Sample input: ancestorParent("/home/") is "/".
+function ancestorParent(path) {
+    var text = String(path)
+    if (text.length > 1 && text.charAt(text.length - 1) === "/")
+        text = text.substring(0, text.length - 1)
+    var cut = text.lastIndexOf("/")
+    return cut <= 0 ? "/" : text.substring(0, cut)
+}
+
+// The nearest distinct ancestors of a path, oldest first, stopping where the climb stops.
+// Sample input: ancestors("/home/gm", 3) is ["/", "/home"].
+function ancestors(path, count) {
+    var n = Math.floor(Number(count))
+    if (!(n >= 1))
+        return []
+    var text = String(path)
+    if (text.length === 0)
+        return []
+    if (text.length > 1 && text.charAt(text.length - 1) === "/")
+        text = text.substring(0, text.length - 1)
+    var near = []
+    var cur = text
+    for (var i = 0; i < n; i++) {
+        var p = ancestorParent(cur)
+        if (p === cur || near.indexOf(p) >= 0)
+            break
+        near.push(p)
+        cur = p
+    }
+    return near.reverse()
+}
+
+// True while an ancestor column of this depth names a directory of its own.
+// Sample input: ancestorShown("/home", 2) is false.
+function ancestorShown(path, depth) {
+    var d = Math.floor(Number(depth))
+    if (!(d >= 1))
+        return false
+    return ancestors(path, d).length >= d
+}
+
+// Sample input: neighbourAsks("/home/gm", 1200, 5) is ["/home"], the shown ancestors oldest first.
+function neighbourAsks(path, width, limit) {
+    var want = ancestorsForCount(columnCountForWidth(Number(width), limit))
+    if (!(want >= 1))
+        return []
+    return ancestors(path, want)
+}
+
+// Sample input: keepAsks({ drawn: ["/a"] }, ["/a"], "/a/b") answers [{path "/a", again false}, {path "/a/b", again true}] and leaves drawn ["/a", "/a/b"]; again names a column not drawn last refresh.
+function keepAsks(keep, asks, child) {
+    var shown = child.length > 0 && asks.indexOf(child) < 0 ? asks.concat([child]) : asks.slice()
+    var plan = shown.map(function (path) { return { path: path, again: keep.drawn.indexOf(path) < 0 } })
+    keep.drawn = shown
+    return plan
+}
+
+// ui.json carries whatever a hand edit wrote, so only a finite number is a stored width; anything else keeps the measured one.
+// Sample input: storedNumber("120") is NaN, storedNumber(120.6) is 121.
+function storedNumber(raw) {
+    if (typeof raw !== "number" || !isFinite(raw) || raw < 0)
+        return NaN
+    return Math.round(raw)
+}
+
+// ListColumns040 board: a dragged edge clamps to the rails, and a double click fits the
+// widest value the window holds, never a directory-wide scan. Sample input: 9999 clamps.
+var MIN_LIST_WIDTH = 48
+var MAX_LIST_WIDTH = 480
+
+// One whole pixel inside the rails, whatever the drag handed in.
+function clampListWidth(px) {
+    var n = Math.round(Number(px))
+    if (!(n >= 0))
+        return MIN_LIST_WIDTH
+    if (n < MIN_LIST_WIDTH)
+        return MIN_LIST_WIDTH
+    if (n > MAX_LIST_WIDTH)
+        return MAX_LIST_WIDTH
+    return n
+}
+
+// The widest held cell, clamped; an empty window keeps the column it has, so a fit can narrow as well as widen.
+function autofitWidth(widths, fallback) {
+    var cells = widths || []
+    if (cells.length === 0)
+        return clampListWidth(fallback)
+    var best = MIN_LIST_WIDTH
+    for (var i = 0; i < cells.length; i++) {
+        var w = Math.round(Number(cells[i]))
+        if (w >= 0 && w > best)
+            best = w
+    }
+    return clampListWidth(best)
+}
+
+function names(s) {
+    var out = ["name"]
+    if (s.location) out.push("location")
+    for (var i = DROP_ORDER.length - 1; i >= 0; i--) {
+        var key = DROP_ORDER[i]
+        if (s[key])
+            out.push(key)
+    }
+    return out.join(",")
+}
+
+// An unanswered folder keeps the old column by data, never by picture.
+// Sample input: folderDataHold(true, false) is true.
+function folderDataHold(cursorIsDir, answered) {
+    return cursorIsDir === true && answered !== true
+}
+
+// A file load needs a real file row: null never loads and a folder waits by data.
+// Sample input: isFileRow({d: false}) is true.
+function isFileRow(row) {
+    return row !== null && row !== undefined && row.d !== true
+}
+
+// A landed peek shows the cursor folder while it is still the one waiting.
+// Sample input: showFolderOnPeek("/a", "/b", true) is true.
+function showFolderOnPeek(childPath, shownChildPath, answered) {
+    return answered === true && childPath.length > 0 && childPath !== shownChildPath
+}
+
+// A data-held empty folder lands settled, the whole frame the picture hold revealed.
+// Sample input: shouldSettleHero(true, "/a", "/a", false, 0) is true.
+function shouldSettleHero(cursorIsDir, path, childPath, readFailed, rowCount) {
+    if (cursorIsDir !== true || readFailed === true)
+        return false
+    if (String(path) !== String(childPath))
+        return false
+    return Math.floor(Number(rowCount)) === 0
+}