flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Tags.js

@@ -0,0 +1,134 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "Status.js" as Status
+
+// Flea's seven tag names in menu order, which is also the 1 to 7 key order; src/backend/tags.rs NAMES is the same list.
+var NAMES = ["Red", "Orange", "Yellow", "Green", "Blue", "Purple", "Gray"]
+
+// The board's tag swatch square, in px.
+var SWATCH_SIZE = 14
+
+// The smaller swatch Properties040's Tags pair draws beside its 14 px text, in px.
+var PAIR_SWATCH_SIZE = 10
+
+// The digit each name answers to, "" when no digit names it.
+function keyFor(name) {
+    var at = NAMES.indexOf(name)
+    return at < 0 ? "" : String(at + 1)
+}
+
+var APPLIED = "applied"
+var MIXED = "mixed"
+var ABSENT = "absent"
+
+// Across a selection: applied when every file carries it, mixed when some do, absent otherwise.
+function stateFor(files, name) {
+    var have = 0
+    for (var i = 0; i < files.length; i++) {
+        if (files[i].indexOf(name) >= 0) {
+            have++
+        }
+    }
+    if (have === 0) {
+        return ABSENT
+    }
+    return have === files.length ? APPLIED : MIXED
+}
+
+function statesFor(files) {
+    var states = {}
+    for (var i = 0; i < NAMES.length; i++) {
+        states[NAMES[i]] = stateFor(files, NAMES[i])
+    }
+    return states
+}
+
+// The same states from a backend read: the names every target carries, then the names only some carry.
+function statesFrom(applied, mixed) {
+    var states = {}
+    for (var i = 0; i < NAMES.length; i++)
+        states[NAMES[i]] = applied.indexOf(NAMES[i]) >= 0 ? APPLIED : mixed.indexOf(NAMES[i]) >= 0 ? MIXED : ABSENT
+    return states
+}
+
+// The status bar's own sentence after a tag change; the count agrees with ui/js/Ops.js nouns.
+function statusLine(ok, name) {
+    if (ok === 1) return Format.fill("Tagged %1 item %2", ok, name) + Status.undoHint()
+    return Format.fill("Tagged %1 items %2", ok, name) + Status.undoHint()
+}
+
+// The same sentence for clearing every tag off the named rows.
+function clearedLine(ok) {
+    if (ok === 1) return Format.fill("Removed all tags from %1 item", ok) + Status.undoHint()
+    return Format.fill("Removed all tags from %1 items", ok) + Status.undoHint()
+}
+
+// The same sentence for taking one tag off the named rows.
+function removedLine(ok, name) {
+    if (ok === 1) return Format.fill("Removed %1 from %2 item", name, ok) + Status.undoHint()
+    return Format.fill("Removed %1 from %2 items", name, ok) + Status.undoHint()
+}
+
+// The line for a settagged answer, read from the op the backend applied rather than from the UI's guess.
+function changedLine(op, ok, name) {
+    if (op === "clear") return clearedLine(ok)
+    return op === "remove" ? removedLine(ok, name) : statusLine(ok, name)
+}
+
+// The line when rows were skipped: the backend leaves out every row that is neither a file nor a folder, so the fragment counts items, not links.
+function skippedLine(names) {
+    if (names.length === 1) return Format.fill("%1 item skipped", Format.count(names.length))
+    return Format.fill("%1 items skipped", Format.count(names.length))
+}
+
+// The whole answer line: the changed sentence, the skip fragment ahead of its undo hint, only the skip when nothing changed, and empty when neither holds.
+function doneLine(op, ok, name, skipped) {
+    var skip = skipped && skipped.length > 0 ? skippedLine(skipped) : ""
+    if (ok <= 0) return skip
+    var changed = changedLine(op, ok, name)
+    if (skip === "") return changed
+    return changed.replace(/ \u00b7 z undoes$/, function () { return Format.fill(" \u00b7 %1 \u00b7 z undoes", skip) })
+}
+
+// The flyout's rows: seven swatches with digit hints, then Remove all tags under a separator.
+var CLEAR_ID = "__clear__"
+function tagEntries(states, fallback) {
+    var out = []
+    for (var i = 0; i < NAMES.length; i++) {
+        out.push({ id: NAMES[i], label: NAMES[i], glyph: "tag", keyHint: String(i + 1), tagRow: { swatch: NAMES[i], fallback: fallback === true,
+                   state: (states || {})[NAMES[i]] || ABSENT, digit: String(i + 1) } })
+    }
+    out.push({ separator: true })
+    out.push({ id: CLEAR_ID, label: "Remove all tags", glyph: "x" })
+    return out
+}
+
+// One rows reply: every row learns whether the folder's slot stands, and inUse gains the tags seen; fresh starts the latch over.
+function stamp(items, latched, inUse, fresh) {
+    var tagged = false
+    var grew = false
+    for (var i = 0; i < items.length; i++) {
+        var names = items[i].tg
+        if (names === undefined) continue
+        tagged = true
+        for (var j = 0; j < names.length; j++) {
+            if (inUse[names[j]] === true) continue
+            inUse[names[j]] = true
+            grew = true
+        }
+    }
+    var stands = tagged || (latched && !fresh)
+    for (var k = 0; k < items.length; k++) items[k].shown = stands
+    return { latched: stands, grew: grew }
+}
+
+// The TAGS section lists only tags in use, each row the rail's own entry shape.
+function railEntries(inUse) {
+    var out = []
+    for (var i = 0; i < NAMES.length; i++) {
+        if (inUse[NAMES[i]] === true)
+            out.push({ label: NAMES[i], kind: "tag", tag: NAMES[i], glyph: "tag", swatch: NAMES[i], digit: String(i + 1) })
+    }
+    return out
+}

