flea-qml 0.0.0-stage → 0.2.0

package/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
+}

package/ui/js/Transfer.js

@@ -0,0 +1,172 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// The model behind ui/TransferCard.qml, kept out of the QML so every state the card can draw is
+// checked without a window. The object each function takes is ui/js/Ops.js's transfer.
+
+// Whole phrases with "%1" for a value, filled by fill so each translates as one; a leading space is the join to the figure drawn before it.
+var WORDS = {
+    movedWaiting: " moved · waiting for the drive",
+    copiedWaiting: " copied · waiting for the drive",
+    moved: " moved",
+    copied: " copied",
+    writingTo: "Writing to %1",
+    moving: "Moving %1 of %2",
+    copying: "Copying %1 of %2",
+    redoing: "Redoing %3 %1 of %2"
+}
+
+// The byte sample for the item in flight. done is the count already finished, so it stays where it
+// was: a sample fills the item in, it does not complete it.
+function sampled(t, index, name, bytes, total, scanned) {
+    // A sample carrying none must not unset the total an earlier one already brought.
+    var settled = scanned > 0 ? scanned : (t.scanned || 0)
+    // A sample for an item itemDone already closed carries the bytes paced lines left out, so they join moved and the card stays put.
+    if (index < (t.done || 0))
+        return Object.assign({}, t, {moved: (t.moved || 0) + bytes, scanned: settled})
+    return Object.assign({}, t, {index: index, name: name, done: index, bytes: bytes, total: total, scanned: settled})
+}
+
+// That item's own terminal line: it counts whole from here, and its byte sample is spent. What it
+// moved joins the running sum first, as the size the wire last named for it, or as the bytes it
+// reported when it never had a total, which is what a directory's own running count is. An item
+// that emitted no sample at all adds nothing, which undercounts a small file and never overcounts.
+function itemDone(t, index, name) {
+    var sampled = t.index === index ? (t.total > 0 ? t.total : t.bytes) : 0
+    return Object.assign({}, t, {index: index, name: name, done: index + 1, bytes: 0, total: 0,
+                                 moved: (t.moved || 0) + sampled})
+}
+
+// Sample input: itemsDone(t, [{index: 0, name: "a"}, {index: 1, name: "b"}]) is itemDone(itemDone(t, 0, "a"), 1, "b") in one write.
+function itemsDone(t, held) {
+    var next = t
+    for (var i = 0; i < held.length; i++)
+        next = itemDone(next, held[i].index, held[i].name)
+    return next
+}
+
+// TransferCard rule 2: what the whole transfer has moved, the finished items plus the one in flight.
+function movedBytes(t) {
+    return (t.moved || 0) + (t.bytes || 0)
+}
+
+// Durability: the backend's last directory flush. Sample input:
+// {"t":"transferprogress","id":12,"index":0,"name":"","bytes":0,"total":0,"scanned":0,"phase":"writing","drive":"128GB"}
+// Every file is already complete, so the counted bytes stay and the sample is spent.
+function markWriting(t, drive) {
+    return Object.assign({}, t, {writing: true, drive: drive || "", name: "", bytes: 0, total: 0})
+}
+
+// A surface that pre-renders its own Cancel state carries noCancel; see ui/js/FlashCard.js.
+function cancelEnabled(t) {
+    if (t.noCancel === true)
+        return false
+    // The flush dims Cancel because every file is already complete, so there is nothing left to stop.
+    return t.running === true && t.writing !== true
+}
+
+// TransferCard rule 1's line under the bar, as the pieces it is drawn from: a figure the card inks
+// in the foreground, or the muted words between them.
+function byteParts(t, rate) {
+    // A surface that pre-renders its own line carries byteText; see ui/js/FlashCard.js.
+    if (t.byteText !== undefined)
+        return t.byteText
+    // The flush has no percentage because the kernel reports none: the confirmed bytes and the wait.
+    if (t.writing === true) {
+        var confirmed = movedBytes(t)
+        if (confirmed <= 0) {
+            return []
+        }
+        return [figure(Format.size(confirmed)), word(t.moving ? WORDS.movedWaiting : WORDS.copiedWaiting)]
+    }
+    var moved = movedBytes(t)
+    if (moved <= 0) {
+        return []
+    }
+    var total = transferTotal(t)
+    var parts = [figure(Format.size(moved))]
+    if (total > 0) {
+        parts.push(word(" of "), figure(Format.size(total)))
+    } else {
+        parts.push(word(t.moving ? WORDS.moved : WORDS.copied))
+    }
+    parts.push(word(" · "), figure(Format.size(rate) + "/s"))
+    // Rule 3b: an estimate needs both a total and a rate, and a stall has neither to divide by.
+    if (total > 0 && rate > 0) {
+        // Clamped: the sweep and the copy count separately, so a file appended mid-copy can pass it.
+        parts.push(word(" · "), figure(Format.duration(Math.max(0, total - moved) / rate * 1000)), word(" left"))
+    }
+    return parts
+}
+
+function figure(text) {
+    return { text: text, figure: true }
+}
+
+function word(text) {
+    return { text: text, figure: false }
+}
+
+// The card's headline, the count with no name in it: the card gives the name a row of its own, and
+// ui/js/Ops.js builds the status bar's one-line form from this same string.
+function head(t) {
+    // A surface that pre-renders its own headline carries headText; see ui/js/FlashCard.js.
+    if (t.headText !== undefined)
+        return t.headText
+    // The flush headline names the drive being waited on, with no percentage, because the kernel reports none.
+    if (t.writing === true)
+        return Format.fill(WORDS.writingTo, t.drive && t.drive.length > 0 ? t.drive : "the drive")
+    // An extract has no items to count, so it names its verb alone.
+    if (t.extract)
+        return "Extracting"
+    return Format.fill(t.redo ? WORDS.redoing : t.moving ? WORDS.moving : WORDS.copying, Format.count(t.index + 1), Format.count(t.n), t.redo)
+}
+
+// The card's second row: the item in flight and how big it is. total is 0 for a directory, whose
+// size is not known in advance without a sweep, so that one names itself and claims nothing more:
+// the running count it does have is the byte line's under the bar, and saying it twice is the thing
+// this canvas exists to stop.
+function fileLine(t) {
+    // A surface that pre-renders its own file line carries fileText; see ui/js/FlashCard.js.
+    if (t.fileText !== undefined)
+        return t.fileText
+    // The flush carries no file line: every file is already complete.
+    if (t.writing === true) {
+        return ""
+    }
+    if (t.name.length === 0) {
+        return ""
+    }
+    return t.total > 0 ? t.name + " · " + Format.size(t.total) : t.name
+}
+
+// The bar is the whole transfer, never the one file: done carries the items already finished and
+// the byte sample only fills in the one in flight. One large file is then its own byte bar, and
+// thirty thousand small ones step it once each instead of restarting it thirty thousand times.
+// t.total is the item in flight's, so it is the transfer's only when the transfer is that one
+// item. One directory is n === 1 with no total of its own, and the sweep is what answers for it.
+function transferTotal(t) {
+    return t.n === 1 && t.total > 0 ? t.total : (t.scanned || 0)
+}
+
+// A bar figure held to 0 through 1, where a missing or non-numeric one reads as empty.
+function unit(value) {
+    if (typeof value !== "number" || !(value > 0))
+        return 0
+    return value > 1 ? 1 : value
+}
+
+// The bar fills against the same total the line under it names, so the two always agree; with no
+// total yet it counts finished items plus the one in flight's share, as it always did.
+function fraction(t) {
+    // A surface that pre-renders its own share carries it; see ui/js/FlashCard.js.
+    if (t.share !== undefined)
+        return unit(t.share)
+    if (t.n <= 0) {
+        return 0
+    }
+    var total = transferTotal(t)
+    var at = total > 0 ? movedBytes(t) / total : (t.done + (t.total > 0 ? t.bytes / t.total : 0)) / t.n
+    return unit(at)
+}

