buninu-browser 0.2.4 → 0.4.0

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

@@ -0,0 +1,157 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Which rows get an Extract, and what a new archive is called; the backend sends no is-archive flag, so this is the mechanism.
+
+// The widened tail of EXTENSIONS, which 7z reads; tar and the zip class keep their own rules.
+var SEVEN_TAILS = [".appimage", ".cpio", ".cab", ".jar", ".apk", ".rpm", ".deb", ".iso"]
+
+// Longest form first, so ".tar.gz" matches before ".gz"; .rar is read here and never offered to write (src/backend/archive.rs).
+var EXTENSIONS = [".tar.zst", ".tar.bz2", ".tar.gz", ".tar.xz", ".tgz", ".tar", ".zip", ".7z", ".rar"].concat(SEVEN_TAILS)
+
+// A disk image lists in the archive preview and is never extracted.
+var LIST_ONLY = [".iso"]
+
+function isArchive(name) {
+    var lower = String(name).toLowerCase()
+    for (var i = 0; i < EXTENSIONS.length; i++) {
+        if (lower.length > EXTENSIONS[i].length && lower.indexOf(EXTENSIONS[i], lower.length - EXTENSIONS[i].length) !== -1) {
+            return true
+        }
+    }
+    return false
+}
+
+// The name an extract unpacks into: the archive's own, with every archive extension taken off.
+function extractDir(name) {
+    var text = String(name)
+    var lower = text.toLowerCase()
+    for (var i = 0; i < EXTENSIONS.length; i++) {
+        if (lower.length > EXTENSIONS[i].length && lower.indexOf(EXTENSIONS[i], lower.length - EXTENSIONS[i].length) !== -1) {
+            return text.substring(0, text.length - EXTENSIONS[i].length)
+        }
+    }
+    return text
+}
+
+// One row compresses under its own name; several compress under the directory holding them.
+function archiveStem(names, parentLeaf) {
+    if (names.length === 1) {
+        return stripExtension(names[0])
+    }
+    return parentLeaf.length > 0 ? parentLeaf : "archive"
+}
+
+function stripExtension(name) {
+    var text = String(name)
+    var cut = text.lastIndexOf(".")
+    return cut > 0 ? text.substring(0, cut) : text
+}
+
+var SHEET_COMPRESS = "Compress to .%1"
+
+// The compress submenu is the probed table, so no 7zip means no .7z; the sheet reads each leaf "Compress to .zip" beside the board's file mark.
+function formatEntries(formats) {
+    var out = []
+    for (var i = 0; i < formats.length; i++) {
+        out.push({ id: formats[i], label: "." + formats[i], sheetLabel: SHEET_COMPRESS.replace("%1", formats[i]), glyph: "file" })
+    }
+    return out
+}
+
+// A disk image by name, longest form first so ".img.xz" wins over ".img"; a zip needs one such member.
+function imageKind(name) {
+    var lower = String(name || "").toLowerCase()
+    var table = [[".img.xz", "xz"], [".img.gz", "gz"], [".img.zst", "zst"], [".img.bz2", "bz2"],
+                 [".iso", "iso"], [".img", "img"], [".raw", "raw"], [".zip", "zip"]]
+    for (var i = 0; i < table.length; i++) {
+        var suffix = table[i][0]
+        if (lower.length > suffix.length && lower.lastIndexOf(suffix) === lower.length - suffix.length)
+            return table[i][1]
+    }
+    return ""
+}
+
+function isDiskImage(name, zipMember) {
+    var kind = imageKind(name)
+    if (kind === "" || kind === "zip")
+        return kind === "zip" && imageKind(zipMember) !== "" && imageKind(zipMember) !== "zip"
+    return true
+}
+
+// Whether an installed tool reads this archive: .7z needs 7z, .zip and .rar either tool, tar bsdtar, a disk image none.
+function canExtract(name, extraction) {
+    var lower = String(name).toLowerCase()
+    var caps = extraction || ({})
+    if (isListOnly(name)) return false
+    if (hasSuffix(lower, ".7z")) return caps.sevenZip === true
+    if (hasSuffix(lower, ".zip") || hasSuffix(lower, ".rar")) return caps.zip === true
+    if (isSevenSuffix(lower)) return caps.sevenZip === true
+    return caps.archive === true
+}
+
+// A disk image lists in the archive preview and is never extracted.
+function isListOnly(name) {
+    var lower = String(name).toLowerCase()
+    for (var i = 0; i < LIST_ONLY.length; i++) {
+        if (hasSuffix(lower, LIST_ONLY[i])) return true
+    }
+    return false
+}
+
+// The seven-tail membership, read off the one table above.
+function isSevenSuffix(lower) {
+    for (var i = 0; i < SEVEN_TAILS.length; i++) {
+        if (hasSuffix(lower, SEVEN_TAILS[i])) return true
+    }
+    return false
+}
+
+// The missing program for a disabled Extract: only bsdtar offers "tar" and only 7z offers "7z".
+function extractHint(formats) {
+    var table = formats || []
+    if (table.indexOf("7z") >= 0) return "bsdtar is not installed"
+    if (table.indexOf("tar") >= 0) return "7-Zip is not installed"
+    return "No archive tool is installed"
+}
+
+// Menu.js's Extract row: absent for none and for a disk image, disabled with its reason for no reader.
+function extractEntry(entry, p, count) {
+    if (!p.rowIsArchive || count !== 1) return false
+    if (isListOnly(p.archiveName || "")) return false
+    if (p.canExtract !== true) {
+        entry.disabled = true
+        entry.hint = extractHint(p.archiveFormats)
+        entry.hintWrap = true
+    }
+    return true
+}
+
+function hasSuffix(lower, suffix) {
+    return lower.length >= suffix.length && lower.indexOf(suffix, lower.length - suffix.length) !== -1
+}
+
+// The compress submenu's last row, which opens the password dialog; hidden where 7z is missing, since bsdtar writes no encryption.
+function passwordEntry(formats) {
+    var table = formats || []
+    if (table.indexOf("7z") < 0) return []
+    return [{ separator: true },
+        { id: "compressPassword", label: "With password…", glyph: "key" }]
+}
+
+// The backend's two password codes, matched exactly the way "cancelled" routes, never as sentences.
+function needsPassword(err) {
+    return String(err) === "encrypted"
+}
+
+function wrongPassword(err) {
+    return String(err) === "wrong-password"
+}
+
+// What an extract's terminal line does: "password" opens the card, "wrong" reopens it with its sentence, "" messages.
+function doneAction(ok, err) {
+    if (!ok && needsPassword(err)) return "password"
+    if (!ok && wrongPassword(err)) return "wrong"
+    return ""
+}

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

