flea-qml 0.0.0-stage → 0.2.0

package/ui/js/SheetKeys.js

@@ -0,0 +1,42 @@
+.pragma library
+.import "Input.js" as Input
+
+// The keymap sheet's key decisions; imports no QML, so tests drive it.
+
+// Sample input: isBareModifier(Qt.Key_Shift) is true, isBareModifier(Qt.Key_A) is false.
+// A bare modifier carries no text, so without this the sheet would close under a shifted letter.
+function isBareModifier(key) {
+    return key === Qt.Key_Shift || key === Qt.Key_Control || key === Qt.Key_Alt
+        || key === Qt.Key_AltGr || key === Qt.Key_Meta || key === Qt.Key_CapsLock
+}
+
+// Sample input: sheetKey("co", Qt.Key_Shift, "") is "ignore".
+// The one decision the sheet's Keys.onPressed runs, so the handler owns no key meaning of its own.
+function sheetKey(query, key, text) {
+    if (key === Qt.Key_Escape)
+        return "close"
+    if (String(query).length > 0) {
+        if (key === Qt.Key_Up)
+            return "up"
+        if (key === Qt.Key_Down)
+            return "down"
+        if (key === Qt.Key_Return || key === Qt.Key_Enter)
+            return "activate"
+    }
+    if (key === Qt.Key_Backspace)
+        return String(query).length > 0 ? "backspace" : "close"
+    if (Input.isPrintable(text))
+        return "type"
+    // Delete edits nothing forward, so it is ignored rather than typed or closed on.
+    if (key === Qt.Key_Delete || isBareModifier(key))
+        return "ignore"
+    return "close"
+}
+
+// Sample input: stepCursor(0, -1, 3) is 2, stepCursor(2, 1, 3) is 0.
+// The cursor wraps at both ends; with no rows it parks at the first.
+function stepCursor(cursor, delta, count) {
+    if (!(count > 0))
+        return 0
+    return (((cursor + delta) % count) + count) % count
+}

package/ui/js/SheetQuery.js

