flea-qml 0.0.0-stage → 0.2.0

package/ui/js/ClipMarks.js

@@ -0,0 +1,73 @@
+.pragma library
+
+.import "Search.js" as Search
+
+// The mark follows the pane's own clipboard, so spending a cut clears every mark at once.
+
+// Sample input: { paths: ["/home/gm/Pictures/phone/IMG_4121.jpg"], moving: true }
+var _cached = null
+var _marks = {}
+// Counts rows reaching the library; production ignores it, tests/listcost.qml asserts on it.
+var markCalls = 0
+
+// One keyed lookup per clipboard, rebuilt when the clipboard object changes; every row after that is a single key read.
+function setFor(clipboard) {
+    if (clipboard === _cached)
+        return _marks
+    _cached = clipboard
+    _marks = {}
+    var paths = (clipboard && clipboard.paths) || []
+    for (var i = 0; i < paths.length; i++)
+        _marks[paths[i]] = true
+    return _marks
+}
+
+// An emptied clipboard drops its lookup once, so a cut of a large directory frees it and later rows allocate nothing.
+function release() {
+    if (_cached === null) return
+    _cached = null
+    _marks = {}
+}
+
+// Sample input: { paths: [], moving: false } is empty, null is empty.
+function isEmpty(clipboard) {
+    return !clipboard || !clipboard.paths || clipboard.paths.length === 0
+}
+
+function markFor(path, clipboard) {
+    if (isEmpty(clipboard)) {
+        release()
+        return ""
+    }
+    return setFor(clipboard)[path] === true ? (clipboard.moving ? "scissors" : "copy") : ""
+}
+
+// An empty clipboard costs nothing: its paths are never joined or searched.
+function markForRow(pane, name, clipboard) {
+    markCalls += 1
+    if (isEmpty(clipboard)) {
+        release()
+        return ""
+    }
+    if (!name) {
+        return ""
+    }
+    return markFor(rowPath(pane, name), clipboard)
+}
+
+// The pane's own join under the listing's base, so a search result resolves against the scope its search walked.
+// Sample input: pane { path: "/home/gm/Pictures/phone" }, name "IMG_4121.jpg".
+function rowPath(pane, name) {
+    if (!name) {
+        return ""
+    }
+    return pane.join(Search.baseOf(pane), name)
+}
+
+// A sent cut empties a cut clipboard, so the marks go with it; anything else keeps it. ui/CollideHost.qml decides through this.
+function spent(clipboard, spendsCut) {
+    if (spendsCut === true && clipboard && clipboard.moving === true) {
+        return { paths: [], moving: false }
+    }
+    return clipboard
+}

package/ui/js/ClipSelection.js

@@ -0,0 +1,67 @@
+.pragma library
+
+.import "Clipboard.js" as Clipboard
+
+function publish(pane, request, copied) {
+    if (request.sequence !== pane.clipSequence) return
+    Clipboard.set(pane, request.paths, request.moving)
+    pane.message(copied(request.paths.length, request.moving), false)
+}
+
+// Untagged paths replies resolve one queued request at a time; only the newest choice publishes.
+function drain(pane) {
+    if (pane.clipPending !== null) return
+    var queue = (pane.clipQueue || []).slice()
+    while (queue.length) {
+        var request = queue[0]
+        if (request.paths !== null || request.sequence !== pane.clipSequence) {
+            queue.shift()
+            continue
+        }
+        if (request.path !== pane.path || request.listing !== pane.backend.heldListing || pane.listInFlight) {
+            queue.shift()
+            pane.message("Selected items changed; copy or cut again.", false)
+            continue
+        }
+        pane.clipQueue = queue
+        pane.clipPending = request
+        pane.backend.askPaths(request.rows)
+        return
+    }
+    pane.clipQueue = queue
+}
+
+function take(pane, moving, paths, indices, copied) {
+    pane.clipSequence = (pane.clipSequence || 0) + 1
+    var request = { sequence: pane.clipSequence, moving: moving, paths: paths ? paths.slice() : null,
+        rows: paths ? null : indices.slice(), path: pane.path, listing: pane.backend.heldListing }
+    pane.clipQueue = (pane.clipQueue || []).concat([request])
+    if (request.paths !== null) publish(pane, request, copied)
+    drain(pane)
+}
+
+function resolved(pane, list, copied) {
+    if (pane.clipPending === null) return
+    var sequence = pane.clipPending.sequence
+    var queue = (pane.clipQueue || []).slice()
+    for (var i = 0; i < queue.length; i++) {
+        if (queue[i].sequence !== sequence) continue
+        var request = Object.assign({}, queue[i], { paths: list.slice() })
+        queue[i] = request
+        publish(pane, request, copied)
+        break
+    }
+    pane.clipQueue = queue
+    pane.clipPending = null
+    drain(pane)
+}
+
+function failed(pane) {
+    if (pane.clipPending === null) return
+    var sequence = pane.clipPending.sequence
+    pane.clipQueue = (pane.clipQueue || []).filter(function (request) {
+        return request.sequence !== sequence
+    })
+    pane.clipPending = null
+    drain(pane)
+}

