buninu-browser 0.2.4 → 0.4.0

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

@@ -0,0 +1,298 @@
+.pragma library
+
+// Which columns a list row of a given width draws. The name is the one column a file manager
+// cannot do without, so it is the one that never loses: each metadata column drops instead, at
+// the width where keeping it would push the name under its floor. ui/Header.qml and ui/Row.qml
+// both resolve their set here, from the same width, so the header can never head a column the
+// rows below it are not drawing.
+
+// The optional columns, widest first, which is the order they drop in. Kind goes first: the row
+// already marks its kind with a glyph and most names carry the extension, so it is the most
+// redundant column as well as the widest. Mode goes last, because it is the permanent column.
+var DROP_ORDER = ["kind", "date", "size", "mode"]
+
+// The row width each optional column needs before it is drawn, keyed by column. t carries the
+// tokens ui/Theme.qml resolved: rowPaddingX, gap, iconSize, nameMin, and one width per column.
+// A floor includes every column that outlives it, because they drop in order and a wider column
+// never survives a narrower one, which is what makes the four floors nest.
+function floors(t) {
+    // The name's own slot at its floor: the row padding either side, the mark and the gap after it.
+    var running = t.rowPaddingX + t.iconSize + t.gap + t.nameMin + t.rowPaddingX
+    var out = {}
+    for (var i = DROP_ORDER.length - 1; i >= 0; i--) {
+        var key = DROP_ORDER[i]
+        running += t[key] + t.gap
+        out[key] = running
+    }
+    return out
+}
+
+// One boolean per optional column, for a row of this width. hidden is the user's own set (keys
+// "mode"/"size"/"date"/"kind", from qs module ViewState), subtracted from what the width
+// affords: a hidden column never draws, and width still wins over a column the user wants back,
+// so the name cannot be crowded out by a column the pane is too narrow to carry.
+function set(width, t, hidden) {
+    var f = floors(t)
+    var h = {}
+    var list = hidden || []
+    for (var i = 0; i < list.length; i++) h[list[i]] = true
+    return {
+        location: false,
+        mode: width >= f.mode && !h["mode"],
+        size: width >= f.size && !h["size"],
+        date: width >= f.date && !h["date"],
+        kind: width >= f.kind && !h["kind"]
+    }
+}
+
+// DualPane protects its name floor without reserving absent Mode and Kind columns.
+function dualSet(width, t, hidden) {
+    var base = 2 * t.rowPaddingX + t.iconSize + t.gap + t.nameMin
+    var showSize = (hidden || []).indexOf("size") < 0 && width >= base + t.size
+    var showDate = (hidden || []).indexOf("date") < 0
+        && width >= base + (showSize ? t.size : 0) + t.date
+    return {mode: false, kind: false, location: false, size: showSize, date: showDate}
+}
+
+// Recent protects its pane's name floor and reserves every non-hidden metadata width for Location.
+function recentSet(width, t, hidden, dual) {
+    var base = 2 * t.rowPaddingX + t.iconSize + t.gap + t.nameMin
+    var metadataGap = dual ? 0 : t.gap
+    var h = hidden || []
+    var showSize = h.indexOf("size") < 0 && width >= base + t.size + metadataGap
+    var sizeSlot = showSize ? t.size + metadataGap : 0
+    var showDate = h.indexOf("date") < 0 && width >= base + sizeSlot + t.date + metadataGap
+    var locationFloor = base + (h.indexOf("size") < 0 ? t.size + metadataGap : 0)
+        + (h.indexOf("date") < 0 ? t.date + metadataGap : 0) + t.location + t.gap
+    return {mode: false, kind: false,
+        size: showSize,
+        date: showDate,
+        location: width >= locationFloor}
+}
+
+// A peeked reply is keyed by what ordered it, so a stale ancestor column never survives the hidden-last toggle: path plus hidden plus hiddenLast.
+// Sample input: peekKey("/a", true, true) is "/a\n11".
+function peekKey(path, hidden, hiddenLast) {
+    return String(path) + "\n" + (hidden === true ? "1" : "0") + (hiddenLast === true ? "1" : "0")
+}
+
+// The folder's own remembered order a column asks under and its reply echoes: "" for name order, else the key and 1 when descending.
+// Sample input: orderTag("size", true) is "size1", orderTag("", false) is "".
+function orderTag(by, desc) {
+    return by ? String(by) + (desc === true ? "1" : "0") : ""
+}
+
+// The row count and the folder order join the key only for an outstanding ask, so a resize or a re-sort never orphans a stored column.
+// Sample input: sentKey("/a\n00", 35) is "/a\n00\n35", and sentKey("/a\n00", 35, "size1") is "/a\n00\n35\nsize1".
+function sentKey(key, first, order) {
+    return String(key) + "\n" + Math.floor(Number(first)) + (order ? "\n" + String(order) : "")
+}
+
+// An ask this view made and still awaits, counted per sentKey (path, flags, row count, order), so another client's reply never lands in its column and a column re-asked in flight lands both replies.
+// Sample input: trackAsk(trackAsk({}, "/a\n10\n35"), "/a\n10\n35") holds that key twice.
+function trackAsk(pending, key) {
+    var next = {}
+    var src = pending || {}
+    for (var k in src) next[k] = src[k]
+    next[String(key)] = (next[String(key)] || 0) + 1
+    return next
+}
+
+// True only for a reply this view asked for; anything else is another client's.
+// Sample input: hasAsk(trackAsk({}, "/a\n10"), "/a\n10") is true.
+function hasAsk(pending, key) {
+    return ((pending || {})[String(key)] || 0) > 0
+}
+
+// One ask answered or superseded; a new listing drops them all.
+// Sample input: dropAsk(trackAsk({}, "/a\n10"), "/a\n10") holds nothing, and dropAsk of a key asked twice holds it once.
+function dropAsk(pending, key) {
+    var next = {}
+    var want = String(key)
+    var src = pending || {}
+    for (var k in src) {
+        var left = k === want ? src[k] - 1 : src[k]
+        if (left > 0) next[k] = left
+    }
+    return next
+}
+
+// The columns view's count follows the window width, capped by Settings View's limit.
+// Sample input: (899, 5) answers 2.
+var COUNT_4_AT = 1700
+var COUNT_5_AT = 2300
+var COUNT_NARROW_AT = 900
+var COUNT_MIN = 2
+var COUNT_MAX = 5
+// The shipped View limit: a default install holds 3 columns from 900 px up.
+var COUNT_DEFAULT = 3
+
+// A stored number clamps to 2 to 5, anything else reads as the shipped default.
+function cappedLimit(limit) {
+    if (typeof limit !== "number")
+        return COUNT_DEFAULT
+    var n = Math.floor(limit)
+    if (!(n >= COUNT_MIN) && !(n <= COUNT_MAX))
+        return COUNT_DEFAULT
+    if (n < COUNT_MIN)
+        return COUNT_MIN
+    if (n > COUNT_MAX)
+        return COUNT_MAX
+    return n
+}
+
+// One integer for a window of this width; resizing re-lays columns without re-reading.
+function columnCountForWidth(width, limit) {
+    var count = width < COUNT_NARROW_AT ? 2 : width < COUNT_4_AT ? 3
+        : width < COUNT_5_AT ? 4 : 5
+    var cap = cappedLimit(limit)
+    if (count > cap)
+        count = cap
+    if (count < COUNT_MIN)
+        count = COUNT_MIN
+    return count
+}
+
+// Extra columns are ancestors, read with the same viewport-scoped peek as the parent today.
+function ancestorsForCount(count) {
+    var n = Math.floor(Number(count))
+    if (!(n >= COUNT_MIN))
+        return 0
+    return Math.min(n, COUNT_MAX) - 2
+}
+
+// The parent one step up, with a trailing slash trimmed except at the root itself.
+// Sample input: ancestorParent("/home/") is "/".
+function ancestorParent(path) {
+    var text = String(path)
+    if (text.length > 1 && text.charAt(text.length - 1) === "/")
+        text = text.substring(0, text.length - 1)
+    var cut = text.lastIndexOf("/")
+    return cut <= 0 ? "/" : text.substring(0, cut)
+}
+
+// The nearest distinct ancestors of a path, oldest first, stopping where the climb stops.
+// Sample input: ancestors("/home/gm", 3) is ["/", "/home"].
+function ancestors(path, count) {
+    var n = Math.floor(Number(count))
+    if (!(n >= 1))
+        return []
+    var text = String(path)
+    if (text.length === 0)
+        return []
+    if (text.length > 1 && text.charAt(text.length - 1) === "/")
+        text = text.substring(0, text.length - 1)
+    var near = []
+    var cur = text
+    for (var i = 0; i < n; i++) {
+        var p = ancestorParent(cur)
+        if (p === cur || near.indexOf(p) >= 0)
+            break
+        near.push(p)
+        cur = p
+    }
+    return near.reverse()
+}
+
+// True while an ancestor column of this depth names a directory of its own.
+// Sample input: ancestorShown("/home", 2) is false.
+function ancestorShown(path, depth) {
+    var d = Math.floor(Number(depth))
+    if (!(d >= 1))
+        return false
+    return ancestors(path, d).length >= d
+}
+
+// Sample input: neighbourAsks("/home/gm", 1200, 5) is ["/home"], the shown ancestors oldest first.
+function neighbourAsks(path, width, limit) {
+    var want = ancestorsForCount(columnCountForWidth(Number(width), limit))
+    if (!(want >= 1))
+        return []
+    return ancestors(path, want)
+}
+
+// Sample input: keepAsks({ drawn: ["/a"] }, ["/a"], "/a/b") answers [{path "/a", again false}, {path "/a/b", again true}] and leaves drawn ["/a", "/a/b"]; again names a column not drawn last refresh.
+function keepAsks(keep, asks, child) {
+    var shown = child.length > 0 && asks.indexOf(child) < 0 ? asks.concat([child]) : asks.slice()
+    var plan = shown.map(function (path) { return { path: path, again: keep.drawn.indexOf(path) < 0 } })
+    keep.drawn = shown
+    return plan
+}
+
+// ui.json carries whatever a hand edit wrote, so only a finite number is a stored width; anything else keeps the measured one.
+// Sample input: storedNumber("120") is NaN, storedNumber(120.6) is 121.
+function storedNumber(raw) {
+    if (typeof raw !== "number" || !isFinite(raw) || raw < 0)
+        return NaN
+    return Math.round(raw)
+}
+
+// ListColumns040 board: a dragged edge clamps to the rails, and a double click fits the
+// widest value the window holds, never a directory-wide scan. Sample input: 9999 clamps.
+var MIN_LIST_WIDTH = 48
+var MAX_LIST_WIDTH = 480
+
+// One whole pixel inside the rails, whatever the drag handed in.
+function clampListWidth(px) {
+    var n = Math.round(Number(px))
+    if (!(n >= 0))
+        return MIN_LIST_WIDTH
+    if (n < MIN_LIST_WIDTH)
+        return MIN_LIST_WIDTH
+    if (n > MAX_LIST_WIDTH)
+        return MAX_LIST_WIDTH
+    return n
+}
+
+// The widest held cell, clamped; an empty window keeps the column it has, so a fit can narrow as well as widen.
+function autofitWidth(widths, fallback) {
+    var cells = widths || []
+    if (cells.length === 0)
+        return clampListWidth(fallback)
+    var best = MIN_LIST_WIDTH
+    for (var i = 0; i < cells.length; i++) {
+        var w = Math.round(Number(cells[i]))
+        if (w >= 0 && w > best)
+            best = w
+    }
+    return clampListWidth(best)
+}
+
+function names(s) {
+    var out = ["name"]
+    if (s.location) out.push("location")
+    for (var i = DROP_ORDER.length - 1; i >= 0; i--) {
+        var key = DROP_ORDER[i]
+        if (s[key])
+            out.push(key)
+    }
+    return out.join(",")
+}
+
+// An unanswered folder keeps the old column by data, never by picture.
+// Sample input: folderDataHold(true, false) is true.
+function folderDataHold(cursorIsDir, answered) {
+    return cursorIsDir === true && answered !== true
+}
+
+// A file load needs a real file row: null never loads and a folder waits by data.
+// Sample input: isFileRow({d: false}) is true.
+function isFileRow(row) {
+    return row !== null && row !== undefined && row.d !== true
+}
+
+// A landed peek shows the cursor folder while it is still the one waiting.
+// Sample input: showFolderOnPeek("/a", "/b", true) is true.
+function showFolderOnPeek(childPath, shownChildPath, answered) {
+    return answered === true && childPath.length > 0 && childPath !== shownChildPath
+}
+
+// A data-held empty folder lands settled, the whole frame the picture hold revealed.
+// Sample input: shouldSettleHero(true, "/a", "/a", false, 0) is true.
+function shouldSettleHero(cursorIsDir, path, childPath, readFailed, rowCount) {
+    if (cursorIsDir !== true || readFailed === true)
+        return false
+    if (String(path) !== String(childPath))
+        return false
+    return Math.floor(Number(rowCount)) === 0
+}

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

