buninu-browser 0.2.4 → 0.4.0

package/test/fixtures/qml/flea-theme/ui/js/Sort.js

@@ -0,0 +1,127 @@
+.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 || [])
+            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)
+}
+
+// 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/test/fixtures/qml/flea-theme/ui/js/StateWords.js

@@ -0,0 +1,42 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// The state word an errored menu row says in its hint slot: a fixed value here, never a provider's reason.
+var WORDS = {
+    taildropFolder: "files only",
+    taildropSignedOut: "signed out",
+    taildropNoPeers: "no devices",
+    taildropDown: "offline",
+    localsendFolder: "files only",
+    localsendNoPeers: "no devices",
+    dropboxSignedOut: "signed out",
+    dropboxDown: "not running",
+    permissionsLink: "symlink",
+    permissionsSpecial: "special file",
+    permissionsNotYours: "not yours"
+}
+
+// Sample input: { rowIsFile: false, taildropCode: "" }, or { rowIsFile: true, taildropCode: "signedOut" }; codes are ui/js/Taildrop.js status().
+function taildrop(p) {
+    if (p.rowIsFile === false) return WORDS.taildropFolder
+    if (p.taildropCode === "signedOut") return WORDS.taildropSignedOut
+    return p.taildropCode === "noPeers" ? WORDS.taildropNoPeers : WORDS.taildropDown
+}
+
+// Sample input: { rowIsFile: false }. The send finds nobody on the network for any other cause.
+function localsend(p) {
+    return p.rowIsFile === false ? WORDS.localsendFolder : WORDS.localsendNoPeers
+}
+
+// Sample input: { dropboxCode: "signedOut" }; codes are ui/js/Dropbox.js account() and status().
+function dropbox(p) {
+    return p.dropboxCode === "signedOut" ? WORDS.dropboxSignedOut : WORDS.dropboxDown
+}
+
+// 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
+}

package/test/fixtures/qml/flea-theme/ui/js/Swap.js