package/ui/js/Clipboard.js

@@ -0,0 +1,179 @@
+.pragma library
+
+.import "ClipMarks.js" as ClipMarks
+.import "Menu.js" as Menu
+.import "Format.js" as Format
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one.
+var WORDS = {
+    setFailed: "Copied in this window only: %1",
+    clearFailed: "Could not clear the system clipboard: %1"
+}
+
+function empty() { return { paths: [], moving: false, token: "" } }
+function state() {
+    return { sets: [], ownTokens: Object.create(null), generation: 0, failed: [], gets: [], deferred: null,
+        getSequence: 0, acceptedGetSequence: 0 }
+}
+function session(pane) {
+    if (!pane.clipboardState) pane.clipboardState = state()
+    return pane.clipboardState
+}
+
+function set(pane, paths, moving) {
+    var s = session(pane)
+    s.generation += 1
+    s.deferred = null
+    var clip = { paths: paths, moving: moving, token: "" }
+    pane.clipboard = clip
+    s.sets.push({ pane: pane, backend: pane.backend, clip: clip })
+    pane.backend.send({ c: "clipSet", op: moving ? "cut" : "copy", paths: paths })
+}
+
+function take(queue, backend) {
+    for (var i = 0; i < queue.length; i++) {
+        if (queue[i].backend === backend) return queue.splice(i, 1)[0]
+    }
+    return null
+}
+
+function replace(pane, message) {
+    pane.clipboard = message.clip === "copy" || message.clip === "cut"
+        ? { paths: message.paths || [], moving: message.clip === "cut", token: message.token || "" }
+        : empty()
+}
+
+function pendingEcho(s, message) {
+    if (!message.token) return false
+    var paths = message.paths || []
+    for (var i = 0; i < s.sets.length; i++) {
+        var clip = s.sets[i].clip
+        if (clip.moving !== (message.clip === "cut") || clip.paths.length !== paths.length) continue
+        var equal = true
+        for (var j = 0; j < clip.paths.length; j++) {
+            if (clip.paths[j] !== paths[j]) {
+                equal = false
+                break
+            }
+        }
+        if (equal) return true
+    }
+    return false
+}
+
+function selection(pane, message, s) {
+    s.deferred = null
+    if (message.token && s.ownTokens[message.token]) return
+    // A watcher can see our owner before set answers with its token.
+    if (pendingEcho(s, message)) { s.deferred = {pane: pane, message: message}; return }
+    s.generation += 1
+    replace(pane, message)
+}
+
+function receive(pane, message) {
+    var s = session(pane)
+    if (message.op === "set") {
+        var entry = take(s.sets, pane.backend)
+        if (!entry) return
+        if (!message.ok) {
+            // The copy itself worked, inside this window: a notice, so the paste's own result line is not held under it.
+            entry.pane.message(Format.fill(WORDS.setFailed, message.error), false)
+        } else {
+            // Both panes can echo any earlier owner after a later set has answered.
+            if (message.token) s.ownTokens[message.token] = true
+            // The collision card may already hold this cut, so its snapshot keeps the token too.
+            entry.clip.token = message.token
+            if (pane.clipboard === entry.clip)
+                pane.clipboard = { paths: entry.clip.paths, moving: entry.clip.moving, token: message.token }
+        }
+        var deferred = s.deferred
+        if (deferred) {
+            s.deferred = null
+            selection(deferred.pane, deferred.message, s)
+        }
+    } else if (message.op === "changed") {
+        var index = s.failed.indexOf(pane.backend)
+        pane.clipboardWatchFailed = !!message.error
+        if (message.error) {
+            if (index < 0) s.failed.push(pane.backend)
+            return
+        }
+        if (index >= 0) s.failed.splice(index, 1)
+        selection(pane, message, s)
+    } else if (message.op === "get") {
+        var waiting = take(s.gets, pane.backend)
+        if (!waiting) return
+        // A local set, newer watcher selection or later accepted read outranks this reply.
+        if (message.ok && s.sets.length === 0 && waiting.generation === s.generation
+                && waiting.sequence > s.acceptedGetSequence) {
+            s.acceptedGetSequence = waiting.sequence
+            replace(pane, message)
+        }
+        waiting.ready()
+    } else if (message.op === "clear" && message.ok === false) {
+        pane.message(Format.fill(WORDS.clearFailed, message.error), true)
+    }
+}
+
+function read(pane, ready) {
+    var s = session(pane)
+    if (s.sets.length > 0 || s.failed.indexOf(pane.backend) < 0) {
+        ready()
+        return
+    }
+    for (var i = 0; i < s.gets.length; i++) {
+        if (s.gets[i].backend === pane.backend) {
+            pane.message("Still reading the clipboard; try again.", false)
+            return
+        }
+    }
+    s.getSequence += 1
+    s.gets.push({ backend: pane.backend, ready: ready, generation: s.generation, sequence: s.getSequence })
+    pane.backend.send({ c: "clipGet" })
+}
+
+var IMAGE_NAME = "Pasted image %1 at %2.png"
+function two(n) {
+    return (n < 10 ? "0" : "") + n
+}
+// Sample input: new Date(2026, 8, 23, 10, 14, 32) -> "Pasted image 2026-09-23 at 10.14.32.png".
+function imageName(at) {
+    var date = at.getFullYear() + "-" + two(at.getMonth() + 1) + "-" + two(at.getDate())
+    var time = two(at.getHours()) + "." + two(at.getMinutes()) + "." + two(at.getSeconds())
+    return IMAGE_NAME.replace("%1", date).replace("%2", time)
+}
+
+// All paste verbs read the same file selection, including the no-watcher fallback.
+function paste(pane, linkKind, forceMove) {
+    var dest = pane.path
+    function ready() {
+        if (pane.path !== dest || pane.listInFlight || pane.recentMode) {
+            pane.message("The paste destination changed; try again.", false)
+            return
+        }
+        var clip = pane.clipboard
+        var sources = clip.paths
+        if (sources.length === 0 && !linkKind) {
+            // No paths: the backend pastes an image as a stamped file, or answers its own sentence.
+            pane.backend.send({ c: "pasteimage", dest: dest, name: imageName(new Date()) })
+            return
+        }
+        if (sources.length === 0) {
+            pane.message(Menu.EMPTY_CLIPBOARD, false)
+            return
+        }
+        pane.asks().ask({ c: linkKind ? "link" : "transfer",
+            op: linkKind || (forceMove || clip.moving ? "move" : "copy"), paths: sources, dest: dest },
+            null, !linkKind && clip.moving)
+    }
+    read(pane, ready)
+}
+
+// Clear only the cut captured by this transfer, never a newer selection on the card.
+function spent(pane, clip, spendsCut) {
+    if (ClipMarks.spent(clip, spendsCut) === clip) return
+    pane.backend.send(clip.token ? { c: "clipClear", token: clip.token }
+                                : { c: "clipClear", cut: clip.paths })
+    if (pane.clipboard === clip || (pane.clipboard.paths === clip.paths && pane.clipboard.token === clip.token))
+        pane.clipboard = empty()
+}