@@ -0,0 +1,157 @@
+.pragma library
+
+// WCAG 2.1 relative luminance, so a test can assert a ratio rather than an eye judging a screenshot.
+function channel(c) {
+    return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4)
+}
+
+function luminance(r, g, b) {
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b)
+}
+
+// Sample input: "#c8ccd0"
+function parse(hex) {
+    var s = String(hex).replace("#", "")
+    if (s.length === 8)
+        s = s.substring(2)
+    return [parseInt(s.substr(0, 2), 16) / 255,
+            parseInt(s.substr(2, 2), 16) / 255,
+            parseInt(s.substr(4, 2), 16) / 255]
+}
+
+function over(fg, alpha, bg) {
+    var f = parse(fg)
+    var b = parse(bg)
+    return [f[0] * alpha + b[0] * (1 - alpha),
+            f[1] * alpha + b[1] * (1 - alpha),
+            f[2] * alpha + b[2] * (1 - alpha)]
+}
+
+function ratioOf(a, b) {
+    var la = luminance(a[0], a[1], a[2])
+    var lb = luminance(b[0], b[1], b[2])
+    var hi = Math.max(la, lb)
+    var lo = Math.min(la, lb)
+    return (hi + 0.05) / (lo + 0.05)
+}
+
+function ratio(fgHex, bgHex) {
+    return ratioOf(parse(fgHex), parse(bgHex))
+}
+
+function pad2(n) {
+    return n < 16 ? "0" + n.toString(16) : n.toString(16)
+}
+
+function hexOf(rgb) {
+    return "#" + pad2(Math.round(Math.max(0, Math.min(1, rgb[0])) * 255))
+            + pad2(Math.round(Math.max(0, Math.min(1, rgb[1])) * 255))
+            + pad2(Math.round(Math.max(0, Math.min(1, rgb[2])) * 255))
+}
+
+function mix(a, b, t) {
+    return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t]
+}
+
+// Keep hue; walk lightness toward black or white until WCAG AA (or minRatio) holds.
+function ensureRatio(fgHex, bgHex, minRatio) {
+    var need = minRatio > 0 ? minRatio : 4.5
+    if (ratio(fgHex, bgHex) >= need)
+        return String(fgHex)
+    var fg = parse(fgHex)
+    var bg = parse(bgHex)
+    var toward = luminance(bg[0], bg[1], bg[2]) > 0.179 ? [0, 0, 0] : [1, 1, 1]
+    var lo = 0
+    var hi = 1
+    var best = toward
+    for (var i = 0; i < 18; i++) {
+        var mid = (lo + hi) / 2
+        var cand = mix(fg, toward, mid)
+        if (ratioOf(cand, bg) >= need) {
+            best = cand
+            hi = mid
+        } else {
+            lo = mid
+        }
+    }
+    if (ratioOf(best, bg) < need)
+        best = toward
+    return stepped(hexOf(best), bgHex, need, toward)
+}
+
+// Rounding to 8 bits can land just under the ratio asked for, 2.99 for 3 on 20 of the 22 stock palettes.
+function stepped(hex, bgHex, need, toward) {
+    var c = parse(hex)
+    var step = toward[0] > 0.5 ? 1 / 255 : -1 / 255
+    var bg = parse(bgHex)
+    for (var i = 0; i < 255; i++) {
+        if (ratioOf(c, bg) >= need)
+            break
+        // Each channel clamps on its own, so one already at the extreme cannot carry the others out.
+        var next = [clamp(c[0] + step), clamp(c[1] + step), clamp(c[2] + step)]
+        // A step that moves no channel at all is the extreme itself, and there is nowhere further to go.
+        if (hexOf(next) === hexOf(c))
+            break
+        c = next
+    }
+    return hexOf(c)
+}
+
+function clamp(v) {
+    return v < 0 ? 0 : (v > 1 ? 1 : v)
+}
+
+// The seven tag names, member for member with src/backend/tags.rs NAMES and ui/js/Tags.js NAMES.
+var TAG_NAMES = ["Red", "Orange", "Yellow", "Green", "Blue", "Purple", "Gray"];
+var TAG_ROLES = { Red: "red", Orange: "orange", Yellow: "yellow", Green: "green",
+                  Blue: "blue", Purple: "magenta", Gray: "dark_foreground" };
+var TAG_HUES = { Red: [335, 12], Orange: [8, 45], Yellow: [28, 70],
+                 Green: [80, 170], Blue: [195, 255], Purple: [250, 335] };
+
+// Each role lifted to 3:1 on the listing ground and the menu ground, plus the digit fallback, decided once per theme load.
+function tagTheme(found, bg, surface) {
+    var colors = {};
+    var menuColors = {};
+    var seen = {};
+    var fallback = false;
+    for (var i = 0; i < TAG_NAMES.length; i++) {
+        var name = TAG_NAMES[i];
+        var hex = (found || {})[TAG_ROLES[name]] || "";
+        if (!hex) {
+            fallback = true;
+        } else {
+            var key = String(hex).toLowerCase();
+            if (seen[key]) fallback = true;
+            seen[key] = true;
+        }
+        colors[name] = hex ? ensureRatio(hex, bg, 3) : "";
+        menuColors[name] = hex ? ensureRatio(hex, surface, 3) : "";
+        if (name !== "Gray" && hex) {
+            var rgb = parse(hex);
+            var hi = Math.max(rgb[0], rgb[1], rgb[2]);
+            var lo = Math.min(rgb[0], rgb[1], rgb[2]);
+            // Almost no chroma is a grey whatever its name claims.
+            if (hi === 0 || (hi - lo) / hi < 0.12) fallback = true;
+            else if (!tagHueHolds(rgb, TAG_HUES[name])) fallback = true;
+        }
+    }
+    return { colors: colors, menuColors: menuColors, fallback: fallback };
+}
+
+// A hue inside a window that wraps past red, so one comparison covers both ends.
+function tagHueHolds(rgb, window) {
+    var hi = Math.max(rgb[0], rgb[1], rgb[2]);
+    var lo = Math.min(rgb[0], rgb[1], rgb[2]);
+    var delta = hi - lo;
+    var hue = 0;
+    if (delta > 0) {
+        if (hi === rgb[0]) {
+            hue = 60 * (((rgb[1] - rgb[2]) / delta + 6) % 6);
+        } else if (hi === rgb[1]) {
+            hue = 60 * ((rgb[2] - rgb[0]) / delta + 2);
+        } else {
+            hue = 60 * ((rgb[0] - rgb[1]) / delta + 4);
+        }
+    }
+    return window[0] <= window[1] ? hue >= window[0] && hue <= window[1] : hue >= window[0] || hue <= window[1];
+}

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

