buninu-browser 0.2.4 → 0.4.0

package/test/fixtures/qml/flea-theme/imports/qs/Commons/I18n.qml

@@ -0,0 +1,118 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "Plural.js" as Plural
+import "Numbers.js" as Numbers
+
+// Display-language strings for the shell. The selected code lives in
+// ~/.config/omarchy/language (omarchy-language owns it); a missing file
+// means English. Strings come from default/i18n/<code>/shell.json layered
+// over the English catalog, so a missing translation falls back to English
+// per string. Use as I18n.t("common.search"), with .arg(...) for %1 holes,
+// and I18n.tn(key, count).arg(I18n.formatNumber(count)) for an
+// entry with plural forms.
+// The language file is watched, so switching language under Setup
+// re-renders the shell without a restart.
+QtObject {
+  id: root
+
+  readonly property string omarchyPath: Quickshell.env("OMARCHY_PATH")
+  readonly property string configHome: Quickshell.env("XDG_CONFIG_HOME") || (Quickshell.env("HOME") + "/.config")
+
+  readonly property string language: languageCode(languageFile.text())
+  readonly property var localeSettings: parseCatalog(registryFile.text())[root.language] || ({})
+  readonly property string formatLocale: localeSettings.formatLocale || "en-US"
+  // From the registry: how numbers are written and which way text runs.
+  readonly property string decimal: localeSettings.decimal || "."
+  readonly property string zeroDigit: localeSettings.zeroDigit || "0"
+  readonly property bool rightToLeft: localeSettings.direction === "rtl"
+
+  // Reading text() makes blockLoading take effect on the first lookup.
+  // These bindings also rebuild the maps when a watched catalog changes.
+  readonly property var englishStrings: parseCatalog(englishCatalogFile.text())
+  readonly property var languageStrings: parseCatalog(languageCatalogFile.text())
+  readonly property var strings: {
+    var merged = ({})
+    for (var k in root.englishStrings) merged[k] = root.englishStrings[k]
+    for (var k2 in root.languageStrings) merged[k2] = root.languageStrings[k2]
+    return merged
+  }
+
+  // The optional fallback is what imperative callers (the JS models) pass
+  // as their English text: for a key the catalogs do not carry, they keep
+  // sensible English instead of a raw key.
+  function t(key, fallback) {
+    var value = root.strings[key]
+    if (value && typeof value === "object") value = value.other
+    if (typeof value === "string" && value.length > 0) return value
+    return fallback !== undefined ? fallback : key
+  }
+
+  // The form of a plural entry for count, by the language's plural rules
+  // (Plural.js). The English entry answers when the translation has none.
+  function tn(key, count, fallback) {
+    var value = Plural.pick(root.languageStrings[key], root.language, count)
+    if (typeof value !== "string" || value.length === 0) value = Plural.pick(root.englishStrings[key], "en", count)
+    if (typeof value === "string" && value.length > 0) return value
+    return fallback !== undefined ? fallback : key
+  }
+
+  // A number with the language's decimal separator and digits, ungrouped:
+  // formatNumber(13.14, 1) is "13,1" in Danish. Pass decimals to round;
+  // without them the value is written as it is.
+  function formatNumber(value, decimals) {
+    return Numbers.format(value, decimals, root.decimal, root.zeroDigit)
+  }
+
+  function parseCatalog(raw) {
+    try {
+      var parsed = JSON.parse(raw || "{}")
+      return (parsed && typeof parsed === "object" && !Array.isArray(parsed)) ? parsed : ({})
+    } catch (e) {
+      return ({})
+    }
+  }
+
+  function languageCode(raw) {
+    var code = String(raw || "").trim()
+    if (!/^[a-z]{2,3}(-[A-Za-z]{2})?$/.test(code)) code = "en"
+    return code
+  }
+
+  // The catalogs are small local files, read synchronously so the first
+  // binding to call t() already gets the string rather than the raw key.
+  property FileView languageFile: FileView {
+    // OMARCHY_LANGUAGE_FILE overrides the location, as it does for
+    // omarchy-i18n, so tests can pin a language whatever the machine uses.
+    path: Quickshell.env("OMARCHY_LANGUAGE_FILE") || (root.configHome + "/omarchy/language")
+    watchChanges: true
+    printErrors: false
+    blockLoading: true
+    onFileChanged: reload()
+  }
+
+  property FileView englishCatalogFile: FileView {
+    path: root.omarchyPath + "/default/i18n/en/shell.json"
+    watchChanges: true
+    printErrors: false
+    blockLoading: true
+    onFileChanged: reload()
+  }
+
+  property FileView languageCatalogFile: FileView {
+    path: root.omarchyPath + "/default/i18n/" + root.language + "/shell.json"
+    watchChanges: true
+    printErrors: false
+    blockLoading: true
+    onFileChanged: reload()
+  }
+
+  property FileView registryFile: FileView {
+    path: root.omarchyPath + "/default/i18n/locales.json"
+    watchChanges: true
+    printErrors: false
+    blockLoading: true
+    onFileChanged: reload()
+  }
+}

package/test/fixtures/qml/flea-theme/imports/qs/Commons/Numbers.js