@@ -0,0 +1,166 @@
+.pragma library
+
+// The listing swap's decisions, see AGENTS.md "The listing swap"; ui/PaneSwap.qml holds the state and the timer.
+
+// Both swaps' cap, the pane mark's hold-off and a PDF page render's cap: with four 120 Hz frames for input, the Timer and the draw, the mark shows by 100 ms.
+var CAP_MS = 66
+
+// The hold-off of a loading state nothing keeps MIN_SHOW_MS: LoadingState outside the pane, the folder fallback, a search walk's mark.
+var HOLD_MS = 150
+
+// A drawn loading state stands this long before content replaces it; under 100 ms the two changes read as one blink.
+var MIN_SHOW_MS = 100
+
+// Answered while a listing is out: the navigations take its place, escape touches no row, the rest change the window.
+var ANSWERED_WHILE_LISTING = ["open", "parent", "historyBack", "historyForward", "escape",
+                              "viewList", "viewColumns", "viewGrid", "viewDual", "sidebar", "windowNew", "togglePreview",
+                              "reload"]
+
+// What a swallowed key says, the sentence every refused navigation already gives.
+var LOADING = "A directory is already loading."
+
+// What a listed or rows line does: dropped, kept for the rows behind it, applied alone, or landed with the kept line.
+var DROP = "drop"
+var KEEP = "keep"
+var APPLY = "apply"
+var LAND = "land"
+var WAIT = "wait"
+
+function idle() {
+    return { holding: false, listed: null, fellBack: false, waits: false, walk: false, query: "", since: 0, relist: false }
+}
+
+// Only a settled listing is held, plus a walk's drawn state for a listing after it; see ui/PaneSwap.qml hold.
+function begin(state, listingState, searchMode, ask, now) {
+    // The exit holds the whole search state, strip and rows, until the folder lands in one turn.
+    var exit = ask.holdWalk === true
+    var afterWalk = state.walk === true && !exit
+    var holding = ask.clearAtOnce !== true && listingState !== "loading" && (searchMode === "" || exit) && !afterWalk
+    // An unheld Back or Forward still keeps its listed line, so the count, the rows and the cursor land in one turn.
+    var waits = !holding && !!ask.restore && String(ask.restore.name || "").length > 0
+    return { holding: holding, listed: null, fellBack: false, waits: waits, walk: state.walk, query: ask.keptQuery || "", since: now,
+             relist: ask.relist === true }
+}
+
+// A session line lands only on its open session's newest sent gen; a closed exit's lines never land either.
+function dropSessionLine(searchMode, gen, searchGen, leaving, openedGen) {
+    if (gen > 0 && leaving === true) {
+        return true
+    }
+    return gen > 0 && ((searchMode || "").length === 0 || gen !== searchGen || gen <= (openedGen || 0))
+}
+
+// A live answer holds old rows until its own rows land, no listing out.
+function keepLive(searchMode, inFlight) {
+    return (searchMode || "").length > 0 && inFlight !== true
+}
+
+// While a list is out, only a listed line naming the directory asked for answers it; an earlier sort's or search's is dropped.
+// Held rows, a fallback or a loading mark already drawn keep it for the rows, so the mark never gives way to a count over none.
+function onListed(state, inFlight, path, asked, marked) {
+    if (inFlight === true && path.length > 0 && path !== asked)
+        return DROP
+    return state.holding || state.fellBack || state.waits || marked === true ? KEEP : APPLY
+}
+
+// A rows line ahead of its listed line answers a listing already replaced; one behind a kept listed line lands with it,
+// once the loading mark it replaces has stood waitMs more.
+function onRows(state, inFlight, listedSeen, waitMs) {
+    if (inFlight === true && listedSeen !== true)
+        return DROP
+    if (state.listed === null)
+        return APPLY
+    return waitMs > 0 ? WAIT : LAND
+}
+
+// How much longer a loading state drawn at since stands before it may go; 0 when none is drawn.
+function showLeft(since, now) {
+    return since > 0 ? Math.max(0, since + MIN_SHOW_MS - now) : 0
+}
+
+// How long a held listing begun at state.since still holds before it falls back; -1 when nothing is held.
+function capLeft(state, now) {
+    return state.holding === true ? Math.max(0, state.since + CAP_MS - now) : -1
+}
+
+// The pane mark's hold-off: a directory listing keeps its mark MIN_SHOW_MS, so it draws at the cap; a walk's does not.
+function markHoldOff(searchMode) {
+    return (searchMode || "") === "" ? CAP_MS : HOLD_MS
+}
+
+// A directory listing out under a drawn mark; a walk's or a search's matches stream into a loading pane, never waiting on it.
+function marked(since, inFlight, searchMode, walk) {
+    return since > 0 && inFlight === true && (searchMode || "") === "" && walk !== true
+}
+
+function kept(state, listed) {
+    return Object.assign({}, state, { listed: listed })
+}
+
+// Every listed line that is applied rather than kept says whether the rows it brings are a walk's.
+function heard(state, walk) {
+    return Object.assign({}, state, { walk: walk === true })
+}
+
+// A held listing is only ever a directory's, which is what begin() asked for.
+function landed(state) {
+    return Object.assign({}, state, { holding: false, listed: null, fellBack: false, waits: false, walk: false, relist: false })
+}
+
+// The cap ran out: the pane shows the loading state until the rows land, and a listed line already kept waits for them.
+function expired(state) {
+    return Object.assign({}, state, { holding: false, fellBack: true })
+}
+
+// A failed or refused listing ends the hold without a swap; the failure draws what it always did.
+function dropped(state) {
+    return Object.assign({}, state, { holding: false, listed: null, fellBack: false, waits: false, relist: false })
+}
+
+// The listing is no longer out, however it ended.
+function ended(state) {
+    return Object.assign({}, state, { holding: false, listed: null, fellBack: false, waits: false, relist: false })
+}
+
+// A stale or window refusal ended only its own request, and so does a scan failure naming a folder no longer asked for; any other failure ends the listing, letting held rows go while it is still out.
+function failListing(pane, where, path) {
+    if (where === "stale" || where === "window")
+        return false
+    if (where === "scan" && !!path && path !== pane.listingPath)
+        return false
+    // An Esc relist that died leaves no cursor file armed for whatever listing comes next.
+    if (pane.swap.phase.relist === true)
+        pane.pendingSelect = ""
+    pane.swap.drop()
+    pane.listInFlight = false
+    pane.listedSeen = false
+    return true
+}
+
+// Sample input: {"c":"transfer","op":"move","rows":[3],"dest":"/home/gm/omarchy"} with held 7 gains "listing":7, unless it names one.
+function named(request, held) {
+    if (request.rows === undefined || request.listing !== undefined || !(held > 0))
+        return request
+    return Object.assign({}, request, { listing: held })
+}
+
+// A key swallowed while a listing is out, held or loading: the backend already numbers rows for the directory asked for.
+function swallows(inFlight, action) {
+    return inFlight === true && action.length > 0 && ANSWERED_WHILE_LISTING.indexOf(action) < 0
+}
+
+// A re-sort renumbers every row without a new list, so a selection made while it was in flight names other files once the new numbering lands.
+function clearsSelection(oldHeld, listing) {
+    return oldHeld > 0 && listing > 0 && listing !== oldHeld
+}
+
+// A blank frame: a listing out and loading before the cap, or no row drawn while a live count still names rows.
+function frameKind(inFlight, listingState, fellBack, drawn, named, live) {
+    if (inFlight === true && listingState === "loading") {
+        return fellBack === true ? "loading" : "blank"
+    }
+    if (live === true && drawn === 0 && named > 0) {
+        return "blank"
+    }
+    return ""
+}