package/ui/js/Taildrop.js

@@ -0,0 +1,128 @@
+.pragma library
+
+// Adapted verbatim from the OEM tailscale plugin's own Model.js, read at
+// /usr/share/omarchy/shell/plugins/panels/tailscale/Model.js: isTaildropTarget,
+// displayHostName/shortDnsName/cleanDnsName and the Online/Mullvad filter in parseStatus.
+
+// Sample input: `tailscale status --json`, trimmed to the fields this file reads.
+// {"Self":{"UserID":1000000000000001},"Peer":{"nodekey:...":{"HostName":"laptop",
+// "DNSName":"laptop.example-net.ts.net.","Online":true,"TaildropTarget":1,
+// "TailscaleIPs":["100.1.2.3"],"UserID":1000000000000001}}}
+function parsePeers(raw) {
+    var text = String(raw || "").trim()
+    if (text === "")
+        return []
+    var data
+    try {
+        data = JSON.parse(text)
+    } catch (e) {
+        return []
+    }
+    if (!data || typeof data !== "object" || Array.isArray(data)) return []
+    var selfUserId = String((data.Self && data.Self.UserID) || "")
+    var rawPeers = (data && data.Peer) || {}
+    var out = []
+    for (var id in rawPeers) {
+        var peer = rawPeers[id] || {}
+        if (!peer.Online)
+            continue
+        if (isMullvad(peer))
+            continue
+        if (!isTaildropTarget(peer, selfUserId))
+            continue
+        var address = peerAddress(peer)
+        if (address === "")
+            continue
+        out.push({ id: id, label: displayHostName(peer.HostName, peer.DNSName), address: address })
+    }
+    out.sort(function (a, b) { return a.label.localeCompare(b.label) })
+    return out
+}
+
+// The code names the state for logic (statusFailed, invalid, signedOut, stopped, disabled, noPeers, or "" when ready); the reason is for people.
+// Sample input: {"BackendState":"Running","Self":{"CapMap":{"https://tailscale.com/cap/file-sharing":[]}},"Peer":{}}.
+function status(raw, exitCode, error) {
+    if (exitCode !== 0) return { peers: [], reason: String(error || "Tailscale could not be checked").trim(), code: "statusFailed" }
+    var data
+    try { data = JSON.parse(raw) } catch (e) { return { peers: [], reason: "invalid status", code: "invalid" } }
+    if (!data || typeof data !== "object") return { peers: [], reason: "invalid status", code: "invalid" }
+    if (data.BackendState === "NeedsLogin") return { peers: [], reason: "signed out", code: "signedOut" }
+    if (data.BackendState !== "Running") return { peers: [], reason: String(data.BackendState || "unavailable").toLowerCase(), code: "stopped" }
+    var self = data.Self || {}, capability = "https://tailscale.com/cap/file-sharing"
+    var capabilities = Array.isArray(self.Capabilities) ? self.Capabilities : []
+    if (!(self.CapMap && self.CapMap[capability] !== undefined)
+            && capabilities.indexOf(capability) < 0)
+        return { peers: [], reason: "disabled for this account", code: "disabled" }
+    var peers = parsePeers(raw)
+    return { peers: peers, reason: peers.length ? "" : "no peers", code: peers.length ? "" : "noPeers" }
+}
+
+// A specific TaildropTarget wins outright; 0 (unset) falls back to "do we own it too".
+function isTaildropTarget(peer, selfUserId) {
+    var target = peer && peer.TaildropTarget
+    if (typeof target === "number" && target !== 0)
+        return target === 1
+    var owner = String((peer && peer.UserID) || "")
+    return owner !== "" && owner === String(selfUserId || "")
+}
+
+function cleanDnsName(name) {
+    var value = String(name || "")
+    return value.charAt(value.length - 1) === "." ? value.slice(0, -1) : value
+}
+
+function shortDnsName(name) {
+    var clean = cleanDnsName(name)
+    return clean === "" ? "" : (clean.split(".")[0] || clean)
+}
+
+function displayHostName(hostName, dnsName) {
+    var host = String(hostName || "")
+    if (host !== "" && host.toLowerCase() !== "localhost")
+        return host
+    return shortDnsName(dnsName) || host || "Unknown"
+}
+
+// An exit-node relay peer, never a real send target; see the OEM's own isMullvadPeer.
+function isMullvad(peer) {
+    var suffix = ".mullvad.ts.net"
+    var dnsName = cleanDnsName((peer && peer.DNSName) || "").toLowerCase()
+    var hostName = String((peer && peer.HostName) || "").toLowerCase()
+    return endsWith(dnsName, suffix) || endsWith(hostName, suffix)
+}
+
+function endsWith(value, suffix) {
+    return value.length > suffix.length && value.lastIndexOf(suffix) === value.length - suffix.length
+}
+
+// omarchy-tailscale-send resolves its own "$machine" argument the same three ways.
+function peerAddress(peer) {
+    if (!peer)
+        return ""
+    if (peer.DNSName)
+        return cleanDnsName(peer.DNSName)
+    if (peer.HostName)
+        return String(peer.HostName)
+    var ips = filterIPv4(peer.TailscaleIPs || [])
+    return ips.length > 0 ? ips[0] : ""
+}
+
+function filterIPv4(ips) {
+    var result = []
+    if (!ips || typeof ips.length !== "number")
+        return result
+    for (var i = 0; i < ips.length; i++) {
+        var ip = String(ips[i] || "")
+        if (/^100\./.test(ip))
+            result.push(ip)
+    }
+    return result
+}
+
+function byId(peers, id) {
+    for (var i = 0; i < peers.length; i++) {
+        if (peers[i].id === id)
+            return peers[i]
+    }
+    return null
+}