@@ -0,0 +1,281 @@
+.pragma library
+.import "Format.js" as Format
+.import "Recent.js" as Recent
+.import "Swap.js" as Swap
+.import "Places.js" as Places
+.import "Focus.js" as Focus
+
+// The sheet's four-section query filter; imports no QML, so tests drive it.
+
+var RESULT_LIMIT = 50
+
+// The one non-listing context a sheet row can carry, named as the UI names that surface; the others have no name on screen.
+var CONTEXT_NAMES = { media: "Preview" }
+
+// Sample input: whereForContext("media") is "Preview", whereForContext("listing") is "".
+// A key that works in one place only says where, in that place's name; a context the UI never names says nothing.
+function whereForContext(context) {
+    var text = String(context || "")
+    if (text.indexOf(",") >= 0 || !Object.prototype.hasOwnProperty.call(CONTEXT_NAMES, text)) {
+        return ""
+    }
+    return CONTEXT_NAMES[text]
+}
+
+// Section 0 from the generated sheet; the caller hands in sheetFor rows.
+function actionCandidates(sheetRows) {
+    var out = []
+    var rows = sheetRows || []
+    for (var i = 0; i < rows.length; i++) {
+        out.push({ label: String(rows[i].label || ""), keys: String(rows[i].keys || ""),
+            section: 0, where: whereForContext(rows[i].context),
+            action: String(rows[i].action || ""), disabled: false, danger: false })
+    }
+    return out
+}
+
+// Section 1 from the menu's own model, hidden rows included; disabled rows never run.
+function menuCandidates(entries, hintFor) {
+    var out = []
+    var rows = entries || []
+    var hint = typeof hintFor === "function" ? hintFor : function () { return "" }
+    for (var i = 0; i < rows.length; i++) {
+        var entry = rows[i]
+        if (!entry || entry.separator === true) {
+            continue
+        }
+        var action = String(entry.action || entry.id || "")
+        out.push({ label: String(entry.label || ""), keys: String(hint(action) || ""),
+            section: 1, where: "", menuAction: actionWithSub(action, ""),
+            disabled: entry.disabled === true, danger: entry.danger === true })
+        var sub = entry.submenu || []
+        for (var j = 0; j < sub.length; j++) {
+            if (!sub[j] || sub[j].separator === true) {
+                continue
+            }
+            var leafId = String(sub[j].id || "")
+            // A leaf with its own sheet wording reads whole, with no muted flyout suffix.
+            var sheetLabel = String(sub[j].sheetLabel || "")
+            out.push({ label: sheetLabel.length > 0 ? sheetLabel : String(sub[j].label || ""), keys: "",
+                section: 1, where: sheetLabel.length > 0 ? "" : String(entry.label || ""),
+                menuAction: actionWithSub(action, leafId), parentAction: action,
+                disabled: entry.disabled === true || sub[j].disabled === true,
+                danger: entry.danger === true })
+        }
+    }
+    return out
+}
+
+function actionWithSub(action, leafId) {
+    return leafId.length > 0 ? action + ":" + leafId : action
+}
+
+// The group name the rail shows: Favorites, Places, or the network/device group.
+function placeWhere(entry) {
+    var group = String((entry && entry.group) || "")
+    // flea-qml: a drive found by looking is a plain folder row drawn under DEVICES.
+    if (entry && entry.volume === true) {
+        return "Devices"
+    }
+    if (group === "favourite" || group === "favorite") {
+        return "Favorites"
+    }
+    if (group === "network") {
+        return "Network"
+    }
+    if (group === "device") {
+        return "Devices"
+    }
+    return "Places"
+}
+
+// Section 2 from the rail's entries; an exact NAME match ranks first.
+function placeCandidates(railEntries) {
+    var out = []
+    var rows = railEntries || []
+    for (var i = 0; i < rows.length; i++) {
+        var entry = rows[i]
+        if (!entry || String(entry.label || "").length === 0) {
+            continue
+        }
+        if (String(entry.kind || "") === "recent") {
+            continue
+        }
+        out.push({ label: "Open " + entry.label, name: String(entry.label),
+            keys: "", section: 2, where: placeWhere(entry), railIndex: i, entry: entry })
+    }
+    return out
+}
+
+// Section 3 from the xbel source, read once per query line and bounded by Recent.LIMIT.
+function recentCandidates(recentPaths, home) {
+    var out = []
+    var rows = recentPaths || []
+    var bound = Math.min(rows.length, Recent.LIMIT)
+    for (var i = 0; i < bound; i++) {
+        var path = String(rows[i] || "")
+        if (path.length === 0) {
+            continue
+        }
+        var leaf = Recent.nameOf(path)
+        var parent = Format.tilde(Recent.locationOf(path), String(home || ""))
+        out.push({ label: "Open " + leaf, keys: "", section: 3,
+            where: parent, path: path })
+    }
+    return out
+}
+
+// The matched run the specimen washes. Case-insensitive substring, null when none.
+function matchOf(label, query) {
+    var text = String(label || "").toLowerCase()
+    var needle = String(query || "").trim().toLowerCase()
+    if (needle.length === 0) {
+        return null
+    }
+    var at = text.indexOf(needle)
+    if (at < 0) {
+        return null
+    }
+    return { start: at, length: needle.length }
+}
+
+// Sample input: a key row {action: "trash"} then a menu row {menuAction: "trash", label: "Move to Trash"} keeps the key row only, carrying menuLabel "Move to Trash".
+// One action, one row: the key row stays, the menu's wording rides on it to be searched, and a disabled menu row's verdict rides on it too, so a folder that refuses Rename refuses it here.
+function unique(candidates) {
+    var at = {}
+    var out = []
+    var list = candidates || []
+    for (var i = 0; i < list.length; i++) {
+        var run = String(list[i].action || list[i].menuAction || "")
+        if (run.length === 0) {
+            out.push(list[i])
+        } else if (at[run] === undefined) {
+            at[run] = out.length
+            out.push(list[i])
+        } else if (list[i].section === 1 && out[at[run]].section === 0) {
+            var held = Object.assign({}, out[at[run]], { menuLabel: String(list[i].label || ""),
+                menuAction: list[i].menuAction })
+            if (list[i].disabled === true) {
+                held.disabled = true
+            }
+            out[at[run]] = held
+        }
+    }
+    return out
+}
+
+// The row as the query reads it: the key row's wording when it matches, else the menu's wording that did.
+function worded(row, needle) {
+    var label = String(row.label || "").toLowerCase()
+    var menuLabel = String(row.menuLabel || "")
+    if (label.indexOf(needle) < 0 && menuLabel.toLowerCase().indexOf(needle) >= 0) {
+        return Object.assign({}, row, { label: menuLabel })
+    }
+    return row
+}
+
+// Sample query: "down" matches "Open Downloads" but not "trash".
+function rank(candidates, query) {
+    var needle = String(query || "").trim().toLowerCase()
+    var list = unique(candidates)
+    if (needle.length === 0) {
+        return list.slice(0, RESULT_LIMIT)
+    }
+    var exactPlace = []
+    var exact = []
+    var matched = []
+    var keyed = []
+    for (var i = 0; i < list.length; i++) {
+        var label = String(list[i].label || "").toLowerCase()
+        var menuLabel = String(list[i].menuLabel || "").toLowerCase()
+        var keys = String(list[i].keys || "").toLowerCase()
+        var name = String(list[i].name || "").toLowerCase()
+        // An exact NAME match ranks first, so "? trash Enter" opens Trash.
+        if (name.length > 0 && name === needle) {
+            exactPlace.push(list[i])
+        } else if (label === needle || menuLabel === needle) {
+            exact.push(worded(list[i], needle))
+        } else if (label.indexOf(needle) >= 0 || menuLabel.indexOf(needle) >= 0) {
+            matched.push(worded(list[i], needle))
+        } else if (keys.length > 0 && keys.indexOf(needle) >= 0) {
+            keyed.push(list[i])
+        }
+    }
+    return withoutListedParents(exactPlace.concat(exact, matched, keyed).slice(0, RESULT_LIMIT))
+}
+
+// A flyout parent whose leaves the bounded list shows is not itself a row; a key row, a leafless parent and a parent whose leaves the bound cut stay.
+function withoutListedParents(rows) {
+    var listed = {}
+    for (var i = 0; i < rows.length; i++) {
+        if (String(rows[i].parentAction || "").length > 0) {
+            listed[rows[i].parentAction] = true
+        }
+    }
+    return rows.filter(function (row) {
+        return !(row.section === 1 && !row.parentAction && listed[String(row.menuAction || "")] === true)
+    })
+}
+
+// Enter runs the highlighted row as its own surface would.
+function dispatch(candidate) {
+    var row = candidate || {}
+    if (row.disabled === true) {
+        return { kind: "disabled" }
+    }
+    if (row.section === 0 && String(row.action || "").length > 0) {
+        return { kind: "action", action: String(row.action) }
+    }
+    if (row.section === 1 && String(row.menuAction || "").length > 0) {
+        if (row.danger === true) {
+            return { kind: "confirm", menuAction: String(row.menuAction) }
+        }
+        return { kind: "menu", menuAction: String(row.menuAction) }
+    }
+    if (row.section === 2 && row.entry) {
+        return { kind: "place", railIndex: row.railIndex, entry: row.entry }
+    }
+    if (row.section === 3 && String(row.path || "").length > 0) {
+        return { kind: "recent", path: String(row.path) }
+    }
+    return { kind: "none" }
+}
+
+// Enter skips the key gate, so Swap.swallows refuses listing actions here while allowing navigation.
+function runAction(holder, action, close) {
+    if (Swap.swallows(holder.listInFlight, action)) {
+        holder.message(Swap.LOADING, false)
+        return
+    }
+    close()
+    if (holder.sheetAction) holder.sheetAction(action)
+    else Focus.dispatchAction(action, holder)
+}
+
+// Every menu row resolves its rows through the snapshot, so it refuses while a listing is out, unlike navigations; the holder runs the row.
+function runMenu(holder, menuAction, close) {
+    if (holder.listInFlight === true) {
+        holder.message(Swap.LOADING, false)
+        return
+    }
+    close()
+    holder.sheetMenuAction(menuAction)
+}
+
+// Sample input: entries two favourites both labelled "src", decided with railIndex 1 answers 1.
+// The rail rebuilds on its poll, so the row is resolved by the rail's own identity, never by label.
+function placeIndex(entries, decided) {
+    var list = entries || []
+    var row = decided || {}
+    var want = Places.railIdentity(row.entry)
+    if (want.length === 0)
+        return -1
+    var at = Number(row.railIndex)
+    if (at >= 0 && at < list.length && Places.railIdentity(list[at]) === want)
+        return at
+    for (var i = 0; i < list.length; i++) {
+        if (Places.railIdentity(list[i]) === want)
+            return i
+    }
+    return -1
+}