package/ui/js/Cloud.js

@@ -0,0 +1,97 @@
+.pragma library
+
+.import "NetFs.js" as NetFs
+
+// Cloud rows: non-network FUSE mounts inside home, read off the rail's own poll; nothing new runs.
+
+// Sample input, /proc/self/mountinfo lines (id parent maj:min root mountpoint options,
+// then fstype source superoptions):
+// 23 1 8:1 / /home/u/gdrive rw,nosuid,nodev - fuse.rclone remote: rw,user_id=1000,group_id=1000
+// 24 1 8:1 / /home/u/My\040Drive rw,nosuid,nodev - fuse.mergerfs merge: rw,user_id=1000,group_id=1000
+// 31 1 0:27 / /home/u/ProtonDrive rw,nosuid,nodev - fuse.protondrive proton: rw,user_id=1000
+// 18 1 8:1 / /home/u rw,nosuid,nodev - btrfs /dev/sda1 rw
+// 40 1 0:40 / /run/user/1000/gvfs rw,nosuid,nodev - fuse.gvfsd-fuse gvfsd-fuse rw,user_id=1000
+// Only the mergerfs line is a cloud row (network fstypes are share rows; home and gvfs are not); a stacked mountpoint keeps the later line.
+function parseCloudMounts(body, home) {
+    var root = String(home || "")
+    if (root.length === 0)
+        return []
+    var prefix = root.charAt(root.length - 1) === "/" ? root : root + "/"
+    var out = []
+    var at = {}
+    var lines = String(body || "").split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var parsed = parseMountinfoLine(lines[i])
+        if (!parsed || !isCloudFstype(parsed.fstype))
+            continue
+        if (NetFs.isNetworkFstype(parsed.fstype))
+            continue // A network fstype is a share row wherever it is mounted.
+        // Strictly inside: the home directory itself mounts whatever the box is made of.
+        if (parsed.path.length <= root.length || parsed.path.indexOf(prefix) !== 0)
+            continue
+        if (at[parsed.path] === undefined)
+            at[parsed.path] = out.length
+        out[at[parsed.path]] = parsed
+    }
+    return out
+}
+
+// Any FUSE mount is a cloud candidate; the home-folder containment above is what keeps
+// gvfs, portals and the box's own mounts out, because none of them lives under it.
+function isCloudFstype(fstype) {
+    var lower = String(fstype || "").toLowerCase()
+    return lower === "fuse" || lower.indexOf("fuse.") === 0
+}
+
+// Every network-fstype mountinfo line outside the box's plumbing is a NETWORK row, home or not.
+// Sample input: "31 1 0:45 / /mnt/nas rw - nfs nas:/share rw" becomes one row.
+function parseNetworkMounts(body) {
+    var out = []
+    var at = {}
+    var lines = String(body || "").split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var parsed = parseMountinfoLine(lines[i])
+        if (!parsed || !NetFs.isNetworkFstype(parsed.fstype))
+            continue
+        if (parsed.path === "/" || isSystemMountPath(parsed.path))
+            continue // The box's own plumbing is never a network row.
+        if (at[parsed.path] === undefined)
+            at[parsed.path] = out.length
+        out[at[parsed.path]] = parsed
+    }
+    return out
+}
+
+// Sample input: "/run/user/1000/gvfs" trues, "/mnt/nas" falses; read without a per-row stat.
+function isSystemMountPath(p) {
+    if (p.indexOf("/proc/") === 0 || p === "/proc")
+        return true
+    if (p.indexOf("/sys/") === 0 || p === "/sys")
+        return true
+    if (p.indexOf("/dev/") === 0 || p === "/dev")
+        return true
+    if (p.indexOf("/run/") === 0)
+        return true
+    return false
+}
+
+// One mountinfo line into its mountpoint and fstype, or null: the mountpoint is field five
+// of the left half and the fstype is the first field of the right half, split on " - ".
+function parseMountinfoLine(line) {
+    var halves = String(line || "").split(" - ")
+    if (halves.length < 2)
+        return null
+    var left = halves[0].split(/\s+/)
+    var right = halves[1].split(/\s+/)
+    if (left.length < 5 || right.length < 1 || left[4].length === 0 || right[0].length === 0)
+        return null
+    return { path: unescapeOctal(left[4]), fstype: right[0] }
+}
+
+// Sample input: "/home/u/My\040Drive" answers "/home/u/My Drive". A mountinfo escape is a
+// backslash and three octal digits, and anything else is kept literally.
+function unescapeOctal(field) {
+    return String(field).replace(/\\([0-7]{3})/g, function (match, digits) {
+        return String.fromCharCode(parseInt(digits, 8))
+    })
+}

