fedora

2026-05-28 21:45:21 +02:00
parent 653439ac24
commit a356a3d369
610 changed files with 205679 additions and 0 deletions
@@ -0,0 +1,158 @@
+pragma Singleton
+
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import qs.Commons
+import qs.Services.Compositor
+import qs.Services.Power
+import qs.Services.System
+
+Singleton {
+  id: root
+
+  property var searchIndex: []
+
+  FileView {
+    path: Quickshell.shellDir + "/Assets/settings-search-index.json"
+    watchChanges: false
+    printErrors: false
+
+    onLoaded: {
+      try {
+        root.searchIndex = JSON.parse(text());
+      } catch (e) {
+        root.searchIndex = [];
+      }
+    }
+  }
+
+  readonly property var _roots: ({
+                                   "CompositorService": CompositorService,
+                                   "Settings": Settings,
+                                   "Quickshell": Quickshell,
+                                   "IdleService": IdleService,
+                                   "SystemStatService": SystemStatService,
+                                   "SoundService": SoundService
+                                 })
+
+  function isEntryVisible(entry) {
+    if (!entry.visibleWhen || entry.visibleWhen.length === 0)
+      return true;
+    for (let i = 0; i < entry.visibleWhen.length; i++) {
+      if (!_evalCondition(entry.visibleWhen[i]))
+        return false;
+    }
+    return true;
+  }
+
+  function _resolveValue(path) {
+    const parts = path.split(".");
+    const rootObj = _roots[parts[0]];
+    if (rootObj === undefined)
+      return undefined;
+
+    let obj = rootObj;
+    for (let i = 1; i < parts.length; i++) {
+      if (obj === undefined || obj === null)
+        return undefined;
+      let key = parts[i];
+      if (key.endsWith("?"))
+        key = key.slice(0, -1);
+      obj = obj[key];
+    }
+    return obj;
+  }
+
+  function _splitAnd(expr) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < expr.length; i++) {
+      const ch = expr[i];
+      if (ch === "(")
+        depth++;
+      else if (ch === ")")
+        depth--;
+      else if (depth === 0 && ch === "&" && i + 1 < expr.length && expr[i + 1] === "&") {
+        parts.push(current);
+        current = "";
+        i++;
+        continue;
+      }
+      current += ch;
+    }
+    parts.push(current);
+    return parts;
+  }
+
+  function _evalCondition(expr) {
+    expr = expr.trim();
+
+    // Strip outer parentheses
+    if (expr.startsWith("(") && expr.endsWith(")")) {
+      let depth = 0;
+      let allWrapped = true;
+      for (let i = 0; i < expr.length - 1; i++) {
+        if (expr[i] === "(")
+          depth++;
+        else if (expr[i] === ")")
+          depth--;
+        if (depth === 0) {
+          allWrapped = false;
+          break;
+        }
+      }
+      if (allWrapped)
+        return _evalCondition(expr.slice(1, -1));
+    }
+
+    // AND: all parts must be true
+    if (expr.includes("&&")) {
+      const parts = _splitAnd(expr);
+      if (parts.length > 1) {
+        for (let i = 0; i < parts.length; i++) {
+          if (!_evalCondition(parts[i]))
+            return false;
+        }
+        return true;
+      }
+    }
+
+    // Negation
+    if (expr.startsWith("!"))
+      return !_evalCondition(expr.slice(1).trim());
+
+    // Literal false
+    if (expr === "false")
+      return false;
+
+    // Strip nullish coalescing fallback
+    const nullishMatch = expr.match(/^(.+?)\s*\?\?\s*(?:false|true)\s*$/);
+    if (nullishMatch)
+      return _evalCondition(nullishMatch[1]);
+
+    // === comparison
+    let m = expr.match(/^(.+?)\s*===\s*"([^"]*)"\s*$/);
+    if (m)
+      return _resolveValue(m[1].trim()) === m[2];
+
+    // !== comparison
+    m = expr.match(/^(.+?)\s*!==\s*"([^"]*)"\s*$/);
+    if (m)
+      return _resolveValue(m[1].trim()) !== m[2];
+
+    // > comparison
+    m = expr.match(/^(.+?)\s*>\s*(\d+)\s*$/);
+    if (m)
+      return _resolveValue(m[1].trim()) > parseInt(m[2]);
+
+    // Simple property path — resolve and return truthiness
+    const val = _resolveValue(expr);
+    if (val !== undefined)
+      return !!val;
+
+    // Unrecognized expression — assume visible
+    return true;
+  }
+}