@@ -0,0 +1,19 @@
+// A number written with a language's decimal separator and digits from the
+// registry, ungrouped: format(13.14, 1, ",", "0") is "13,1". Without
+// decimals the value is written as it is. default/i18n/plural.jq's
+// localize_number does the same for omarchy-i18n.
+function format(value, decimals, decimal, zeroDigit) {
+  var number = Number(value)
+  if (!isFinite(number)) return String(value)
+  var text = decimals === undefined ? String(number) : number.toFixed(decimals)
+  if (decimal && decimal !== ".") text = text.replace(".", decimal)
+  if (zeroDigit && zeroDigit !== "0") {
+    var zero = zeroDigit.charCodeAt(0)
+    text = text.replace(/[0-9]/g, function(digit) { return String.fromCharCode(zero + digit.charCodeAt(0) - 48) })
+  }
+  return text
+}
+
+if (typeof module !== "undefined") {
+  module.exports = { format: format }
+}

package/test/fixtures/qml/flea-theme/imports/qs/Commons/Plural.js

@@ -0,0 +1,91 @@
+// CLDR cardinal plural categories for whole counts, per Omarchy language
+// code. A plural catalog entry is an object keyed by these categories
+// ({ "one": "%1 file", "other": "%1 files" }); every language needs "other",
+// plus whichever categories its counts can reach. default/i18n/plural.jq
+// holds the same rules for omarchy-i18n, and i18n-test.sh keeps the two
+// in agreement.
+
+function within(value, low, high) {
+  return value >= low && value <= high
+}
+
+function category(code, count) {
+  var n = Math.abs(Math.trunc(Number(count) || 0))
+  var n10 = n % 10
+  var n100 = n % 100
+  var millions = n !== 0 && n % 1000000 === 0
+
+  switch (String(code || "")) {
+  case "ja": case "ko": case "zh-CN": case "zh-TW": case "th": case "vi": case "id": case "ms":
+    return "other"
+  case "hi": case "bn": case "fa": case "si":
+    return n <= 1 ? "one" : "other"
+  case "fr": case "pt-BR":
+    return n <= 1 ? "one" : millions ? "many" : "other"
+  case "ca": case "es-MX": case "it": case "pt":
+    return n === 1 ? "one" : millions ? "many" : "other"
+  case "fil":
+    return (n10 === 4 || n10 === 6 || n10 === 9) ? "other" : "one"
+  case "is":
+    return n10 === 1 && n100 !== 11 ? "one" : "other"
+  case "cs": case "sk":
+    return n === 1 ? "one" : within(n, 2, 4) ? "few" : "other"
+  case "pl":
+    if (n === 1) return "one"
+    return within(n10, 2, 4) && !within(n100, 12, 14) ? "few" : "many"
+  case "ru": case "uk":
+    if (n10 === 1 && n100 !== 11) return "one"
+    return within(n10, 2, 4) && !within(n100, 12, 14) ? "few" : "many"
+  case "hr": case "sr":
+    if (n10 === 1 && n100 !== 11) return "one"
+    return within(n10, 2, 4) && !within(n100, 12, 14) ? "few" : "other"
+  case "sl":
+    if (n100 === 1) return "one"
+    if (n100 === 2) return "two"
+    return within(n100, 3, 4) ? "few" : "other"
+  case "lt":
+    if (within(n100, 11, 19)) return "other"
+    return n10 === 1 ? "one" : n10 >= 2 ? "few" : "other"
+  case "lv":
+    if (n10 === 0 || within(n100, 11, 19)) return "zero"
+    return n10 === 1 ? "one" : "other"
+  case "ro":
+    if (n === 1) return "one"
+    return n === 0 || within(n100, 1, 19) ? "few" : "other"
+  case "ar":
+    if (n <= 2) return ["zero", "one", "two"][n]
+    return within(n100, 3, 10) ? "few" : within(n100, 11, 99) ? "many" : "other"
+  case "he":
+    return n === 1 ? "one" : n === 2 ? "two" : "other"
+  case "ga":
+    if (n <= 2) return n === 0 ? "other" : n === 1 ? "one" : "two"
+    return within(n, 3, 6) ? "few" : within(n, 7, 10) ? "many" : "other"
+  default:
+    return n === 1 ? "one" : "other"
+  }
+}
+
+var ORDER = ["zero", "one", "two", "few", "many", "other"]
+
+// The categories a translation of a plural entry must provide.
+function categories(code) {
+  var seen = { other: true }
+  for (var n = 0; n <= 1000; n++) seen[category(code, n)] = true
+  seen[category(code, 1000000)] = true
+  return ORDER.filter(function(name) { return seen[name] })
+}
+
+// The string for a count from a plural entry, or the entry itself when it
+// is a plain string. A translation missing a category falls back to its
+// "other" form.
+function pick(entry, code, count) {
+  if (typeof entry === "string") return entry
+  if (!entry || typeof entry !== "object") return undefined
+  var form = entry[category(code, count)]
+  if (typeof form === "string" && form.length > 0) return form
+  return typeof entry.other === "string" ? entry.other : undefined
+}
+
+if (typeof module !== "undefined") {
+  module.exports = { category: category, categories: categories, pick: pick }
+}