buninu-browser 0.3.0 → 0.5.0

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

@@ -0,0 +1,145 @@
+.pragma library
+
+.import "Archive.js" as Archive
+.import "Format.js" as Format
+
+// How a row is classified: which of the twelve preview states it is, and the extension families that
+// decide the three the backend's icon cannot. Split out of Facts.js, which owns the fact tables.
+
+var IMAGE = "image"
+var VIDEO = "video"
+var AUDIO = "audio"
+var PDF = "pdf"
+var TEXT = "text"
+var CODE = "code"
+var ARCHIVE = "archive"
+var SYMLINK = "symlink"
+var MULTI = "multi"
+var LOADING = "loading"
+var ERROR = "error"
+var UNSUPPORTED = "unsupported"
+var FONT = "font"
+
+// src/backend/rows.rs's own UNKNOWN_KIND: the Kind a row gets when nothing could describe its type.
+var UNKNOWN_KIND = "Data"
+
+var CODE_EXTENSIONS = [
+    ".rs", ".py", ".js", ".ts", ".jsx", ".tsx", ".c", ".h", ".cpp", ".hpp", ".cc", ".go", ".rb",
+    ".java", ".kt", ".swift", ".lua", ".pl", ".php", ".sh", ".bash", ".zsh", ".fish", ".vim",
+    ".qml", ".css", ".scss", ".html", ".xml", ".json", ".toml", ".yaml", ".yml", ".ini", ".conf",
+    ".sql", ".mjs", ".cjs"
+]
+
+function isCode(name) {
+    var lower = String(name).toLowerCase()
+    for (var i = 0; i < CODE_EXTENSIONS.length; i++) {
+        var e = CODE_EXTENSIONS[i]
+        if (lower.length > e.length && lower.indexOf(e, lower.length - e.length) !== -1) {
+            return true
+        }
+    }
+    return false
+}
+
+var MARKDOWN_EXTENSIONS = [".md", ".markdown", ".mkd"]
+
+function isMarkdown(name) {
+    var lower = String(name).toLowerCase()
+    for (var i = 0; i < MARKDOWN_EXTENSIONS.length; i++) {
+        var e = MARKDOWN_EXTENSIONS[i]
+        if (lower.length > e.length && lower.indexOf(e, lower.length - e.length) !== -1) {
+            return true
+        }
+    }
+    return false
+}
+
+function isHtml(name) { return /\.(html|htm)$/i.test(String(name)) }
+
+// TrueType, OpenType and collections (font/ttf, font/otf, font/collection); the backend checks the MIME type again.
+var FONT_EXTENSIONS = [".ttf", ".otf", ".ttc"]
+
+function isFont(name) {
+    var lower = String(name).toLowerCase()
+    return FONT_EXTENSIONS.some(function (e) { return lower.length > e.length && lower.indexOf(e, lower.length - e.length) !== -1 })
+}
+
+// Quick Look's font sample: one sentence at three sizes, in board pixels before the text-size ratio and the pixel ratio.
+var SAMPLE_TEXT = "The quick brown fox jumps over the lazy dog"
+var SAMPLE_SIZES = [22, 15, 12]
+
+// One count for every font pane, so an answer meant for an earlier pane never carries a later pane's id.
+var lookSeq = 0
+function nextLookId() { lookSeq += 1; return lookSeq }
+
+// "Inter · Bold · 312.0 kB · 2,548 glyphs"; a table the font lacks drops its part, and the size is always known.
+// pluralWord is Ops.pluralWord, handed in because Ops reaches Sort.js and RecentMode.js, which import this file.
+function fontLine(family, style, bytes, glyphs, pluralWord) {
+    var parts = [family, style, Format.size(bytes)].filter(function (p) { return p })
+    if (glyphs > 0)
+        parts.push(pluralWord(glyphs, "%1 glyph", "%1 glyphs").replace("%1", Format.count(glyphs)))
+    return parts.join(" \u00b7 ")
+}
+
+// The eleven camera RAW types the backend copies a preview out of, told apart by extension like a PDF; Sample input: "IMG_0412.CR3" is true.
+function isRaw(name) {
+    return /\.(cr[23]|nef|nrw|arw|sr2|dng|raf|orf|rw2|pef)$/i.test(String(name))
+}
+
+function isPdf(name) {
+    var lower = String(name).toLowerCase()
+    return lower.length > 4 && lower.indexOf(".pdf", lower.length - 4) !== -1
+}
+
+// The MIME icon table files 3D models under image-x-generic, so they route as images, but no Qt image plugin decodes one.
+function isModel(name) {
+    return /\.(stl|3mf|obj|mtl|gltf|glb)$/i.test(String(name))
+}
+
+// The icon name is the classification the backend already made, so the column never re-derives one.
+// Its first segment is the freedesktop family, and the family is what classifies: this box's
+// generic-icons table maps text/* to five different text- names, and a list of the names seen so
+// far is exactly how the Quick Look refused every image for as long as it kept one.
+function kindState(icon) {
+    var name = String(icon)
+    switch (name) {
+    case "text-x-script":
+    case "text-html":
+    case "application-xml": return CODE
+    case "package-x-generic": return ARCHIVE
+    }
+    if (name.indexOf("image-") === 0) return IMAGE
+    if (name.indexOf("video-") === 0) return VIDEO
+    if (name.indexOf("audio-") === 0) return AUDIO
+    if (name.indexOf("text-") === 0) return TEXT
+    // A .doc or .odt shares the office icon with a PDF, and a PDF was already told apart by its
+    // extension. What is left is binary, so it is Unsupported rather than a newline count over a blob.
+    return UNSUPPORTED
+}
+
+// A directory is not a preview subject: the column shows what is inside it instead.
+function isPreviewable(row) {
+    return row !== null && row !== undefined && row.d !== true
+}
+
+// A name the icon cannot route, told apart by its own extension: a PDF shares x-office-document, and widened archives draw other marks.
+function stateByExtension(name) {
+    if (isPdf(name)) return PDF
+    if (Archive.isArchive(name)) return ARCHIVE
+    if (/\.(csv|tsv)$/i.test(String(name))) return TEXT
+    return ""
+}
+
+// Quick Look's kind from the icon, the name and a served thumbnail, Facts.state's row-free tests; code and markdown read as text.
+function quickLookKind(icon, name, thumbnailed) {
+    if (isPdf(name)) return PDF
+    if (isFont(name)) return FONT
+    if (isMarkdown(name)) return TEXT
+    if (/\.(csv|tsv)$/i.test(String(name))) return TEXT
+    // The client's own extension rule, because the backend's icon cannot name the widened formats.
+    if (Archive.isArchive(name)) return ARCHIVE
+    var byIcon = kindState(icon)
+    // A model no thumbnailer serves has nothing to draw, so it takes the generic file pane.
+    if (byIcon === IMAGE && isModel(name) && !thumbnailed) return UNSUPPORTED
+    return byIcon === CODE ? TEXT : byIcon
+}

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