@@ -0,0 +1,110 @@
+.pragma library
+
+// Back and Forward entries and the landing ui/PaneSwap.qml runs in the rows' turn.
+
+// A stack entry names the directory and the row its cursor stood on; bare paths read as empty rows.
+function makeEntry(path, name, index) {
+    return { path: String(path), name: String(name || ""), index: Math.max(0, Math.floor(Number(index) || 0)) }
+}
+
+function pathOf(entry) {
+    return typeof entry === "string" ? entry : String(entry.path || "")
+}
+
+function asEntry(target) {
+    return typeof target === "string" ? makeEntry(target, "", 0) : target
+}
+
+// The place a listing still out asked for, with the cursor its Back or Forward owes it; null when none is out or it re-reads the drawn folder.
+function pending(pane) {
+    if (!pane.listInFlight || !pane.listingPath || pane.listingPath === pane.path)
+        return null
+    var owed = pane.swap ? pane.swap.restore : null
+    if (owed && owed.path === pane.listingPath)
+        return makeEntry(owed.path, owed.name, owed.index)
+    return makeEntry(pane.listingPath, "", 0)
+}
+
+// A tab switch left its cursor, order and located row to its landing; the listing let go never lands, so a later one must not take them.
+function dropOwed(pane) {
+    if (pane.tabs)
+        Object.assign(pane.tabs, { pendingCursor: -1, pendingCursorName: null, pendingLocatePath: "", pendingSortBy: "", pendingSortDesc: false })
+}
+
+// The stack a Back or Forward still out pushed the drawn place onto, or "" when the listing out is any other.
+function pushedOnto(pane) {
+    var owed = pending(pane) && pane.swap ? pane.swap.restore : null
+    return owed && owed.pushedOnto ? owed.pushedOnto : ""
+}
+
+// The drawn folder with the cursor row it stands on; leaving a walk names no row, so the landing stays at the top.
+function drawn(pane) {
+    var walk = pane.searchMode === "results" || (pane.searchFrom || "").length > 0
+    var row = !walk && pane.rowFor ? pane.rowFor(pane.cursorIndex) : null
+    return makeEntry(pane.path, row ? row.n : "", walk ? 0 : pane.cursorIndex)
+}
+
+// The departing cursor, or the pending place while a listing is out.
+function capture(pane) {
+    return pending(pane) || drawn(pane)
+}
+
+// One step through the stacks after Nav's guard, popping before the open pushes back.
+function travel(pane, from, to) {
+    var stack = pane[from]
+    var target = asEntry(stack[stack.length - 1])
+    pane[to] = (pane[to] || []).concat([capture(pane)])
+    pane[from] = stack.slice(0, -1)
+    pane.openWithoutHistory(pathOf(target), { restore: Object.assign({}, target, { pushedOnto: to }), supersede: true })
+}
+
+// The landing in the rows reply's turn: name, then clamped index, then the top.
+function landRestore(pane, entry) {
+    if (!entry)
+        return
+    if (pane.path !== entry.path || (pane.searchMode || "").length > 0 || pane.total === 0)
+        return
+    var name = String(entry.name || "")
+    if (name.length > 0) {
+        for (var i = 0; i < pane.rows.length; i++) {
+            if (String(pane.rows[i].n) === name) {
+                pane.setCursor(pane.held + i)
+                return
+            }
+        }
+    }
+    pane.setCursor(Math.min(entry.index, pane.total - 1))
+}
+
+// True when a Back listing's first window lacks the owed name: the existing locate is sent and the rows wait for its window.
+function deferForLocate(pane, entry, items, listed) {
+    if (!entry || entry.pendingPath || !listed || listed.path !== entry.path)
+        return false
+    var name = String(entry.name || "")
+    if (name.length === 0 || !(listed.total > items.length) || (pane.searchMode || "").length > 0)
+        return false
+    for (var i = 0; i < items.length; i++) {
+        if (String(items[i].n) === name)
+            return false
+    }
+    if (!(pane.windowSize > 0) || typeof pane.backend.window !== "function")
+        return false
+    entry.pendingPath = pane.join(entry.path, name)
+    entry.total = listed.total
+    pane.backend.send({ c: "locate", path: entry.pendingPath })
+    return true
+}
+
+// The locate reply for a waiting landing fetches the window holding the row, or the clamped index on a miss.
+function takeLocated(pane, message) {
+    var entry = pane.swap ? pane.swap.restore : null
+    if (!entry || !entry.pendingPath || entry.fetched || !message
+            || message.path !== entry.pendingPath || message.directory !== entry.path)
+        return false
+    var index = Number(message.index)
+    if (!(index >= 0) || index >= entry.total)
+        index = Math.min(entry.index, entry.total - 1)
+    entry.fetched = true
+    pane.backend.window(index, pane.windowSize)
+    return true
+}

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

