flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Status.js

@@ -0,0 +1,238 @@
+.pragma library
+
+.import "DirSizes.js" as DirSizes
+.import "Format.js" as Format
+.import "Keymap.js" as Keymap
+.import "Match.js" as Match
+
+// A finished operation names its own reversal and the clipboard names the key that spends it. The
+// strip draws either in its secondary, so no sentence it shows ends in advice of its own.
+// The key comes from the running preset, so the default preset draws " · z undoes" and " · p pastes" and another preset draws its own.
+var HINTS = {
+    undo: " · %1 undoes",
+    paste: " · %1 pastes",
+    deletes: " · %1 deletes",
+    note: " · %1",
+    noteUndo: " · %1 · %2 undoes"
+}
+function undoHint() {
+    var key = Keymap.hintFor("undo")
+    return key.length > 0 ? Format.fill(HINTS.undo, key) : ""
+}
+function pasteHint() {
+    var key = Keymap.hintFor("paste")
+    return key.length > 0 ? Format.fill(HINTS.paste, key) : ""
+}
+// The hint is the strip's second lane, so a finished line takes it as its tail and hintOf splits it off again.
+function withUndo(line) { return line + undoHint() }
+function withPaste(line) { return line + pasteHint() }
+
+// The key that still removes the rows where there is no Trash, drawn in the secondary lane.
+function trashHint() {
+    var key = Keymap.hintFor("deletePermanently")
+    return key.length > 0 ? Format.fill(HINTS.deletes, key) : ""
+}
+
+// Refusal where gio has no Trash: the place in the primary, the key that still works in the secondary.
+var NO_TRASH = "This location has no Trash"
+function noTrashLine() { return NO_TRASH + trashHint() }
+
+// An arm's record: its owner (the pane, or the Trash view while it is open) and the stamp that owner set before the prompt.
+function armOf(owner, stamp) { return { owner: owner, stamp: stamp } }
+
+// Live while the bar still has that owner and the owner still holds that stamp; its second press, any other key and a new listing zero it.
+function armLive(arm, owner) { return arm !== null && arm.stamp > 0 && arm.owner === owner && owner.trashArmedAt === arm.stamp }
+
+// What the arm has left by its owner's clock, the stamp, so a Qt timer that fires early never ends it while the key still acts.
+function armLeft(arm, now, armMs) { return arm === null ? 0 : armMs - (now - arm.stamp) }
+
+// A live arm's prompt, else the oldest unacknowledged error, else the notice: a hidden live prompt's second press acts unannounced.
+function transientOf(errors, notice, prompt, live) {
+    if (live === true) return { text: prompt, isError: false, detail: "" }
+    if (errors.length) return { text: errors[0].text, isError: true, detail: errors[0].detail }
+    return { text: notice, isError: false, detail: "" }
+}
+
+// The no-Trash refusal names its place and replaces its own copy there, where it stands; other errors name none.
+function withError(errors, text, detail, place) {
+    var entry = { text: text, detail: detail || "", place: text === noTrashLine() ? place : "" }
+    var at = entry.place.length === 0 ? -1
+        : errors.findIndex(function (e) { return e.text === text && e.place === entry.place })
+    if (at < 0) return errors.concat([entry])
+    var next = errors.slice()
+    next[at] = entry
+    return next
+}
+
+// Leaving a place drops its refusals; other errors wait for dismissal, and an unchanged queue is the same array.
+function errorsAt(errors, place) {
+    var kept = errors.filter(function (entry) { return entry.place.length === 0 || entry.place === place })
+    return kept.length === errors.length ? errors : kept
+}
+
+// The durable verdict's own notes, mirrored from src/backend/durable.rs: a done line
+// carrying one draws "Copied N items" with "<note> · z undoes" beside it, the way the
+// CloudMounts board draws the rclone upload sentence.
+var VERDICT_NOTES = ["rclone uploads them in the background", "copied, but the drive did not confirm the folder"]
+
+// Which hint a result carries, if any.
+function hintOf(notice) {
+    var text = String(notice || "")
+    for (var i = 0; i < VERDICT_NOTES.length; i++) {
+        var undoKey = Keymap.hintFor("undo")
+        var tail = undoKey.length > 0 ? Format.fill(HINTS.noteUndo, VERDICT_NOTES[i], undoKey) : Format.fill(HINTS.note, VERDICT_NOTES[i])
+        if (text.length >= tail.length && text.lastIndexOf(tail) === text.length - tail.length)
+            return tail
+    }
+    if (undoHint().length > 0 && text.indexOf(undoHint()) >= 0) {
+        return undoHint()
+    }
+    if (pasteHint().length > 0 && text.indexOf(pasteHint()) >= 0) {
+        return pasteHint()
+    }
+    var trash = trashHint()
+    if (trash.length > 0 && text.indexOf(trash) >= 0) {
+        return trash
+    }
+    return ""
+}
+
+// Sample input: " · rclone uploads them in the background · z undoes"; any hint ending in undoHint() carries undo.
+function hasUndoHint(hint) {
+    var text = String(hint || "")
+    var undo = undoHint()
+    return undo.length > 0 && text.length >= undo.length
+        && text.lastIndexOf(undo) === text.length - undo.length
+}
+
+// Only the displayed activity's Starting line walks the busy mark, never one queued behind it; the record says so, not its text.
+function displayedStarting(activities) {
+    var list = activities || []
+    return list.length > 0 && list[0].starting === true
+}
+
+// The key it names. ui/StatusBar.qml draws the separator itself, so the key arrives without one.
+function hintKey(hint) {
+    return hint.replace(" \u00b7 ", "")
+}
+
+// Sample input: "esc dismisses · z undoes". The undo segment lifted out of a hint, so the strip
+// can draw it as its own click target; the middot between them stays muted.
+function withoutUndoKey(keyHint) {
+    var undo = hintKey(undoHint())
+    if (keyHint === undo) {
+        return ""
+    }
+    var tail = " \u00b7 " + undo
+    if (keyHint.length > tail.length && keyHint.lastIndexOf(tail) === keyHint.length - tail.length) {
+        return keyHint.substring(0, keyHint.length - tail.length)
+    }
+    return keyHint
+}
+
+// Sample input: keyHint "z undoes" with nothing else standing. The secondary lane as one string,
+// so ui/StatusBar.qml draws the rest beside the undo target from this same join.
+function secondaryText(keyHint, transientIsError, stickyHere, sticky, activities, searching, searchLine, retryLine) {
+    var extra = activities.slice(1).map(function (entry) { return entry.text }).join(" · ")
+    return [keyHint,
+        transientIsError && stickyHere ? sticky : "",
+        extra,
+        stickyHere && !transientIsError && searching ? searchLine : "",
+        transientIsError ? "" : retryLine]
+        .filter(function (s) { return s.length > 0 }).map(function (s) { return " · " + s }).join("")
+}
+
+// Sample input: { transient: "Copy failed", transientIsError: true, searching: true, searchLine: "3 found in 1.6 s", stickyHere: true, sticky: "Copying 2 of 5" }
+function errorHere(slot) {
+    return slot.transient.length > 0 && slot.transientIsError
+}
+
+function promptHere(slot) {
+    return slot.armLive === true
+}
+
+// The centre zone is what just happened, and nothing else. The disk facts have a zone of their own,
+// so this no longer falls back to them: an idle bar's centre is empty. StatusBar board rule 1.
+// The ordering rule: acknowledged errors leave the slot; activity cannot displace them.
+function centreText(slot) {
+    // A prompt stands over activity and search as well, for the reason transientOf gives.
+    if (errorHere(slot) || promptHere(slot))
+        return slot.transient
+    if (slot.stickyHere)
+        return slot.sticky
+    if (slot.searching)
+        return slot.searchLine
+    return slot.transient
+}
+
+function centreRole(slot) {
+    return errorHere(slot) ? "error" : "foreground"
+}
+
+// Whether the centre draws the notice, whose display time is the one ui/StatusBar.qml's timer ends.
+function noticeShown(slot) {
+    return !promptHere(slot) && slot.transient.length > 0 && !slot.transientIsError && !slot.stickyHere && !slot.searching
+}
+
+// The selection's byte total, or -1 when the bar may not claim one. StatusBar board rule 3: every
+// selected row has to be held and every size known and complete, and nothing here starts a sweep.
+// A file carries its own bytes; a directory has them only from a finished DirSizes answer.
+function selectionBytes(pane) {
+    var count = pane.selection.count()
+    // More rows selected than the window holds means at least one of them is not here to measure.
+    if (count === 0 || count > pane.rows.length) {
+        return -1
+    }
+    var indices = pane.selection.indices()
+    var bytes = 0
+    for (var i = 0; i < indices.length; i++) {
+        var row = pane.rows[indices[i] - pane.held]
+        if (!row) {
+            return -1
+        }
+        if (row.d) {
+            var walked = DirSizes.known(DirSizes.sizeFor(pane.dirSizeState, indices[i]), row)
+            if (!walked || walked.partial) {
+                return -1
+            }
+            bytes += walked.bytes
+            continue
+        }
+        bytes += row.s
+    }
+    return bytes
+}
+
+// Each backend numbers its own transfers, so an id is meaningful only with its pane owner.
+function activityChanged(activities, owner, text, transfer, starting) {
+    var next = activities.slice()
+    var at = next.findIndex(function (activity) { return activity.owner === owner })
+    if (!text) {
+        if (at >= 0) next.splice(at, 1)
+        return next
+    }
+    var previous = at >= 0 ? next[at] : null
+    var activity = { owner: owner, text: text, transfer: transfer, starting: starting === true,
+                     cancelling: !!(previous && previous.transfer.id === transfer.id && previous.cancelling) }
+    if (at >= 0) next[at] = activity
+    else next.push(activity)
+    return next
+}
+
+function cancelActivity(activities) {
+    if (!activities.length || !activities[0].transfer.running || activities[0].cancelling)
+        return activities
+    var next = activities.slice()
+    next[0] = Object.assign({}, next[0], { cancelling: true })
+    return next
+}
+
+// One marked item wins; otherwise name the visible cursor row, including in a
+// multi-selection. Reuse display names so Trash never leaks collision-safe names.
+function fileName(pane) {
+    if (!pane || pane.listInFlight) return ""
+    var indices = pane.selection.indices()
+    var index = indices.length === 1 ? indices[0] : pane.cursorIndex
+    if (indices.length !== 1 && pane.shown !== null && pane.shown.indexOf(index) < 0) return ""
+    return Match.rowName(pane.rowFor(index), true)
+}