@@ -0,0 +1,44 @@
+.pragma library
+
+// One job: the numbers every surface draws from, so tests/js/density.js pins them.
+
+// The four stops in the board's own order, Tight first as the opt-in below Compact.
+var STOPS = ["tight", "compact", "normal", "comfortable"]
+var LABELS = ["Tight", "Compact", "Normal", "Comfortable"]
+
+// Tight drops the padding, Compact keeps half, Normal keeps all, Comfortable one half more.
+var RATIOS = ({ tight: 0, compact: 0.5, normal: 1, comfortable: 1.5 })
+
+// Sample input: ratioFor("tight") is 0, ratioFor("nope") is 0.5.
+function ratioFor(density) {
+    return RATIOS[density] !== undefined ? RATIOS[density] : 0.5
+}
+
+// Sample input: rowHeight(23, 7, "tight") is 23, the line box with no padding.
+function rowHeight(lineBox, rowPaddingY, density) {
+    return lineBox + 2 * Math.round(rowPaddingY * ratioFor(density))
+}
+
+// The six thumbnail stops in the board's walk order, Small 48 to Largest 256.
+var THUMB_SIZES = ({ small: 48, medium: 64, large: 96, xlarge: 128, huge: 192, largest: 256 })
+
+// Sample input: thumbPixelsFor("huge") is 192, thumbPixelsFor("nope") is 64.
+function thumbPixelsFor(size) {
+    return THUMB_SIZES[size] !== undefined ? THUMB_SIZES[size] : 64
+}
+
+// A folder mark never grows past its 128 px size, centred in the larger slots.
+var GLYPH_CAP = 128
+
+// Sample input: glyphCap(192) is 128, glyphCap(48) is 48.
+function glyphCap(pixels) {
+    return Math.min(pixels, GLYPH_CAP)
+}
+
+// The grid's vertical pad tracks density with Compact anchored at today's pad.
+var GRID_BASE = 0.5
+
+// Sample input: gridPadY(14, "compact") is 14, gridPadY(14, "tight") is 7.
+function gridPadY(padX, density) {
+    return Math.round(padX * (GRID_BASE + ratioFor(density)))
+}

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