package/test/fixtures/qml/flea-theme/ui/js/TextSize.js

@@ -0,0 +1,107 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "KeyName.js" as KeyName
+
+// Flea's text size, which is the Display section's one control. The SettingsScale board rules the
+// shape: Omarchy owns the size by default, and an override pins one stop from Omarchy's own range
+// rather than a free number or a multiplier of its own. The monitor scale beside it belongs to the
+// compositor, which is why nothing here steps or cycles one.
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one.
+var WORDS = {
+    followsOmarchy: "Text size follows Omarchy, %1",
+    override: "Text size %1. %2 follows Omarchy again",
+    overrideAlone: "Text size %1"
+}
+
+// The board's seven documented stops, in px, read off its own layout table. They are not
+// contiguous: 13, 15, 17, 18 and 19 are not stops. The range is the OEM one, 9 to 20, so Flea
+// offers no size Omarchy does not.
+var STOPS = [9, 10, 11, 12, 14, 16, 20]
+
+// Omarchy's own type ladder, from Commons/Style.qml, whose bodySmall is fontPx(0.917) and caption
+// fontPx(0.833) over the base size. Running the same two ratios at a stop is what makes an override
+// the size Omarchy itself would have drawn, rather than a second ladder that can disagree with it.
+var BODY_RATIO = 1.0
+var BODY_SMALL_RATIO = 0.917
+var CAPTION_RATIO = 0.833
+
+var FOLLOW = "system"
+
+function follow() {
+    return { mode: FOLLOW }
+}
+
+// Follow Omarchy is the default, and the board names its stored shape: {"mode":"system"}. An
+// override is the same key holding a number instead, which is src/uischema.rs's own display.textSize
+// rule: "system", or one stop the OEM panel could have produced. There is no second stored shape.
+function following(stored) {
+    return !stored || !(Number(stored.mode) > 0)
+}
+
+// The nearest stop, so a base Omarchy invented that is not on the list still enters the override on
+// a real stop, and a hand-edited file cannot pin a free number. A tie takes the smaller stop, which
+// is what the strict comparison below does: 13 enters at 12 and 15 at 14, so nothing grows unasked.
+function nearest(px) {
+    var best = STOPS[0]
+    for (var i = 1; i < STOPS.length; i++) {
+        if (Math.abs(STOPS[i] - px) < Math.abs(best - px))
+            best = STOPS[i]
+    }
+    return best
+}
+
+// The size Flea actually draws at: Omarchy's own while following, the stored stop while overriding.
+function effective(stored, omarchyBase) {
+    return following(stored) ? omarchyBase : nearest(Number(stored.mode))
+}
+
+// Switching to Override starts on the stop beside the size already on screen, so the switch itself
+// changes nothing and only a step does.
+function pin(stored, omarchyBase) {
+    return { mode: nearest(effective(stored, omarchyBase)) }
+}
+
+// One stop along the list, clamped at both ends. Stepping while following becomes an override,
+// which is what the first press of Ctrl+Shift+Plus should do.
+function stepped(stored, omarchyBase, direction) {
+    var at = STOPS.indexOf(pin(stored, omarchyBase).mode)
+    var to = Math.max(0, Math.min(STOPS.length - 1, at + direction))
+    return { mode: STOPS[to] }
+}
+
+// A stored value another hand wrote, and 0.1.3's own {"mode":"override","px":N}: anything this
+// cannot read as a size follows Omarchy, which is both the default and the state deleting ui.json
+// restores, and a number that is not a stop lands on the nearest one rather than pinning a size the
+// OEM panel could not produce. src/uistate.rs refuses the same shapes on the way in.
+function parse(stored) {
+    var px = stored ? Number(stored.mode) : NaN
+    return px > 0 ? { mode: nearest(px) } : follow()
+}
+
+// One action-to-delta mapping for every caller, so Focus and the Trash host cannot drift apart.
+function direction(action) {
+    return action === "textSizeReset" ? 0 : (action === "textSizeUp" ? 1 : -1)
+}
+
+function body(base) {
+    return Math.max(1, Math.round(base * BODY_RATIO))
+}
+
+function bodySmall(base) {
+    return Math.max(1, Math.round(base * BODY_SMALL_RATIO))
+}
+
+function caption(base) {
+    return Math.max(1, Math.round(base * CAPTION_RATIO))
+}
+
+// The sentence the status bar shows, because a size changed by a chord with the panel shut is
+// otherwise a state with no readout and no named way back.
+function announce(stored, omarchyBase) {
+    var px = effective(stored, omarchyBase) + "px"
+    if (following(stored)) return Format.fill(WORDS.followsOmarchy, px)
+    var reset = KeyName.keyFor("textSizeReset")
+    return reset.length > 0 ? Format.fill(WORDS.override, px, reset) : Format.fill(WORDS.overrideAlone, px)
+}

