buninu-browser 0.3.0 → 0.4.0

package/test/fixtures/qml/flea-theme/ui/js/Settings.js

@@ -0,0 +1,476 @@
+.pragma library
+.import "TextSize.js" as TextSize
+.import "Places.js" as Places
+.import "Format.js" as Format
+.import "Keymap.js" as Keymap
+.import "KeyName.js" as KeyName
+.import "SettingsShelf.js" as Shelf
+.import "SettingsAbout.js" as About
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one.
+var WORDS = {
+    sheetTip: "Press %1 for the keyboard sheet.",
+    loadTip: "%1 loads the current selection.",
+    textKeys: "%1 and %2 step through them; %3 follows Omarchy again.",
+    nearestStop: "Omarchy's own size. The ruler marks %1, the nearest stop."
+}
+
+// Sections follow the current Desktop boards; their state uses the shared ui.json updater.
+var SECTIONS = [
+    { id: "view", label: "View", glyph: "sliders" },
+    { id: "places", label: "Places", glyph: "star" },
+    { id: "shelf", label: "Shelf", glyph: "shelf" },
+    { id: "preview", label: "Preview", glyph: "preview" },
+    { id: "keys", label: "Keys", glyph: "keyboard" },
+    { id: "display", label: "Display", glyph: "maximize" },
+    { id: "menus", label: "Menus", glyph: "list" },
+    { id: "about", label: "About", glyph: "info" }
+]
+
+// Where a section id sits in SECTIONS, or 0 for an id no section carries.
+function sectionIndex(id) {
+    for (var i = 0; i < SECTIONS.length; i++) {
+        if (SECTIONS[i].id === id)
+            return i
+    }
+    return 0
+}
+
+// The six SettingsMenus.html puts under the Basic file actions heading, and the ids ui/js/Menu.js gives those rows.
+var BASIC = ["cut", "copy", "paste", "duplicate", "rename", "trash"]
+
+// Storage ids remain stable while the action dispatcher uses descriptive verbs. SettingsMenus rule 3: the master rides its group's heading, so a group is its own id here and a group of one row has no master to ride it, which is why Destructive carries neither box nor count.
+var MENU_GROUPS = [
+    { id: "basic", label: "Basic file actions", ids: BASIC },
+    { id: "destructive", label: "Destructive", ids: ["delete"] },
+    { id: "openInspect", label: "Open and inspect",
+      ids: ["openwith", "run", "openAsText", "openTerminal", "moveto", "copyto", "properties", "permissions", "makeExecutable", "copyAs", "showOriginal", "tags"] },
+    { id: "extras", label: "Extras", features: ["placeMenu"],  // features gate a surface, not a row
+      ids: ["shelf", "compress", "extract", "convert", "flashDrive", "taildrop", "localsend", "dropbox", "sharelink", "runScript", "placeMenu", "updateFlea", "toggleLangMarks", "extThumbs", "pasteAs", "invertSelection"] }
+]
+
+// Open and Show hidden files draw the lock mark instead of a box, and the board says why: a menu that cannot open the row under the cursor is not a menu, and the hidden toggle is the one background row with no keyboard-independent alternative.
+var LOCKED = ["open", "toggleHidden"]
+
+var LABELS = {
+    cut: "Cut", copy: "Copy", paste: "Paste", duplicate: "Duplicate", rename: "Rename",
+    trash: "Move to Trash", openTerminal: "Open in terminal", copyAs: "Copy as", showOriginal: "Show original",
+    pasteAs: "Paste as", invertSelection: "Invert selection", permissions: "Permissions", makeExecutable: "Make executable",
+    delete: "Delete permanently", openwith: "Open with", moveto: "Move to", copyto: "Copy to", properties: "Properties",
+    compress: "Compress", extract: "Extract", localsend: "Send with LocalSend",
+    convert: "Convert", flashDrive: "Flash to drive", taildrop: "Send with Taildrop", dropbox: "Move to Dropbox", tags: "Tags",
+    sharelink: "Copy share link", open: "Open", toggleHidden: "Show hidden files", shelf: "Enable shelf", placeMenu: "Places row menu", runScript: "Run script",
+    updateFlea: "Update Flea", toggleLangMarks: "Show code icons", extThumbs: "Show thumbnails", run: "Run", openAsText: "Open as text"
+}
+
+// The four values of the Keys row, in SettingsKeys.html's own chooser order. The first is what a missing or unrecognised stored name resolves to, which that board says is Default.
+var PRESETS = ["default", "vim", "mac", "windows"]
+var PRESET_LABELS = { "default": "Default", vim: "Vim", mac: "Mac", windows: "Windows" }
+
+// Every board row carries a left mark, and a switch wears the mark of the row it governs: these are ui/js/Menu.js's own glyphs by action id, which tests/js/settings.js asserts the two agree on.
+var GLYPHS = {
+    cut: "scissors", copy: "copy", paste: "clipboard", duplicate: "file-plus", rename: "rename",
+    trash: "trash", openTerminal: "terminal", copyAs: "file-text", showOriginal: "symlink",
+    pasteAs: "symlink", invertSelection: "contrast", permissions: "lock", makeExecutable: "play", compress: "archive",
+    delete: "trash", openwith: "app-window", moveto: "folder-plus", copyto: "copy", properties: "info",
+    extract: "archive-out",
+    convert: "sliders", flashDrive: "drive", sharelink: "network", open: "folder-open", toggleHidden: "eye", placeMenu: "folder-open", runScript: "terminal",
+    updateFlea: "download", toggleLangMarks: "code", extThumbs: "image", shelf: "shelf", run: "play", openAsText: "file-text", tags: "tag"
+}
+
+// The shelf switch wears the cut glyph the menu row draws, never the animated brand mark.
+var MARKS = { taildrop: "tailscale", localsend: "localsend", dropbox: "dropbox", "display.hyprlandIcons": "hyprland" }
+
+function label(id) {
+    return LABELS[id] || id
+}
+
+function glyph(id) {
+    return GLYPHS[id]
+}
+
+function contains(list, id) {
+    for (var i = 0; list && i < list.length; i++) {
+        if (list[i] === id)
+            return true
+    }
+    return false
+}
+
+function isHidden(hidden, id) {
+    return contains(hidden, id)
+}
+
+// The rule: the count is of ENABLED actions, so "5 of 6" means one of the six is switched off.
+function basicEnabled(hidden, list) {
+    var on = 0
+    for (var i = 0; i < list.length; i++) {
+        if (!isHidden(hidden, list[i]))
+            on += 1
+    }
+    return on
+}
+
+// All, some and none are read off the group's own ids, which is the tri-state the SettingsMenus board draws. A master is derived here and never stored, so there is no second value that could disagree.
+function masterState(hidden, list) {
+    var on = basicEnabled(hidden, list)
+    if (on === list.length)
+        return "all"
+    return on === 0 ? "none" : "some"
+}
+
+// Activating a checked master switches its whole group off; an unchecked or partial one switches the group on, so the recovering move is always the one keystroke. Ids outside the group are preserved either way.
+function toggleMaster(hidden, list) {
+    var enable = masterState(hidden, list) !== "all"
+    var next = []
+    for (var i = 0; hidden && i < hidden.length; i++) {
+        if (!enable || !contains(list, hidden[i]))
+            next.push(hidden[i])
+    }
+    if (!enable) {
+        for (var b = 0; b < list.length; b++) {
+            if (!contains(next, list[b]))
+                next.push(list[b])
+        }
+    }
+    return next
+}
+
+function toggleId(hidden, id) {
+    var next = []
+    var had = false
+    for (var i = 0; hidden && i < hidden.length; i++) {
+        if (hidden[i] === id) {
+            had = true
+            continue
+        }
+        next.push(hidden[i])
+    }
+    if (!had)
+        next.push(id)
+    return next
+}
+
+// One row per line of the panel's pane. kind decides what ui/SettingsPanel.qml draws and whether the row is a focus stop: group, hint, fact and lock rows are read-only and the cursor steps over them. A ruler reports the effective size while Omarchy owns it and only becomes a control on an override.
+function focusable(row) {
+    // SettingsGrammar rule 7: a dependent greyed by its parent cannot be operated, so it is no stop either.
+    if (row.available === false)
+        return false
+    // SettingsMenus rule 3 and SettingsRest rule 3: a heading carrying its group's master or its one action is a control, and one carrying neither stays a heading.
+    if (row.kind === "group")
+        return row.master === true || row.action !== undefined
+    if (row.kind === "ruler")
+        return row.on === true
+    return row.kind === "check" || row.kind === "choice" || row.kind === "action" || row.kind === "favourite"
+}
+
+// state: { textSize, hidden, keyHints, preset, baseSize, monitorScale, cornerRadius, presetKeys }
+function rows(section, state) {
+    if (section === "columns")
+        return columnRows(state)
+    if (section === "places")
+        return placesRows(state)
+    if (section === "shelf")
+        return Shelf.rows(state, choice)
+    if (section === "view")
+        return viewRows(state)
+    if (section === "preview")
+        return previewRows(state)
+    if (section === "about")
+        return About.rows(state)
+    if (section === "display")
+        return displayRows(state)
+    if (section === "menus")
+        return menuRows(state.hidden, state.keyHints)
+    return keyRows(state)
+}
+
+// The sentence beside Effective has a job only while the ruler cannot state the running size: in Follow the two differ whenever Omarchy's size is not one of the seven, and an override is always a stop.
+function effectiveNote(follows, baseSize) {
+    var nearest = TextSize.nearest(baseSize)
+    return !follows ? "Your override." : nearest === baseSize ? "Omarchy's own size."
+        : Format.fill(WORDS.nearestStop, nearest)
+}
+
+// The SettingsScale board's own division: Flea owns its text override and Omarchy owns the rest. The size follows the desktop until one of TextSize's seven stops is pinned, and the monitor scale and the corner rounding are the compositor's, drawn as the read-only facts they are.
+function displayRows(state) {
+    var follows = TextSize.following(state.textSize)
+    var out = [
+        { kind: "group", label: "Text size" },
+        { kind: "choice", id: "textMode", label: "Text size", glyph: "type",
+          labels: ["Follow Omarchy", "Override"],
+          value: follows ? "Follow Omarchy" : "Override" },
+        // The board's seven-stop ruler, the override's own control, now carrying the numbers it stands for; a size Omarchy invented that is not a stop marks the nearest one.
+        { kind: "ruler", id: "textStop", stops: TextSize.STOPS, on: !follows,
+          index: TextSize.STOPS.indexOf(TextSize.nearest(state.baseSize)) }
+    ]
+    // SettingsRest rule 2 keeps only the chords; the hint wraps onto two lines at this width.
+    var textKeys = KeyName.hintedAll(WORDS.textKeys, ["textSizeUp", "textSizeDown", "textSizeReset"])
+    if (textKeys.length > 0) out.push({ kind: "hint", label: textKeys })
+    // And Effective stays: it is state.baseSize, the size actually running, where the ruler marks TextSize.nearest() and a tie takes the smaller stop, so a base of 13 marks 12.
+    out.push({ kind: "fact", id: "textEffective", label: "Effective", role: "live",
+               value: state.baseSize + " px", caption: effectiveNote(follows, state.baseSize) })
+    out.push({ kind: "group", label: "Scale" })
+    out.push({ kind: "fact", label: "Scale", glyph: "maximize",
+               value: scaleLabel(state.monitorScale) })
+    out.push({ kind: "hint",
+               label: "Flea follows Hyprland's scale and does not change it." })
+    out.push({ kind: "group", label: "Appearance" })
+    out.push({ kind: "check", id: "display.hyprlandIcons", label: "Hyprland-aware icons",
+               mark: MARKS["display.hyprlandIcons"],
+               on: ((state.data || {}).display || {}).hyprlandIcons === true })
+    return out
+}
+
+// The compositor's own number, as Hyprland writes it: 1.00 and 1.25. An unanswered query says so rather than reading as 1x, because a wrong number here looks exactly like a right one. The row carries no control, which is what says it cannot be changed; SettingsGrammar rule 5.
+function scaleLabel(scale) {
+    if (!(scale > 0))
+        return "not reported"
+    return (Math.round(scale * 100) / 100) + "x"
+}
+
+// The one row of this section that is not a menu action: it governs how every menu row is drawn rather than whether it exists, so it sits in its own group and never in MENU_GROUPS.
+function menuRows(hidden, keyHints) {
+    var out = []
+    for (var g = 0; g < MENU_GROUPS.length; g++) {
+        var group = MENU_GROUPS[g]
+        var master = group.ids.length > 1
+        out.push({ kind: "group", label: group.label, id: master ? group.id : "", master: master,
+                   ids: group.ids, state: master ? masterState(hidden, group.ids) : "",
+                   value: master ? basicEnabled(hidden, group.ids) + " of " + group.ids.length : "" })
+        for (var i = 0; i < group.ids.length; i++) {
+            out.push({ kind: "check", id: group.ids[i], label: label(group.ids[i]),
+                       glyph: GLYPHS[group.ids[i]], mark: MARKS[group.ids[i]],
+                       role: group.ids[i] === "delete" ? "error" : "",
+                       value: group.ids[i] === "delete" ? "off by default" : "",
+                       on: !isHidden(hidden, group.ids[i]) })
+        }
+    }
+    out.push({ kind: "group", label: "Shortcuts" })
+    out.push({ kind: "check", id: "keyHints", label: "Show keyboard hints", glyph: "keyboard",
+               on: keyHints === true })
+    // HANDOFF rule 8: one short line. The switch's own label says what it draws, so the hint keeps
+    // only the part it cannot: turning it off binds nothing differently.
+    out.push({ kind: "hint", label: "Every key stays bound either way." })
+    out.push({ kind: "group", label: "Always shown" })
+    for (var l = 0; l < LOCKED.length; l++)
+        out.push({ kind: "lock", id: LOCKED[l], label: label(LOCKED[l]), glyph: GLYPHS[LOCKED[l]] })
+    return out
+}
+
+// Settings shows six examples; the keyboard sheet retains the complete generated inventory.
+function keyPreview(preset) {
+    var bindings = Keymap.bindingRows(preset, "gui")
+    var enter = Keymap.lookupFor(preset, Qt.Key_Return, "", 0, "listing", "gui")
+    var items = [
+        { keys: "arrows", label: preset === "mac" ? "move, open, up" : "move cursor", glyph: "" },
+        { keys: "enter", label: enter, glyph: "" },
+        { keys: "space", label: "quick look", glyph: "" }
+    ]
+    var actions = ["copy", "paste", "trash"]
+    for (var i = 0; i < actions.length; i++) {
+        var action = actions[i]
+        var mods = preset === "mac" ? "super" : preset === "windows" ? "ctrl" : "text"
+        if (action === "trash" && (preset === "mac" || preset === "windows")) mods = "none"
+        for (var j = 0; j < bindings.length; j++) {
+            var binding = bindings[j]
+            if (Keymap.actionGroup(binding.action) === action && binding.mods === mods) {
+                items.push({ keys: binding.keys, label: action, glyph: action === "trash" ? "" : GLYPHS[action] })
+                break
+            }
+        }
+    }
+    return items
+}
+
+function keyRows(state) {
+    var out = [
+        { kind: "group", label: "Preset" },
+        { kind: "choice", id: "preset", label: "Keybinding preset", glyph: "keyboard",
+          labels: PRESETS.map(function (p) { return PRESET_LABELS[p] }),
+          value: PRESET_LABELS[state.preset] || state.preset },
+        // Rule 3: the hint says what the preset does, where the old one listed the same four labels the control draws.
+        { kind: "hint", label: "Keys change, actions do not." },
+        { kind: "group", label: "This preset" },
+        { kind: "keyPreview", id: "keyPreview", items: keyPreview(state.preset) }
+    ]
+    var sheetTip = KeyName.hinted(WORDS.sheetTip, "keymapSheet")
+    if (sheetTip.length > 0) out.push({ kind: "hint", label: sheetTip })
+    return out
+}
+
+// A read-only row is never the cursor, so both key steps and the opening cursor skip over one; the same shape ui/ContextMenu.qml's stepCursor uses, because a settings row and a menu row step alike.
+function stepRow(list, from, delta) {
+    var i = from + delta
+    while (i >= 0 && i < list.length) {
+        if (focusable(list[i]))
+            return i
+        i += delta
+    }
+    return from
+}
+
+function firstRow(list) {
+    return list.length > 0 && focusable(list[0]) ? 0 : stepRow(list, 0, 1)
+}
+
+// Choice values are stored separately from labels so presentation never becomes a persistence format. Which control a choice gets is decided by fit, in ui/SettingsRow.qml, not declared here: rule 1 of the SettingsGrammar board, after two named values were a segment and three were a chevron.
+function choice(id, label, glyph, values, labels, value) {
+    return { kind: "choice", id: id, label: label, glyph: glyph, values: values, labels: labels,
+             value: labels[Math.max(0, values.indexOf(value))], selected: value }
+}
+
+function viewRows(state) {
+    var data = state.data || {}
+    var sort = data.sort || {}
+    var columns = data.columns || ["name", "size", "date"]
+    var out = [
+        { kind: "group", label: "View" },
+        choice("view", "Last-used view", undefined, ["list", "columns", "grid", "dual"],
+               ["List", "Columns", "Grid", "Dual pane"], data.view || "list"),
+        { kind: "check", id: "rememberViewPerFolder", label: "Remember each folder's view", glyph: "folder",
+          on: data.rememberViewPerFolder === true },
+        choice("density", "Row density", "list", ["tight", "compact", "normal", "comfortable"],
+               ["Tight", "Compact", "Normal", "Comfortable"], data.density || "compact"),
+        { kind: "hint", label: "Compact stays the default." },
+        { kind: "action", id: "columns", label: "Columns", glyph: "columns",
+          value: columns.map(function (key) { return key.charAt(0).toUpperCase() + key.slice(1) }).join(", ") },
+        choice("addressBar", "Address bar", undefined, ["path", "breadcrumb"],
+               ["Path", "Breadcrumb"], data.addressBar || "breadcrumb"),
+        // ColumnsWidth board, #167 and #69: the count follows the window width, capped here.
+        choice("columnsLimit", "Columns view limit", "columns", [2, 3, 4, 5],
+               ["2", "3", "4", "5"], data.columnsLimit || 3),
+        { kind: "check", id: "highlightToday", label: "Highlight today's dates", glyph: "history",
+          on: data.highlightToday === true },
+        // Drops callout 2: off until switched on, and the board draws it with no mark, like escapeUp.
+        { kind: "check", id: "openFoldersWhileDragging", label: "Open folders while dragging",
+          on: data.openFoldersWhileDragging === true },
+        { kind: "group", label: "Sorting" },
+        choice("sort.key", "Sort by", "sort", ["name", "size", "date", "kind"],
+               ["Name", "Size", "Date", "Kind"], sort.key || "name"),
+        { kind: "check", id: "foldersFirst", label: "Folders first", glyph: "folders-first", on: data.foldersFirst !== false },
+        { kind: "check", id: "groupByKind", label: "Group by kind", caption: "folders, photos, files", glyph: "grid", on: data.groupByKind === true },
+        { kind: "check", id: "hidden", label: "Show hidden files", glyph: "eye", on: data.hidden === true },
+        // Issue 70: a dependent greys in place at the same column while hidden files are off, with no hint.
+        { kind: "check", id: "hiddenLast", label: "Hidden files last", glyph: "eye-off",
+          on: data.hiddenLast === true, available: data.hidden === true },
+        { kind: "check", id: "langMarks", label: "Show code icons", glyph: "code", on: data.langMarks !== false },
+        // Issue 179: the group's last row; off, every folder takes the default sort and nothing is written.
+        { kind: "check", id: "rememberSort", label: "Remember each folder's sort", glyph: "sort",
+          on: data.rememberSort !== false },
+        { kind: "group", label: "Cursor" },
+        { kind: "check", id: "wrapAtEnds", label: "Wrap at list ends", caption: "arrow-up at the top", glyph: "arrow-up", on: data.wrapAtEnds === true },
+        // Issue 29: Escape climbs to the parent while on, and stays put while off, which is 0.3.4.
+        { kind: "check", id: "escapeUp", label: "Escape goes up a folder", caption: "with nothing to close", on: data.escapeUp === true },
+        { kind: "group", label: "Opening" },
+        choice("startIn", "Flea opens in", "house", ["home", "last", "folder"],
+               ["Home", "Last folder", "Chosen folder"], data.startIn || "home"),
+        // The action writes the folder the panel was opened over and selects the mode with it, so the row above never names a chosen folder that was never chosen. The value is the path itself.
+        { kind: "action", id: "startFolder", label: "Chosen folder", glyph: "folder",
+          value: data.startFolder || "Use this folder" },
+        choice("newTab", "New tabs open in", "columns", ["current", "home", "start"],
+               ["Current folder", "Home", "Start folder"], data.newTab || "current"),
+        // ClickAndRefresh: one tap opens in single mode and selects with a modifier, so the
+        // slow-click rename below has nothing to answer and greys in place, the way hiddenLast does.
+        choice("openMode", "Open items with", "pointer", ["double", "single"],
+               ["Double click", "Single click"], data.openMode || "double"),
+        { kind: "check", id: "clickRename", label: "Click a selected name to rename",
+          on: data.clickRename !== false, available: data.openMode !== "single" },
+        { kind: "hint", footer: true, label: state.saveStatus || "Saved",
+          role: (state.saveStatus || "").indexOf("Could not") === 0 ? "error" : "accent" }
+    ]
+    // Tabs040 callout 2, the board's own sentence, under the control it explains and only there.
+    if ((data.startIn || "home") === "last") {
+        for (var i = 0; i < out.length; i++) {
+            if (out[i].id === "startIn") {
+                out.splice(i + 1, 0, { kind: "hint", label: "Last folder reopens every tab you had." })
+                break
+            }
+        }
+    }
+    return out
+}
+
+function previewRows(state) {
+    var data = (state.data || {}).preview || {}
+    var load = choice("preview.loadOn", "Load", "eye", ["automatic", "manual"],
+                      ["Automatic", "Manual"], data.loadOn || "automatic")
+    // Rule 7: with the column off, SelectionPreview.canRead is false and both load paths return, so Load is the one real dependent here and it greys rather than lying.
+    load.available = data.column !== false
+    // One value per row, rule 4: the board drops the figure outright, because "64 px  Medium" is one fact twice.
+    var size = choice("preview.thumbSize", "Thumbnail size", "maximize", ["small", "medium", "large", "xlarge", "huge", "largest"],
+                      ["Small", "Medium", "Large", "Extra large", "Huge", "Largest"], data.thumbSize || "medium")
+    var head = [
+        { kind: "group", label: "Preview column" },
+        // Preview board rule 4: the heading names the group, so the row under it names the switch.
+        { kind: "check", id: "preview.column", label: "Show the preview column", glyph: "columns", on: data.column !== false },
+        load
+    ]
+    // Rule 3: a hint sits under the control it explains, not two hairlines below it in a footer; none when the preset binds no key to name.
+    var loadTip = data.loadOn === "manual" ? KeyName.hinted(WORDS.loadTip, "loadPreview") : "Automatic follows the cursor."
+    var tail = [
+        { kind: "group", label: "Thumbnails" },
+        choice("preview.thumbnails", "Thumbnails", "image", ["off", "images", "media"],
+               ["Off", "Images", "Everything"], data.thumbnails || "media"),
+        size,
+        // ExtThumbs: one switch per storage class, at the same column and never indented.
+        // They grey with the segment at 0.55 and keep their values, the way a disabled
+        // chrome control keeps its state; grid zoom below never greys with them.
+        // No glyph: the board leaves their 19 px slot empty.
+        { kind: "check", id: "preview.thumbNetwork", label: "On network shares",
+          on: data.thumbNetwork === true, available: data.thumbnails !== "off" },
+        { kind: "check", id: "preview.thumbPhone", label: "On phones",
+          on: data.thumbPhone === true, available: data.thumbnails !== "off" },
+        { kind: "check", id: "preview.thumbUsb", label: "On USB drives",
+          on: data.thumbUsb !== false, available: data.thumbnails !== "off" },
+        { kind: "hint", label: "Off still shows thumbnails that were already made.",
+          available: data.thumbnails !== "off" },
+        // Rule 7: GridArea gates ctrl-scroll on ViewState.ctrlZoom alone and sizes the tiles from it with thumbnails off, so it is grid zoom, it is named that, and it never greys with them.
+        { kind: "check", id: "preview.ctrlZoom", label: "Zoom the grid with ctrl and scroll", glyph: "move-horizontal", on: data.ctrlZoom !== false }
+    ]
+    return head.concat(loadTip.length > 0 ? [{ kind: "hint", label: loadTip }] : [], tail)
+}
+
+function columnRows(state) {
+    var columns = (state.data || {}).columns || ["name", "size", "date"]
+    var rows = [{ kind: "group", label: "Columns" }, { kind: "lock", label: "Name", glyph: "file" }]
+    for (var i = 0; i < 4; i++) {
+        var id = ["mode", "size", "date", "kind"][i]
+        rows.push({ kind: "check", id: "column:" + id, label: ["Mode", "Size", "Date", "Kind"][i], on: columns.indexOf(id) >= 0 })
+    }
+    rows.push({ kind: "action", id: "backView", label: "Back to View", value: "Back" })
+    return rows
+}
+
+function placesRows(state) {
+    var data = (state.data || {}).places || {}
+    var entries = Places.storedEntries(data.favourites || [], state.home || "")
+    // SettingsRest rule 3: the one action that governs the whole group rides its heading, the slot the Menus master takes.
+    var rows = [{ kind: "group", label: "Favorites", id: "addFavourite", action: "addFavourite", value: "Add this folder" }]
+    for (var i = 0; i < entries.length; i++) {
+        rows.push({ kind: "favourite", id: "favourite:" + i, label: entries[i].label,
+            value: entries[i].storedPath, display: Format.tilde(entries[i].storedPath, state.home || ""), glyph: entries[i].glyph, error: entries[i].error || (state.favouriteStatuses || {})[i] || "", favouriteIndex: i })
+    }
+    rows.push({ kind: "group", label: "Built in" })
+    // Sidebar040: Recent sits beside Home, Network, Devices and Trash, and ships off.
+    // The fourth field is what a key the file never stored reads as, the way the Rail group below reads its own.
+    var builtins = [["showHome", "Home", "house", true], ["showRecent", "Recent", "history", false],
+                    ["showNetwork", "Network", "network", true],
+                    ["showDevices", "Devices", "drive", true], ["showTrash", "Trash", "trash", true]]
+    for (var b = 0; b < builtins.length; b++) rows.push({ kind: "check", id: "places." + builtins[b][0], label: builtins[b][1], glyph: builtins[b][2], on: builtins[b][3] ? data[builtins[b][0]] !== false : data[builtins[b][0]] === true })
+    rows.push({ kind: "group", label: "Sidebar" })
+    // The fourth field is src/uischema.rs's shipped value, which is what a key the file never stored reads as.
+    var rail = [["driveSize", "Show drive size", "drive", false], ["trashCount", "Show Trash count", "trash", false], ["showUnmounted", "Show unmounted drives", "drive", true], ["showTags", "Show tags", "tag", false], ["autoHide", "Auto-hide sidebar", "maximize", false]]
+    for (var r = 0; r < rail.length; r++) rows.push({ kind: "check", id: "places." + rail[r][0], label: rail[r][1], glyph: rail[r][2], on: rail[r][3] ? data[rail[r][0]] !== false : data[rail[r][0]] === true })
+    // Directive 74: the rail is remembered as a word, so this row reads it as one; ctrl-b writes the same leaf. Directive 77: auto-hide answers the pointer instead, so the remembered choice is greyed while that is on rather than quietly ignored.
+    rows.push({ kind: "check", id: "places.rail", label: "Show sidebar", glyph: "columns", on: data.rail !== "hidden", available: data.autoHide !== true })
+    rows.push(choice("places.sidebarWidth", "Sidebar width", "maximize", Places.WIDTH_STOPS,
+        ["160 px", "192 px", "224 px", "256 px"], Places.sidebarWidth(data.sidebarWidth)))
+    // Trash lives in Places, and the sweep is off until switched on: permanent deletion is outside the undo journal.
+    rows.push({ kind: "group", label: "Trash" })
+    // The eyebrow says TRASH, so the label does not repeat it; a fuller one elided the caption to "permanently, once a...".
+    rows.push({ kind: "check", id: "trashAutoEmpty", label: "Empty after 30 days",
+        caption: "permanently", glyph: "history",
+        on: (state.data || {}).trashAutoEmpty === true })
+    return rows
+}