package/ui/js/ShelfPile.js

@@ -0,0 +1,27 @@
+.pragma library
+
+// The pile file the bar plugin writes, read here for the Settings panel's Pinned list. Sample input:
+// {"items":[{"path":"/home/gm/Invoices","name":"Invoices","folder":true,"pinned":true}]}
+function pinned(text) {
+    var doc = {}
+    try {
+        doc = JSON.parse(String(text || "")) || {}
+    } catch (e) {
+        return []
+    }
+    var items = doc.items instanceof Array ? doc.items : []
+    var out = []
+    for (var i = 0; i < items.length; i++) {
+        if (items[i] && items[i].pinned === true && typeof items[i].path === "string") {
+            out.push({ path: items[i].path, name: leaf(items[i].path),
+                       folder: items[i].folder === true, missing: items[i].missing === true })
+        }
+    }
+    return out
+}
+
+function leaf(path) {
+    var trimmed = String(path).replace(/\/+$/, "")
+    var at = trimmed.lastIndexOf("/")
+    return at < 0 ? trimmed : trimmed.substring(at + 1)
+}

package/ui/js/SlowClick.js

@@ -0,0 +1,53 @@
+.pragma library
+
+// Slow-click rename shared by the list, grid and columns views: tap arms the pane timer, double click cancels, fire renames a still-held sole row.
+var CLEARED = -2 // SlowClick.cancel's cleared value, read by Pane.qml's slowClickIndex.
+
+// Pre-tap sole-selection fact the views capture before Tap.tapped selects for this tap.
+function wasSoleSelection(pane, index) {
+    if (!pane || index < 0) return false
+    if (pane.selectionCount() !== 1 || !pane.isSelected(index)) return false
+    return pane.cursorIndex === index
+}
+// Whether this tap starts the timer; records every tap so a tap on another row re-arms.
+function arm(pane, index, modifiers, now, interval, dragging, wasSole) {
+    var plain = (modifiers & (Qt.ControlModifier | Qt.ShiftModifier)) === 0
+    var drag = dragging === undefined ? pane.dragActive : dragging
+    var priorAt = pane.slowClickAt || 0
+    var priorIndex = pane.slowClickIndex === undefined ? CLEARED : pane.slowClickIndex
+    pane.slowClickAt = now
+    pane.slowClickIndex = index
+    if (!(index >= 0 && plain && pane.singleClick !== true && pane.clickRename !== false
+            && pane.searchMode === "" && pane.renamingIndex < 0 && !pane.renamePending
+            && pane.selectionBand === null && drag !== true))
+        return false
+    if (wasSole !== undefined) {
+        if (!wasSole) return false
+    } else if (!wasSoleSelection(pane, index)) {
+        return false
+    }
+    return priorIndex === index && now - priorAt > interval
+}
+
+// The timer firing renames only when the cursor and sole selection still hold the armed row.
+function fire(pane, dragging) {
+    var index = pane.slowClickIndex
+    pane.slowClickIndex = CLEARED
+    if (index === undefined || index < 0) return false
+    if (pane.menuVisible === true) return false
+    var liveDrag = dragging === undefined ? pane.dragActive : dragging
+    if (liveDrag === true) return false
+    if (pane.renamingIndex >= 0 || pane.renamePending) return false
+    if (pane.singleClick === true || pane.clickRename === false) return false
+    if (pane.searchMode !== "" || pane.selectionBand !== null) return false
+    var picked = pane.selectedIndices()
+    if (picked.length !== 1 || picked[0] !== index || pane.cursorIndex !== index) return false
+    // The pointer chose this row, so the reveal carries context 0 and the list never moves under it.
+    pane.act("rename", 0, null, 0)
+    return true
+}
+
+// A second tap in time, or a tap failing the arm, disarms without renaming.
+function cancel(pane) {
+    pane.slowClickIndex = CLEARED
+}