@@ -0,0 +1,11 @@
+.pragma library
+
+// The largest length an ECMAScript array can hold, 2^32 - 1.
+var MAX_LENGTH = 4294967295
+
+// QVariant sequences crossing a QML var signal expose list methods without being JavaScript Arrays.
+function isList(value) {
+    return Array.isArray(value) || (value !== null && typeof value === "object"
+        && Number.isInteger(value.length) && value.length >= 0 && value.length <= MAX_LENGTH
+        && typeof value.every === "function")
+}

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

@@ -0,0 +1,186 @@
+.pragma library
+
+// Settings > About's Make Flea the default: which state the row is in, the note under it and what a press runs; ui/DefaultClaim.qml runs the processes.
+
+.import "Format.js" as Format
+
+// Whole sentences with "%1" for the program that never started, its name and not its command line.
+var WORDS = {
+    unstarted: "%1 could not start"
+}
+
+// The row's id, which ui/SettingsPanel.qml routes to the run instead of writing it into ui.json.
+var ROW_ID = "makeDefault"
+// The entry flea --default points the desktop at; the box is ticked exactly when xdg-mime answers it.
+var DESKTOP_ID = "com.thisisgm.flea.desktop"
+// src/main.rs claim_both() says this and still exits 0 when a build has no flea.portal to route file dialogs to.
+var SKIPPED = "no file chooser service is installed, so Flea could not become the file chooser"
+// src/defaults.rs EXIT_UNINSTALLED: the status claim() exits with when the running binary has no desktop entry to point at.
+var UNINSTALLED_STATUS = 3
+// The portal reads its routing once, at startup; try-restart leaves a portal that is not running alone.
+var RESTART = ["systemctl", "--user", "try-restart", "xdg-desktop-portal.service"]
+// flea's own stderr lines start with its name, which the note drops.
+var OWN_PREFIX = "flea: "
+
+// Nothing run in this process yet; an entry is assumed until the probe or a refusal says otherwise.
+function idle() {
+    return { running: false, claiming: false, reading: false, readFrom: 0, restarting: false, outcome: "", error: "", packaged: true }
+}
+
+// A run in flight, or a build with no entry, takes no press.
+function inert(claim) {
+    return claim.running || claim.packaged === false
+}
+
+// flea's arguments for a press, or null while the row is inert.
+function press(handler, claim) {
+    if (inert(claim))
+        return null
+    return handler === DESKTOP_ID ? ["--default", "off"] : ["--default"]
+}
+
+// A new run drops the last one's outcome; which way it goes picks the working note.
+function started(claim, args) {
+    return { running: true, claiming: args.length === 1, reading: false, readFrom: 0, restarting: false, outcome: "", error: "",
+             packaged: claim.packaged }
+}
+
+// Still running until a handler read numbered nextRead or later lands and a switch that went through has restarted the portal.
+// Sample stderr: "flea: no file chooser service is installed, so Flea could not become the file chooser\n"
+function finished(claim, code, stderr, nextRead) {
+    var text = stderr || ""
+    var next = Object.assign({}, claim, { reading: true, readFrom: nextRead, restarting: code === 0 })
+    if (code === 0) {
+        next.outcome = text.indexOf(SKIPPED) >= 0 ? "partly" : ""
+        return next
+    }
+    if (code === UNINSTALLED_STATUS) {
+        next.packaged = false
+        return next
+    }
+    next.outcome = "failed"
+    next.error = errorLine(text, code, claim.claiming)
+    return next
+}
+
+// xdg-mime's stderr reaches flea's own, so flea's line is the one that starts with its name.
+// Sample stderr: "xdg-mime: no method available\nflea: xdg-mime default exited 3\n"
+function errorLine(stderr, code, claiming) {
+    var lines = stderr.split("\n").map(function (line) { return line.trim() })
+    var own = lines.filter(function (line) { return line.indexOf(OWN_PREFIX) === 0 })[0]
+    if (own !== undefined)
+        return own.substring(OWN_PREFIX.length)
+    var first = lines.filter(function (line) { return line.length > 0 })[0]
+    return first !== undefined ? first : (claiming ? "flea --default" : "flea --default off") + " exited " + code
+}
+
+// The handler read numbered read has landed; only one begun after the run exited ends it, and only once the portal restart has answered too.
+function settled(claim, read) {
+    if (!claim.reading || read < claim.readFrom)
+        return claim
+    return Object.assign({}, claim, { reading: false, running: claim.restarting })
+}
+
+// A Process's exit and its collector's text land in either order (AGENTS.md "The state file"), so an answer is read once it holds both.
+// Sample: landed(landed({}, { code: 0 }), { text: "com.thisisgm.flea.desktop\n" }) is { code: 0, text: "com.thisisgm.flea.desktop\n" }
+function landed(answer, half) {
+    return Object.assign({}, answer, half)
+}
+
+// An empty text is an answer too: a run that says nothing has still finished saying it.
+function whole(answer) {
+    return answer.code !== undefined && answer.text !== undefined
+}
+
+// The whole answer a program that never started is given: no real exit status is negative.
+var NEVER_RAN = { code: -1, text: "" }
+
+// ui/ViewState.qml's writer rule, measured on Quickshell 0.3.1: a program that cannot start raises no exited, only running going false, and a real exit lands its status before that false.
+function neverRan(answer, running) {
+    return !running && answer.code === undefined
+}
+
+// The handler an answer states; any other status, a read that never ran among them, states none, which About shows as Not reported.
+function handlerOf(answer) {
+    return answer.code === 0 ? answer.text.trim() : ""
+}
+
+// A run whose program never started wrote nothing, so it is over at once, failed, naming what could not start.
+// Sample command: ["/usr/bin/flea", "--default"]
+function unstarted(claim, command) {
+    return Object.assign({}, claim, { running: false, reading: false, restarting: false, outcome: "failed",
+                                      error: Format.fill(WORDS.unstarted, String(command[0]).split("/").pop()) })
+}
+
+// A portal that would not restart keeps the switch as it went; partly keeps its own note, whose dialogs never follow.
+function restarted(claim, ok) {
+    var outcome = !ok && claim.outcome === "" ? "portal" : claim.outcome
+    return Object.assign({}, claim, { restarting: false, running: claim.reading, outcome: outcome })
+}
+
+// restarted() clears restarting on a real exit before running goes false, so a stop that finds it still set is a systemctl that never ran.
+function restartStopped(claim, running) {
+    return !running && claim.restarting ? restarted(claim, false) : claim
+}
+
+function probed(claim, found) {
+    return Object.assign({}, claim, { packaged: found })
+}
+
+// One of off, on, working, partly, portal, failed, unpackaged.
+function state(handler, claim) {
+    if (claim.packaged === false)
+        return "unpackaged"
+    if (claim.running)
+        return "working"
+    if (claim.outcome === "failed")
+        return "failed"
+    if (handler === DESKTOP_ID && claim.outcome === "partly")
+        return "partly"
+    if (claim.outcome === "portal")
+        return "portal"
+    return handler === DESKTOP_ID ? "on" : "off"
+}
+
+// [words, role] for the one line under the row, or null when off says nothing.
+function note(handler, claim) {
+    var now = state(handler, claim)
+    if (now === "on")
+        return ["Folders, Show in folder and file dialogs open Flea.", "foreground"]
+    if (now === "working")
+        return [claim.claiming ? "Making Flea the default" : "Handing folders back", "muted"]
+    if (now === "partly")
+        return ["File dialogs need the flea package's portal files.", "foreground"]
+    if (now === "portal")
+        return ["File dialogs follow after xdg-desktop-portal restarts.", "foreground"]
+    if (now === "failed")
+        return [claim.error, "error"]
+    if (now === "unpackaged")
+        return ["Install a Flea package to make it the default.", "foreground"]
+    return null
+}
+
+// The check row and its note for About's This box group; the note elides on one line rather than wrapping.
+function rows(handler, claim) {
+    var live = claim || idle()
+    var out = [{ kind: "check", id: ROW_ID, label: "Make Flea the default", on: handler === DESKTOP_ID, inert: inert(live) }]
+    var line = note(handler, live)
+    if (line !== null)
+        out.push({ kind: "hint", label: line[0], role: line[1], elide: "right" })
+    return out
+}
+
+// src/userfile.rs data_file()'s ladder: the data home, then every data dir, an empty variable read as unset.
+// Sample env: { HOME: "/home/gm", XDG_DATA_HOME: "", XDG_DATA_DIRS: "/usr/local/share:/usr/share" }
+function entryPaths(env) {
+    var home = env.XDG_DATA_HOME || (env.HOME ? env.HOME + "/.local/share" : "")
+    var dirs = (env.XDG_DATA_DIRS || "/usr/local/share:/usr/share").split(":")
+    return [home].concat(dirs)
+        .filter(function (dir) { return dir.length > 0 })
+        .map(function (dir) { return dir + "/applications/" + DESKTOP_ID })
+}
+
+// data_file()'s regular-file test; each path is an argument, so no path reaches the shell as code.
+function probeCommand(paths) {
+    return ["sh", "-c", "for f; do [ -f \"$f\" ] && exit 0; done; exit 1", "sh"].concat(paths)
+}

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