package/test/fixtures/qml/flea-theme/ui/js/SettingsAbout.js

@@ -0,0 +1,99 @@
+.pragma library
+.import "Update.js" as Update
+.import "MakeDefault.js" as MakeDefault
+
+// The Settings panel's About section: what is installed, the one updater, and where help lives; it came out of ui/js/Settings.js whole when the Updates group grew.
+
+// The two rows that leave Flea for a web page carry their destination, so ui/SettingsPanel.qml opens whatever a row names.
+var ISSUES_URL = "https://github.com/thisisgm/flea/issues"
+var SPONSORS_URL = "https://github.com/sponsors/thisisgm"
+
+// state.about is ui/AboutFacts.qml's facts, the updater's status and the default's claim among them; state.data is ui.json.
+function rows(state) {
+    var facts = state.about || {}
+    var out = [
+        { kind: "hero", label: "Flea", value: "A file manager for Omarchy" },
+        { kind: "fact", label: "Version", value: facts.version || "Not reported" },
+        { kind: "fact", label: "Built", value: facts.built || "Not recorded in this build" },
+        { kind: "fact", label: "Installed from", value: facts.source || "Not reported" },
+        { kind: "fact", label: "Package", value: facts.package || "Not reported" },
+        { kind: "fact", label: "License", value: "MIT, © 2026 GM" },
+        { kind: "group", label: "Language" },
+        { kind: "fact", label: "Language", glyph: "globe", value: "English" },
+        { kind: "group", label: "Updates" }
+    ]
+    out = out.concat(updateRows(facts.update || Update.idle(), state.data))
+    out.push({ kind: "group", label: "This computer" })
+    // Rule 5: the identity is in the tail, so a handler too long for the row loses its head instead.
+    out.push({ kind: "fact", label: "File manager", glyph: "folder", elide: "head", value: facts.handler || "Not reported" })
+    out = out.concat(MakeDefault.rows(facts.handler, facts.claim))
+    out.push({ kind: "action", id: "keyboardSheet", label: "Keyboard sheet", glyph: "keyboard", value: "?" })
+    out.push({ kind: "action", id: "reportIssue", label: "Report an issue", glyph: "network", value: "Open", url: ISSUES_URL })
+    // SettingsGrammar rule 6: a brand is never given a generic glyph, and the mark set holds no GitHub reproduction.
+    out.push({ kind: "action", id: "support", label: "Support Flea", value: "GitHub Sponsors", url: SPONSORS_URL })
+    return out
+}
+
+// Omarchy installs and Flea may check and launch: the row's value is the check, its chevron says Enter acts, and the note explains the states that need it.
+function updateRows(update, data) {
+    var out = [
+        { kind: Update.isFact(update) ? "fact" : "action", id: "updateFlea", label: "Update Flea", glyph: "download",
+          value: Update.value(update), role: Update.role(update), inert: !Update.acts(update) },
+        { kind: "check", id: "updates.autoCheck", label: "Check automatically", caption: "when About opens, every 6 h",
+          on: autoCheck(data) }
+    ]
+    var note = Update.note(update)
+    if (note !== null)
+        out.push({ kind: "hint", label: note[0], role: note[1] })
+    return out
+}
+
+// On until switched off, the default src/uischema.rs ships for updates.autoCheck.
+function autoCheck(data) {
+    return ((data || {}).updates || {}).autoCheck !== false
+}
+
+// The three names Flea is packaged under, src/update.rs's OPR_PACKAGE, AUR_PACKAGE and GIT_PACKAGE.
+var PACKAGES = { opr: "flea", aur: "flea-bin", git: "flea-git" }
+
+// Installed from, one sentence per kind src/update.rs derives, so this row and the Update Flea row name one source.
+var SOURCES = { opr: "Omarchy Package Repository", aur: "AUR, flea-bin", git: "AUR, flea-git",
+                local: "Local package", unowned: "Not from a package" }
+
+// src/update.rs kind_for, over pacman -Qqo's owner ("" when no package owns Flea); pacman -Si knows no AUR package.
+function installKind(owner, signed) {
+    if (!owner)
+        return "unowned"
+    if (owner === PACKAGES.opr && signed)
+        return "opr"
+    if (owner === PACKAGES.aur)
+        return "aur"
+    return owner === PACKAGES.git ? "git" : "local"
+}
+
+function installedFrom(owner, signed) {
+    return SOURCES[installKind(owner, signed)]
+}
+
+// pacman -Qi under LC_ALL=C, read the way src/update.rs package_info reads it; "" for a query that failed.
+// Sample input: "Name            : flea-bin\nVersion         : 0.3.4-1\nBuild Date      : Wed Sep 23 12:40:50 2026\nValidated By    : None\n"
+function packageFacts(text) {
+    var facts = { package: "", built: "", signed: false }
+    var lines = String(text || "").split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var cut = lines[i].indexOf(":")
+        if (cut < 0)
+            continue
+        var key = lines[i].substring(0, cut).trim(), value = lines[i].substring(cut + 1).trim()
+        if (key === "Name")
+            facts.package = value
+        else if (key === "Version")
+            facts.package = facts.package.length > 0 ? facts.package + " " + value : value
+        else if (key === "Build Date")
+            facts.built = value
+        // One or more methods separated by two spaces, such as "SHA-256 Sum  Signature".
+        else if (key === "Validated By")
+            facts.signed = value.split(/\s+/).indexOf("Signature") >= 0
+    }
+    return facts
+}