package/ui/js/Trash.js

@@ -0,0 +1,84 @@
+.pragma library
+
+.import "KeyName.js" as KeyName
+.import "Format.js" as Format
+.import "Ops.js" as Ops
+
+// Whole sentences with "%1" for the key that arms and "%2" for the key that acts on its own, filled by Format.fill.
+var WORDS = {
+    trash: "Press %1 again to move it to Trash, or %2 on its own.",
+    review: "Press %1 again to review permanent deletion, or %2 on its own.",
+    trashAlone: "Press %1 again to move it to Trash.",
+    trashMany: "Press %1 again to move them to Trash, or %2 on its own.",
+    trashManyAlone: "Press %1 again to move them to Trash.",
+    reviewAlone: "Press %1 again to review permanent deletion.",
+    deleteOne: "Delete 1 item permanently?",
+    deleteMany: "Delete %1 items permanently?"
+}
+
+// The keys come from the running preset: the arming key, and the key that acts at once when the preset binds one; the count of rows the pair would trash picks it or them.
+function trashPrompt(count) {
+    var alone = KeyName.keyOf("trash", "none"), many = count > 1
+    if (alone.length > 0) return Format.fill(many ? WORDS.trashMany : WORDS.trash, KeyName.keyFor("trash"), alone)
+    return Format.fill(many ? WORDS.trashManyAlone : WORDS.trashAlone, KeyName.keyFor("trash"))
+}
+function reviewPrompt() {
+    var alone = KeyName.keyOf("trash", "none")
+    return alone.length > 0 ? Format.fill(WORDS.review, KeyName.keyFor("trash"), alone) : Format.fill(WORDS.reviewAlone, KeyName.keyFor("trash"))
+}
+
+// The dd pair. A single d used to trash, and it sat in the middle of the letters a name is typed
+// with, so the third keystroke of "Vid" trashed the row (issue 7). Delete and Ctrl+Delete are not
+// letters and still go on one press, through Ops.trash directly.
+
+// How long the first d stays armed. Long enough to be a deliberate pair, short enough that an arm
+// nobody finished cannot be completed by a d typed minutes later.
+var ARM_MS = 1500
+
+// ui/js/Focus.js clears pane.trashArmedAt for every other action, so an arm never survives the key
+// after it; this reads the stamp before it writes one, which is what makes the second press the pair.
+function arm(pane) {
+    if (pane.trashArmedAt > 0 && Date.now() - pane.trashArmedAt < ARM_MS) {
+        pane.trashArmedAt = 0
+        Ops.trash(pane)
+        return
+    }
+    pane.trashArmedAt = Date.now()
+    pane.armPrompted(trashPrompt(Ops.targetIndices(pane).length))
+}
+
+// Window-level keys the Trash view borrows: "direct" skips pane.act as Focus.handleKey does, "act" goes through it, "trash" stays here.
+function route(action) {
+    if (action === "keymapSheet" || action === "pathBar") return "direct"
+    if (action.indexOf("textSize") === 0) return "direct"
+    if (action === "settings" || action === "sidebar") return "act"
+    if (action.indexOf("tab") === 0) return "act"
+    return "trash"
+}
+
+// The delete card's words come from a filled snapshot only (R0: the whole filled card or nothing), so an unfilled one says no word at all.
+function filled(snapshot) {
+    return typeof snapshot.count === "number"
+}
+
+// "Empty Trash?", or one whole sentence per count; Format.fill takes the grouped count into the placeholder.
+function confirmTitle(snapshot) {
+    if (!filled(snapshot)) return ""
+    if (snapshot.all) return "Empty Trash?"
+    return snapshot.count === 1 ? WORDS.deleteOne : Format.fill(WORDS.deleteMany, Format.count(snapshot.count))
+}
+
+function confirmBody(snapshot, scope) {
+    if (!filled(snapshot)) return ""
+    var body = snapshot.all ? Ops.deleteAllLine(snapshot.count, Format.size(snapshot.bytes || 0)) : Ops.deleteScopeLine(scope, snapshot.count)
+    if (snapshot.count === 1 && typeof snapshot.name === "string" && snapshot.name.length > 0)
+        body = "“" + snapshot.name + "”\n\n" + body
+    return body
+}
+
+// Where m opens: the cursor row's menu when no row is marked or the only mark is the cursor row, the marked rows' menu otherwise, the whole-Trash menu when nothing is listed.
+function menuTarget(total, markedCount, cursorMarked) {
+    if (total === 0) return "strip"
+    if (markedCount === 0 || (markedCount === 1 && cursorMarked)) return "cursor"
+    return "marked"
+}