package/ui/js/SlowOp.js

@@ -0,0 +1,6 @@
+.pragma library
+
+// The late reply closes exactly what the in-time reply would close.
+function closesRename(request, path) {
+    return !!request && path === request.destination
+}

package/ui/js/Sort.js

@@ -0,0 +1,134 @@
+.pragma library
+
+.import "DirSizes.js" as DirSizes
+.import "FolderSorts.js" as FolderSorts
+.import "RecentMode.js" as RecentMode
+.import "Thumbs.js" as Thumbs
+
+// What the header's click and the s and S keys do, taking ui/Pane.qml's root the way Nav.js and
+// Ops.js do: the pane holds the state, this holds what the state does. ui/Backend.qml records the
+// order the listing is actually in, because list re-sorts by name ascending and only this file
+// changes it after that.
+
+// The orders the backend can actually produce, in the order s steps through them, and the only keys
+// that may move the recorded order. It is not the list of what gets refused: docs/protocol.md "sort"
+// refuses every other key by name, and the backend is the one that says so, see ui/js/Errors.js, aliased from FolderSorts.ORDERS, the one key table.
+var ORDERS = FolderSorts.ORDERS
+
+// The three sort decisions, kept apart from what a pane does with them: the chooser makes the same ones over its narrower list.
+
+// The sorted column reverses; any other starts ascending, the order the canvas header draws beside "Name".
+function columnOrder(orders, by, desc, key) {
+    if (orders.indexOf(key) < 0)
+        return null
+    return { key: key, desc: by === key ? !desc : false }
+}
+
+// Always ascending, column and direction separate; an outside order, a saved kind in the chooser, starts over at the first.
+function nextOrder(orders, by) {
+    return { key: orders[(orders.indexOf(by) + 1) % orders.length], desc: false }
+}
+
+// Whichever order the listing is in, offered or inherited: the user asked for the reverse of what they have.
+function reverseOrder(by, desc) {
+    return { key: by, desc: !desc }
+}
+
+// An edit open or a rename pending holds the sort and commits an open edit; it applies once the rename settles.
+function holdForRename(pane, request) {
+    if (!(pane.renamingIndex >= 0 || pane.renamePending)) return false
+    pane.pendingSort = request
+    if (pane.renamingIndex >= 0 && !pane.renamePending) pane.commitOpenRename()
+    return true
+}
+
+// ui/Header.qml's click: only ORDERS leave this file except the forget row.
+function column(pane, key) {
+    // The flyout's last row (issue 179) forgets the folder and lists it on the default.
+    // Recent stands on the root, so forgetting re-asks its history instead of listing the root over it.
+    if (key === "__default__") {
+        // Forgetting re-lists, so it holds like any other sort request.
+        if (holdForRename(pane, { forget: true })) return
+        if ((pane.recentMode || "").length > 0) {
+            RecentMode.run(pane, pane.recentPaths || [], pane.recentVisits, pane.recentMode)
+            return
+        }
+        if (pane.backend && pane.backend.forgetFolderSort)
+            pane.backend.forgetFolderSort(pane.path)
+        // A preserved pane skips the reset a list would do, so refresh here or it keeps its old order.
+        if (pane.backend && pane.backend.resetSort)
+            pane.backend.resetSort(pane.path)
+        pane.openWithoutHistory(pane.path)
+        return
+    }
+    // Unsupported columns remain labels rather than sending a sort the backend must refuse.
+    var order = columnOrder(ORDERS, pane.backend.sortBy, pane.backend.sortDesc, key)
+    if (order)
+        resort(pane, order.key, order.desc)
+}
+
+// s walks ORDERS so it never lands on a refusal-only column; an aimed click earns the reason, a walking key only noise.
+function next(pane) {
+    var order = nextOrder(ORDERS, pane.backend.sortBy)
+    resort(pane, order.key, order.desc)
+}
+
+// S: the capital-is-the-variant pair g/G and j/J use.
+function reverse(pane) {
+    var order = reverseOrder(pane.backend.sortBy, pane.backend.sortDesc)
+    resort(pane, order.key, order.desc)
+}
+
+// The request goes out for every key, so the refusal is the backend's alone. Only an order it will
+// really produce moves the recorded one, or the mark would describe a listing that never changed.
+function resort(pane, key, desc) {
+    if (holdForRename(pane, { key: key, desc: desc })) return
+    // Asking for the order the listing is already in would drop every row-indexed cache and put the
+    // cursor back to redraw the rows already on screen, so it is not asked for at all.
+    if (pane.backend.sortBy === key && pane.backend.sortDesc === desc) {
+        return
+    }
+    pane.backend.sort(key, desc)
+    if (ORDERS.indexOf(key) < 0) {
+        return
+    }
+    pane.backend.sortBy = key
+    pane.backend.sortDesc = desc
+    // A walk's rows are matches, not the folder's, so sorting them writes nothing. Recent stands
+    // on the root, so its order is never remembered as the root's own.
+    if (pane.backend && pane.backend.rememberFolderSort
+            && (pane.searchMode || "") === "" && (pane.recentMode || "") === "")
+        pane.backend.rememberFolderSort(pane.path, key, desc)
+    // A reorder moves every row, so the caches keyed by a row index are as stale as a new listing's,
+    // and a selection of row indices would silently come to name different files.
+    pane.thumbState = Thumbs.empty()
+    pane.dirSizeState = DirSizes.empty()
+    pane.clearSelection()
+    pane.setCursor(0)
+    // sort emits no rows of its own, so the reordered window is asked for here; see docs/protocol.md.
+    pane.backend.window(0, pane.windowSize)
+}
+
+// The held sort a resort deferred; runs when the edit ends or the listing lands.
+function applyPending(pane) {
+    var held = pane.pendingSort
+    if (!held) return
+    // Not settled yet, or nowhere to send it: the hold stands.
+    if (pane.listInFlight || pane.renamingIndex >= 0 || pane.renamePending) return
+    if (!pane.backend || pane.backend.quitting || !pane.backend.running) { pane.pendingSort = null; return }
+    pane.pendingSort = null
+    if (held.forget) { column(pane, "__default__"); return }
+    resort(pane, held.key, held.desc)
+}
+
+// Each flag is read the way its reader reads it, and state.sort stays as written because Pane.openWithoutHistory compares it with ViewState's own.
+// Sample input: preferences({}) and preferences({hidden: false, foldersFirst: true, groupByKind: false, hiddenLast: false, rememberSort: true}) are the same string.
+function preferences(state) {
+    return JSON.stringify([state.hidden === true, state.sort, state.foldersFirst !== false,
+                           state.groupByKind === true, state.hiddenLast === true, state.rememberSort !== false])
+}
+
+// A sorted column's title: the label and the geometric mark of the direction, characters the stock monospace has, so the mark scales with the font like the label.
+function title(label, descending) {
+    return label + " " + (descending ? "\u25be" : "\u25b4")
+}

