switch hto monorepo structure

quickshell/Common/Proc.qml

@@ -0,0 +1,110 @@
+pragma Singleton
+pragma ComponentBehavior: Bound
+
+import QtQuick
+import Quickshell
+import Quickshell.Io
+
+Singleton {
+    id: root
+
+    property int defaultDebounceMs: 50
+    property int defaultTimeoutMs: 10000
+    property var _procDebouncers: ({})
+
+    function runCommand(id, command, callback, debounceMs, timeoutMs) {
+        const wait = (typeof debounceMs === "number" && debounceMs >= 0) ? debounceMs : defaultDebounceMs
+        const timeout = (typeof timeoutMs === "number" && timeoutMs > 0) ? timeoutMs : defaultTimeoutMs
+        let procId = id ? id : Math.random()
+        const isRandomId = !id
+
+        if (!_procDebouncers[procId]) {
+            const t = Qt.createQmlObject('import QtQuick; Timer { repeat: false }', root)
+            t.triggered.connect(function() { _launchProc(procId, isRandomId) })
+            _procDebouncers[procId] = { timer: t, command: command, callback: callback, waitMs: wait, timeoutMs: timeout, isRandomId: isRandomId }
+        } else {
+            _procDebouncers[procId].command = command
+            _procDebouncers[procId].callback = callback
+            _procDebouncers[procId].waitMs = wait
+            _procDebouncers[procId].timeoutMs = timeout
+        }
+
+        const entry = _procDebouncers[procId]
+        entry.timer.interval = entry.waitMs
+        entry.timer.restart()
+    }
+
+    function _launchProc(id, isRandomId) {
+        const entry = _procDebouncers[id]
+        if (!entry) return
+
+        const proc = Qt.createQmlObject('import Quickshell.Io; Process { running: false }', root)
+        const out = Qt.createQmlObject('import Quickshell.Io; StdioCollector {}', proc)
+        const err = Qt.createQmlObject('import Quickshell.Io; StdioCollector {}', proc)
+        const timeoutTimer = Qt.createQmlObject('import QtQuick; Timer { repeat: false }', root)
+
+        proc.stdout = out
+        proc.stderr = err
+        proc.command = entry.command
+
+        let capturedOut = ""
+        let capturedErr = ""
+        let exitSeen = false
+        let exitCodeValue = -1
+        let outSeen = false
+        let errSeen = false
+        let timedOut = false
+
+        timeoutTimer.interval = entry.timeoutMs
+        timeoutTimer.triggered.connect(function() {
+            if (!exitSeen) {
+                timedOut = true
+                proc.running = false
+                exitSeen = true
+                exitCodeValue = 124
+                maybeComplete()
+            }
+        })
+
+        out.streamFinished.connect(function() {
+            capturedOut = out.text || ""
+            outSeen = true
+            maybeComplete()
+        })
+
+        err.streamFinished.connect(function() {
+            capturedErr = err.text || ""
+            errSeen = true
+            maybeComplete()
+        })
+
+        proc.exited.connect(function(code) {
+            timeoutTimer.stop()
+            exitSeen = true
+            exitCodeValue = code
+            maybeComplete()
+        })
+
+        function maybeComplete() {
+            if (!exitSeen || !outSeen || !errSeen) return
+            timeoutTimer.stop()
+            if (typeof entry.callback === "function") {
+                try { entry.callback(capturedOut, exitCodeValue) } catch (e) { console.warn("runCommand callback error:", e) }
+            }
+            try { proc.destroy() } catch (_) {}
+            try { timeoutTimer.destroy() } catch (_) {}
+
+            if (isRandomId || entry.isRandomId) {
+                Qt.callLater(function() {
+                    if (_procDebouncers[id]) {
+                        try { _procDebouncers[id].timer.destroy() } catch (_) {}
+                        delete _procDebouncers[id]
+                    }
+                })
+            }
+        }
+
+        proc.running = true
+        timeoutTimer.start()
+    }
+}