package/ui/js/CodeRuns.js

@@ -0,0 +1,72 @@
+.pragma library
+
+.import "Contrast.js" as Contrast
+.import "Palette.js" as Palette
+
+// The ink names after the foreground, in the order the code reply numbers its roles: 1 to 6 are bat's SGR 31 to 36.
+var INKS = ["red", "green", "yellow", "blue", "magenta", "cyan"]
+// The inks a theme without that colour draws in.
+var FALLBACK = { red: "#f38ba8", green: "#a6e3a1", yellow: "#f9e2af", blue: "#89b4fa", magenta: "#cba6f7", cyan: "#94e2d5" }
+// A tab fills to the next multiple of this many columns.
+var TAB = 8
+
+// The foreground, then bat's six colours, each the palette's own (its ANSI slot when unnamed) lifted to 4.5:1 on the background or surface it contrasts less with.
+function inks(found, fallback, foreground) {
+    var bg = Palette.pick(found, ["background"], fallback.background)
+    var surface = Palette.pick(found, Palette.SURFACE_KEYS, fallback.surface)
+    var out = [foreground]
+    for (var i = 0; i < INKS.length; i++) {
+        var ink = Palette.pick(found, [INKS[i], "color" + (i + 1)], FALLBACK[INKS[i]])
+        out.push(Contrast.ensureRatio(ink, Contrast.ratio(ink, bg) < Contrast.ratio(ink, surface) ? bg : surface, 4.5))
+    }
+    return out
+}
+
+function roleName(role) {
+    return role >= 1 && role <= INKS.length ? INKS[role - 1] : "foreground"
+}
+
+function escape(text) {
+    return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;")
+}
+
+// The reply's flat [role, text, role, text, ...] as [role, text] pairs with every tab filled to its stop, since a rich text folds a tab into one space.
+// Sample input: [5, "ab", 0, "\tx"] answers [[5, "ab"], [0, "      x"]].
+function pairs(runs) {
+    var out = []
+    var column = 0
+    for (var i = 0; i + 1 < runs.length; i += 2) {
+        var text = ""
+        var raw = String(runs[i + 1])
+        for (var j = 0; j < raw.length; j++) {
+            var fill = raw.charAt(j) === "\t" ? TAB - column % TAB : 1
+            text += raw.charAt(j) === "\t" ? " ".repeat(fill) : raw.charAt(j)
+            column += fill
+        }
+        out.push([runs[i], text])
+    }
+    return out
+}
+
+function plain(runs) {
+    return pairs(runs).map(function (pair) { return pair[1] }).join("")
+}
+
+// One line as StyledText: every run escaped, a coloured run in one font tag, and each space kept as a non-breaking space unless it is a single space between two characters, which a rich text keeps and may wrap at.
+// Sample input: [5, "fn", 0, "  x <b>"] answers <font color="#cba6f7">fn</font>&nbsp;&nbsp;x &lt;b&gt; with the magenta ink.
+function styled(runs, colors) {
+    var parts = pairs(runs)
+    var line = parts.map(function (pair) { return pair[1] }).join("")
+    var out = ""
+    var at = 0
+    for (var i = 0; i < parts.length; i++) {
+        var body = ""
+        for (var j = 0; j < parts[i][1].length; j++, at++) {
+            var c = parts[i][1].charAt(j)
+            var kept = c === " " && at > 0 && at < line.length - 1 && line.charAt(at - 1) !== " " && line.charAt(at + 1) !== " "
+            body += c === " " ? (kept ? " " : "&nbsp;") : escape(c)
+        }
+        out += parts[i][0] > 0 ? "<font color=\"" + colors[parts[i][0]] + "\">" + body + "</font>" : body
+    }
+    return out
+}