@@ -0,0 +1,129 @@
+.pragma library
+
+// A row this listing has asked about: null means asked and waiting, an object is the answer.
+var ASKED = null
+
+function empty() {
+    return { file: {}, order: [] }
+}
+
+// Only visible rows, only rows the backend called directories, only rows never asked.
+function plan(state, rows, held, first, last) {
+    var ask = []
+    for (var i = first; i <= last; i++) {
+        if (state.file[i] !== undefined) {
+            continue
+        }
+        var row = rows[i - held]
+        if (row && row.d) {
+            ask.push(i)
+        }
+    }
+    return ask
+}
+
+// The wrapper is new so a QML binding on it re-evaluates; the map inside is mutated in place.
+function applied(state, ask) {
+    for (var i = 0; i < ask.length; i++) {
+        state.file[ask[i]] = ASKED
+        state.order.push(ask[i])
+    }
+    return { file: state.file, order: state.order }
+}
+
+// Gates the cancel wire message, since a fling fires onContentYChanged on every pixel and a fresh listing has nothing queued to cancel yet.
+function hasPending(state) {
+    for (var i = 0; i < state.order.length; i++) {
+        if (state.file[state.order[i]] === ASKED) {
+            return true
+        }
+    }
+    return false
+}
+
+// A scroll cancels every row still waiting, not only the ones off-viewport, matching what the backend's own dirsizecancel means.
+function cancelled(state) {
+    var file = {}
+    var order = []
+    for (var i = 0; i < state.order.length; i++) {
+        var row = state.order[i]
+        if (state.file[row] === ASKED) {
+            continue
+        }
+        file[row] = state.file[row]
+        order.push(row)
+    }
+    return { file: file, order: order }
+}
+
+// A live answer re-lists some folders: each answered size follows its row, by name, to that row's new index. Pending asks do not follow.
+function carried(state, oldRows, oldHeld, newRows, newHeld) {
+    var at = Object.create(null)
+    for (var j = 0; j < newRows.length; j++) {
+        if (newRows[j].d) {
+            at[newRows[j].n] = newHeld + j
+        }
+    }
+    var next = empty()
+    for (var k = 0; k < state.order.length; k++) {
+        var answer = state.file[state.order[k]]
+        var row = oldRows[state.order[k] - oldHeld]
+        if (answer && row && at[row.n] !== undefined) {
+            next.file[at[row.n]] = answer
+            next.order.push(at[row.n])
+        }
+    }
+    return next
+}
+
+// Sizes a live answer carried on its rows land with those rows; with none the state comes back as it was.
+// Sample input: (null, [{n: "x", d: true}, {n: "c", d: true, z: 96}], 20) answers file {21: {bytes: 96, partial: false}}, order [21].
+function inlined(state, rows, held) {
+    var next = null
+    for (var i = 0; i < rows.length; i++) {
+        if (rows[i].z === undefined)
+            continue
+        next = next || state || empty()
+        if (next.file[held + i] === undefined)
+            next.order.push(held + i)
+        next.file[held + i] = { bytes: rows[i].z, partial: false }
+    }
+    return next || state
+}
+
+// The cap bounds a policy bug, not normal use, the same reason ui/js/Thumbs.js has one; callers pass Pane's own thumbCap.
+function remember(state, row, bytes, partial, cap) {
+    if (state.file[row] === undefined) {
+        state.order.push(row)
+    }
+    state.file[row] = { bytes: bytes, partial: partial }
+    while (state.order.length > cap) {
+        delete state.file[state.order.shift()]
+    }
+    return { file: state.file, order: state.order }
+}
+
+// Sample input: ("network") trues, ("usb") falses.
+function isRemoteClass(storageClass) {
+    return storageClass === "network" || storageClass === "phone"
+}
+
+// Sample input: (["size"]) trues, ([]) falses.
+function sizeHidden(hiddenCols) {
+    return hiddenCols.indexOf("size") >= 0
+}
+
+// Sample input: ("list", [], "", true) trues, ("grid", [], "", true) falses.
+function wantsSizes(viewMode, hiddenCols, storageClass, storageKnown) {
+    if (!storageKnown) return false
+    if (isRemoteClass(storageClass)) return false
+    if (viewMode === "grid") return false
+    if (viewMode === "list" && sizeHidden(hiddenCols)) return false
+    return true
+}
+
+// null covers both "never asked" and "asked and still waiting": the Size cell renders both as the middle dot.
+function sizeFor(state, row) {
+    var value = state.file[row]
+    return value && typeof value === "object" ? value : null
+}