package/ui/js/Startup.js

@@ -0,0 +1,63 @@
+.pragma library
+
+// Where a window opens, and where a new tab opens. Both were fixed before 0.2.1: a window always
+// opened on $HOME unless the command line named a path, and a new tab always cloned the folder the
+// pane was resting on. Settings > View > Opening now decides, and this is the only place that reads
+// those keys, so the panel, ui/shell.qml and ui/js/Tabs.js can never disagree about the answer.
+
+// Sample state, as ui/ViewState.qml holds it:
+// {startIn: "folder", startFolder: "/home/gm/Work", lastPath: "/home/gm/Pictures", newTab: "home"}
+// argvPath is FLEA_PATH, which ui/shell.qml reads off the command line.
+function startPath(state, home, argvPath) {
+    // A path the caller named outranks every setting: a file manager asked to open somewhere opens
+    // there, and this is the same precedence the --select flag already has over the remembered pair.
+    if (argvPath && String(argvPath).length > 0)
+        return String(argvPath)
+    var data = state || {}
+    var mode = data.startIn || "home"
+    if (mode === "last")
+        return orHome(data.lastPath, home)
+    if (mode === "folder")
+        return orHome(data.startFolder, home)
+    return home
+}
+
+// A named folder goes to the focused side while the other keeps its own; launchSide says which took it.
+// Sample dual state, as ui/ViewState.qml holds it: {paths: ["/home/gm", "/home/gm/Work"], focus: 1}.
+function dualPaths(dual, start, argvPath) {
+    var saved = (dual || {}).paths || []
+    var named = argvPath && String(argvPath).length > 0 ? String(argvPath) : ""
+    // With no pair both sides open where one pane would, and a named folder outranks start here too.
+    if (saved.length !== 2) {
+        var only = named.length > 0 ? named : start
+        return { paths: [only, only], launchSide: named.length > 0 ? 0 : -1 }
+    }
+    if (named.length === 0)
+        return { paths: [String(saved[0]), String(saved[1])], launchSide: -1 }
+    if ((dual || {}).focus === 1)
+        return { paths: [String(saved[0]), named], launchSide: 1 }
+    return { paths: [named, String(saved[1])], launchSide: 0 }
+}
+
+// here is the folder the pane is resting on, which is what a new tab used to clone unconditionally.
+function newTabPath(state, here, home) {
+    var mode = (state || {}).newTab || "current"
+    if (mode === "home")
+        return home
+    if (mode === "start")
+        return startPath(state, home, "")
+    return here
+}
+
+// A chosen folder can be deleted or renamed between two runs, and a remembered one can be a stick
+// that is no longer plugged in. Nothing here can stat a path, so an empty setting falls back to home
+// and a path that no longer exists is left to the listing's own error, which names what is wrong.
+function orHome(path, home) {
+    return path && String(path).length > 0 ? String(path) : home
+}
+
+// How long a restored folder waits for its first listing before it stops loading.
+var LISTING_WAIT_MS = 10000
+
+// How long the favourite inspector waits for its answer before its guard clears anyway.
+var INSPECT_WAIT_MS = 10000

package/ui/js/StateWords.js

@@ -0,0 +1,17 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Permissions refusals keep their short state words; unavailable app rows use error ink alone.
+var WORDS = {
+    permissionsLink: "symlink",
+    permissionsSpecial: "special file",
+    permissionsNotYours: "not yours"
+}
+
+// A link names itself; any other kind that is neither a file nor a folder is special, and a mode never read names nothing.
+function permissions(mode) {
+    var kind = (Number(mode) || 0) & Format.S_IFMT
+    if (kind === 0) return ""
+    return kind === Format.S_IFLNK ? WORDS.permissionsLink : WORDS.permissionsSpecial
+}