@@ -0,0 +1,54 @@
+.pragma library
+
+// Sample input: primaryFor("collide") === "keep", isDestructive("trash", "delete") === true.
+// Variant A: one control for every dialog button, sized by Theme, primary is the safe Enter action.
+
+// The members of a set (the protocols) sit this many hairlines apart, 4 px at base size 14.
+var SET_GAP = 4
+// The segments of a settings chooser sit this many hairlines apart, 2 px at base size 14.
+var SEGMENT_GAP = 2
+// A focused control whose foreground hairline would match its rest draws its own frame this wide, inward.
+var RING = 2
+var DISABLED_OPACITY = 0.55
+// The pointer's wash and the press wash, laid in the control's own ink.
+var WASH_HOVER = 0.08
+var WASH_PRESS = 0.14
+// A primary's resting accent wash, at the press wash's weight.
+var WASH_PRIMARY = WASH_PRESS
+// Chrome marks scale by this factor; dialog buttons inset only their frame and wash by whole pixels.
+var PRESS_SCALE = 0.96
+var PRESS_MS = 150
+
+// One primary per dialog, fixed: it never moves with focus.
+var PRIMARY = {
+    trash: "cancel",
+    collide: "keep",
+    openWith: "open",
+    convert: "convert",
+    newFile: "create",
+    moveTo: "move",
+    copyTo: "copy",
+    network: "action",
+    permissions: "apply",
+    picker: "accept"
+}
+
+// A destructive action rests as the error label in a muted frame, never primary.
+var DESTRUCTIVE = {
+    trash: { "delete": true },
+    collide: { "replace": true },
+    picker: { "replace": true }
+}
+
+// Sample input: focusFrame(true, false, false) === "foreground", focusFrame(true, false, true) === "thick", focusFrame(false, false, true) === "thick", focusFrame(true, true, true) === "accent", focusFrame(false, true, false) === "thick".
+// What a focused control's own frame draws: one foreground hairline, one accent hairline for a set member where the accent has hue, or "thick", RING wide in the foreground, where a hairline would match the rest.
+function focusFrame(accentHasHue, setMember, restIsForeground) { return setMember !== true ? (restIsForeground === true ? "thick" : "foreground") : accentHasHue === true ? "accent" : "thick" }
+
+function primaryFor(dialog) {
+    return PRIMARY[dialog] || ""
+}
+
+function isDestructive(dialog, name) {
+    var set = DESTRUCTIVE[dialog] || {}
+    return set[name] === true
+}

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