@@ -0,0 +1,27 @@
+.pragma library
+
+// A search row's name is its path relative to the search root, so the display splits it here and
+// the wire never carries a second shape; see docs/protocol.md "search".
+function base(path) {
+    var i = String(path).lastIndexOf("/")
+    return i < 0 ? String(path) : String(path).substring(i + 1)
+}
+
+// The location column: the parent path relative to the scope, empty for a match in the root itself.
+function location(path) {
+    var i = String(path).lastIndexOf("/")
+    return i < 0 ? "" : String(path).substring(0, i)
+}
+
+// Where to paint the accent run inside a name, mirroring the backend's own case-insensitive match.
+// corner: a character whose lowercase form is a different length (Turkish dotted capital I) can
+// shift the run by one; the name still renders whole, and the backend alone decides what matched.
+function run(hay, needle) {
+    var h = String(hay)
+    var n = String(needle)
+    if (n.length === 0) {
+        return { start: -1, length: 0 }
+    }
+    var at = h.toLowerCase().indexOf(n.toLowerCase())
+    return at < 0 ? { start: -1, length: 0 } : { start: at, length: n.length }
+}

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

@@ -0,0 +1,109 @@
+.pragma library
+.import "Contrast.js" as Contrast
+
+// Omarchy Glassy dims its blurred backdrop to 0.75; channels and alpha use whole 8-bit steps.
+var STEPS = 255
+var MIN_ALPHA = Math.ceil(0.75 * STEPS)
+var INK_STEP = 1.25
+// Twenty bisections resolve lightness more finely than one 8-bit colour channel.
+var LIGHTNESS_SEARCH_STEPS = 20
+// Half an 8-bit channel step repairs rounding without skipping the first passing colour.
+var ROUNDING_REPAIR_STEPS = 512
+
+function ground(plane, a, backdrop) {
+    return Contrast.hexOf(Contrast.over(String(plane), a / STEPS, backdrop))
+}
+
+function worst(ink, c, a, planes) {
+    var least = Infinity
+    var grounds = planes || [c.background, c.surface]
+    var brightness = c.blurBrightness === undefined ? 0.75 : c.blurBrightness
+    var white = Contrast.hexOf([brightness, brightness, brightness])
+    var backdrops = [white, "#000000"]
+    for (var p = 0; p < grounds.length; p++)
+        for (var b = 0; b < backdrops.length; b++)
+            least = Math.min(least, Contrast.ratio(String(ink), ground(grounds[p], a, backdrops[b])))
+    return least
+}
+
+function direction(c) {
+    var fg = Contrast.parse(String(c.foreground)), bg = Contrast.parse(String(c.background))
+    return Contrast.luminance(fg[0], fg[1], fg[2]) > Contrast.luminance(bg[0], bg[1], bg[2]) ? [1, 1, 1] : [0, 0, 0]
+}
+
+// The R3 lightness walk, including its rounding repair, applied to the live palette rather than a theme-name table.
+function inkHolds(ink, c, a, need, quiet) {
+    if (worst(ink, c, a) < need) return false
+    if (quiet === undefined) return true
+    var x = Contrast.parse(String(ink)), q = Contrast.parse(String(quiet))
+    var lx = Contrast.luminance(x[0], x[1], x[2]), lq = Contrast.luminance(q[0], q[1], q[2])
+    return direction(c)[0] === 1 ? lx >= lq : lx <= lq
+}
+
+function liftInk(ink, c, a, need, quiet) {
+    if (inkHolds(ink, c, a, need, quiet)) return String(ink)
+    var from = Contrast.parse(String(ink)), to = direction(c), lo = 0, hi = 1
+    for (var i = 0; i < LIGHTNESS_SEARCH_STEPS; i++) {
+        var mid = (lo + hi) / 2
+        if (inkHolds(Contrast.hexOf(Contrast.mix(from, to, mid)), c, a, need, quiet)) hi = mid
+        else lo = mid
+    }
+    for (var t = hi; t <= 1; t += 1 / ROUNDING_REPAIR_STEPS) {
+        var hex = Contrast.hexOf(Contrast.mix(from, to, t))
+        if (inkHolds(hex, c, a, need, quiet)) return hex
+    }
+    return Contrast.hexOf(to)
+}
+
+function quieter(ink, primary, c) {
+    var x = Contrast.parse(String(ink)), fg = Contrast.parse(String(primary))
+    var lx = Contrast.luminance(x[0], x[1], x[2]), lf = Contrast.luminance(fg[0], fg[1], fg[2])
+    return (direction(c)[0] === 1 ? lx < lf : lx > lf) && Contrast.ratio(String(ink), String(primary)) >= INK_STEP
+}
+
+function primaryHolds(primary, c, a, need, muted, metadata) {
+    return worst(primary, c, a) >= need && quieter(muted, primary, c) && quieter(metadata, primary, c)
+}
+
+// A mode may lift primary ink too, so legible secondary ink never becomes the primary rung.
+function primaryInk(c, a, need, muted, metadata) {
+    if (primaryHolds(c.foreground, c, a, need, muted, metadata)) return String(c.foreground)
+    var from = Contrast.parse(String(c.foreground)), to = direction(c), lo = 0, hi = 1
+    for (var i = 0; i < LIGHTNESS_SEARCH_STEPS; i++) {
+        var mid = (lo + hi) / 2
+        if (primaryHolds(Contrast.hexOf(Contrast.mix(from, to, mid)), c, a, need, muted, metadata)) hi = mid
+        else lo = mid
+    }
+    for (var t = hi; t <= 1; t += 1 / ROUNDING_REPAIR_STEPS) {
+        var hex = Contrast.hexOf(Contrast.mix(from, to, t))
+        if (primaryHolds(hex, c, a, need, muted, metadata)) return hex
+    }
+    return Contrast.hexOf(to)
+}
+
+function inks(c, a, need) {
+    var muted = liftInk(c.muted, c, a, need), metadata = liftInk(c.metadata, c, a, need)
+    var meta = Contrast.parse(metadata), fg = Contrast.parse(String(c.foreground))
+    var lm = Contrast.luminance(meta[0], meta[1], meta[2]), lf = Contrast.luminance(fg[0], fg[1], fg[2])
+    // Darkening a light palette's foreground put metadata beyond primary, or on it in White; reuse its muted rung.
+    if (direction(c)[0] === 1 ? lm >= lf : lm <= lf) metadata = muted
+    var primary = primaryInk(c, a, need, muted, metadata)
+    return {foreground: primary, muted: muted, metadata: metadata}
+}
+
+// One alpha for every main plane in A, raised only if its ink cannot hold the two text rungs.
+function floor(c, need) {
+    for (var a = MIN_ALPHA; a < STEPS; a++) {
+        var ink = inks(c, a, need)
+        if (primaryHolds(ink.foreground, c, a, need, ink.muted, ink.metadata)
+                && worst(ink.muted, c, a) >= need && worst(ink.metadata, c, a) >= need) return a
+    }
+    return STEPS
+}
+
+// B keeps the unlifted listing text legible on its own background plane, never thinner than A.
+function listFloor(c, need) {
+    var a = STEPS
+    while (a > 0 && Math.min(worst(c.muted, c, a - 1, [c.background]), worst(c.metadata, c, a - 1, [c.background])) >= need) a--
+    return a
+}