package/test/fixtures/qml/flea-theme/ui/js/SettingsShelf.js

@@ -0,0 +1,52 @@
+.pragma library
+
+// The Settings panel's Shelf section, SettingsRest rules 1 to 4 and ledger directive 59. It lives
+// beside Settings.js rather than in it: the section owns the shelf's switches, the bar plugin reads
+// them from ui.json, and the pins are the shelf's own entries the panel is handed.
+
+// `choice` is handed in because this library cannot import the one that imports it.
+function rows(state, choice) {
+    var data = (state.data || {}).shelf || {}
+    var on = data.enabled === true
+    var out = [{ kind: "group", label: "Shelf", id: "shelf.enabled", master: true,
+                  state: on ? "all" : "none", value: on ? "on" : "off" }]
+    out.push({ kind: "check", id: "shelf.bar", label: "Show in bar", mark: "flea",
+                available: on, on: data.bar !== false })
+    out.push(choice("shelf.rail", "Edge rail", "maximize", ["off", "left", "right", "bottom"],
+                     ["Off", "Left", "Right", "Bottom"], railEdge(data.rail)))
+    out[out.length - 1].available = on
+    // The board's own sentence, second half included: the bind is the user's line in hyprland's
+    // config and nothing here installs it.
+    out.push({ kind: "hint", label: "Super+D opens it from anywhere once you add the bind from the README." })
+    out.push({ kind: "group", label: "Recent captures" })
+    out.push({ kind: "check", id: "shelf.screenshots", label: "Screenshots", glyph: "image",
+                available: on, on: data.screenshots !== false })
+    out.push({ kind: "check", id: "shelf.recordings", label: "Recordings", glyph: "film",
+                available: on, on: data.recordings !== false })
+    out.push(choice("shelf.recent", "Show", "list", CAPTURE_COUNTS, ["1", "2", "3", "5"],
+                     captureCount(data.recent)))
+    out[out.length - 1].available = on
+    out.push({ kind: "group", label: "Pinned", id: "pinFolder", action: "pinFolder",
+                value: "Pin this folder" })
+    var pins = state.pins || []
+    for (var i = 0; i < pins.length; i++) {
+        out.push({ kind: "favourite", id: "pin:" + i, label: pins[i].name, value: pins[i].path,
+                    glyph: pins[i].folder ? "folder" : "file", pinPath: pins[i].path,
+                    pinIndex: i, pinCount: pins.length,
+                    available: on, error: pins[i].missing === true ? "missing" : "" })
+    }
+    return out
+}
+
+// The four the board offers, and the fallback for a count a hand-edited file left behind.
+var CAPTURE_COUNTS = [1, 2, 3, 5]
+
+function captureCount(value) {
+    var n = Number(value)
+    return CAPTURE_COUNTS.indexOf(n) >= 0 ? n : 3
+}
+
+function railEdge(value) {
+    var edges = ["off", "left", "right", "bottom"]
+    return edges.indexOf(String(value)) >= 0 ? String(value) : "off"
+}