package/ui/js/TrashDates.js

@@ -0,0 +1,47 @@
+.pragma library
+
+.import "Format.js" as Format
+
+function location(original, home) {
+    var cut = String(original).lastIndexOf("/")
+    if (cut < 0) return "Unknown"
+    var folder = cut === 0 ? "/" : original.slice(0, cut)
+    if (home && (folder === home || folder.indexOf(home + "/") === 0))
+        return "~" + folder.slice(home.length)
+    return folder
+}
+
+// Sample input, GIO trash::deletion-date: "2026-09-08T10:00:00" in local time.
+function deleted(text) {
+    // The same guard expired() carries below, and for the same reason: new Date(null) is the epoch,
+    // so an item with no date would have been labelled with a day in 1970 instead of Unknown.
+    if (typeof text !== "string" || text.length === 0) return "Unknown"
+    var date = new Date(text)
+    if (!isFinite(date.getTime())) return "Unknown"
+    // Format.stamp is the product's one date form, so the trash queue sorts against the file list.
+    return Format.stamp(date)
+}
+
+// The 30 day sweep's own two questions. Decided 2026-09-11: the sweep is off by default and
+// opt in, because permanent deletion is outside the undo journal and nobody opted into it by
+// installing an update.
+var DAY_MS = 24 * 60 * 60 * 1000
+
+// Sample input is deleted()'s own: gio's trash::deletion-date, "2026-09-08T10:00:00" in local time.
+// An item whose date cannot be read is NEVER swept: this is the one direction a wrong answer here
+// can be taken in, and "leave it alone" is that direction.
+function expired(text, nowMs, days) {
+    // new Date(null) is the EPOCH, not an invalid date, so a missing value reads as 1970 and would
+    // be swept by every run. The type is checked before the parse rather than after it.
+    if (typeof text !== "string" || text.length === 0) return false
+    var date = new Date(text)
+    if (!isFinite(date.getTime())) return false
+    return nowMs - date.getTime() >= days * DAY_MS
+}
+
+// Which day it is, in whole days since the epoch at local midnight, which is what the sweep records
+// so that it runs once a day rather than once per launch.
+function dayNumber(nowMs) {
+    var now = new Date(nowMs)
+    return Math.floor(new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime() / DAY_MS)
+}