package/ui/js/Tap.js

@@ -0,0 +1,180 @@
+.pragma library
+.import "Search.js" as Search
+.import "Tabs.js" as Tabs
+.import "Filter.js" as Filter
+
+// flea-qml: a pointer on the list takes the keys back from a query line, as the arrows already do
+// (ui/js/Focus.js leavesLine): the filter keeps its query standing and gives up its caret, and a Find
+// line hands the keys to the results without running. Otherwise the next Space or letter is typed
+// into the line the pointer has just left.
+function focusListing(root) {
+    if (root.renameEditor && root.renameEditor()) return
+    root.focusView = "list"
+    if (root.listArea) root.listArea.forceActiveFocus()
+}
+function releaseLines(root) {
+    if (root.filterTyping) Filter.commit(root)
+    if (root.searchMode === Search.TYPING) root.searchMode = Search.RESULTS
+    focusListing(root)
+}
+
+// Hit the drawn label instead of the whole name slot, including centered grid captions.
+function onName(label, owner, point, centered) {
+    if (!label || !label.visible) return false
+    var at = label.mapFromItem(owner, point.x, point.y)
+    var width = Math.min(label.width, label.contentWidth === undefined ? label.implicitWidth : label.contentWidth)
+    var height = Math.min(label.height, label.contentHeight === undefined ? label.implicitHeight : label.contentHeight)
+    var left = centered ? (label.width - width) / 2 : 0
+    return at.x >= left && at.x < left + width && at.y >= 0 && at.y < height
+}
+
+// The pointer contract, declared in keys.toml's [[pointer]] table and decided here and nowhere
+// else. tests/js/tap.js drives every row of Keymap.POINTER through the three functions below, so a
+// click cannot change meaning without the table saying so and the table cannot advertise a click the
+// code does not make.
+//
+// The rule is macOS's and the operator's: one tap selects, the second opens. The single-tap action is
+// idempotent on a row, so it runs on both taps of a double click rather than behind a double-click
+// timer, which would delay every selection by the whole mouseDoubleClickInterval.
+
+// A view keeps its delegates across a re-list, so a tap count can outlive the row its first tap named.
+var firstTap = null
+// A later tap counts only on the row its gesture's first tap named; a tap on another row answers 0 and starts the count again.
+function gestureCount(index, tapCount, root) {
+    var row = index >= 0 ? root.rowFor(index) : null
+    var key = String(root.path) + "\n" + (row ? row.n : "")
+    if (tapCount === 1 || firstTap === null || firstTap.pane !== root) {
+        firstTap = { pane: root, key: key, base: 0 }
+        return tapCount
+    }
+    if (firstTap.key !== key) {
+        firstTap = { pane: root, key: key, base: tapCount }
+        return 0
+    }
+    return tapCount - firstTap.base
+}
+
+// One tap selects, the second opens; a click carries context 0 so the list never moves under the pointer.
+function tapped(index, tapCount, modifiers, root) {
+    if (index < 0) return
+    releaseLines(root)
+    tapCount = gestureCount(index, tapCount, root)
+    if (tapCount === 0) return
+    // Single-click mode opens on the first tap alone, so later taps of one gesture add nothing.
+    if (root.singleClick === true && tapCount !== 1) return
+    // Finder's two selection modifiers. Neither ever opens, and only the first tap of one counts,
+    // so a modified double click selects once instead of toggling itself back off.
+    if (modifiers & Qt.ControlModifier) {
+        if (tapCount === 1) root.toggleSelectAt(index)
+        return
+    }
+    if (modifiers & Qt.ShiftModifier) {
+        if (tapCount === 1) root.extendSelectionTo(index)
+        return
+    }
+    // What a tap means is the search's to say, not this file's. flea-qml: on Find's results it is the
+    // same as anywhere, select on one tap and open on two, so the pointer browses results and the
+    // search stays; upstream revealed on the first tap. ui/js/Search.js activateAction answers it.
+    var verb = Search.activateAction(root)
+    if (verb === "reveal" && tapCount !== 1)
+        return
+    // Finder commits an open rename on click-away first, so its text lands before the selection moves.
+    root.commitOpenRename()
+    // A plain tap replaces the selection, so the next shift+click extends from a row on screen.
+    root.selectOnly(index, 0)
+    if (tapCount === 2 || verb === "reveal")
+        root.act(verb)
+    // Single-click mode opens files and folders on one tap, like the middle column already does.
+    if (tapCount === 1 && verb === "open" && root.singleClick === true)
+        root.act("open")
+}
+
+// The columns view's own middle column, and ui/ColumnsArea.qml is its only caller, which is what
+// keeps this out of the list and the grid. Its two neighbour columns already go into a directory on
+// one tap, and the operator's 2026-09-11 ruling is that the column holding the cursor does the same,
+// which is Finder's column view. A directory alone: everything else is an ordinary listing tap and
+// reads tapped() above, so a file still opens on the second tap and a modifier still only selects.
+function tappedMiddle(index, tapCount, modifiers, root) {
+    if (index >= 0) releaseLines(root)
+    var row = index >= 0 ? root.rowFor(index) : null
+    var plain = (modifiers & (Qt.ControlModifier | Qt.ShiftModifier)) === 0
+    // tapped() counts the gesture itself, so a tap is counted once on either path.
+    // flea-qml: a folder among Find's results is a result like any other: one tap selects it and the
+    // search stays; only a plain folder listing goes in on one tap.
+    if (!row || !row.d || !plain || Search.live(root)) {
+        tapped(index, tapCount, modifiers, root)
+        return
+    }
+    tapCount = gestureCount(index, tapCount, root)
+    if (tapCount === 0) return
+    // The first tap moved the pane, so a second one is another directory's row, the same reason
+    // tappedColumn refuses to reveal a neighbour twice.
+    if (tapCount !== 1)
+        return
+    root.commitOpenRename()
+    root.selectOnly(index, 0)
+    // A directory listed as a search result is still a result, so the one decision point answers here
+    // too: it reveals rather than opening, exactly as the same row does in the list view.
+    root.act(Search.activateAction(root))
+}
+
+// Right click, in all three views: the row under the pointer takes the cursor and the menu opens there.
+// Which rows it then means is decided by the pressed row, ui/js/Drag.js carried()'s rule for the
+// pointer's other gesture: pressed inside the selection the menu addresses all of it, pressed outside
+// it that row replaces the selection. Every entry ui/ContextMenu.qml draws is built from the cursor
+// row while Move to Trash, Compress and Move to Dropbox dispatch through Ops.targetIndices, which
+// prefers the selection, so a right click that left a selection elsewhere standing trashed rows the
+// menu had never described.
+function tappedMenu(index, eventPoint, root, menu) {
+    releaseLines(root)
+    var picked = root.selectedIndices()
+    if (picked.length > 0 && picked.indexOf(index) < 0)
+        root.clearSelection()
+    root.setCursor(index, 0)
+    menu.openAt(eventPoint.scenePosition)
+    root.cancelSlowClick()
+}
+
+// A right click that landed on no row raises the directory's own menu, in all three views and the
+// Trash; a row's own TapHandler has already answered for a row. A TapHandler declared inside a
+// ListView or GridView belongs to its contentItem, so its position is already the content coordinate
+// indexAt takes: adding contentY again read every row past the first screenful as empty space.
+function onBackground(view, eventPoint) {
+    return view.indexAt(eventPoint.position.x, eventPoint.position.y) < 0
+}
+
+// A neighbour column in the columns view is a peek with no cursor of its own, so its rows answer a
+// verb rather than acting. One tap on a directory makes it the pane's listing, which is the column
+// view's own reveal and not an open; only a second tap opens a file. A peeked row belongs to another
+// directory and every menu action addresses the pane's cursor, so a right click there is routed by
+// ColumnPane to menuOnNeighbour before this is asked.
+function tappedColumn(row, button, tapCount) {
+    if (!row || button === Qt.RightButton)
+        return ""
+    if (button === Qt.MiddleButton)
+        return row.d && tapCount === 1 ? "openTab" : ""
+    if (row.d)
+        return tapCount === 1 ? "reveal" : ""
+    return tapCount === 2 ? "open" : ""
+}
+
+// Middle click on a directory opens it in a new tab; a file has no directory to show.
+function tabTarget(row, base, root) {
+    return row && row.d && typeof row.n === "string" ? root.join(base, row.n) : ""
+}
+
+function tappedTab(row, base, root) {
+    var target = tabTarget(row, base, root)
+    if (target.length === 0)
+        return
+    root.commitOpenRename()
+    Tabs.openNew(root, target)
+}
+
+// The slow click renames on the pane's timer; a second tap opens through tapped() instead, so only a lone tap on the name arms it.
+function slowTap(pane, armed, index, modifiers, dragActive, wasSole) {
+    if (armed)
+        pane.armSlowClick(index, modifiers, dragActive, wasSole)
+    else
+        pane.cancelSlowClick()
+}

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