package/test/fixtures/qml/flea-theme/ui/js/Thumbs.js

@@ -0,0 +1,158 @@
+.pragma library
+
+// A row this listing has dealt with: null means asked and waiting, a string is the answer.
+// A cache-only ask carries a mark, so its empty answer means "not tried" and a class switch forgets it.
+var ASKED = null
+var CACHE_ASKED = "cache-asked"
+var CACHE_MISS = "cache-missed"
+
+// Asked and not answered yet, a plain ask or a cache-only one; only these have a job to cancel.
+function pending(value) {
+    return value === ASKED || value === CACHE_ASKED
+}
+
+function empty() {
+    return { file: {}, order: [] }
+}
+
+// The rows a request may name: the viewport in row indices, clamped to the last row of the listing.
+function viewport(contentY, rowHeight, visibleRows, total) {
+    var first = Math.floor(contentY / rowHeight)
+    // A window that is not row aligned straddles one more row than it holds, so the bottom comes off its pixel extent.
+    var bottom = contentY + visibleRows * rowHeight
+    return { first: first, last: Math.min(total - 1, Math.ceil(bottom / rowHeight) - 1) }
+}
+
+// Only visible rows, only rows the backend called thumbnailable, only rows never asked.
+function plan(state, rows, held, first, last, mode) {
+    var ask = []
+    for (var i = first; i <= last; i++) {
+        if (state.file[i] !== undefined) {
+            continue
+        }
+        var row = rows[i - held]
+        if (allowed(row, mode)) {
+            ask.push(i)
+        }
+    }
+    var drop = []
+    for (var key in state.file) {
+        if (!pending(state.file[key])) {
+            continue
+        }
+        var at = Number(key)
+        if (at < first || at > last || !allowed(rows[at - held], mode)) {
+            drop.push(at)
+        }
+    }
+    return { ask: ask, drop: drop }
+}
+
+// A cancelled row is forgotten here too, because the backend forgets it when it drops the job.
+function forget(state, row) {
+    delete state.file[row]
+    var at = state.order.indexOf(row)
+    if (at >= 0) {
+        state.order.splice(at, 1)
+    }
+}
+
+// A miss on a generating class returns to unasked; on a cache-only class it stays a miss.
+function miss(state, row, generating, cap) {
+    if (generating === true) {
+        forget(state, row)
+        return { file: state.file, order: state.order }
+    }
+    return remember(state, row, "", cap)
+}
+
+// The wrapper is new so a QML binding on it re-evaluates; the map inside is mutated in place.
+function applied(state, work) {
+    for (var i = 0; i < work.drop.length; i++) {
+        forget(state, work.drop[i])
+    }
+    var mark = work.cacheOnly === true ? CACHE_ASKED : ASKED
+    for (var j = 0; j < work.ask.length; j++) {
+        state.file[work.ask[j]] = mark
+        state.order.push(work.ask[j])
+    }
+    return { file: state.file, order: state.order }
+}
+
+// A live answer re-lists some rows: each finished thumbnail follows its row, by name, to that row's new index. Asked and missed rows do not follow.
+function carried(state, oldRows, oldHeld, newRows, newHeld) {
+    var at = Object.create(null)
+    for (var j = 0; j < newRows.length; j++) {
+        if (newRows[j].t) {
+            at[newRows[j].n] = newHeld + j
+        }
+    }
+    var next = empty()
+    for (var k = 0; k < state.order.length; k++) {
+        var file = state.file[state.order[k]]
+        var row = oldRows[state.order[k] - oldHeld]
+        if (file && file !== CACHE_ASKED && file !== CACHE_MISS && row && at[row.n] !== undefined) {
+            next.file[at[row.n]] = file
+            next.order.push(at[row.n])
+        }
+    }
+    return next
+}
+
+// The cap bounds a policy bug, not normal use: only the rows a viewport held are ever recorded.
+function remember(state, row, file, cap) {
+    if (state.file[row] === undefined) {
+        state.order.push(row)
+    }
+    // An empty answer to a cache-only ask was never a decode, so it keeps its mark.
+    state.file[row] = (file === "" && state.file[row] === CACHE_ASKED) ? CACHE_MISS : file
+    while (state.order.length > cap) {
+        delete state.file[state.order.shift()]
+    }
+    return { file: state.file, order: state.order }
+}
+
+function fileFor(state, row) {
+    var value = state.file[row]
+    if (value === CACHE_ASKED || value === CACHE_MISS) return ""
+    return typeof value === "string" ? value : ""
+}
+
+// Answered with nothing, which is not the same as not answered yet. A thumbnailer that could not
+// read the file reports an empty name, and only once that has arrived is it honest to say so.
+function refused(state, row) {
+    return state.file[row] === ""
+}
+
+// src/backend/thumbs.rs THUMB_SIZE: the longest side of a cache file made from a larger original.
+var CACHE_SIZE = 256
+
+// How much a picture may be enlarged to fit its box, and never past limit: 1 for an original, which
+// draws at its own size when it is smaller than the box (decided 2026-09-24). Sample input: (754, 471, 120, 68, 1) is 1.
+function fitScale(boxWidth, boxHeight, width, height, limit) {
+    return Math.min(limit, boxWidth / Math.max(1, width), boxHeight / Math.max(1, height))
+}
+
+// A cache file stands in for its original, so it is enlarged at most to the original's own size. The
+// longest side is compared because EXIF can turn either one. Unknown dimensions leave a full-size cache
+// file free to fill the box, while a smaller one already is the original. Sample input: (256, 171, 300, 200) is 300/256.
+function thumbLimit(thumbWidth, thumbHeight, originalWidth, originalHeight) {
+    var thumbLongest = Math.max(1, thumbWidth, thumbHeight)
+    var originalLongest = Math.max(Number(originalWidth) || 0, Number(originalHeight) || 0)
+    if (originalLongest > 0)
+        return originalLongest / thumbLongest
+    return thumbLongest < CACHE_SIZE ? 1 : Infinity
+}
+
+// A video poster fills the frame; an image keeps the never-enlarge cap.
+function posterLimit(isVideo, thumbWidth, thumbHeight, originalWidth, originalHeight) {
+    if (isVideo)
+        return Infinity
+    return thumbLimit(thumbWidth, thumbHeight, originalWidth, originalHeight)
+}
+
+// Backend icon identity distinguishes image thumbnails from video without opening any extra file; an AppImage's own icon is its identity, so Images draws a row the backend flagged a.
+function allowed(row, mode) {
+    if (!row || !row.t || mode === "off") return false
+    return mode !== "images" || row.i === "image-x-generic" || row.a === true
+}