package/ui/js/TrashDrop.js

@@ -0,0 +1,64 @@
+.pragma library
+
+.import "Drag.js" as Drag
+.import "DragOut.js" as DragOut
+.import "Ops.js" as Ops
+.import "Swap.js" as Swap
+.import "Mounts.js" as Mounts
+
+// Only rows lifted in this window may trash through ui/RailTrashRow.qml, with dd's request and z's undo.
+// Sample marker: "<instance>\n1,3\nmove\n%2Fd\n42\n1\n0\n7".
+function markerRows(marker) {
+    var field = String(marker).split("\n")[1] || ""
+    if (field.length === 0) return []
+    var rows = []
+    var parts = field.split(",")
+    for (var i = 0; i < parts.length; i++) {
+        if (!/^[0-9]+$/.test(parts[i])) return []
+        var n = Number(parts[i])
+        if (!Number.isInteger(n) || n < 0) return []
+        rows.push(n)
+    }
+    return rows
+}
+
+// The request or null: carried paths survive listing changes; rows are only for a selection too wide to carry paths, on its source listing in lift-time numbering, so src/backend/rowguard.rs refuses stale indices.
+function request(marker, urls, path, backend) {
+    if (!Drag.isOwnDrag(marker)) return null
+    // Issue 133: a GVFS mount has no trash, so the drop is refused up front as d and the menu are.
+    if (!Mounts.trashable(Drag.markerSource(marker) || path)) return null
+    var paths = DragOut.filePaths(urls)
+    if (paths.length > 0) return { c: "trash", paths: paths }
+    var rows = markerRows(marker)
+    var listing = Drag.markerListing(marker)
+    if (rows.length === 0 || listing <= 0 || !Drag.sameListing(marker, path) || !Drag.liftedBy(marker, backend)) return null
+    return Swap.named({ c: "trash", rows: rows }, listing)
+}
+
+// Whether the drag can trash its carried files here, used by the hover check and status line.
+function accepts(marker, urls, path, backend) {
+    return request(marker, urls, path, backend) !== null
+}
+
+// Sends trash through the pane's backend and answers whether it sent; the trashed reply clears the selection and re-reads the listing.
+function drop(pane, marker, urls) {
+    if (!pane || !pane.backend) return false
+    var sent = request(marker, urls, pane.path, pane.backend)
+    if (!sent) return false
+    // Where the cursor lands once the rows are gone, as dd sets it; only a drag from this listing has one.
+    var rows = Drag.sameListing(marker, pane.path) && Drag.liftedBy(marker, pane.backend) ? markerRows(marker) : []
+    var first = rows.length > 0 ? rows[0] : -1
+    for (var i = 1; i < rows.length; i++)
+        if (rows[i] < first) first = rows[i]
+    pane.trashedFirst = first
+    pane.backend.send(sent)
+    return true
+}
+
+// The status bar while the drag rests on the Trash row. Sample: "Move 2 items to Trash".
+function line(marker, urls, path, backend) {
+    if (!accepts(marker, urls, path, backend)) return ""
+    var rows = markerRows(marker)
+    var n = rows.length > 0 ? rows.length : DragOut.filePaths(urls).length
+    return "Move " + Ops.items(n) + " to Trash"
+}