flea-qml 0.0.0-stage → 0.2.0

package/ui/js/FlashEndings.js

@@ -0,0 +1,125 @@
+.pragma library
+
+.import "Flash.js" as Flash
+.import "Format.js" as Format
+
+// Every ending is a row in the Flash step with its fix in a hint; only the mark reads error.
+
+// Ending headlines and hints, each one whole sentence with placeholders.
+var DONE_HEADLINE = "Flashed {image} to {drive}"
+var CANCELLED_HEADLINE = "Flash cancelled at {at} of {total}"
+var CANCELLED_HINT = "{drive} is blank now. Flash again, or format it in Disks."
+var CANCELLED_UNKNOWN_HEADLINE = "Flash cancelled at {at}"
+var PREWRITE_CANCELLED_HINT = "The flash was cancelled before it started. Flash again when ready."
+var VERIFY_CANCELLED_HEADLINE = "Verify cancelled"
+var VERIFY_CANCELLED_HINT = "{image} is on {drive}, not verified."
+var NOTHING_WRITTEN = "Nothing was written"
+var PASSWORD_CLOSED_HINT = "The password prompt was closed. Flash again to be asked once more."
+var UNMOUNT_HEADLINE = "{drive} could not be unmounted"
+var BUSY_HINT = "Nothing was written. Close what is using it, then flash again."
+var CHANGED_HEADLINE = "{drive} changed since you chose it"
+var CHOOSE_AGAIN_HINT = "Nothing was written. Choose the drive again."
+var UNPLUGGED_HEADLINE = "{drive} was unplugged"
+var LEFT_AT_HINT = "It left at {at}. Plug it in again and flash again."
+var IO_HEADLINE = "Could not flash {drive}"
+var BLANK_STOP_HINT = "It stopped answering at {at} and is blank now. Plug it in again."
+var PARTIAL_STOP_HINT = "It stopped answering at {at} and holds part of the image. Plug it in again and flash again."
+var TOO_BIG_HEADLINE = "{image} is larger than {drive}"
+var UNPACKED_PAST_HINT = "It unpacked past {size}. Use a larger drive."
+var NOT_VERIFY_HEADLINE = "{drive} did not verify"
+var VERIFY_HINT = "It read back different data at {at}. Flash again, or use another drive."
+var NO_UNPACK_HEADLINE = "Could not unpack {image}"
+var NEED_BUBBLE_HEADLINE = "Compressed images need bubblewrap"
+var INSTALL_BUBBLE_HINT = "Install bubblewrap, then flash again."
+var NO_OPEN_HEADLINE = "Could not open {drive}"
+
+function endingFor(err, ctx) {
+    var c = ctx || {}
+    var image = c.image || "", drive = c.drive || ""
+    var at = Format.size(c.at || 0)
+    if (!err)
+        return { headline: Flash.fill(DONE_HEADLINE, { image: image, drive: drive }), hint: "",
+                 role: "foreground", mark: "check", eject: true, flashBack: false }
+    if (err === "cancelled" && c.phase === "verify")
+        return { headline: VERIFY_CANCELLED_HEADLINE,
+                 hint: Flash.fill(VERIFY_CANCELLED_HINT, { image: image, drive: drive }),
+                 role: "foreground", mark: "x", eject: true, flashBack: false }
+    // A cancel before the write moved no byte, so no offset reads true.
+    if (err === "cancelled" && (c.phase === "prepare" || c.phase === "password"))
+        return { headline: NOTHING_WRITTEN, hint: PREWRITE_CANCELLED_HINT,
+                 role: "foreground", mark: "x", eject: false, flashBack: true }
+    // An unknown total names where it stopped, never the packed file's size.
+    if (err === "cancelled" && !(c.total > 0))
+        return { headline: Flash.fill(CANCELLED_UNKNOWN_HEADLINE, { at: at }),
+                 hint: Flash.fill(CANCELLED_HINT, { drive: drive }),
+                 role: "foreground", mark: "x", eject: false, flashBack: true }
+    if (err === "cancelled")
+        return { headline: Flash.fill(CANCELLED_HEADLINE, { at: at, total: Format.size(c.total || 0) }),
+                 hint: Flash.fill(CANCELLED_HINT, { drive: drive }),
+                 role: "foreground", mark: "x", eject: false, flashBack: true }
+    if (err === "denied")
+        return { headline: NOTHING_WRITTEN, hint: PASSWORD_CLOSED_HINT,
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    if (err === "busy")
+        return { headline: Flash.fill(UNMOUNT_HEADLINE, { drive: drive }), hint: BUSY_HINT,
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    if (err === "changed")
+        return { headline: Flash.fill(CHANGED_HEADLINE, { drive: drive }), hint: CHOOSE_AGAIN_HINT,
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    if (err === "gone")
+        return { headline: Flash.fill(UNPLUGGED_HEADLINE, { drive: drive }),
+                 hint: Flash.fill(LEFT_AT_HINT, { at: at }),
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    if (err === "io")
+        return { headline: Flash.fill(IO_HEADLINE, { drive: drive }),
+                 hint: Flash.fill(c.blank ? BLANK_STOP_HINT : PARTIAL_STOP_HINT, { at: at }),
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    if (err === "nospace")
+        return { headline: Flash.fill(TOO_BIG_HEADLINE, { image: image, drive: drive }),
+                 hint: Flash.fill(UNPACKED_PAST_HINT, { size: Format.size(c.driveBytes || 0) }),
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    if (err === "verify")
+        return { headline: Flash.fill(NOT_VERIFY_HEADLINE, { drive: drive }),
+                 hint: Flash.fill(VERIFY_HINT, { at: at }),
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    if (err === "decompress")
+        return { headline: Flash.fill(NO_UNPACK_HEADLINE, { image: image }), hint: String(c.tool || ""),
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    if (err === "sandbox")
+        return { headline: NEED_BUBBLE_HEADLINE, hint: INSTALL_BUBBLE_HINT,
+                 role: "error", mark: "alert", eject: false, flashBack: true }
+    return { headline: Flash.fill(NO_OPEN_HEADLINE, { drive: drive }), hint: String(c.tool || ""),
+             role: "error", mark: "alert", eject: false, flashBack: true }
+}
+
+// A flash that ends while the listing shows reports in the status line as a copy does.
+var DONE_LINE = "Flashed {image} to {drive}."
+var VERIFY_AGAIN_LINE = "{drive} did not verify; flash it again."
+var EJECTED_LINE = "Ejected {drive}. It is safe to unplug."
+var STILL_MOUNTED_LINE = "{drive} is still mounted; close what is using it."
+var EJECT_FAILED_LINE = "Could not eject {drive}."
+
+function ejectDoneLine(drive) {
+    return Flash.fill(EJECTED_LINE, { drive: drive })
+}
+
+function ejectBusyLine(drive) {
+    return Flash.fill(STILL_MOUNTED_LINE, { drive: drive })
+}
+
+function ejectFailedLine(drive) {
+    return Flash.fill(EJECT_FAILED_LINE, { drive: drive })
+}
+
+function statusFor(err, ctx) {
+    var ending = endingFor(err, ctx)
+    if (!err) {
+        var c = ctx || {}
+        return { text: Flash.fill(DONE_LINE, { image: c.image || "", drive: c.drive || "" }), isError: false }
+    }
+    if (err === "cancelled")
+        return { text: Flash.fill("{headline}.", { headline: ending.headline }), isError: false }
+    if (err === "verify")
+        return { text: Flash.fill(VERIFY_AGAIN_LINE, { drive: (ctx || {}).drive || "" }), isError: true }
+    return { text: Flash.fill("{headline}.", { headline: ending.headline }), isError: true }
+}

package/ui/js/FlashPane.js

@@ -0,0 +1,116 @@
+.pragma library
+
+.import "Flash.js" as Flash
+.import "FlashCard.js" as FlashCard
+.import "Ops.js" as Ops
+
+// The flash pane's decisions, checked headless by tests/js/flashpane.js; the QML only applies them.
+
+// A drive is the disk the backend re-checks at flash time, so the pane holds its choice by identity, never by a row index.
+function same(a, b) {
+    return !!a && !!b && a.dev === b.dev && a.seq === b.seq && a.serial === b.serial
+}
+
+function indexOf(drives, drive) {
+    for (var i = 0; i < (drives || []).length; i++) {
+        if (same(drives[i], drive))
+            return i
+    }
+    return -1
+}
+
+// What a cursor position names: the image, a drive by identity, or the Flash step.
+function target(cursor, drives) {
+    if (cursor <= 0)
+        return { kind: "image", drive: null }
+    if (cursor > drives.length)
+        return { kind: "flash", drive: null }
+    return { kind: "drive", drive: drives[cursor - 1] }
+}
+
+// The drive a move lands on when it fits, else null; a refused row never becomes chosen by moving.
+function driveAt(cursor, drives) {
+    var at = target(cursor, drives || [])
+    return at.kind === "drive" && Flash.fits(at.drive) ? at.drive : null
+}
+
+// The choice after a move: the landed drive when it fits, else the kept one.
+function chooseKept(cursor, drives, kept) {
+    var landed = driveAt(cursor, drives)
+    return landed !== null ? landed : kept
+}
+
+// One drive-list answer folded in: the choice kept by identity, the cursor kept on what it named.
+function reconcile(state, rows) {
+    var list = rows || []
+    var chosen = null
+    // An opening that has held a drive keeps that mark until the pane opens again, so a choice that left is never replaced unasked.
+    var held = !state.first && (state.held === true || !!state.chosen)
+    if (state.pendingDisk) {
+        var disk = Flash.railDisk(state.pendingDisk)
+        for (var i = 0; i < list.length && chosen === null; i++) {
+            if (list[i].dev === disk && Flash.fits(list[i]))
+                chosen = list[i]
+        }
+    } else {
+        var at = indexOf(list, state.chosen)
+        chosen = at >= 0 && Flash.fits(list[at]) ? list[at] : null
+        if (chosen === null && !held && Flash.preselect(list) >= 0)
+            chosen = list[Flash.preselect(list)]
+    }
+    var selected = indexOf(list, chosen)
+    if (state.first || state.pendingDisk)
+        return { chosen: chosen, held: held || chosen !== null, selected: selected, cursor: selected + 1, moved: true }
+    var was = target(state.cursor, state.drives || [])
+    var cursor = was.kind === "image" ? 0 : was.kind === "flash" ? Flash.flashPos(list.length) : -1
+    if (was.kind === "drive") {
+        var named = indexOf(list, was.drive)
+        cursor = named >= 0 && Flash.fits(list[named]) ? named + 1 : selected + 1
+    }
+    var now = target(cursor, list)
+    return { chosen: chosen, held: held || chosen !== null, selected: selected, cursor: cursor,
+             moved: now.kind !== was.kind || (now.kind === "drive" && !same(now.drive, was.drive)) }
+}
+
+// A folded answer lands on the view: the rail's pending disk is spent, and the choice, its held mark and the cursor follow the answer.
+function land(view, next) {
+    view.pendingDrive = ""
+    view.chosen = next.chosen
+    view.held = next.held
+    view.cursor = next.cursor
+}
+
+// The host marks the pane it covers; moving to another pane or leaving by Back clears the mark it leaves.
+function cover(host, pane) {
+    if (host.coverPane && host.coverPane !== pane)
+        host.coverPane.flashActive = false
+    host.coverPane = pane
+    pane.flashActive = true
+}
+
+function uncover(host) {
+    if (host.coverPane)
+        host.coverPane.flashActive = false
+}
+
+// Reopening onto a running flash takes back the card Back handed the pane; a copy's card stays.
+function reclaim(pane) {
+    if (!pane.transfer || pane.transfer.flash !== true)
+        return
+    pane.transfer = Ops.emptyTransfer()
+    pane.sticky("")
+}
+
+// Which press a flashdone answers: the running flash, a refusal of the press just sent before any flashstarted, or neither.
+function doneFor(runner, message) {
+    var id = message.id || 0
+    if (runner.running)
+        return id === runner.transferId ? "finished" : "ignore"
+    return runner.pressSent && id === runner.pendingId ? "refused" : "ignore"
+}
+
+// The ending's figures: a verify miss names the backend's offset, every other ending the bytes the drive took, against the card's total.
+function endingContext(transfer, message) {
+    var at = String(message.err || "") === "verify" ? (message.at || 0) : (transfer.bytes || 0)
+    return { at: at, total: FlashCard.total(transfer) || transfer.total || 0 }
+}

package/ui/js/FleaBin.js

@@ -0,0 +1,12 @@
+.pragma library
+
+// flea-qml: the command that runs this repository's own `flea`, so the interface never looks for a
+// `flea` on PATH and never relies on a script's shebang. `shellDir` is Quickshell.shellDir, ui/boot,
+// so src/flea.js sits two levels up. `bun` is buninu-browser's BUNINU_BUN, the Bun it found with
+// Bun.which("bun") || process.argv0. A non-empty FLEA_BIN still names another executable,
+// upstream's binary included.
+function command(fleaBin, bun, shellDir, args) {
+    if (fleaBin)
+        return [String(fleaBin)].concat(args)
+    return [String(bun || "bun"), String(shellDir) + "/../../src/flea.js"].concat(args)
+}