package/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/ui/js/TabMove.js

@@ -0,0 +1,39 @@
+.pragma library
+
+// Reorder is pure with no pane; Tabs.js snapshots around it.
+// Sample input: items ["a","b","c"], from 0.
+
+// A drag names the insertion point, not the tab it takes.
+function insertionAt(x, tabWidth, count) {
+    if (!(tabWidth > 0) || !(count > 0))
+        return 0
+    return Math.max(0, Math.min(count, Math.floor(x / tabWidth + 0.5)))
+}
+
+// The { and } keys move one place, clamping at either end rather than wrapping.
+function step(from, delta, count) {
+    return Math.max(0, Math.min(count - 1, from + delta))
+}
+
+// A favourite drag answers where the row lands and the line draws: (40, 1, 30, 5) drops at 2, line at 3.
+function railReorder(dy, from, rowHeight, count) {
+    var n = Math.max(1, count)
+    var step = Math.round(dy / rowHeight)
+    return { to: Math.max(0, Math.min(n - 1, from + step)),
+        line: Math.max(0, Math.min(n, from + step + (dy >= 0 ? 1 : 0))) }
+}
+
+// A move keeps the current tab current: the dragged tab follows its destination, and a crossed tab shifts back.
+function reorder(items, from, to, index) {
+    if (from < 0 || from >= items.length || to < 0 || to >= items.length || from === to)
+        return index
+    var moving = items.splice(from, 1)[0]
+    items.splice(to, 0, moving)
+    if (index === from)
+        return to
+    if (from < index && to >= index)
+        return index - 1
+    if (from > index && to <= index)
+        return index + 1
+    return index
+}