@@ -0,0 +1,111 @@
+.pragma library
+
+// Neighbour-column background menus: a peek's empty space navigates to its DRAWN directory (parent/ancestor or shownChildPath, never pending childPath) and opens the background menu once its rows land.
+
+// A trailing slash trimmed except at the root itself.
+// Sample input: trimSlash("/home/gm/") is "/home/gm".
+function trimSlash(path) {
+    var text = String(path)
+    return text.length > 1 && text.charAt(text.length - 1) === "/" ? text.substring(0, text.length - 1) : text
+}
+
+// True when two paths name the same directory, trailing slash aside.
+// Sample input: samePath("/a/", "/a") is true.
+function samePath(a, b) {
+    return trimSlash(a) === trimSlash(b)
+}
+
+// "" when a background intent may arm, else the busy reason: rejects before any intent is stored, so a refused open never leaves one behind.
+// Sample input: canArm({listInFlight: true}) is "loading".
+function canArm(pane) {
+    if (!pane)
+        return "no pane"
+    if (pane.listInFlight === true)
+        return "loading"
+    if (pane.trash && (pane.trash.opened === true || pane.trash.confirming === true))
+        return "trash"
+    if (pane.searchMode && pane.searchMode.length > 0)
+        return "search"
+    if (pane.collide && (pane.collide.opened === true || pane.collide.pending !== null))
+        return "collide"
+    if (pane.menuVisible === true)
+        return "menu"
+    if (pane.menuActions && pane.menuActions.opened === true)
+        return "menu"
+    if (pane.renamingIndex >= 0 || pane.renamePending === true)
+        return "rename"
+    if (pane.filterTyping === true)
+        return "filter"
+    if (pane.selectionBand !== null && pane.selectionBand !== undefined)
+        return "band"
+    return ""
+}
+
+// True when the target is already shown: open the menu where it stands, no navigation.
+// Sample input: directOpen("/a", "/a/") is true.
+function directOpen(target, panePath) {
+    return target.length > 0 && samePath(target, panePath)
+}
+
+// True when landed rows may open the deferred menu: the pending target names this listing and it succeeded; empty counts because an empty directory is where the menu matters most, while locked, error and loading drop the intent.
+// Sample input: shouldOpen("/a", "/a", "ready") is true.
+function shouldOpen(panePath, pending, listingState) {
+    if (!pending || pending.length === 0)
+        return false
+    if (!samePath(panePath, pending))
+        return false
+    return listingState === "ready" || listingState === "empty"
+}
+
+// A failed listing drops the deferred menu, so no later rows open it.
+function clearPendingBackground(pane) {
+    if (!pane)
+        return
+    pane.pendingBackground = ""
+    pane.pendingBackgroundAt = null
+}
+
+// The deferred neighbour background, consumed either way so later rows never open it: opens only a successful listing of the drawn target, at the stored point.
+function applyPendingBackground(pane) {
+    if (!pane || !pane.pendingBackground || pane.pendingBackground.length === 0)
+        return
+    var target = pane.pendingBackground
+    var at = pane.pendingBackgroundAt
+    pane.pendingBackground = ""
+    pane.pendingBackgroundAt = null
+    if (!shouldOpen(pane.path, target, pane.listingState))
+        return
+    if (pane.searchMode && pane.searchMode.length > 0)
+        return
+    if (pane.trash && pane.trash.opened)
+        return
+    if (at === null || at === undefined)
+        return
+    pane.openBackgroundMenu(at)
+}
+
+// Routes one neighbour background for the columns view: busy refuses before any intent is stored, the shown folder opens its menu where it stands, and any other target navigates with the menu waiting on its rows. Answers opened, navigating, ignored or refused:<reason>.
+// Sample input: routeBackground({path: "/a"}, "/a", {x: 1}, {openBackground: function () {}}) is "opened".
+function routeBackground(pane, base, scenePoint, menu) {
+    if (!pane || !base || base.length === 0 || !scenePoint)
+        return "ignored"
+    var busy = canArm(pane)
+    if (busy.length > 0) {
+        if (busy === "loading")
+            pane.message("A directory is already loading.", false)
+        return "refused:" + busy
+    }
+    if (directOpen(base, pane.path)) {
+        menu.openBackground(scenePoint)
+        return "opened"
+    }
+    pane.pendingBackground = base
+    pane.pendingBackgroundAt = scenePoint
+    pane.open(base)
+    if (!pane.listInFlight) {
+        pane.pendingBackground = ""
+        pane.pendingBackgroundAt = null
+        return "refused:not-started"
+    }
+    return "navigating"
+}