diff --git a/config/astal/components/QuickActions/modules/Bluetooth/Bluetooth.tsx b/config/astal/components/QuickActions/modules/Bluetooth/Bluetooth.tsx index 2ee82aa..00f44ff 100644 --- a/config/astal/components/QuickActions/modules/Bluetooth/Bluetooth.tsx +++ b/config/astal/components/QuickActions/modules/Bluetooth/Bluetooth.tsx @@ -1,4 +1,4 @@ -import { bind, readFile, Variable, writeFile } from "astal"; +import { bind, readFile, writeFile } from "astal"; import { Gtk } from "astal/gtk4"; import AstalBluetooth from "gi://AstalBluetooth"; import BTDevice from "./Device"; @@ -74,7 +74,7 @@ const openBTPicker = () => { }; const BluetoothPickerList = () => { - let btEnableState = readFile("./btconf") === "true" ? true : false; + let btEnableState = readFile(`${DATADIR}./btconf`) === "true" ? true : false; bt.adapter.set_powered(btEnableState); const updateState = () => { diff --git a/config/astal/components/bar/modules/Hyprland.tsx b/config/astal/components/bar/modules/Hyprland.tsx index d540b5e..7755d63 100644 --- a/config/astal/components/bar/modules/Hyprland.tsx +++ b/config/astal/components/bar/modules/Hyprland.tsx @@ -3,6 +3,7 @@ import { bind, GObject } from "astal"; import AstalHyprland from "gi://AstalHyprland"; import { Gtk } from "astal/gtk4"; +const hypr = AstalHyprland.get_default(); const SYNC = GObject.BindingFlags.SYNC_CREATE; const SysTray = () => { @@ -48,8 +49,6 @@ const SysTray = () => { }; const Workspace = () => { - const hypr = AstalHyprland.get_default(); - return ( {bind(hypr, "workspaces").as(wss => @@ -61,9 +60,9 @@ const Workspace = () => { cssClasses={bind(hypr, "focusedWorkspace").as(fw => ws === fw ? [ - "focused-workspace-button", - "workspace-button", - ] + "focused-workspace-button", + "workspace-button", + ] : ["workspace-button"], )} onButtonPressed={() => ws.focus()} @@ -80,88 +79,13 @@ const Workspace = () => { * displaying all available clients */ const ActiveWindow = () => { - const hypr = AstalHyprland.get_default(); const focused = bind(hypr, "focusedClient"); const WindowPopover = (): Gtk.Popover => { // Set up boxes + Popover - const clients = new Map(); const popover = new Gtk.Popover(); - const popoverBox = new Gtk.Box({ - orientation: Gtk.Orientation.VERTICAL, - }); - const widgetTitle = new Gtk.Label({ - cssClasses: ["title-2"], - label: "Available Windows", - }); - - popoverBox.append(widgetTitle); - - const seaparator = new Gtk.Separator({ - marginTop: 5, - marginBottom: 10, - }); - - popoverBox.append(seaparator); - - const addClient = (client: AstalHyprland.Client) => { - const clientBox = new Gtk.Box(); - - // Workspace description - const descWS = new Gtk.Label({ label: "(WS " }); - - // Workpsace information - const workspace = new Gtk.Label(); - client.workspace.bind_property("name", workspace, "label", SYNC); - - const windowClassDesc = new Gtk.Label({ label: ") [" }); - - const windowClass = new Gtk.Label(); - windowClass.label = client.get_initial_class(); - - const titleDesc = new Gtk.Label({ label: "] " }); - titleDesc.set_margin_end(2); - - const title = new Gtk.Label(); - client.bind_property("title", title, "label", SYNC); - - clientBox.append(descWS); - clientBox.append(workspace); - clientBox.append(windowClassDesc); - clientBox.append(windowClass); - clientBox.append(titleDesc); - clientBox.append(title); - - const button = new Gtk.Button(); - button.connect( 'clicked', () => { - client.workspace.focus(); - } ); - button.set_child(clientBox); - - popoverBox.append(button); - - clients.set(client.get_address(), button); - }; - - // Populate with already added clients - const c = hypr.get_clients(); - for (let index = 0; index < c.length; index++) { - addClient(c[index]); - } - - hypr.connect("client-added", (_, client) => { - addClient(client); - }); - - hypr.connect("client-removed", (_, client) => { - const c = clients.get(client); - if (c) { - popoverBox.remove(c); - c.run_dispose(); - clients.delete(client); - } - }); + const popoverBox = WindowPopoverBox(); popover.set_child(popoverBox); return popover; @@ -177,19 +101,37 @@ const ActiveWindow = () => { + child={ + focused.as( + client => + client && ( + + ); }; +const WindowPopoverBox = () => { + return + + + + {bind(hypr, 'clients').as(clients => { + return clients.map(client => { + return + + + + + }) + })} + + +} + export default { Workspace, ActiveWindow, diff --git a/config/astal/btconf b/config/astal/config/btconf similarity index 100% rename from config/astal/btconf rename to config/astal/config/btconf diff --git a/config/astal/env.d.ts b/config/astal/env.d.ts index 467c0a4..7808a73 100644 --- a/config/astal/env.d.ts +++ b/config/astal/env.d.ts @@ -1,4 +1,5 @@ declare const SRC: string +declare const DATADIR: string declare module "inline:*" { const content: string diff --git a/config/astal/meson.build b/config/astal/meson.build new file mode 100644 index 0000000..5d0254e --- /dev/null +++ b/config/astal/meson.build @@ -0,0 +1,27 @@ +pkgdatadir = get_option('prefix') / get_option('datadir') / meson.project_name() +main = meson.project_name() + '.wrapped' + +custom_target( + command: [ + find_program('ags'), + 'bundle', + '--root', meson.project_source_root(), + meson.project_source_root() / 'app.ts', + main, + ], + output: main, + input: files('app.ts'), + install: true, + install_dir: pkgdatadir, +) + +configure_file( + input: files('wrapper.sh'), + output: meson.project_name(), + configuration: { + 'MAIN_PROGRAM': pkgdatadir / main, + 'LAYER_SHELL_LIBDIR': dependency('gtk4-layer-shell-0').get_variable('libdir'), + }, + install: true, + install_dir: get_option('prefix') / get_option('bindir'), +) diff --git a/config/astal/runner b/config/astal/runner new file mode 100755 index 0000000..dd2625d --- /dev/null +++ b/config/astal/runner @@ -0,0 +1,2789 @@ +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __typeError = (msg) => { + throw TypeError(msg); +}; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __decorateClass = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if (decorator = decorators[i]) + result = (kind ? decorator(target, key, result) : decorator(result)) || result; + if (kind && result) __defProp(target, key, result); + return result; +}; +var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); +var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg); +var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)); +var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value); + +// ../../../../../../../usr/share/astal/gjs/gtk4/index.ts +import Astal6 from "gi://Astal?version=4.0"; +import Gtk4 from "gi://Gtk?version=4.0"; +import Gdk2 from "gi://Gdk?version=4.0"; + +// ../../../../../../../usr/share/astal/gjs/variable.ts +import Astal3 from "gi://AstalIO"; + +// ../../../../../../../usr/share/astal/gjs/binding.ts +var snakeify = (str) => str.replace(/([a-z])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase(); +var kebabify = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").replaceAll("_", "-").toLowerCase(); +var Binding = class _Binding { + transformFn = (v) => v; + #emitter; + #prop; + static bind(emitter, prop) { + return new _Binding(emitter, prop); + } + constructor(emitter, prop) { + this.#emitter = emitter; + this.#prop = prop && kebabify(prop); + } + toString() { + return `Binding<${this.#emitter}${this.#prop ? `, "${this.#prop}"` : ""}>`; + } + as(fn) { + const bind2 = new _Binding(this.#emitter, this.#prop); + bind2.transformFn = (v) => fn(this.transformFn(v)); + return bind2; + } + get() { + if (typeof this.#emitter.get === "function") + return this.transformFn(this.#emitter.get()); + if (typeof this.#prop === "string") { + const getter = `get_${snakeify(this.#prop)}`; + if (typeof this.#emitter[getter] === "function") + return this.transformFn(this.#emitter[getter]()); + return this.transformFn(this.#emitter[this.#prop]); + } + throw Error("can not get value of binding"); + } + subscribe(callback) { + if (typeof this.#emitter.subscribe === "function") { + return this.#emitter.subscribe(() => { + callback(this.get()); + }); + } else if (typeof this.#emitter.connect === "function") { + const signal = `notify::${this.#prop}`; + const id = this.#emitter.connect(signal, () => { + callback(this.get()); + }); + return () => { + this.#emitter.disconnect(id); + }; + } + throw Error(`${this.#emitter} is not bindable`); + } +}; +var { bind } = Binding; +var binding_default = Binding; + +// ../../../../../../../usr/share/astal/gjs/time.ts +import Astal from "gi://AstalIO"; +var Time = Astal.Time; +function interval(interval2, callback) { + return Astal.Time.interval(interval2, () => void callback?.()); +} + +// ../../../../../../../usr/share/astal/gjs/process.ts +import Astal2 from "gi://AstalIO"; +var Process = Astal2.Process; +function subprocess(argsOrCmd, onOut = print, onErr = printerr) { + const args = Array.isArray(argsOrCmd) || typeof argsOrCmd === "string"; + const { cmd, err, out } = { + cmd: args ? argsOrCmd : argsOrCmd.cmd, + err: args ? onErr : argsOrCmd.err || onErr, + out: args ? onOut : argsOrCmd.out || onOut + }; + const proc = Array.isArray(cmd) ? Astal2.Process.subprocessv(cmd) : Astal2.Process.subprocess(cmd); + proc.connect("stdout", (_, stdout) => out(stdout)); + proc.connect("stderr", (_, stderr) => err(stderr)); + return proc; +} +function exec(cmd) { + return Array.isArray(cmd) ? Astal2.Process.execv(cmd) : Astal2.Process.exec(cmd); +} +function execAsync(cmd) { + return new Promise((resolve, reject) => { + if (Array.isArray(cmd)) { + Astal2.Process.exec_asyncv(cmd, (_, res) => { + try { + resolve(Astal2.Process.exec_asyncv_finish(res)); + } catch (error) { + reject(error); + } + }); + } else { + Astal2.Process.exec_async(cmd, (_, res) => { + try { + resolve(Astal2.Process.exec_finish(res)); + } catch (error) { + reject(error); + } + }); + } + }); +} + +// ../../../../../../../usr/share/astal/gjs/variable.ts +var VariableWrapper = class extends Function { + variable; + errHandler = console.error; + _value; + _poll; + _watch; + pollInterval = 1e3; + pollExec; + pollTransform; + pollFn; + watchTransform; + watchExec; + constructor(init) { + super(); + this._value = init; + this.variable = new Astal3.VariableBase(); + this.variable.connect("dropped", () => { + this.stopWatch(); + this.stopPoll(); + }); + this.variable.connect("error", (_, err) => this.errHandler?.(err)); + return new Proxy(this, { + apply: (target, _, args) => target._call(args[0]) + }); + } + _call(transform) { + const b = binding_default.bind(this); + return transform ? b.as(transform) : b; + } + toString() { + return String(`Variable<${this.get()}>`); + } + get() { + return this._value; + } + set(value) { + if (value !== this._value) { + this._value = value; + this.variable.emit("changed"); + } + } + startPoll() { + if (this._poll) + return; + if (this.pollFn) { + this._poll = interval(this.pollInterval, () => { + const v = this.pollFn(this.get()); + if (v instanceof Promise) { + v.then((v2) => this.set(v2)).catch((err) => this.variable.emit("error", err)); + } else { + this.set(v); + } + }); + } else if (this.pollExec) { + this._poll = interval(this.pollInterval, () => { + execAsync(this.pollExec).then((v) => this.set(this.pollTransform(v, this.get()))).catch((err) => this.variable.emit("error", err)); + }); + } + } + startWatch() { + if (this._watch) + return; + this._watch = subprocess({ + cmd: this.watchExec, + out: (out) => this.set(this.watchTransform(out, this.get())), + err: (err) => this.variable.emit("error", err) + }); + } + stopPoll() { + this._poll?.cancel(); + delete this._poll; + } + stopWatch() { + this._watch?.kill(); + delete this._watch; + } + isPolling() { + return !!this._poll; + } + isWatching() { + return !!this._watch; + } + drop() { + this.variable.emit("dropped"); + } + onDropped(callback) { + this.variable.connect("dropped", callback); + return this; + } + onError(callback) { + delete this.errHandler; + this.variable.connect("error", (_, err) => callback(err)); + return this; + } + subscribe(callback) { + const id = this.variable.connect("changed", () => { + callback(this.get()); + }); + return () => this.variable.disconnect(id); + } + poll(interval2, exec2, transform = (out) => out) { + this.stopPoll(); + this.pollInterval = interval2; + this.pollTransform = transform; + if (typeof exec2 === "function") { + this.pollFn = exec2; + delete this.pollExec; + } else { + this.pollExec = exec2; + delete this.pollFn; + } + this.startPoll(); + return this; + } + watch(exec2, transform = (out) => out) { + this.stopWatch(); + this.watchExec = exec2; + this.watchTransform = transform; + this.startWatch(); + return this; + } + observe(objs, sigOrFn, callback) { + const f = typeof sigOrFn === "function" ? sigOrFn : callback ?? (() => this.get()); + const set = (obj, ...args) => this.set(f(obj, ...args)); + if (Array.isArray(objs)) { + for (const obj of objs) { + const [o, s] = obj; + const id = o.connect(s, set); + this.onDropped(() => o.disconnect(id)); + } + } else { + if (typeof sigOrFn === "string") { + const id = objs.connect(sigOrFn, set); + this.onDropped(() => objs.disconnect(id)); + } + } + return this; + } + static derive(deps, fn = (...args) => args) { + const update = () => fn(...deps.map((d) => d.get())); + const derived = new Variable(update()); + const unsubs = deps.map((dep) => dep.subscribe(() => derived.set(update()))); + derived.onDropped(() => unsubs.map((unsub) => unsub())); + return derived; + } +}; +var Variable = new Proxy(VariableWrapper, { + apply: (_t, _a, args) => new VariableWrapper(args[0]) +}); +var { derive } = Variable; +var variable_default = Variable; + +// ../../../../../../../usr/share/astal/gjs/_astal.ts +var noImplicitDestroy = Symbol("no no implicit destroy"); +var setChildren = Symbol("children setter method"); +function mergeBindings(array) { + function getValues(...args) { + let i = 0; + return array.map( + (value) => value instanceof binding_default ? args[i++] : value + ); + } + const bindings = array.filter((i) => i instanceof binding_default); + if (bindings.length === 0) + return array; + if (bindings.length === 1) + return bindings[0].as(getValues); + return variable_default.derive(bindings, getValues)(); +} +function setProp(obj, prop, value) { + try { + const setter = `set_${snakeify(prop)}`; + if (typeof obj[setter] === "function") + return obj[setter](value); + return obj[prop] = value; + } catch (error) { + console.error(`could not set property "${prop}" on ${obj}:`, error); + } +} +function construct(widget, config) { + let { setup, child, children = [], ...props } = config; + if (children instanceof binding_default) { + children = [children]; + } + if (child) { + children.unshift(child); + } + for (const [key, value] of Object.entries(props)) { + if (value === void 0) { + delete props[key]; + } + } + const bindings = Object.keys(props).reduce((acc, prop) => { + if (props[prop] instanceof binding_default) { + const binding = props[prop]; + delete props[prop]; + return [...acc, [prop, binding]]; + } + return acc; + }, []); + const onHandlers = Object.keys(props).reduce((acc, key) => { + if (key.startsWith("on")) { + const sig = kebabify(key).split("-").slice(1).join("-"); + const handler = props[key]; + delete props[key]; + return [...acc, [sig, handler]]; + } + return acc; + }, []); + const mergedChildren = mergeBindings(children.flat(Infinity)); + if (mergedChildren instanceof binding_default) { + widget[setChildren](mergedChildren.get()); + widget.connect("destroy", mergedChildren.subscribe((v) => { + widget[setChildren](v); + })); + } else { + if (mergedChildren.length > 0) { + widget[setChildren](mergedChildren); + } + } + for (const [signal, callback] of onHandlers) { + const sig = signal.startsWith("notify") ? signal.replace("-", "::") : signal; + if (typeof callback === "function") { + widget.connect(sig, callback); + } else { + widget.connect(sig, () => execAsync(callback).then(print).catch(console.error)); + } + } + for (const [prop, binding] of bindings) { + if (prop === "child" || prop === "children") { + widget.connect("destroy", binding.subscribe((v) => { + widget[setChildren](v); + })); + } + widget.connect("destroy", binding.subscribe((v) => { + setProp(widget, prop, v); + })); + setProp(widget, prop, binding.get()); + } + for (const [key, value] of Object.entries(props)) { + if (value === void 0) { + delete props[key]; + } + } + Object.assign(widget, props); + setup?.(widget); + return widget; +} +function isArrowFunction(func) { + return !Object.hasOwn(func, "prototype"); +} +function jsx(ctors2, ctor, { children, ...props }) { + children ??= []; + if (!Array.isArray(children)) + children = [children]; + children = children.filter(Boolean); + if (children.length === 1) + props.child = children[0]; + else if (children.length > 1) + props.children = children; + if (typeof ctor === "string") { + if (isArrowFunction(ctors2[ctor])) + return ctors2[ctor](props); + return new ctors2[ctor](props); + } + if (isArrowFunction(ctor)) + return ctor(props); + return new ctor(props); +} + +// ../../../../../../../usr/share/astal/gjs/gtk4/astalify.ts +import Gtk from "gi://Gtk?version=4.0"; +import Gdk from "gi://Gdk?version=4.0"; +var type = Symbol("child type"); +var dummyBulder = new Gtk.Builder(); +function _getChildren(widget) { + if ("get_child" in widget && typeof widget.get_child == "function") { + return widget.get_child() ? [widget.get_child()] : []; + } + const children = []; + let ch = widget.get_first_child(); + while (ch !== null) { + children.push(ch); + ch = ch.get_next_sibling(); + } + return children; +} +function _setChildren(widget, children) { + children = children.flat(Infinity).map((ch) => ch instanceof Gtk.Widget ? ch : new Gtk.Label({ visible: true, label: String(ch) })); + for (const child of children) { + widget.vfunc_add_child( + dummyBulder, + child, + type in child ? child[type] : null + ); + } +} +function astalify(cls, config = {}) { + Object.assign(cls.prototype, { + [setChildren](children) { + const w = this; + for (const child of config.getChildren?.(w) || _getChildren(w)) { + if (child instanceof Gtk.Widget) { + child.unparent(); + if (!children.includes(child) && noImplicitDestroy in this) + child.run_dispose(); + } + } + if (config.setChildren) { + config.setChildren(w, children); + } else { + _setChildren(w, children); + } + } + }); + return { + [cls.name]: (props = {}, ...children) => { + const widget = new cls("cssName" in props ? { cssName: props.cssName } : {}); + if ("cssName" in props) { + delete props.cssName; + } + if (props.noImplicitDestroy) { + Object.assign(widget, { [noImplicitDestroy]: true }); + delete props.noImplicitDestroy; + } + if (props.type) { + Object.assign(widget, { [type]: props.type }); + delete props.type; + } + if (children.length > 0) { + Object.assign(props, { children }); + } + return construct(widget, setupControllers(widget, props)); + } + }[cls.name]; +} +function setupControllers(widget, { + onFocusEnter, + onFocusLeave, + onKeyPressed, + onKeyReleased, + onKeyModifier, + onLegacy, + onButtonPressed, + onButtonReleased, + onHoverEnter, + onHoverLeave, + onMotion, + onScroll, + onScrollDecelerate, + ...props +}) { + if (onFocusEnter || onFocusLeave) { + const focus = new Gtk.EventControllerFocus(); + widget.add_controller(focus); + if (onFocusEnter) + focus.connect("enter", () => onFocusEnter(widget)); + if (onFocusLeave) + focus.connect("leave", () => onFocusLeave(widget)); + } + if (onKeyPressed || onKeyReleased || onKeyModifier) { + const key = new Gtk.EventControllerKey(); + widget.add_controller(key); + if (onKeyPressed) + key.connect("key-pressed", (_, val, code, state) => onKeyPressed(widget, val, code, state)); + if (onKeyReleased) + key.connect("key-released", (_, val, code, state) => onKeyReleased(widget, val, code, state)); + if (onKeyModifier) + key.connect("modifiers", (_, state) => onKeyModifier(widget, state)); + } + if (onLegacy || onButtonPressed || onButtonReleased) { + const legacy = new Gtk.EventControllerLegacy(); + widget.add_controller(legacy); + legacy.connect("event", (_, event) => { + if (event.get_event_type() === Gdk.EventType.BUTTON_PRESS) { + onButtonPressed?.(widget, event); + } + if (event.get_event_type() === Gdk.EventType.BUTTON_RELEASE) { + onButtonReleased?.(widget, event); + } + onLegacy?.(widget, event); + }); + } + if (onMotion || onHoverEnter || onHoverLeave) { + const hover = new Gtk.EventControllerMotion(); + widget.add_controller(hover); + if (onHoverEnter) + hover.connect("enter", (_, x, y) => onHoverEnter(widget, x, y)); + if (onHoverLeave) + hover.connect("leave", () => onHoverLeave(widget)); + if (onMotion) + hover.connect("motion", (_, x, y) => onMotion(widget, x, y)); + } + if (onScroll || onScrollDecelerate) { + const scroll = new Gtk.EventControllerScroll(); + scroll.flags = Gtk.EventControllerScrollFlags.BOTH_AXES | Gtk.EventControllerScrollFlags.KINETIC; + widget.add_controller(scroll); + if (onScroll) + scroll.connect("scroll", (_, x, y) => onScroll(widget, x, y)); + if (onScrollDecelerate) + scroll.connect("decelerate", (_, x, y) => onScrollDecelerate(widget, x, y)); + } + return props; +} + +// ../../../../../../../usr/share/astal/gjs/gtk4/app.ts +import GLib from "gi://GLib?version=2.0"; +import Gtk2 from "gi://Gtk?version=4.0"; +import Astal4 from "gi://Astal?version=4.0"; + +// ../../../../../../../usr/share/astal/gjs/overrides.ts +var snakeify2 = (str) => str.replace(/([a-z])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase(); +async function suppress(mod, patch2) { + return mod.then((m) => patch2(m.default)).catch(() => void 0); +} +function patch(proto, prop) { + Object.defineProperty(proto, prop, { + get() { + return this[`get_${snakeify2(prop)}`](); + } + }); +} +await suppress(import("gi://AstalApps"), ({ Apps, Application }) => { + patch(Apps.prototype, "list"); + patch(Application.prototype, "keywords"); + patch(Application.prototype, "categories"); +}); +await suppress(import("gi://AstalBattery"), ({ UPower }) => { + patch(UPower.prototype, "devices"); +}); +await suppress(import("gi://AstalBluetooth"), ({ Adapter, Bluetooth, Device }) => { + patch(Adapter.prototype, "uuids"); + patch(Bluetooth.prototype, "adapters"); + patch(Bluetooth.prototype, "devices"); + patch(Device.prototype, "uuids"); +}); +await suppress(import("gi://AstalHyprland"), ({ Hyprland, Monitor, Workspace: Workspace2 }) => { + patch(Hyprland.prototype, "binds"); + patch(Hyprland.prototype, "monitors"); + patch(Hyprland.prototype, "workspaces"); + patch(Hyprland.prototype, "clients"); + patch(Monitor.prototype, "availableModes"); + patch(Monitor.prototype, "available_modes"); + patch(Workspace2.prototype, "clients"); +}); +await suppress(import("gi://AstalMpris"), ({ Mpris, Player }) => { + patch(Mpris.prototype, "players"); + patch(Player.prototype, "supported_uri_schemes"); + patch(Player.prototype, "supportedUriSchemes"); + patch(Player.prototype, "supported_mime_types"); + patch(Player.prototype, "supportedMimeTypes"); + patch(Player.prototype, "comments"); +}); +await suppress(import("gi://AstalNetwork"), ({ Wifi }) => { + patch(Wifi.prototype, "access_points"); + patch(Wifi.prototype, "accessPoints"); +}); +await suppress(import("gi://AstalNotifd"), ({ Notifd, Notification }) => { + patch(Notifd.prototype, "notifications"); + patch(Notification.prototype, "actions"); +}); +await suppress(import("gi://AstalPowerProfiles"), ({ PowerProfiles }) => { + patch(PowerProfiles.prototype, "actions"); +}); +await suppress(import("gi://AstalWp"), ({ Wp, Audio: Audio2, Video }) => { + patch(Wp.prototype, "endpoints"); + patch(Wp.prototype, "devices"); + patch(Audio2.prototype, "streams"); + patch(Audio2.prototype, "recorders"); + patch(Audio2.prototype, "microphones"); + patch(Audio2.prototype, "speakers"); + patch(Audio2.prototype, "devices"); + patch(Video.prototype, "streams"); + patch(Video.prototype, "recorders"); + patch(Video.prototype, "sinks"); + patch(Video.prototype, "sources"); + patch(Video.prototype, "devices"); +}); + +// ../../../../../../../usr/share/astal/gjs/_app.ts +import { setConsoleLogDomain } from "console"; +import { exit, programArgs } from "system"; +import IO from "gi://AstalIO"; +import GObject from "gi://GObject"; +function mkApp(App) { + return new class AstalJS extends App { + static { + GObject.registerClass({ GTypeName: "AstalJS" }, this); + } + eval(body) { + return new Promise((res, rej) => { + try { + const fn = Function(`return (async function() { + ${body.includes(";") ? body : `return ${body};`} + })`); + fn()().then(res).catch(rej); + } catch (error) { + rej(error); + } + }); + } + requestHandler; + vfunc_request(msg, conn) { + if (typeof this.requestHandler === "function") { + this.requestHandler(msg, (response) => { + IO.write_sock( + conn, + String(response), + (_, res) => IO.write_sock_finish(res) + ); + }); + } else { + super.vfunc_request(msg, conn); + } + } + apply_css(style, reset = false) { + super.apply_css(style, reset); + } + quit(code) { + super.quit(); + exit(code ?? 0); + } + start({ requestHandler, css, hold, main, client, icons, ...cfg } = {}) { + const app = this; + client ??= () => { + print(`Astal instance "${app.instanceName}" already running`); + exit(1); + }; + Object.assign(this, cfg); + setConsoleLogDomain(app.instanceName); + this.requestHandler = requestHandler; + app.connect("activate", () => { + main?.(...programArgs); + }); + try { + app.acquire_socket(); + } catch (error) { + return client((msg) => IO.send_request(app.instanceName, msg), ...programArgs); + } + if (css) + this.apply_css(css, false); + if (icons) + app.add_icons(icons); + hold ??= true; + if (hold) + app.hold(); + app.runAsync([]); + } + }(); +} + +// ../../../../../../../usr/share/astal/gjs/gtk4/app.ts +Gtk2.init(); +GLib.unsetenv("LD_PRELOAD"); +await import("gi://Adw?version=1").then(({ default: Adw }) => Adw.init()).catch(() => void 0); +var app_default = mkApp(Astal4.Application); + +// ../../../../../../../usr/share/astal/gjs/gtk4/widget.ts +import Astal5 from "gi://Astal?version=4.0"; +import Gtk3 from "gi://Gtk?version=4.0"; +function filter(children) { + return children.flat(Infinity).map((ch) => ch instanceof Gtk3.Widget ? ch : new Gtk3.Label({ visible: true, label: String(ch) })); +} +Object.defineProperty(Astal5.Box.prototype, "children", { + get() { + return this.get_children(); + }, + set(v) { + this.set_children(v); + } +}); +var Box = astalify(Astal5.Box, { + getChildren(self) { + return self.get_children(); + }, + setChildren(self, children) { + return self.set_children(filter(children)); + } +}); +var Button = astalify(Gtk3.Button); +var CenterBox = astalify(Gtk3.CenterBox, { + getChildren(box) { + return [box.startWidget, box.centerWidget, box.endWidget]; + }, + setChildren(box, children) { + const ch = filter(children); + box.startWidget = ch[0] || new Gtk3.Box(); + box.centerWidget = ch[1] || new Gtk3.Box(); + box.endWidget = ch[2] || new Gtk3.Box(); + } +}); +var Entry = astalify(Gtk3.Entry, { + getChildren() { + return []; + } +}); +var Image = astalify(Gtk3.Image, { + getChildren() { + return []; + } +}); +var Label = astalify(Gtk3.Label, { + getChildren() { + return []; + }, + setChildren(self, children) { + self.label = String(children); + } +}); +var LevelBar = astalify(Gtk3.LevelBar, { + getChildren() { + return []; + } +}); +var Overlay = astalify(Gtk3.Overlay, { + getChildren(self) { + const children = []; + let ch = self.get_first_child(); + while (ch !== null) { + children.push(ch); + ch = ch.get_next_sibling(); + } + return children.filter((ch2) => ch2 !== self.child); + }, + setChildren(self, children) { + for (const child of filter(children)) { + const types = type in child ? child[type].split(/\s+/) : []; + if (types.includes("overlay")) { + self.add_overlay(child); + } else { + self.set_child(child); + } + self.set_measure_overlay(child, types.includes("measure")); + self.set_clip_overlay(child, types.includes("clip")); + } + } +}); +var Revealer = astalify(Gtk3.Revealer); +var Slider = astalify(Astal5.Slider, { + getChildren() { + return []; + } +}); +var Stack = astalify(Gtk3.Stack, { + setChildren(self, children) { + for (const child of filter(children)) { + if (child.name != "" && child.name != null) { + self.add_named(child, child.name); + } else { + self.add_child(child); + } + } + } +}); +var Switch = astalify(Gtk3.Switch, { + getChildren() { + return []; + } +}); +var Window = astalify(Astal5.Window); +var MenuButton = astalify(Gtk3.MenuButton, { + getChildren(self) { + return [self.popover, self.child]; + }, + setChildren(self, children) { + for (const child of filter(children)) { + if (child instanceof Gtk3.Popover) { + self.set_popover(child); + } else { + self.set_child(child); + } + } + } +}); +var Popover = astalify(Gtk3.Popover); + +// sass:/home/janis/projects/active/dotfiles/config/astal/style.scss +var style_default = `/* @use './components/notifications/notifications.scss'; */ +window.Bar { + font-family: "Comfortaa, sans-serif"; + background: transparent; + color: #E6E6E6; + font-weight: bold; + /* >centerbox { */ + /* background: $bg-color; */ + /* border-radius: 10px; */ + /* margin: 8px; */ + /* } */ +} +window.Bar .bar-button { + border-radius: 20px; + margin: 2px; + padding-left: 10px; + padding-right: 10px; + background-color: #141414; +} +window.Bar .bar-button button { + background-color: #141414; +} +window.Bar .quick-action-button { + border-radius: 20px; + margin: 2px; + padding-left: 10px; + padding-right: 10px; + background-color: #141414; +} +window.Bar button.workspace-button { + border-radius: 20px; + margin: 1px; +} +window.Bar button.workspace-button.focused-workspace-button { + color: #5F50A6; +} +window.Bar .tray-item { + margin: 0; + padding: 0; +} +window.Bar .tray-item button { + margin: 2px; + box-shadow: none; +} +window.Bar .time { + min-width: 11rem; + padding: 3px; +} +window.Bar .time button { + box-shadow: none; + padding: 0; +} + +box.players-box { + margin-top: 20px; +} + +box.player { + padding: 0.6rem; +} +box.player .cover-art { + min-width: 100px; + min-height: 100px; + border-radius: 9px; + margin-right: 0.6rem; + background-size: contain; + background-position: center; +} +box.player .title { + font-weight: bold; + font-size: 1.1em; +} +box.player scale { + padding: 0; + margin: 0.4rem 0; + border-radius: 20px; +} +box.player scale trough { + min-height: 8px; + border-radius: 20px; +} +box.player scale highlight { + background-color: @theme_fg_color; + border-radius: 20px; +} +box.player scale slider { + all: unset; + border-radius: 20px; +} +box.player centerbox.actions { + min-width: 220px; +} +box.player centerbox.actions button { + min-width: 0; + min-height: 0; + padding: 0.4rem; + margin: 0 0.2rem; +} + +.audio-box { + min-width: 320px; +} + +.quick-actions-wrapper { + min-width: 520px; +} + +box.quick-actions { + padding: 10px; +} + +popover * { + border-radius: 20px; +} + +button { + margin: 4px; +} + +.button-no-margin { + margin-top: 0; + margin-bottom: 0; +} + +.devices-list { + margin-bottom: 20px; +} + +button.toggle-button { + min-width: 220px; + border-radius: 50px; +} +button.toggle-button.toggle-on { + min-width: 190px; + margin-right: 0; + border-top-right-radius: 0; + border-bottom-right-radius: 0; + background-color: #B27BD1; +} + +button.actions-button { + margin-left: 0; + border-radius: 0; + background-color: #B27BD1; + border-top-right-radius: 50px; + border-bottom-right-radius: 50px; +} + +.avatar-icon { + border-radius: 100px; + min-height: 40px; + min-width: 40px; + margin-right: 10px; +} + +* { + font-size: 1rem; +} + +empty { + min-width: 0; + background-color: transparent; +} + +.title { + font-size: 1.5rem; + font-weight: bold; +} + +.title-2 { + font-size: 1.2rem; + font-weight: bold; +}`; + +// components/bar/modules/Hyprland.tsx +import AstalTray from "gi://AstalTray"; + +// ../../../../../../../usr/share/astal/gjs/index.ts +import { default as default3 } from "gi://AstalIO?version=0.1"; + +// ../../../../../../../usr/share/astal/gjs/file.ts +import Astal7 from "gi://AstalIO"; +import Gio from "gi://Gio?version=2.0"; +function readFile(path) { + return Astal7.read_file(path) || ""; +} +function readFileAsync(path) { + return new Promise((resolve, reject) => { + Astal7.read_file_async(path, (_, res) => { + try { + resolve(Astal7.read_file_finish(res) || ""); + } catch (error) { + reject(error); + } + }); + }); +} +function writeFile(path, content) { + Astal7.write_file(path, content); +} +function monitorFile(path, callback) { + return Astal7.monitor_file(path, (file, event) => { + callback(file, event); + }); +} + +// ../../../../../../../usr/share/astal/gjs/gobject.ts +import GObject2 from "gi://GObject"; +import { default as default2 } from "gi://GLib?version=2.0"; +var meta = Symbol("meta"); +var priv = Symbol("priv"); +var { ParamSpec, ParamFlags } = GObject2; +var kebabify2 = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").replaceAll("_", "-").toLowerCase(); +function register(options = {}) { + return function(cls) { + const t = options.Template; + if (typeof t === "string" && !t.startsWith("resource://") && !t.startsWith("file://")) { + options.Template = new TextEncoder().encode(t); + } + GObject2.registerClass({ + Signals: { ...cls[meta]?.Signals }, + Properties: { ...cls[meta]?.Properties }, + ...options + }, cls); + delete cls[meta]; + }; +} +function property(declaration = Object) { + return function(target, prop, desc) { + target.constructor[meta] ??= {}; + target.constructor[meta].Properties ??= {}; + const name = kebabify2(prop); + if (!desc) { + Object.defineProperty(target, prop, { + get() { + return this[priv]?.[prop] ?? defaultValue(declaration); + }, + set(v) { + if (v !== this[prop]) { + this[priv] ??= {}; + this[priv][prop] = v; + this.notify(name); + } + } + }); + Object.defineProperty(target, `set_${name.replace("-", "_")}`, { + value(v) { + this[prop] = v; + } + }); + Object.defineProperty(target, `get_${name.replace("-", "_")}`, { + value() { + return this[prop]; + } + }); + target.constructor[meta].Properties[kebabify2(prop)] = pspec(name, ParamFlags.READWRITE, declaration); + } else { + let flags = 0; + if (desc.get) flags |= ParamFlags.READABLE; + if (desc.set) flags |= ParamFlags.WRITABLE; + target.constructor[meta].Properties[kebabify2(prop)] = pspec(name, flags, declaration); + } + }; +} +function pspec(name, flags, declaration) { + if (declaration instanceof ParamSpec) + return declaration; + switch (declaration) { + case String: + return ParamSpec.string(name, "", "", flags, ""); + case Number: + return ParamSpec.double(name, "", "", flags, -Number.MAX_VALUE, Number.MAX_VALUE, 0); + case Boolean: + return ParamSpec.boolean(name, "", "", flags, false); + case Object: + return ParamSpec.jsobject(name, "", "", flags); + default: + return ParamSpec.object(name, "", "", flags, declaration.$gtype); + } +} +function defaultValue(declaration) { + if (declaration instanceof ParamSpec) + return declaration.get_default_value(); + switch (declaration) { + case String: + return ""; + case Number: + return 0; + case Boolean: + return false; + case Object: + default: + return null; + } +} + +// components/bar/modules/Hyprland.tsx +import AstalHyprland from "gi://AstalHyprland"; + +// ../../../../../../../usr/share/astal/gjs/gtk4/jsx-runtime.ts +function jsx2(ctor, props) { + return jsx(ctors, ctor, props); +} +var ctors = { + box: Box, + button: Button, + centerbox: CenterBox, + // circularprogress: Widget.CircularProgress, + // drawingarea: Widget.DrawingArea, + entry: Entry, + image: Image, + label: Label, + levelbar: LevelBar, + overlay: Overlay, + revealer: Revealer, + slider: Slider, + stack: Stack, + switch: Switch, + window: Window, + menubutton: MenuButton, + popover: Popover +}; +var jsxs = jsx2; + +// components/bar/modules/Hyprland.tsx +var hypr = AstalHyprland.get_default(); +var SYNC = GObject2.BindingFlags.SYNC_CREATE; +var SysTray = () => { + const trayBox = new Gtk4.Box({ cssClasses: ["bar-button"] }); + const tray = AstalTray.get_default(); + const trayItems = /* @__PURE__ */ new Map(); + const trayAddedHandler = tray.connect("item-added", (_, id) => { + const item = tray.get_item(id); + const popover = Gtk4.PopoverMenu.new_from_model(item.menu_model); + const icon = new Gtk4.Image(); + const button = new Gtk4.MenuButton({ + popover, + child: icon, + cssClasses: ["tray-item"] + }); + item.bind_property("gicon", icon, "gicon", SYNC); + popover.insert_action_group("dbusmenu", item.action_group); + item.connect("notify::action-group", () => { + popover.insert_action_group("dbusmenu", item.action_group); + }); + trayItems.set(id, button); + trayBox.append(button); + }); + const trayRemovedHandler = tray.connect("item-removed", (_, id) => { + const button = trayItems.get(id); + if (button) { + trayBox.remove(button); + button.run_dispose(); + trayItems.delete(id); + } + }); + trayBox.connect("destroy", () => { + tray.disconnect(trayAddedHandler); + tray.disconnect(trayRemovedHandler); + }); + return trayBox; +}; +var Workspace = () => { + return /* @__PURE__ */ jsx2("box", { children: bind(hypr, "workspaces").as( + (wss) => wss.filter((ws) => !(ws.id >= -99 && ws.id <= -2)).sort((a, b) => a.id - b.id).map((ws) => /* @__PURE__ */ jsx2( + "button", + { + cssClasses: bind(hypr, "focusedWorkspace").as( + (fw) => ws === fw ? [ + "focused-workspace-button", + "workspace-button" + ] : ["workspace-button"] + ), + onButtonPressed: () => ws.focus(), + child: /* @__PURE__ */ jsx2("label", { label: String(ws.id) }) + } + )) + ) }); +}; +var ActiveWindow = () => { + const focused = bind(hypr, "focusedClient"); + const WindowPopover = () => { + const popover = new Gtk4.Popover(); + const popoverBox = WindowPopoverBox(); + popover.set_child(popoverBox); + return popover; + }; + const windowPopover = WindowPopover(); + return /* @__PURE__ */ jsxs("box", { visible: focused.as(Boolean), children: [ + /* @__PURE__ */ jsx2( + "button", + { + onClicked: () => windowPopover.popup(), + cssClasses: ["bar-button"], + child: focused.as( + (client) => client && /* @__PURE__ */ jsx2("label", { label: bind(client, "title").as(String) }) + ) + } + ), + windowPopover + ] }); +}; +var WindowPopoverBox = () => { + return /* @__PURE__ */ jsxs("box", { vertical: true, children: [ + /* @__PURE__ */ jsx2("label", { label: "Available Windows", cssClasses: ["title-2"] }), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginTop: 5, marginBottom: 5 }), + /* @__PURE__ */ jsx2("box", { vertical: true, children: bind(hypr, "clients").as((clients) => { + return clients.map((client) => { + return /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2("label", { label: bind(client, "workspace").as((w) => `(WS ${w})`) }), + /* @__PURE__ */ jsx2("label", { label: bind(client, "initialClass").as((c) => `[${c}]`) }), + /* @__PURE__ */ jsx2("label", { label: bind(client, "title") }) + ] }); + }); + }) }) + ] }); +}; +var Hyprland_default = { + Workspace, + ActiveWindow, + SysTray +}; + +// components/bar/modules/Calendar.tsx +var Time2 = ({ format = "%a, %e.%m %H:%M:%S" }) => { + const time = Variable("").poll( + 1e3, + () => default2.DateTime.new_now_local().format(format) + ); + return /* @__PURE__ */ jsxs( + "menubutton", + { + cssClasses: ["time", "bar-button"], + hexpand: true, + halign: Gtk4.Align.CENTER, + children: [ + /* @__PURE__ */ jsx2("label", { onDestroy: () => time.drop(), label: time(), halign: Gtk4.Align.CENTER }), + /* @__PURE__ */ jsx2("popover", { children: /* @__PURE__ */ jsx2(Gtk4.Calendar, {}) }) + ] + } + ); +}; +var Calendar_default = { + Time: Time2 +}; + +// components/bar/modules/QuickView.tsx +import AstalBattery from "gi://AstalBattery"; +import AstalBluetooth2 from "gi://AstalBluetooth"; +import AstalNetwork3 from "gi://AstalNetwork"; +import AstalWp2 from "gi://AstalWp"; + +// util/brightness.ts +var get = (args) => Number(exec(`brightnessctl ${args}`)); +var screen = exec(`bash -c "ls -w1 /sys/class/backlight | head -1"`); +var kbd = exec(`bash -c "ls -w1 /sys/class/leds | head -1"`); +var _kbdMax, _kbd, _screenMax, _screen, _screenAvailable; +var Brightness = class extends GObject2.Object { + constructor() { + super(); + __privateAdd(this, _kbdMax, get(`--device ${kbd} max`)); + __privateAdd(this, _kbd, get(`--device ${kbd} get`)); + __privateAdd(this, _screenMax, get("max")); + __privateAdd(this, _screen, get("get") / (get("max") || 1)); + __privateAdd(this, _screenAvailable, false); + const screenPath = `/sys/class/backlight/${screen}/brightness`; + const kbdPath = `/sys/class/leds/${kbd}/brightness`; + monitorFile(screenPath, async (f) => { + const v = await readFileAsync(f); + __privateSet(this, _screen, Number(v) / __privateGet(this, _screenMax)); + this.notify("screen"); + }); + monitorFile(kbdPath, async (f) => { + const v = await readFileAsync(f); + __privateSet(this, _kbd, Number(v) / __privateGet(this, _kbdMax)); + this.notify("kbd"); + }); + try { + get("g -c backlight"); + } catch (_) { + __privateSet(this, _screenAvailable, false); + } + } + static get_default() { + if (!this.instance) + this.instance = new Brightness(); + return this.instance; + } + get screenAvailable() { + return __privateGet(this, _screenAvailable); + } + get kbd() { + return __privateGet(this, _kbd); + } + set kbd(value) { + if (value < 0 || value > __privateGet(this, _kbdMax)) + return; + execAsync(`brightnessctl -d ${kbd} s ${value} -q`).then(() => { + __privateSet(this, _kbd, value); + this.notify("kbd"); + }); + } + get screen() { + return __privateGet(this, _screen); + } + set screen(percent) { + if (percent < 0) + percent = 0; + if (percent > 1) + percent = 1; + execAsync(`brightnessctl set ${Math.floor(percent * 100)}% -q`).then(() => { + __privateSet(this, _screen, percent); + this.notify("screen"); + }); + } +}; +_kbdMax = new WeakMap(); +_kbd = new WeakMap(); +_screenMax = new WeakMap(); +_screen = new WeakMap(); +_screenAvailable = new WeakMap(); +__publicField(Brightness, "instance"); +__decorateClass([ + property(Boolean) +], Brightness.prototype, "screenAvailable", 1); +__decorateClass([ + property(Number) +], Brightness.prototype, "kbd", 1); +__decorateClass([ + property(Number) +], Brightness.prototype, "screen", 1); +Brightness = __decorateClass([ + register({ GTypeName: "Brightness" }) +], Brightness); + +// components/QuickActions/modules/Power.tsx +var PowerMenu = () => { + const popover = new Gtk4.Popover({ cssClasses: ["PowerMenu"] }); + const powerMenuBox = () => { + return /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["power-button"], + child: /* @__PURE__ */ jsx2("image", { iconName: "system-shutdown-symbolic" }), + onClicked: () => exec("/bin/sh -c 'shutdown now'") + } + ), + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["power-button"], + child: /* @__PURE__ */ jsx2("image", { iconName: "system-reboot-symbolic" }), + onClicked: () => exec("/bin/sh -c 'reboot'") + } + ), + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["power-button"], + child: /* @__PURE__ */ jsx2("image", { iconName: "system-suspend-symbolic" }), + onClicked: () => exec("/bin/sh -c 'systemctl suspend'") + } + ) + ] }); + }; + popover.set_child(powerMenuBox()); + return popover; +}; +var Power = () => { + const pm = PowerMenu(); + return /* @__PURE__ */ jsx2( + "button", + { + widthRequest: 0, + hexpand: false, + vexpand: false, + cssClasses: ["power-menu-button"], + child: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2("image", { iconName: "system-shutdown-symbolic" }), + pm + ] }), + onClicked: () => pm.popup() + } + ); +}; +var UserMenu = () => { + const popover = new Gtk4.Popover(); + const powerMenuBox = () => { + return /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["power-button"], + child: /* @__PURE__ */ jsx2("image", { iconName: "system-lock-screen-symbolic" }), + onClicked: () => exec("/bin/sh -c 'hyprlock'") + } + ), + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["power-button"], + child: /* @__PURE__ */ jsx2("image", { iconName: "system-log-out-symbolic" }), + onClicked: () => exec("/bin/sh -c 'hyprctl dispatch exit 0'") + } + ) + ] }); + }; + popover.set_child(powerMenuBox()); + return popover; +}; +var Power_default = { + Power, + UserMenu +}; + +// components/QuickActions/modules/Audio/Audio.tsx +import AstalWp from "gi://AstalWp"; +var wp = AstalWp.get_default(); +var AudioModule = () => { + const setVolumeSpeaker = (volume) => { + wp.defaultSpeaker.set_volume(volume / 100); + }; + const setVolumeMicrophone = (volume) => { + wp.defaultMicrophone.set_volume(volume / 100); + }; + const speakerSelector = SinkSelectPopover(AstalWp.MediaClass.AUDIO_SPEAKER); + const micSelector = SinkSelectPopover(AstalWp.MediaClass.AUDIO_MICROPHONE); + return /* @__PURE__ */ jsxs("box", { cssClasses: ["audio-box"], vertical: true, children: [ + /* @__PURE__ */ jsxs("box", { hexpand: true, vexpand: true, children: [ + /* @__PURE__ */ jsx2( + "button", + { + onClicked: () => wp.defaultSpeaker.set_mute( + !wp.defaultSpeaker.get_mute() + ), + tooltipText: "Mute audio output", + child: /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(wp.defaultSpeaker, "volumeIcon"), + marginEnd: 3 + } + ) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind(wp.defaultSpeaker, "volume").as( + (v) => Math.round(100 * v) + "%" + ) + } + ), + /* @__PURE__ */ jsx2( + "slider", + { + value: bind(wp.defaultSpeaker, "volume").as((v) => 100 * v), + max: 100, + min: 0, + step: 1, + hexpand: true, + vexpand: true, + onChangeValue: (self) => setVolumeSpeaker(self.value) + } + ), + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["sink-select-button"], + tooltipText: "Pick audio output", + child: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2("image", { iconName: "speaker-symbolic" }), + speakerSelector + ] }), + onClicked: () => speakerSelector.popup() + } + ) + ] }), + /* @__PURE__ */ jsxs("box", { hexpand: true, vexpand: true, children: [ + /* @__PURE__ */ jsx2( + "button", + { + onClicked: () => wp.defaultMicrophone.set_mute( + !wp.defaultMicrophone.get_mute() + ), + tooltipText: "Mute audio input", + child: /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(wp.defaultMicrophone, "volumeIcon"), + marginEnd: 3 + } + ) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind(wp.defaultMicrophone, "volume").as( + (v) => Math.round(100 * v) + "%" + ) + } + ), + /* @__PURE__ */ jsx2( + "slider", + { + value: bind(wp.defaultMicrophone, "volume").as( + (v) => 100 * v + ), + max: 100, + min: 0, + step: 1, + hexpand: true, + vexpand: true, + onChangeValue: (self) => setVolumeMicrophone(self.value) + } + ), + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["sink-select-button"], + tooltipText: "Select audio input", + child: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2("image", { iconName: "microphone" }), + micSelector + ] }), + onClicked: () => micSelector.popup() + } + ) + ] }) + ] }); +}; +var SinkPicker = (type2) => { + const devices = bind(wp, "endpoints"); + return /* @__PURE__ */ jsxs("box", { vertical: true, children: [ + /* @__PURE__ */ jsx2( + "label", + { + label: `Available Audio ${type2 === AstalWp.MediaClass.AUDIO_SPEAKER ? "Output" : type2 === AstalWp.MediaClass.AUDIO_MICROPHONE ? "Input" : ""} Devices` + } + ), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginBottom: 5, marginTop: 3 }), + /* @__PURE__ */ jsx2("box", { vertical: true, cssClasses: ["sink-picker"], children: devices.as((d) => { + return d.map((device) => { + if (device.get_media_class() !== type2) { + return /* @__PURE__ */ jsx2("box", { cssClasses: ["empty"] }); + } + return /* @__PURE__ */ jsx2( + "button", + { + cssClasses: bind(device, "id").as((id) => { + if (id === (type2 === AstalWp.MediaClass.AUDIO_SPEAKER ? wp.defaultSpeaker.id : type2 === AstalWp.MediaClass.AUDIO_MICROPHONE ? wp.defaultMicrophone.id : "")) { + return [ + "sink-option", + "currently-selected-sink-option" + ]; + } else { + return ["sink-option"]; + } + }), + child: /* @__PURE__ */ jsxs("box", { halign: Gtk4.Align.START, children: [ + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(device, "icon").as( + (icon) => icon + ), + marginEnd: 3 + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind( + device, + "description" + ).as((t) => t ?? "") + } + ) + ] }), + onClicked: () => { + device.set_is_default(true); + } + } + ); + }); + }) }) + ] }); +}; +var SinkSelectPopover = (type2) => { + const popover = new Gtk4.Popover(); + popover.set_child(SinkPicker(type2)); + return popover; +}; +var Audio_default = { + AudioModule +}; + +// components/QuickActions/modules/Bluetooth/Bluetooth.tsx +import AstalBluetooth from "gi://AstalBluetooth"; + +// components/QuickActions/modules/Bluetooth/Device.tsx +var BTDevice = ({ device }) => { + return /* @__PURE__ */ jsx2( + "button", + { + visible: bind(device, "name").as((n) => n !== null), + child: /* @__PURE__ */ jsx2( + "centerbox", + { + startWidget: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "image", + { + iconName: "chronometer-reset", + tooltipText: "Device is currently connecting", + visible: bind(device, "connecting") + } + ), + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(device, "icon"), + marginEnd: 3 + } + ) + ] }), + centerWidget: /* @__PURE__ */ jsx2( + "label", + { + label: bind(device, "name").as((n) => n ?? "No name"), + marginEnd: 5 + } + ), + endWidget: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "label", + { + label: bind(device, "batteryPercentage").as( + (bat) => bat >= 0 ? bat + "%" : "?%" + ), + tooltipText: "Device's battery percentage", + marginEnd: 3 + } + ), + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(device, "paired").as( + (v) => v ? "network-bluetooth-activated-symbolic" : "bluetooth-disconnected-symbolic" + ) + } + ), + /* @__PURE__ */ jsx2( + "button", + { + tooltipText: "Device trusted status", + child: /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(device, "trusted").as( + (v) => v ? "checkbox" : "window-close-symbolic" + ) + } + ), + onClicked: () => device.set_trusted(!device.get_trusted()), + cssClasses: ["button-no-margin"] + } + ) + ] }) + } + ), + onClicked: () => { + connectOrPair(device); + } + } + ); +}; +var connectOrPair = (device) => { + if (device.get_paired()) { + device.connect_device(() => { + }); + } else { + device.pair(); + } +}; +var Device_default = BTDevice; + +// components/QuickActions/modules/Bluetooth/Bluetooth.tsx +var ALIGN = Gtk4.Align; +var bt = AstalBluetooth.get_default(); +var BluetoothModule = () => { + return /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: bind(bt.adapter, "powered").as( + (powered) => powered ? ["toggle-button", "toggle-on"] : ["toggle-button"] + ), + onClicked: () => bt.adapter.set_powered(!bt.adapter.get_powered()), + child: /* @__PURE__ */ jsxs("box", { vertical: true, children: [ + /* @__PURE__ */ jsx2( + "label", + { + cssClasses: ["title-2"], + label: "Bluetooth", + halign: ALIGN.CENTER, + valign: ALIGN.CENTER + } + ), + /* @__PURE__ */ jsxs("box", { halign: ALIGN.CENTER, valign: ALIGN.CENTER, children: [ + /* @__PURE__ */ jsx2( + "label", + { + visible: bind(bt.adapter, "powered").as( + (p) => !p + ), + label: "Disabled" + } + ), + /* @__PURE__ */ jsx2( + "label", + { + visible: bind(bt.adapter, "powered"), + label: bind(bt, "devices").as((devices) => { + let count = 0; + devices.forEach((device) => { + if (device.connected) { + count++; + } + }); + return `On (${count} ${count === 1 ? "client" : "clients"} connected)`; + }) + } + ) + ] }), + /* @__PURE__ */ jsx2("label", {}) + ] }) + } + ), + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["actions-button"], + visible: bind(bt.adapter, "powered"), + child: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2("image", { iconName: "arrow-right-symbolic" }), + picker + ] }), + tooltipText: "View available devices", + onClicked: () => openBTPicker() + } + ) + ] }); +}; +var openBTPicker = () => { + picker.popup(); + try { + bt.adapter.start_discovery(); + } catch (_) { + } +}; +var BluetoothPickerList = () => { + let btEnableState = readFile(`${"~/projects/active/dotfiles/config/astal/config"}./btconf`) === "true" ? true : false; + bt.adapter.set_powered(btEnableState); + const updateState = () => { + btEnableState = !btEnableState; + writeFile("./btconf", "" + btEnableState); + }; + return /* @__PURE__ */ jsxs( + "box", + { + vertical: true, + onDestroy: () => bt.adapter.stop_discovery(), + cssClasses: ["popover-box"], + children: [ + /* @__PURE__ */ jsx2("label", { cssClasses: ["title"], label: "Bluetooth" }), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginTop: 3, marginBottom: 5 }), + /* @__PURE__ */ jsx2( + "centerbox", + { + startWidget: /* @__PURE__ */ jsx2("label", { label: "Turn on at startup" }), + endWidget: /* @__PURE__ */ jsx2( + "switch", + { + valign: ALIGN.END, + halign: ALIGN.END, + active: btEnableState, + onButtonPressed: () => updateState() + } + ) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + marginTop: 10, + label: "Connected & Trusted devices", + cssClasses: ["title-2"] + } + ), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginTop: 3, marginBottom: 5 }), + /* @__PURE__ */ jsx2("box", { vertical: true, cssClasses: ["devices-list"], children: bind(bt, "devices").as((devices) => { + return devices.filter((device) => { + if (device.get_connected() || device.get_paired()) { + return device; + } + }).map((device) => { + return /* @__PURE__ */ jsx2(Device_default, { device }); + }); + }) }), + /* @__PURE__ */ jsx2( + "label", + { + visible: bind(bt, "devices").as((devices) => { + return devices.filter((device) => { + if (device.get_connected() || device.get_paired()) { + return device; + } + }).length === 0; + }), + label: "No connected / trusted devices", + cssClasses: ["bt-no-found", "bt-conn-list"] + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: "Discovered bluetooth devices", + cssClasses: ["title-2"] + } + ), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginBottom: 5, marginTop: 3 }), + /* @__PURE__ */ jsx2("box", { vertical: true, children: bind(bt, "devices").as((devices) => { + return devices.filter((data) => { + if (!data.get_connected() && !data.get_paired()) { + return data; + } + }).map((device) => { + return /* @__PURE__ */ jsx2(Device_default, { device }); + }); + }) }), + /* @__PURE__ */ jsx2( + "label", + { + visible: bind(bt, "devices").as((devices) => { + return devices.filter((device) => { + if (!device.get_connected() && !device.get_paired()) { + return device; + } + }).length === 0; + }), + label: "No discovered devices", + cssClasses: ["bt-no-found"] + } + ) + ] + } + ); +}; +var BluetoothPicker = () => { + const popover = new Gtk4.Popover(); + popover.set_child(BluetoothPickerList()); + popover.connect("closed", () => bt.adapter.stop_discovery()); + return popover; +}; +var picker = BluetoothPicker(); +var Bluetooth_default = { + BluetoothModule +}; + +// components/QuickActions/modules/Brightness/Brightness.tsx +var brightness = Brightness.get_default(); +var BrightnessModule = () => { + return /* @__PURE__ */ jsxs("box", { visible: bind(brightness, "screenAvailable"), children: [ + /* @__PURE__ */ jsx2("image", { iconName: "brightness-high-symbolic" }), + /* @__PURE__ */ jsx2("label", { label: bind(brightness, "screen").as((b) => b + "%") }), + /* @__PURE__ */ jsx2("slider", {}) + ] }); +}; +var Brightness_default = { + BrightnessModule +}; + +// components/QuickActions/modules/Player/Player.tsx +import AstalMpris from "gi://AstalMpris"; +import Pango from "gi://Pango?version=1.0"; +var ALIGN2 = Gtk4.Align; +var mpris = AstalMpris.get_default(); +mpris.connect("player-added", (p) => { + print("Player added:", p); +}); +var PlayerModule = () => { + return /* @__PURE__ */ jsxs("box", { vertical: true, cssClasses: ["players-box"], children: [ + /* @__PURE__ */ jsx2("label", { label: "Music Players", halign: ALIGN2.CENTER, cssClasses: ["title-2"] }), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginTop: 3, marginBottom: 5 }), + /* @__PURE__ */ jsx2("box", { cssClasses: ["players"], children: bind(mpris, "players").as((players) => { + return players.map((player) => { + return /* @__PURE__ */ jsx2(PlayerItem, { player }); + }); + }) }), + /* @__PURE__ */ jsx2("label", { label: "No playback active", visible: bind(mpris, "players").as((players) => players.length === 0) }) + ] }); +}; +var pbStatus = AstalMpris.PlaybackStatus; +var PlayerItem = ({ player }) => { + return /* @__PURE__ */ jsxs("box", { cssClasses: ["player"], children: [ + /* @__PURE__ */ jsx2( + "image", + { + cssClasses: ["cover-art"], + file: bind(player, "coverArt"), + hexpand: true, + vexpand: true + } + ), + /* @__PURE__ */ jsxs("box", { vertical: true, children: [ + /* @__PURE__ */ jsx2( + "label", + { + label: bind(player, "title").as( + (title) => title ?? "Unknown title" + ), + cssClasses: ["title"], + halign: ALIGN2.START, + valign: ALIGN2.START, + maxWidthChars: 30, + ellipsize: Pango.EllipsizeMode.END + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind(player, "artist").as( + (artist) => artist ?? "Unknown artist" + ), + halign: ALIGN2.START, + valign: ALIGN2.START, + maxWidthChars: 30, + ellipsize: Pango.EllipsizeMode.END + } + ), + /* @__PURE__ */ jsx2( + "slider", + { + visible: bind(player, "length").as((l) => l > 0), + value: bind(player, "position"), + min: 0, + max: bind(player, "length"), + onChangeValue: (v) => player.set_position(v.get_value()) + } + ), + /* @__PURE__ */ jsx2( + "centerbox", + { + cssClasses: ["actions"], + startWidget: /* @__PURE__ */ jsx2( + "label", + { + label: bind(player, "position").as( + (v) => secondsToFriendlyTime(v) + ), + hexpand: true, + cssClasses: ["position"] + } + ), + centerWidget: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "button", + { + visible: bind(player, "canGoPrevious"), + child: /* @__PURE__ */ jsx2( + "image", + { + iconName: "media-skip-backward-symbolic" + } + ), + onClicked: () => player.previous() + } + ), + /* @__PURE__ */ jsx2( + "button", + { + visible: bind(player, "canControl"), + child: /* @__PURE__ */ jsx2( + "image", + { + iconName: bind( + player, + "playbackStatus" + ).as((status) => { + if (status === pbStatus.PLAYING) { + return "media-playback-pause-symbolic"; + } else { + return "media-playback-start-symbolic"; + } + }) + } + ), + onClicked: () => player.play_pause() + } + ), + /* @__PURE__ */ jsx2( + "button", + { + visible: bind(player, "canGoNext"), + child: /* @__PURE__ */ jsx2( + "image", + { + iconName: "media-skip-forward-symbolic" + } + ), + onClicked: () => player.next() + } + ) + ] }), + endWidget: /* @__PURE__ */ jsx2( + "label", + { + cssClasses: ["length"], + hexpand: true, + label: bind(player, "length").as( + (v) => secondsToFriendlyTime(v) + ) + } + ) + } + ) + ] }) + ] }); +}; +var secondsToFriendlyTime = (time) => { + const minutes = Math.floor(time / 60); + const hours = Math.floor(minutes / 60); + const seconds = Math.floor(time % 60); + if (hours > 0) { + return `${hours}:${expandTime(minutes)}:${expandTime(seconds)}`; + } else { + return `${minutes}:${expandTime(seconds)}`; + } +}; +var expandTime = (time) => { + return time < 10 ? `0${time}` : "" + time; +}; +var Player_default = { + PlayerModule +}; + +// components/QuickActions/modules/Battery.tsx +import Battery from "gi://AstalBattery"; +var BatteryBox = () => { + const battery = Battery.get_default(); + const batteryEnergy = (energyRate) => { + return energyRate > 0.1 ? `${Math.round(energyRate * 10) / 10} W ` : ""; + }; + return /* @__PURE__ */ jsx2( + "box", + { + cssClasses: ["battery-info"], + visible: bind(battery, "isBattery"), + children: /* @__PURE__ */ jsxs("box", { cssClasses: ["battery-box"], children: [ + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(battery, "batteryIconName"), + tooltipText: bind(battery, "energyRate").as( + (er) => batteryEnergy(er) + ) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind(battery, "percentage").as( + (p) => ` ${Math.round(p * 100)}%` + ) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + cssClasses: ["time"], + hexpand: true, + halign: Gtk4.Align.END, + visible: bind(battery, "charging").as((c) => !c), + label: bind(battery, "timeToEmpty").as((t) => toTime(t)) + } + ) + ] }) + } + ); +}; +var toTime = (time) => { + const MINUTE = 60; + const HOUR = MINUTE * 60; + if (time > 24 * HOUR) return ""; + const hours = Math.round(time / HOUR); + const minutes = Math.round((time - hours * HOUR) / MINUTE); + const hoursDisplay = hours > 0 ? `${hours}h ` : ""; + const minutesDisplay = minutes > 0 ? `${minutes}m ` : ""; + return `${hoursDisplay}${minutesDisplay}`; +}; + +// components/QuickActions/modules/Networking/Network.tsx +import AstalNetwork2 from "gi://AstalNetwork"; + +// components/QuickActions/modules/Networking/network-helper.ts +import AstalNetwork from "gi://AstalNetwork"; +var networkEnabled = Variable(exec("nmcli networking connectivity") !== "none"); +var network = AstalNetwork.get_default(); +var setNetworking = (status) => { + if (status === true) { + exec("nmcli networking on"); + networkEnabled.set(true); + } else { + exec("nmcli networking off"); + networkEnabled.set(false); + } +}; +var getIP = () => { + return exec(`/bin/bash -c "ip addr show | grep 'inet ' | awk '{print $2}' | grep -v '127'"`).split("/")[0]; +}; +var network_helper_default = { + networkEnabled, + setNetworking, + getIP +}; + +// components/QuickActions/modules/Networking/NetworkMenu.tsx +var NetworkMenu = () => { + const popover = new Gtk4.Popover(); + popover.set_child(renderMenu()); + return popover; +}; +var renderMenu = () => { + return /* @__PURE__ */ jsxs("box", { vertical: true, children: [ + /* @__PURE__ */ jsx2("image", { iconName: "appointment-soon-symbolic", iconSize: Gtk4.IconSize.LARGE }), + /* @__PURE__ */ jsx2("label", { label: "Coming later" }) + ] }); +}; +var NetworkMenu_default = { + NetworkMenu +}; + +// components/QuickActions/modules/Networking/Network.tsx +var net = AstalNetwork2.get_default(); +var STATE = AstalNetwork2.DeviceState; +var Network = () => { + const netMenu = NetworkMenu_default.NetworkMenu(); + return /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: network_helper_default.networkEnabled((en) => { + if (en) return ["toggle-button", "toggle-on"]; + else return ["toggle-button"]; + }), + onClicked: () => network_helper_default.setNetworking( + !network_helper_default.networkEnabled.get() + ), + child: /* @__PURE__ */ jsxs("box", { vertical: true, children: [ + /* @__PURE__ */ jsx2( + "label", + { + label: bind(net.wifi, "enabled").as( + (stat) => `Network (${stat ? "WiFi" : "Wired"})` + ), + cssClasses: ["title-2"] + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind(net.wired, "state").as((state) => { + if (state === STATE.ACTIVATED) { + return "Wired. IP: " + network_helper_default.getIP(); + } else if (state === STATE.DISCONNECTED) { + return "Disconnected"; + } else if (state === STATE.FAILED) { + return "Error"; + } else if (state === STATE.PREPARE || state === STATE.CONFIG || state === STATE.IP_CHECK || state === STATE.IP_CONFIG) { + return "Connecting..."; + } else { + return "Unavailable"; + } + }), + visible: bind(net.wifi, "enabled").as((v) => !v) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind(net.wifi, "state").as((state) => { + if (state === STATE.ACTIVATED) { + return `${net.wifi.get_ssid()} (${network_helper_default.getIP()})`; + } else if (state === STATE.DISCONNECTED) { + return "Disconnected"; + } else if (state === STATE.FAILED) { + return "Error"; + } else if (state === STATE.PREPARE || state === STATE.CONFIG || state === STATE.IP_CHECK || state === STATE.IP_CONFIG) { + return "Connecting..."; + } else { + return "Unavailable"; + } + }), + visible: bind(net.wifi, "enabled") + } + ) + ] }) + } + ), + /* @__PURE__ */ jsx2( + "button", + { + cssClasses: ["actions-button"], + visible: network_helper_default.networkEnabled(), + onClicked: () => netMenu.popup(), + child: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2("image", { iconName: "arrow-right-symbolic" }), + netMenu + ] }), + tooltipText: "View available devices" + } + ) + ] }); +}; +var Network_default = { + Network +}; + +// components/QuickActions/QuickActions.tsx +var QuickActions = () => { + const popover = new Gtk4.Popover({ cssClasses: ["quick-actions-wrapper"] }); + popover.set_child(renderQuickActions()); + return popover; +}; +var renderQuickActions = () => { + const user = exec("/bin/sh -c whoami"); + const profile = exec("/bin/fish -c get-profile-picture"); + const cwd = exec("pwd"); + const um = Power_default.UserMenu(); + return /* @__PURE__ */ jsxs("box", { visible: true, cssClasses: ["quick-actions", "popover-box"], vertical: true, children: [ + /* @__PURE__ */ jsx2( + "centerbox", + { + startWidget: /* @__PURE__ */ jsx2( + "button", + { + onClicked: () => um.popup(), + cssClasses: ["stealthy-button"], + child: /* @__PURE__ */ jsxs("box", { children: [ + um, + /* @__PURE__ */ jsx2( + Gtk4.Frame, + { + cssClasses: ["avatar-icon"], + child: /* @__PURE__ */ jsx2( + "image", + { + file: profile !== "" ? profile : cwd + "/no-avatar-icon.jpg" + } + ) + } + ), + /* @__PURE__ */ jsx2("label", { label: user }) + ] }) + } + ), + endWidget: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2(BatteryBox, {}), + /* @__PURE__ */ jsx2(Power_default.Power, {}) + ] }) + } + ), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginTop: 10, marginBottom: 20 }), + /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2(Bluetooth_default.BluetoothModule, {}), + /* @__PURE__ */ jsx2(Network_default.Network, {}) + ] }), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginTop: 10, marginBottom: 10 }), + /* @__PURE__ */ jsx2(Brightness_default.BrightnessModule, {}), + /* @__PURE__ */ jsx2(Audio_default.AudioModule, {}), + /* @__PURE__ */ jsx2(Player_default.PlayerModule, {}) + ] }); +}; +var QuickActions_default = { + QuickActions +}; + +// components/bar/modules/QuickView.tsx +var STATE2 = AstalNetwork3.DeviceState; +var QuickView = () => { + const qa = QuickActions_default.QuickActions(); + const showQuickActions = () => { + qa.popup(); + }; + return /* @__PURE__ */ jsx2( + "button", + { + onClicked: () => showQuickActions(), + cssClasses: ["quick-action-button"], + child: /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2(BatteryWidget, {}), + /* @__PURE__ */ jsx2(Audio, {}), + /* @__PURE__ */ jsx2(BluetoothWidget, {}), + /* @__PURE__ */ jsx2(NetworkWidget, {}), + /* @__PURE__ */ jsx2(BrightnessWidget, {}), + /* @__PURE__ */ jsx2("image", { iconName: "system-shutdown-symbolic" }), + qa + ] }) + } + ); +}; +var NetworkWidget = () => { + const network2 = AstalNetwork3.get_default(); + return /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(network2, "state").as((state) => { + if (state === AstalNetwork3.State.CONNECTING) { + return "chronometer-reset-symbolic"; + } else if (state === AstalNetwork3.State.CONNECTED_LOCAL || state === AstalNetwork3.State.CONNECTED_SITE || state === AstalNetwork3.State.CONNECTED_GLOBAL) { + return "network-wired-activated-symbolic"; + } else { + return "paint-unknown-symbolic"; + } + }), + cssClasses: ["network-widget", "quick-view-symbol"], + visible: bind(network2.wifi, "state").as( + (state) => state !== STATE2.ACTIVATED + ) + } + ), + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(network2.wifi, "state").as((state) => { + if (state === STATE2.ACTIVATED) { + return network2.wifi.iconName; + } else { + return ""; + } + }), + cssClasses: ["network-widget", "quick-view-symbol"], + visible: bind(network2.wifi, "state").as( + (state) => state === STATE2.ACTIVATED + ) + } + ) + ] }); +}; +var BluetoothWidget = () => { + const bluetooth = AstalBluetooth2.get_default(); + const enabled2 = bind(bluetooth.adapter, "powered"); + const connected = bind(bluetooth, "isConnected"); + return /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsxs("box", { visible: enabled2.as((e) => e), children: [ + /* @__PURE__ */ jsx2( + "image", + { + iconName: "bluetooth-active-symbolic", + visible: connected.as((c) => c) + } + ), + /* @__PURE__ */ jsx2( + "image", + { + iconName: "bluetooth-disconnected-symbolic", + visible: connected.as((c) => !c) + } + ) + ] }), + /* @__PURE__ */ jsx2( + "image", + { + iconName: "bluetooth-disabled-symbolic", + visible: enabled2.as((e) => !e) + } + ), + /* @__PURE__ */ jsx2("box", { children: bind(bluetooth, "devices").as((devices) => { + return devices.map((device) => { + return /* @__PURE__ */ jsxs("box", { visible: bind(device, "connected").as((c) => c), children: [ + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(device, "icon").as( + (icon) => icon + ) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind(device, "batteryPercentage").as( + (n) => { + return n + "%"; + } + ) + } + ) + ] }); + }); + }) }) + ] }); +}; +var BatteryWidget = () => { + const battery = AstalBattery.get_default(); + if (battery.get_is_present()) { + return /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(battery, "iconName").as((icon) => icon), + cssClasses: ["quick-view-symbol"] + } + ); + } else { + return /* @__PURE__ */ jsx2("box", {}); + } +}; +var BrightnessWidget = () => { + const brightness2 = Brightness.get_default(); + const screen_brightness = bind(brightness2, "screen"); + return /* @__PURE__ */ jsx2( + "label", + { + label: "\u{1F323}" + screen_brightness, + visible: bind(brightness2, "screenAvailable"), + cssClasses: ["quick-view-symbol"] + } + ); +}; +var Audio = () => { + const wireplumber = AstalWp2.get_default(); + if (wireplumber) { + return /* @__PURE__ */ jsxs("box", { orientation: Gtk4.Orientation.HORIZONTAL, children: [ + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind(wireplumber.defaultSpeaker, "volumeIcon").as( + (icon) => icon + ), + cssClasses: ["quick-view-symbol"] + } + ), + /* @__PURE__ */ jsx2( + "image", + { + iconName: bind( + wireplumber.defaultMicrophone, + "volumeIcon" + ).as((icon) => icon), + cssClasses: ["quick-view-symbol"] + } + ) + ] }); + } else { + print( + "[ WirePlumber ] Could not connect, Audio support in bar will be missing" + ); + return /* @__PURE__ */ jsx2("image", { iconName: "action-unavailable-symbolic" }); + } +}; +var QuickView_default = { + QuickView +}; + +// components/bar/modules/SystemInfo.tsx +var FETCH_INTERVAL = 2e3; +var cpuUtil = Variable("0%"); +var ramUtil = Variable("0%"); +var ramUsed = Variable("0MiB"); +var gpuUtil = Variable("0%"); +var gpuName = "card1"; +var enabled = false; +var refreshStats = () => { + gpuName = exec(`/bin/bash -c "ls /sys/class/drm/ | grep '^card[0-9]*$'"`); + const cpuNameInSensors = "CPUTIN"; + const stats = { + kernel: exec("uname -sr"), + netSpeed: exec( + `/bin/bash -c "interface=$(ip route get 8.8.8.8 | awk '{print $5; exit}') && cat "/sys/class/net/$interface/speed""` + ), + cpuTemp: exec( + `/bin/bash -c "sensors | grep -m1 ${cpuNameInSensors} | awk '{print $2}'"` + ), + cpuClk: exec( + `awk '/cpu MHz/ {sum+=$4; ++n} END {print sum/n " MHz"}' /proc/cpuinfo` + ), + gpuTemp: exec( + `/bin/bash -c "sensors | grep -E 'edge' | awk '{print $2}'"` + ), + gpuClk: exec( + `/bin/bash -c "cat /sys/class/drm/${gpuName}/device/pp_dpm_sclk | grep '\\*' | awk '{print $2 $3}'"` + ), + vram: Math.round( + parseInt( + exec( + `cat /sys/class/drm/${gpuName}/device/mem_info_vram_used` + ) + ) / 1024 / 1024 + ) + "MiB", + availableVRAM: Math.round( + parseInt( + exec( + `cat /sys/class/drm/${gpuName}/device/mem_info_vram_total` + ) + ) / 1024 / 1024 + ) + "MiB" + }; + return stats; +}; +var systemStats = Variable(refreshStats()); +var availableFeatures = { + cpu: true, + ram: true +}; +var featureTest = () => { + try { + exec("awk -V"); + exec("sed --version"); + enabled = true; + } catch (e) { + printerr( + "[ SysInfo ] AWK or SED missing! No system info will be available" + ); + enabled = false; + return; + } + try { + exec("mpstat -V"); + } catch (e) { + availableFeatures.cpu = false; + printerr( + "[ SysInfo ] Feature Test for CPU info failed. mpstat from the sysstat package missing!" + ); + } +}; +var info = () => { + return /* @__PURE__ */ jsxs("box", { vertical: true, children: [ + /* @__PURE__ */ jsx2( + "label", + { + label: "System Information", + cssClasses: ["title-2"] + } + ), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginTop: 5, marginBottom: 10 }), + /* @__PURE__ */ jsx2( + "label", + { + vexpand: true, + halign: Gtk4.Align.START, + hexpand: true, + label: ramUsed((used) => { + return "RAM: " + used + ` (${ramUtil.get()}%)`; + }) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: systemStats((stats) => { + return `CPU: ${stats.cpuTemp}, ${stats.cpuClk} +GPU: ${stats.gpuTemp}, ${stats.gpuClk} (${stats.vram} / ${stats.availableVRAM}) +Network: ${stats.netSpeed} mb/s +Kernel: ${stats.kernel}`; + }) + } + ), + /* @__PURE__ */ jsx2(Gtk4.Separator, { marginTop: 10 }), + /* @__PURE__ */ jsx2( + "button", + { + onClicked: () => exec(`/bin/sh -c "kitty --hold fish -c 'fastfetch'"`), + child: /* @__PURE__ */ jsx2("label", { label: "View FastFetch" }) + } + ) + ] }); +}; +var SystemInformationPanel = () => { + const popover = new Gtk4.Popover(); + popover.set_child(info()); + return popover; +}; +var sysInfoFetcher = () => { + if (enabled) { + if (availableFeatures.cpu) { + cpuUtil.set( + "" + Math.round( + parseFloat(exec(`/bin/fish -c cpu-utilization`)) + ) + ); + } + if (availableFeatures.ram) { + ramUtil.set( + "" + Math.round( + parseFloat( + exec( + `/bin/bash -c "free | awk '/Mem/ { printf(\\"%.2f\\\\n\\", ($3/$2)*100) }'"` + ) + ) + ) + ); + ramUsed.set( + exec( + `/bin/bash -c "free -h | awk '/^Mem:/ {print $3 \\" used of \\" $2}'"` + ).replaceAll("Gi", "GiB").replaceAll("Mi", "MiB") + ); + } + gpuUtil.set(exec("cat /sys/class/drm/card1/device/gpu_busy_percent")); + } +}; +var panel = SystemInformationPanel(); +var SystemInfo = () => { + featureTest(); + const openSysInfo = async () => { + panel.popup(); + systemStats.set(refreshStats()); + }; + if (enabled) { + sysInfoFetcher(); + interval(FETCH_INTERVAL, sysInfoFetcher); + return /* @__PURE__ */ jsx2( + "button", + { + onClicked: () => openSysInfo(), + child: /* @__PURE__ */ jsxs("box", { tooltipText: ramUsed((v) => v), children: [ + /* @__PURE__ */ jsx2( + "image", + { + iconName: "power-profile-performance-symbolic", + marginEnd: 1 + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: cpuUtil((util) => util), + marginEnd: 5 + } + ), + /* @__PURE__ */ jsx2("image", { iconName: "histogram-symbolic" }), + /* @__PURE__ */ jsx2("label", { label: ramUtil((util) => util) }), + /* @__PURE__ */ jsx2("image", { iconName: "show-gpu-effects-symbolic" }), + /* @__PURE__ */ jsx2("label", { label: gpuUtil((util) => util) }), + panel + ] }), + cssClasses: ["bar-button"] + } + ); + } else { + return /* @__PURE__ */ jsx2("image", { iconName: "action-unavailable-symbolic" }); + } +}; +var SystemInfo_default = { + SystemInfo, + panel +}; + +// components/bar/Bar.tsx +var Bar = ({ gdkmonitor, name }) => { + const { TOP, LEFT, RIGHT } = Astal6.WindowAnchor; + return /* @__PURE__ */ jsx2( + "window", + { + gdkmonitor, + cssClasses: ["Bar"], + name, + namespace: "bar", + exclusivity: Astal6.Exclusivity.EXCLUSIVE, + anchor: TOP | LEFT | RIGHT, + visible: true, + application: app_default, + child: /* @__PURE__ */ jsx2( + CenterBox, + { + orientation: Gtk4.Orientation.HORIZONTAL, + start_widget: /* @__PURE__ */ jsxs( + "box", + { + hexpand: true, + halign: Gtk4.Align.START, + children: [ + /* @__PURE__ */ jsx2(Calendar_default.Time, {}), + /* @__PURE__ */ jsx2(SystemInfo_default.SystemInfo, {}), + /* @__PURE__ */ jsx2(Hyprland_default.Workspace, {}) + ] + } + ), + centerWidget: /* @__PURE__ */ jsx2(Hyprland_default.ActiveWindow, {}), + endWidget: /* @__PURE__ */ jsxs( + "box", + { + hexpand: true, + halign: Gtk4.Align.END, + cssClasses: ["BarRight"], + children: [ + /* @__PURE__ */ jsx2(Hyprland_default.SysTray, {}), + /* @__PURE__ */ jsx2(QuickView_default.QuickView, {}) + ] + } + ) + } + ) + } + ); +}; +var cliHandler = (args) => { + return "Not implemented"; +}; +var BarLauncher = (monitor) => { + const windowName = `bar-${monitor.get_connector()}`; + const createBar = () => { + return /* @__PURE__ */ jsx2(Bar, { gdkmonitor: monitor, name: windowName }); + }; + createBar(); + return windowName; +}; +var Bar_default = { + BarLauncher, + cliHandler +}; + +// app.ts +import AstalHyprland2 from "gi://AstalHyprland?version=0.1"; + +// util/hyprland.ts +function hyprToGdk(monitor) { + const monitors = app_default.get_monitors(); + if (!monitors || monitors.length === 0) return null; + for (let gdkmonitor of monitors) { + if (monitor && gdkmonitor && monitor.get_name() === gdkmonitor.get_connector()) + return gdkmonitor; + } + return monitors.length > 0 ? monitors[0] : null; +} + +// app.ts +app_default.start({ + instanceName: "runner", + css: style_default, + main() { + const hypr2 = AstalHyprland2.get_default(); + const bars = /* @__PURE__ */ new Map(); + const barCreator = (monitor) => { + const gdkMonitor = hyprToGdk(monitor); + if (gdkMonitor) { + print("Bar added for screen " + monitor.get_id()); + bars.set(monitor.get_id(), Bar_default.BarLauncher(gdkMonitor)); + } + }; + for (const monitor of hypr2.monitors) { + barCreator(monitor); + } + hypr2.connect("monitor-added", (_, monitor) => { + barCreator(monitor); + }); + hypr2.connect("monitor-removed", (_, monitor) => { + const windowName = bars.get(monitor); + if (windowName) { + const win = app_default.get_window(windowName); + if (win) { + app_default.toggle_window(windowName); + win.set_child(null); + app_default.remove_window(win); + print("Bar removed for screen", monitor); + } + bars.delete(monitor); + } + }); + }, + requestHandler(request, res) { + const args = request.trimStart().split(" "); + if (args[0] === "notifier") { + res("Not available here yet, run astal -i notifier " + args[1]); + } else if (args[0] === "bar") { + res(Bar_default.cliHandler(args)); + } + } +}); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../../usr/share/astal/gjs/gtk4/index.ts", "../../../../../../../usr/share/astal/gjs/variable.ts", "../../../../../../../usr/share/astal/gjs/binding.ts", "../../../../../../../usr/share/astal/gjs/time.ts", "../../../../../../../usr/share/astal/gjs/process.ts", "../../../../../../../usr/share/astal/gjs/_astal.ts", "../../../../../../../usr/share/astal/gjs/gtk4/astalify.ts", "../../../../../../../usr/share/astal/gjs/gtk4/app.ts", "../../../../../../../usr/share/astal/gjs/overrides.ts", "../../../../../../../usr/share/astal/gjs/_app.ts", "../../../../../../../usr/share/astal/gjs/gtk4/widget.ts", "sass:/home/janis/projects/active/dotfiles/config/astal/style.scss", "components/bar/modules/Hyprland.tsx", "../../../../../../../usr/share/astal/gjs/index.ts", "../../../../../../../usr/share/astal/gjs/file.ts", "../../../../../../../usr/share/astal/gjs/gobject.ts", "../../../../../../../usr/share/astal/gjs/gtk4/jsx-runtime.ts", "components/bar/modules/Calendar.tsx", "components/bar/modules/QuickView.tsx", "util/brightness.ts", "components/QuickActions/modules/Power.tsx", "components/QuickActions/modules/Audio/Audio.tsx", "components/QuickActions/modules/Bluetooth/Bluetooth.tsx", "components/QuickActions/modules/Bluetooth/Device.tsx", "components/QuickActions/modules/Brightness/Brightness.tsx", "components/QuickActions/modules/Player/Player.tsx", "components/QuickActions/modules/Battery.tsx", "components/QuickActions/modules/Networking/Network.tsx", "components/QuickActions/modules/Networking/network-helper.ts", "components/QuickActions/modules/Networking/NetworkMenu.tsx", "components/QuickActions/QuickActions.tsx", "components/bar/modules/SystemInfo.tsx", "components/bar/Bar.tsx", "app.ts", "util/hyprland.ts"],
  "sourcesContent": ["import Astal from \"gi://Astal?version=4.0\"\nimport Gtk from \"gi://Gtk?version=4.0\"\nimport Gdk from \"gi://Gdk?version=4.0\"\nimport astalify, { type ConstructProps } from \"./astalify.js\"\n\nexport { Astal, Gtk, Gdk }\nexport { default as App } from \"./app.js\"\nexport { astalify, ConstructProps }\nexport * as Widget from \"./widget.js\"\nexport { hook } from \"../_astal\"\n", "import Astal from \"gi://AstalIO\"\nimport Binding, { type Connectable, type Subscribable } from \"./binding.js\"\nimport { interval } from \"./time.js\"\nimport { execAsync, subprocess } from \"./process.js\"\n\nclass VariableWrapper<T> extends Function {\n    private variable!: Astal.VariableBase\n    private errHandler? = console.error\n\n    private _value: T\n    private _poll?: Astal.Time\n    private _watch?: Astal.Process\n\n    private pollInterval = 1000\n    private pollExec?: string[] | string\n    private pollTransform?: (stdout: string, prev: T) => T\n    private pollFn?: (prev: T) => T | Promise<T>\n\n    private watchTransform?: (stdout: string, prev: T) => T\n    private watchExec?: string[] | string\n\n    constructor(init: T) {\n        super()\n        this._value = init\n        this.variable = new Astal.VariableBase()\n        this.variable.connect(\"dropped\", () => {\n            this.stopWatch()\n            this.stopPoll()\n        })\n        this.variable.connect(\"error\", (_, err) => this.errHandler?.(err))\n        return new Proxy(this, {\n            apply: (target, _, args) => target._call(args[0]),\n        })\n    }\n\n    private _call<R = T>(transform?: (value: T) => R): Binding<R> {\n        const b = Binding.bind(this)\n        return transform ? b.as(transform) : b as unknown as Binding<R>\n    }\n\n    toString() {\n        return String(`Variable<${this.get()}>`)\n    }\n\n    get(): T { return this._value }\n    set(value: T) {\n        if (value !== this._value) {\n            this._value = value\n            this.variable.emit(\"changed\")\n        }\n    }\n\n    startPoll() {\n        if (this._poll)\n            return\n\n        if (this.pollFn) {\n            this._poll = interval(this.pollInterval, () => {\n                const v = this.pollFn!(this.get())\n                if (v instanceof Promise) {\n                    v.then(v => this.set(v))\n                        .catch(err => this.variable.emit(\"error\", err))\n                } else {\n                    this.set(v)\n                }\n            })\n        } else if (this.pollExec) {\n            this._poll = interval(this.pollInterval, () => {\n                execAsync(this.pollExec!)\n                    .then(v => this.set(this.pollTransform!(v, this.get())))\n                    .catch(err => this.variable.emit(\"error\", err))\n            })\n        }\n    }\n\n    startWatch() {\n        if (this._watch)\n            return\n\n        this._watch = subprocess({\n            cmd: this.watchExec!,\n            out: out => this.set(this.watchTransform!(out, this.get())),\n            err: err => this.variable.emit(\"error\", err),\n        })\n    }\n\n    stopPoll() {\n        this._poll?.cancel()\n        delete this._poll\n    }\n\n    stopWatch() {\n        this._watch?.kill()\n        delete this._watch\n    }\n\n    isPolling() { return !!this._poll }\n    isWatching() { return !!this._watch }\n\n    drop() {\n        this.variable.emit(\"dropped\")\n    }\n\n    onDropped(callback: () => void) {\n        this.variable.connect(\"dropped\", callback)\n        return this as unknown as Variable<T>\n    }\n\n    onError(callback: (err: string) => void) {\n        delete this.errHandler\n        this.variable.connect(\"error\", (_, err) => callback(err))\n        return this as unknown as Variable<T>\n    }\n\n    subscribe(callback: (value: T) => void) {\n        const id = this.variable.connect(\"changed\", () => {\n            callback(this.get())\n        })\n        return () => this.variable.disconnect(id)\n    }\n\n    poll(\n        interval: number,\n        exec: string | string[],\n        transform?: (stdout: string, prev: T) => T\n    ): Variable<T>\n\n    poll(\n        interval: number,\n        callback: (prev: T) => T | Promise<T>\n    ): Variable<T>\n\n    poll(\n        interval: number,\n        exec: string | string[] | ((prev: T) => T | Promise<T>),\n        transform: (stdout: string, prev: T) => T = out => out as T,\n    ) {\n        this.stopPoll()\n        this.pollInterval = interval\n        this.pollTransform = transform\n        if (typeof exec === \"function\") {\n            this.pollFn = exec\n            delete this.pollExec\n        } else {\n            this.pollExec = exec\n            delete this.pollFn\n        }\n        this.startPoll()\n        return this as unknown as Variable<T>\n    }\n\n    watch(\n        exec: string | string[],\n        transform: (stdout: string, prev: T) => T = out => out as T,\n    ) {\n        this.stopWatch()\n        this.watchExec = exec\n        this.watchTransform = transform\n        this.startWatch()\n        return this as unknown as Variable<T>\n    }\n\n    observe(\n        objs: Array<[obj: Connectable, signal: string]>,\n        callback: (...args: any[]) => T,\n    ): Variable<T>\n\n    observe(\n        obj: Connectable,\n        signal: string,\n        callback: (...args: any[]) => T,\n    ): Variable<T>\n\n    observe(\n        objs: Connectable | Array<[obj: Connectable, signal: string]>,\n        sigOrFn: string | ((obj: Connectable, ...args: any[]) => T),\n        callback?: (obj: Connectable, ...args: any[]) => T,\n    ) {\n        const f = typeof sigOrFn === \"function\" ? sigOrFn : callback ?? (() => this.get())\n        const set = (obj: Connectable, ...args: any[]) => this.set(f(obj, ...args))\n\n        if (Array.isArray(objs)) {\n            for (const obj of objs) {\n                const [o, s] = obj\n                const id = o.connect(s, set)\n                this.onDropped(() => o.disconnect(id))\n            }\n        } else {\n            if (typeof sigOrFn === \"string\") {\n                const id = objs.connect(sigOrFn, set)\n                this.onDropped(() => objs.disconnect(id))\n            }\n        }\n\n        return this as unknown as Variable<T>\n    }\n\n    static derive<\n        const Deps extends Array<Subscribable<any>>,\n        Args extends {\n            [K in keyof Deps]: Deps[K] extends Subscribable<infer T> ? T : never\n        },\n        V = Args,\n    >(deps: Deps, fn: (...args: Args) => V = (...args) => args as unknown as V) {\n        const update = () => fn(...deps.map(d => d.get()) as Args)\n        const derived = new Variable(update())\n        const unsubs = deps.map(dep => dep.subscribe(() => derived.set(update())))\n        derived.onDropped(() => unsubs.map(unsub => unsub()))\n        return derived\n    }\n}\n\nexport interface Variable<T> extends Omit<VariableWrapper<T>, \"bind\"> {\n    <R>(transform: (value: T) => R): Binding<R>\n    (): Binding<T>\n}\n\nexport const Variable = new Proxy(VariableWrapper as any, {\n    apply: (_t, _a, args) => new VariableWrapper(args[0]),\n}) as {\n    derive: typeof VariableWrapper[\"derive\"]\n    <T>(init: T): Variable<T>\n    new<T>(init: T): Variable<T>\n}\n\nexport const { derive } = Variable\nexport default Variable\n", "export const snakeify = (str: string) => str\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .replaceAll(\"-\", \"_\")\n    .toLowerCase()\n\nexport const kebabify = (str: string) => str\n    .replace(/([a-z])([A-Z])/g, \"$1-$2\")\n    .replaceAll(\"_\", \"-\")\n    .toLowerCase()\n\nexport interface Subscribable<T = unknown> {\n    subscribe(callback: (value: T) => void): () => void\n    get(): T\n    [key: string]: any\n}\n\nexport interface Connectable {\n    connect(signal: string, callback: (...args: any[]) => unknown): number\n    disconnect(id: number): void\n    [key: string]: any\n}\n\nexport class Binding<Value> {\n    private transformFn = (v: any) => v\n\n    #emitter: Subscribable<Value> | Connectable\n    #prop?: string\n\n    static bind<\n        T extends Connectable,\n        P extends keyof T,\n    >(object: T, property: P): Binding<T[P]>\n\n    static bind<T>(object: Subscribable<T>): Binding<T>\n\n    static bind(emitter: Connectable | Subscribable, prop?: string) {\n        return new Binding(emitter, prop)\n    }\n\n    private constructor(emitter: Connectable | Subscribable<Value>, prop?: string) {\n        this.#emitter = emitter\n        this.#prop = prop && kebabify(prop)\n    }\n\n    toString() {\n        return `Binding<${this.#emitter}${this.#prop ? `, \"${this.#prop}\"` : \"\"}>`\n    }\n\n    as<T>(fn: (v: Value) => T): Binding<T> {\n        const bind = new Binding(this.#emitter, this.#prop)\n        bind.transformFn = (v: Value) => fn(this.transformFn(v))\n        return bind as unknown as Binding<T>\n    }\n\n    get(): Value {\n        if (typeof this.#emitter.get === \"function\")\n            return this.transformFn(this.#emitter.get())\n\n        if (typeof this.#prop === \"string\") {\n            const getter = `get_${snakeify(this.#prop)}`\n            if (typeof this.#emitter[getter] === \"function\")\n                return this.transformFn(this.#emitter[getter]())\n\n            return this.transformFn(this.#emitter[this.#prop])\n        }\n\n        throw Error(\"can not get value of binding\")\n    }\n\n    subscribe(callback: (value: Value) => void): () => void {\n        if (typeof this.#emitter.subscribe === \"function\") {\n            return this.#emitter.subscribe(() => {\n                callback(this.get())\n            })\n        } else if (typeof this.#emitter.connect === \"function\") {\n            const signal = `notify::${this.#prop}`\n            const id = this.#emitter.connect(signal, () => {\n                callback(this.get())\n            })\n            return () => {\n                (this.#emitter.disconnect as Connectable[\"disconnect\"])(id)\n            }\n        }\n        throw Error(`${this.#emitter} is not bindable`)\n    }\n}\n\nexport const { bind } = Binding\nexport default Binding\n", "import Astal from \"gi://AstalIO\"\n\nexport type Time = Astal.Time\nexport const Time = Astal.Time\n\nexport function interval(interval: number, callback?: () => void) {\n    return Astal.Time.interval(interval, () => void callback?.())\n}\n\nexport function timeout(timeout: number, callback?: () => void) {\n    return Astal.Time.timeout(timeout, () => void callback?.())\n}\n\nexport function idle(callback?: () => void) {\n    return Astal.Time.idle(() => void callback?.())\n}\n", "import Astal from \"gi://AstalIO\"\n\ntype Args = {\n    cmd: string | string[]\n    out?: (stdout: string) => void\n    err?: (stderr: string) => void\n}\n\nexport type Process = Astal.Process\nexport const Process = Astal.Process\n\nexport function subprocess(args: Args): Astal.Process\n\nexport function subprocess(\n    cmd: string | string[],\n    onOut?: (stdout: string) => void,\n    onErr?: (stderr: string) => void,\n): Astal.Process\n\nexport function subprocess(\n    argsOrCmd: Args | string | string[],\n    onOut: (stdout: string) => void = print,\n    onErr: (stderr: string) => void = printerr,\n) {\n    const args = Array.isArray(argsOrCmd) || typeof argsOrCmd === \"string\"\n    const { cmd, err, out } = {\n        cmd: args ? argsOrCmd : argsOrCmd.cmd,\n        err: args ? onErr : argsOrCmd.err || onErr,\n        out: args ? onOut : argsOrCmd.out || onOut,\n    }\n\n    const proc = Array.isArray(cmd)\n        ? Astal.Process.subprocessv(cmd)\n        : Astal.Process.subprocess(cmd)\n\n    proc.connect(\"stdout\", (_, stdout: string) => out(stdout))\n    proc.connect(\"stderr\", (_, stderr: string) => err(stderr))\n    return proc\n}\n\n/** @throws {GLib.Error} Throws stderr */\nexport function exec(cmd: string | string[]) {\n    return Array.isArray(cmd)\n        ? Astal.Process.execv(cmd)\n        : Astal.Process.exec(cmd)\n}\n\nexport function execAsync(cmd: string | string[]): Promise<string> {\n    return new Promise((resolve, reject) => {\n        if (Array.isArray(cmd)) {\n            Astal.Process.exec_asyncv(cmd, (_, res) => {\n                try {\n                    resolve(Astal.Process.exec_asyncv_finish(res))\n                } catch (error) {\n                    reject(error)\n                }\n            })\n        } else {\n            Astal.Process.exec_async(cmd, (_, res) => {\n                try {\n                    resolve(Astal.Process.exec_finish(res))\n                } catch (error) {\n                    reject(error)\n                }\n            })\n        }\n    })\n}\n", "import Variable from \"./variable.js\"\nimport { execAsync } from \"./process.js\"\nimport Binding, { Connectable, kebabify, snakeify, Subscribable } from \"./binding.js\"\n\nexport const noImplicitDestroy = Symbol(\"no no implicit destroy\")\nexport const setChildren = Symbol(\"children setter method\")\n\nexport function mergeBindings(array: any[]) {\n    function getValues(...args: any[]) {\n        let i = 0\n        return array.map(value => value instanceof Binding\n            ? args[i++]\n            : value,\n        )\n    }\n\n    const bindings = array.filter(i => i instanceof Binding)\n\n    if (bindings.length === 0)\n        return array\n\n    if (bindings.length === 1)\n        return bindings[0].as(getValues)\n\n    return Variable.derive(bindings, getValues)()\n}\n\nexport function setProp(obj: any, prop: string, value: any) {\n    try {\n        const setter = `set_${snakeify(prop)}`\n        if (typeof obj[setter] === \"function\")\n            return obj[setter](value)\n\n        return (obj[prop] = value)\n    } catch (error) {\n        console.error(`could not set property \"${prop}\" on ${obj}:`, error)\n    }\n}\n\nexport type BindableProps<T> = {\n    [K in keyof T]: Binding<T[K]> | T[K];\n}\n\nexport function hook<Widget extends Connectable>(\n    widget: Widget,\n    object: Connectable | Subscribable,\n    signalOrCallback: string | ((self: Widget, ...args: any[]) => void),\n    callback?: (self: Widget, ...args: any[]) => void,\n) {\n    if (typeof object.connect === \"function\" && callback) {\n        const id = object.connect(signalOrCallback, (_: any, ...args: unknown[]) => {\n            return callback(widget, ...args)\n        })\n        widget.connect(\"destroy\", () => {\n            (object.disconnect as Connectable[\"disconnect\"])(id)\n        })\n    } else if (typeof object.subscribe === \"function\" && typeof signalOrCallback === \"function\") {\n        const unsub = object.subscribe((...args: unknown[]) => {\n            signalOrCallback(widget, ...args)\n        })\n        widget.connect(\"destroy\", unsub)\n    }\n}\n\nexport function construct<Widget extends Connectable & { [setChildren]: (children: any[]) => void }>(widget: Widget, config: any) {\n    // eslint-disable-next-line prefer-const\n    let { setup, child, children = [], ...props } = config\n\n    if (children instanceof Binding) {\n        children = [children]\n    }\n\n    if (child) {\n        children.unshift(child)\n    }\n\n    // remove undefined values\n    for (const [key, value] of Object.entries(props)) {\n        if (value === undefined) {\n            delete props[key]\n        }\n    }\n\n    // collect bindings\n    const bindings: Array<[string, Binding<any>]> = Object\n        .keys(props)\n        .reduce((acc: any, prop) => {\n            if (props[prop] instanceof Binding) {\n                const binding = props[prop]\n                delete props[prop]\n                return [...acc, [prop, binding]]\n            }\n            return acc\n        }, [])\n\n    // collect signal handlers\n    const onHandlers: Array<[string, string | (() => unknown)]> = Object\n        .keys(props)\n        .reduce((acc: any, key) => {\n            if (key.startsWith(\"on\")) {\n                const sig = kebabify(key).split(\"-\").slice(1).join(\"-\")\n                const handler = props[key]\n                delete props[key]\n                return [...acc, [sig, handler]]\n            }\n            return acc\n        }, [])\n\n    // set children\n    const mergedChildren = mergeBindings(children.flat(Infinity))\n    if (mergedChildren instanceof Binding) {\n        widget[setChildren](mergedChildren.get())\n        widget.connect(\"destroy\", mergedChildren.subscribe((v) => {\n            widget[setChildren](v)\n        }))\n    } else {\n        if (mergedChildren.length > 0) {\n            widget[setChildren](mergedChildren)\n        }\n    }\n\n    // setup signal handlers\n    for (const [signal, callback] of onHandlers) {\n        const sig = signal.startsWith(\"notify\")\n            ? signal.replace(\"-\", \"::\")\n            : signal\n\n        if (typeof callback === \"function\") {\n            widget.connect(sig, callback)\n        } else {\n            widget.connect(sig, () => execAsync(callback)\n                .then(print).catch(console.error))\n        }\n    }\n\n    // setup bindings handlers\n    for (const [prop, binding] of bindings) {\n        if (prop === \"child\" || prop === \"children\") {\n            widget.connect(\"destroy\", binding.subscribe((v: any) => {\n                widget[setChildren](v)\n            }))\n        }\n        widget.connect(\"destroy\", binding.subscribe((v: any) => {\n            setProp(widget, prop, v)\n        }))\n        setProp(widget, prop, binding.get())\n    }\n\n    // filter undefined values\n    for (const [key, value] of Object.entries(props)) {\n        if (value === undefined) {\n            delete props[key]\n        }\n    }\n\n    Object.assign(widget, props)\n    setup?.(widget)\n    return widget\n}\n\nfunction isArrowFunction(func: any): func is (args: any) => any {\n    return !Object.hasOwn(func, \"prototype\")\n}\n\nexport function jsx(\n    ctors: Record<string, { new(props: any): any } | ((props: any) => any)>,\n    ctor: string | ((props: any) => any) | { new(props: any): any },\n    { children, ...props }: any,\n) {\n    children ??= []\n\n    if (!Array.isArray(children))\n        children = [children]\n\n    children = children.filter(Boolean)\n\n    if (children.length === 1)\n        props.child = children[0]\n    else if (children.length > 1)\n        props.children = children\n\n    if (typeof ctor === \"string\") {\n        if (isArrowFunction(ctors[ctor]))\n            return ctors[ctor](props)\n\n        return new ctors[ctor](props)\n    }\n\n    if (isArrowFunction(ctor))\n        return ctor(props)\n\n    return new ctor(props)\n}\n", "import { noImplicitDestroy, setChildren, type BindableProps, construct } from \"../_astal.js\"\nimport Gtk from \"gi://Gtk?version=4.0\"\nimport Gdk from \"gi://Gdk?version=4.0\"\nimport Binding from \"../binding.js\"\n\nexport const type = Symbol(\"child type\")\nconst dummyBulder = new Gtk.Builder\n\nfunction _getChildren(widget: Gtk.Widget): Array<Gtk.Widget> {\n    if (\"get_child\" in widget && typeof widget.get_child == \"function\") {\n        return widget.get_child() ? [widget.get_child()] : []\n    }\n\n    const children: Array<Gtk.Widget> = []\n    let ch = widget.get_first_child()\n    while (ch !== null) {\n        children.push(ch)\n        ch = ch.get_next_sibling()\n    }\n    return children\n}\n\nfunction _setChildren(widget: Gtk.Widget, children: any[]) {\n    children = children.flat(Infinity).map(ch => ch instanceof Gtk.Widget\n        ? ch\n        : new Gtk.Label({ visible: true, label: String(ch) }))\n\n\n    for (const child of children) {\n        widget.vfunc_add_child(\n            dummyBulder,\n            child,\n            type in child ? child[type] : null,\n        )\n    }\n}\n\ntype Config<T extends Gtk.Widget> = {\n    setChildren(widget: T, children: any[]): void\n    getChildren(widget: T): Array<Gtk.Widget>\n}\n\nexport default function astalify<\n    Widget extends Gtk.Widget,\n    Props extends Gtk.Widget.ConstructorProps = Gtk.Widget.ConstructorProps,\n    Signals extends Record<`on${string}`, Array<unknown>> = Record<`on${string}`, any[]>,\n>(cls: { new(...args: any[]): Widget }, config: Partial<Config<Widget>> = {}) {\n    Object.assign(cls.prototype, {\n        [setChildren](children: any[]) {\n            const w = this as unknown as Widget\n            for (const child of (config.getChildren?.(w) || _getChildren(w))) {\n                if (child instanceof Gtk.Widget) {\n                    child.unparent()\n                    if (!children.includes(child) && noImplicitDestroy in this)\n                        child.run_dispose()\n                }\n            }\n\n            if (config.setChildren) {\n                config.setChildren(w, children)\n            } else {\n                _setChildren(w, children)\n            }\n        },\n    })\n\n    return {\n        [cls.name]: (\n            props: ConstructProps<Widget, Props, Signals> = {},\n            ...children: any[]\n        ): Widget => {\n            const widget = new cls(\"cssName\" in props ? { cssName: props.cssName } : {})\n\n            if (\"cssName\" in props) {\n                delete props.cssName\n            }\n\n            if (props.noImplicitDestroy) {\n                Object.assign(widget, { [noImplicitDestroy]: true })\n                delete props.noImplicitDestroy\n            }\n\n            if (props.type) {\n                Object.assign(widget, { [type]: props.type })\n                delete props.type\n            }\n\n            if (children.length > 0) {\n                Object.assign(props, { children })\n            }\n\n            return construct(widget as any, setupControllers(widget, props as any))\n        },\n    }[cls.name]\n}\n\ntype SigHandler<\n    W extends InstanceType<typeof Gtk.Widget>,\n    Args extends Array<unknown>,\n> = ((self: W, ...args: Args) => unknown) | string | string[]\n\nexport { BindableProps }\nexport type BindableChild = Gtk.Widget | Binding<Gtk.Widget>\n\nexport type ConstructProps<\n    Self extends InstanceType<typeof Gtk.Widget>,\n    Props extends Gtk.Widget.ConstructorProps,\n    Signals extends Record<`on${string}`, Array<unknown>> = Record<`on${string}`, any[]>,\n> = Partial<{\n    // @ts-expect-error can't assign to unknown, but it works as expected though\n    [S in keyof Signals]: SigHandler<Self, Signals[S]>\n}> & Partial<{\n    [Key in `on${string}`]: SigHandler<Self, any[]>\n}> & Partial<BindableProps<Omit<Props, \"cssName\" | \"css_name\">>> & {\n    noImplicitDestroy?: true\n    type?: string\n    cssName?: string\n} & EventController<Self> & {\n    onDestroy?: (self: Self) => unknown\n    setup?: (self: Self) => void\n}\n\ntype EventController<Self extends Gtk.Widget> = {\n    onFocusEnter?: (self: Self) => void\n    onFocusLeave?: (self: Self) => void\n\n    onKeyPressed?: (self: Self, keyval: number, keycode: number, state: Gdk.ModifierType) => void\n    onKeyReleased?: (self: Self, keyval: number, keycode: number, state: Gdk.ModifierType) => void\n    onKeyModifier?: (self: Self, state: Gdk.ModifierType) => void\n\n    onLegacy?: (self: Self, event: Gdk.Event) => void\n    onButtonPressed?: (self: Self, state: Gdk.ButtonEvent) => void\n    onButtonReleased?: (self: Self, state: Gdk.ButtonEvent) => void\n\n    onHoverEnter?: (self: Self, x: number, y: number) => void\n    onHoverLeave?: (self: Self) => void\n    onMotion?: (self: Self, x: number, y: number) => void\n\n    onScroll?: (self: Self, dx: number, dy: number) => void\n    onScrollDecelerate?: (self: Self, vel_x: number, vel_y: number) => void\n}\n\nfunction setupControllers<T>(widget: Gtk.Widget, {\n    onFocusEnter,\n    onFocusLeave,\n    onKeyPressed,\n    onKeyReleased,\n    onKeyModifier,\n    onLegacy,\n    onButtonPressed,\n    onButtonReleased,\n    onHoverEnter,\n    onHoverLeave,\n    onMotion,\n    onScroll,\n    onScrollDecelerate,\n    ...props\n}: EventController<Gtk.Widget> & T) {\n    if (onFocusEnter || onFocusLeave) {\n        const focus = new Gtk.EventControllerFocus\n        widget.add_controller(focus)\n\n        if (onFocusEnter)\n            focus.connect(\"enter\", () => onFocusEnter(widget))\n\n        if (onFocusLeave)\n            focus.connect(\"leave\", () => onFocusLeave(widget))\n    }\n\n    if (onKeyPressed || onKeyReleased || onKeyModifier) {\n        const key = new Gtk.EventControllerKey\n        widget.add_controller(key)\n\n        if (onKeyPressed)\n            key.connect(\"key-pressed\", (_, val, code, state) => onKeyPressed(widget, val, code, state))\n\n        if (onKeyReleased)\n            key.connect(\"key-released\", (_, val, code, state) => onKeyReleased(widget, val, code, state))\n\n        if (onKeyModifier)\n            key.connect(\"modifiers\", (_, state) => onKeyModifier(widget, state))\n    }\n\n    if (onLegacy || onButtonPressed || onButtonReleased) {\n        const legacy = new Gtk.EventControllerLegacy\n        widget.add_controller(legacy)\n\n        legacy.connect(\"event\", (_, event) => {\n            if (event.get_event_type() === Gdk.EventType.BUTTON_PRESS) {\n                onButtonPressed?.(widget, event as Gdk.ButtonEvent)\n            }\n\n            if (event.get_event_type() === Gdk.EventType.BUTTON_RELEASE) {\n                onButtonReleased?.(widget, event as Gdk.ButtonEvent)\n            }\n\n            onLegacy?.(widget, event)\n        })\n    }\n\n    if (onMotion || onHoverEnter || onHoverLeave) {\n        const hover = new Gtk.EventControllerMotion\n        widget.add_controller(hover)\n\n        if (onHoverEnter)\n            hover.connect(\"enter\", (_, x, y) => onHoverEnter(widget, x, y))\n\n        if (onHoverLeave)\n            hover.connect(\"leave\", () => onHoverLeave(widget))\n\n        if (onMotion)\n            hover.connect(\"motion\", (_, x, y) => onMotion(widget, x, y))\n    }\n\n    if (onScroll || onScrollDecelerate) {\n        const scroll = new Gtk.EventControllerScroll\n        scroll.flags = Gtk.EventControllerScrollFlags.BOTH_AXES | Gtk.EventControllerScrollFlags.KINETIC\n        widget.add_controller(scroll)\n\n        if (onScroll)\n            scroll.connect(\"scroll\", (_, x, y) => onScroll(widget, x, y))\n\n        if (onScrollDecelerate)\n            scroll.connect(\"decelerate\", (_, x, y) => onScrollDecelerate(widget, x, y))\n    }\n\n    return props\n}\n", "import GLib from \"gi://GLib?version=2.0\"\nimport Gtk from \"gi://Gtk?version=4.0\"\nimport Astal from \"gi://Astal?version=4.0\"\nimport { mkApp } from \"../_app\"\n\nGtk.init()\n\n// stop this from leaking into subprocesses\n// and gio launch invocations\nGLib.unsetenv(\"LD_PRELOAD\")\n\n// users might want to use Adwaita in which case it has to be initialized\n// it might be common pitfall to forget it because `App` is not `Adw.Application`\nawait import(\"gi://Adw?version=1\")\n    .then(({ default: Adw }) => Adw.init())\n    .catch(() => void 0)\n\nexport default mkApp(Astal.Application)\n", "/**\n * Workaround for \"Can't convert non-null pointer to JS value \"\n */\n\nexport { }\n\nconst snakeify = (str: string) => str\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .replaceAll(\"-\", \"_\")\n    .toLowerCase()\n\nasync function suppress<T>(mod: Promise<{ default: T }>, patch: (m: T) => void) {\n    return mod.then(m => patch(m.default)).catch(() => void 0)\n}\n\nfunction patch<P extends object>(proto: P, prop: Extract<keyof P, string>) {\n    Object.defineProperty(proto, prop, {\n        get() { return this[`get_${snakeify(prop)}`]() },\n    })\n}\n\nawait suppress(import(\"gi://AstalApps\"), ({ Apps, Application }) => {\n    patch(Apps.prototype, \"list\")\n    patch(Application.prototype, \"keywords\")\n    patch(Application.prototype, \"categories\")\n})\n\nawait suppress(import(\"gi://AstalBattery\"), ({ UPower }) => {\n    patch(UPower.prototype, \"devices\")\n})\n\nawait suppress(import(\"gi://AstalBluetooth\"), ({ Adapter, Bluetooth, Device }) => {\n    patch(Adapter.prototype, \"uuids\")\n    patch(Bluetooth.prototype, \"adapters\")\n    patch(Bluetooth.prototype, \"devices\")\n    patch(Device.prototype, \"uuids\")\n})\n\nawait suppress(import(\"gi://AstalHyprland\"), ({ Hyprland, Monitor, Workspace }) => {\n    patch(Hyprland.prototype, \"binds\")\n    patch(Hyprland.prototype, \"monitors\")\n    patch(Hyprland.prototype, \"workspaces\")\n    patch(Hyprland.prototype, \"clients\")\n    patch(Monitor.prototype, \"availableModes\")\n    patch(Monitor.prototype, \"available_modes\")\n    patch(Workspace.prototype, \"clients\")\n})\n\nawait suppress(import(\"gi://AstalMpris\"), ({ Mpris, Player }) => {\n    patch(Mpris.prototype, \"players\")\n    patch(Player.prototype, \"supported_uri_schemes\")\n    patch(Player.prototype, \"supportedUriSchemes\")\n    patch(Player.prototype, \"supported_mime_types\")\n    patch(Player.prototype, \"supportedMimeTypes\")\n    patch(Player.prototype, \"comments\")\n})\n\nawait suppress(import(\"gi://AstalNetwork\"), ({ Wifi }) => {\n    patch(Wifi.prototype, \"access_points\")\n    patch(Wifi.prototype, \"accessPoints\")\n})\n\nawait suppress(import(\"gi://AstalNotifd\"), ({ Notifd, Notification }) => {\n    patch(Notifd.prototype, \"notifications\")\n    patch(Notification.prototype, \"actions\")\n})\n\nawait suppress(import(\"gi://AstalPowerProfiles\"), ({ PowerProfiles }) => {\n    patch(PowerProfiles.prototype, \"actions\")\n})\n\nawait suppress(import(\"gi://AstalWp\"), ({ Wp, Audio, Video }) => {\n    patch(Wp.prototype, \"endpoints\")\n    patch(Wp.prototype, \"devices\")\n    patch(Audio.prototype, \"streams\")\n    patch(Audio.prototype, \"recorders\")\n    patch(Audio.prototype, \"microphones\")\n    patch(Audio.prototype, \"speakers\")\n    patch(Audio.prototype, \"devices\")\n    patch(Video.prototype, \"streams\")\n    patch(Video.prototype, \"recorders\")\n    patch(Video.prototype, \"sinks\")\n    patch(Video.prototype, \"sources\")\n    patch(Video.prototype, \"devices\")\n})\n", "import \"./overrides.js\"\nimport { setConsoleLogDomain } from \"console\"\nimport { exit, programArgs } from \"system\"\nimport IO from \"gi://AstalIO\"\nimport GObject from \"gi://GObject\"\nimport Gio from \"gi://Gio?version=2.0\"\nimport type Astal3 from \"gi://Astal?version=3.0\"\nimport type Astal4 from \"gi://Astal?version=4.0\"\n\ntype Config = Partial<{\n    instanceName: string\n    css: string\n    icons: string\n    gtkTheme: string\n    iconTheme: string\n    cursorTheme: string\n    hold: boolean\n    requestHandler(request: string, res: (response: any) => void): void\n    main(...args: string[]): void\n    client(message: (msg: string) => string, ...args: string[]): void\n}>\n\ninterface Astal3JS extends Astal3.Application {\n    eval(body: string): Promise<any>\n    requestHandler: Config[\"requestHandler\"]\n    apply_css(style: string, reset?: boolean): void\n    quit(code?: number): void\n    start(config?: Config): void\n}\n\ninterface Astal4JS extends Astal4.Application {\n    eval(body: string): Promise<any>\n    requestHandler?: Config[\"requestHandler\"]\n    apply_css(style: string, reset?: boolean): void\n    quit(code?: number): void\n    start(config?: Config): void\n}\n\ntype App3 = typeof Astal3.Application\ntype App4 = typeof Astal4.Application\n\nexport function mkApp<App extends App3>(App: App): Astal3JS\nexport function mkApp<App extends App4>(App: App): Astal4JS\n\nexport function mkApp(App: App3 | App4) {\n    return new (class AstalJS extends App {\n        static { GObject.registerClass({ GTypeName: \"AstalJS\" }, this as any) }\n\n        eval(body: string): Promise<any> {\n            return new Promise((res, rej) => {\n                try {\n                    const fn = Function(`return (async function() {\n                        ${body.includes(\";\") ? body : `return ${body};`}\n                    })`)\n                    fn()().then(res).catch(rej)\n                } catch (error) {\n                    rej(error)\n                }\n            })\n        }\n\n        requestHandler?: Config[\"requestHandler\"]\n\n        vfunc_request(msg: string, conn: Gio.SocketConnection): void {\n            if (typeof this.requestHandler === \"function\") {\n                this.requestHandler(msg, (response) => {\n                    IO.write_sock(conn, String(response), (_, res) =>\n                        IO.write_sock_finish(res),\n                    )\n                })\n            } else {\n                super.vfunc_request(msg, conn)\n            }\n        }\n\n        apply_css(style: string, reset = false) {\n            super.apply_css(style, reset)\n        }\n\n        quit(code?: number): void {\n            super.quit()\n            exit(code ?? 0)\n        }\n\n        start({ requestHandler, css, hold, main, client, icons, ...cfg }: Config = {}) {\n            const app = this as unknown as InstanceType<App3 | App4>\n\n            client ??= () => {\n                print(`Astal instance \"${app.instanceName}\" already running`)\n                exit(1)\n            }\n\n            Object.assign(this, cfg)\n            setConsoleLogDomain(app.instanceName)\n\n            this.requestHandler = requestHandler\n            app.connect(\"activate\", () => {\n                main?.(...programArgs)\n            })\n\n            try {\n                app.acquire_socket()\n            } catch (error) {\n                return client(msg => IO.send_request(app.instanceName, msg)!, ...programArgs)\n            }\n\n            if (css)\n                this.apply_css(css, false)\n\n            if (icons)\n                app.add_icons(icons)\n\n            hold ??= true\n            if (hold)\n                app.hold()\n\n            app.runAsync([])\n        }\n    })\n}\n", "import Astal from \"gi://Astal?version=4.0\"\nimport Gtk from \"gi://Gtk?version=4.0\"\nimport astalify, { type, type ConstructProps } from \"./astalify.js\"\n\nfunction filter(children: any[]) {\n    return children.flat(Infinity).map(ch => ch instanceof Gtk.Widget\n        ? ch\n        : new Gtk.Label({ visible: true, label: String(ch) }))\n}\n\n// Box\nObject.defineProperty(Astal.Box.prototype, \"children\", {\n    get() { return this.get_children() },\n    set(v) { this.set_children(v) },\n})\n\nexport type BoxProps = ConstructProps<Astal.Box, Astal.Box.ConstructorProps>\nexport const Box = astalify<Astal.Box, Astal.Box.ConstructorProps>(Astal.Box, {\n    getChildren(self) { return self.get_children() },\n    setChildren(self, children) { return self.set_children(filter(children)) },\n})\n\n// Button\ntype ButtonSignals = {\n    onClicked: []\n}\n\nexport type ButtonProps = ConstructProps<Gtk.Button, Gtk.Button.ConstructorProps, ButtonSignals>\nexport const Button = astalify<Gtk.Button, Gtk.Button.ConstructorProps, ButtonSignals>(Gtk.Button)\n\n// CenterBox\nexport type CenterBoxProps = ConstructProps<Gtk.CenterBox, Gtk.CenterBox.ConstructorProps>\nexport const CenterBox = astalify<Gtk.CenterBox, Gtk.CenterBox.ConstructorProps>(Gtk.CenterBox, {\n    getChildren(box) {\n        return [box.startWidget, box.centerWidget, box.endWidget]\n    },\n    setChildren(box, children) {\n        const ch = filter(children)\n        box.startWidget = ch[0] || new Gtk.Box\n        box.centerWidget = ch[1] || new Gtk.Box\n        box.endWidget = ch[2] || new Gtk.Box\n    },\n})\n\n// TODO: CircularProgress\n// TODO: DrawingArea\n\n// Entry\ntype EntrySignals = {\n    onActivate: []\n    onNotifyText: []\n}\n\nexport type EntryProps = ConstructProps<Gtk.Entry, Gtk.Entry.ConstructorProps, EntrySignals>\nexport const Entry = astalify<Gtk.Entry, Gtk.Entry.ConstructorProps, EntrySignals>(Gtk.Entry, {\n    getChildren() { return [] },\n})\n\n// Image\nexport type ImageProps = ConstructProps<Gtk.Image, Gtk.Image.ConstructorProps>\nexport const Image = astalify<Gtk.Image, Gtk.Image.ConstructorProps>(Gtk.Image, {\n    getChildren() { return [] },\n})\n\n// Label\nexport type LabelProps = ConstructProps<Gtk.Label, Gtk.Label.ConstructorProps>\nexport const Label = astalify<Gtk.Label, Gtk.Label.ConstructorProps>(Gtk.Label, {\n    getChildren() { return [] },\n    setChildren(self, children) { self.label = String(children) },\n})\n\n// LevelBar\nexport type LevelBarProps = ConstructProps<Gtk.LevelBar, Gtk.LevelBar.ConstructorProps>\nexport const LevelBar = astalify<Gtk.LevelBar, Gtk.LevelBar.ConstructorProps>(Gtk.LevelBar, {\n    getChildren() { return [] },\n})\n\n// TODO: ListBox\n\n// Overlay\nexport type OverlayProps = ConstructProps<Gtk.Overlay, Gtk.Overlay.ConstructorProps>\nexport const Overlay = astalify<Gtk.Overlay, Gtk.Overlay.ConstructorProps>(Gtk.Overlay, {\n    getChildren(self) {\n        const children: Array<Gtk.Widget> = []\n        let ch = self.get_first_child()\n        while (ch !== null) {\n            children.push(ch)\n            ch = ch.get_next_sibling()\n        }\n\n        return children.filter(ch => ch !== self.child)\n    },\n    setChildren(self, children) {\n        for (const child of filter(children)) {\n            const types = type in child\n                ? (child[type] as string).split(/\\s+/)\n                : []\n\n            if (types.includes(\"overlay\")) {\n                self.add_overlay(child)\n            } else {\n                self.set_child(child)\n            }\n\n            self.set_measure_overlay(child, types.includes(\"measure\"))\n            self.set_clip_overlay(child, types.includes(\"clip\"))\n        }\n    },\n})\n\n// Revealer\nexport type RevealerProps = ConstructProps<Gtk.Revealer, Gtk.Revealer.ConstructorProps>\nexport const Revealer = astalify<Gtk.Revealer, Gtk.Revealer.ConstructorProps>(Gtk.Revealer)\n\n// Slider\ntype SliderSignals = {\n    onChangeValue: []\n}\n\nexport type SliderProps = ConstructProps<Astal.Slider, Astal.Slider.ConstructorProps, SliderSignals>\nexport const Slider = astalify<Astal.Slider, Astal.Slider.ConstructorProps, SliderSignals>(Astal.Slider, {\n    getChildren() { return [] },\n})\n\n// Stack\nexport type StackProps = ConstructProps<Gtk.Stack, Gtk.Stack.ConstructorProps>\nexport const Stack = astalify<Gtk.Stack, Gtk.Stack.ConstructorProps>(Gtk.Stack, {\n    setChildren(self, children) {\n        for (const child of filter(children)) {\n            if (child.name != \"\" && child.name != null) {\n                self.add_named(child, child.name)\n            } else {\n                self.add_child(child)\n            }\n        }\n    },\n})\n\n// Switch\nexport type SwitchProps = ConstructProps<Gtk.Switch, Gtk.Switch.ConstructorProps>\nexport const Switch = astalify<Gtk.Switch, Gtk.Switch.ConstructorProps>(Gtk.Switch, {\n    getChildren() { return [] },\n})\n\n// Window\nexport type WindowProps = ConstructProps<Astal.Window, Astal.Window.ConstructorProps>\nexport const Window = astalify<Astal.Window, Astal.Window.ConstructorProps>(Astal.Window)\n\n// MenuButton\nexport type MenuButtonProps = ConstructProps<Gtk.MenuButton, Gtk.MenuButton.ConstructorProps>\nexport const MenuButton = astalify<Gtk.MenuButton, Gtk.MenuButton.ConstructorProps>(Gtk.MenuButton, {\n    getChildren(self) { return [self.popover, self.child] },\n    setChildren(self, children) {\n        for (const child of filter(children)) {\n            if (child instanceof Gtk.Popover) {\n                self.set_popover(child)\n            } else {\n                self.set_child(child)\n            }\n        }\n    },\n})\n\n// Popoper\nexport type PopoverProps = ConstructProps<Gtk.Popover, Gtk.Popover.ConstructorProps>\nexport const Popover = astalify<Gtk.Popover, Gtk.Popover.ConstructorProps>(Gtk.Popover)\n", "/* @use './components/notifications/notifications.scss'; */\nwindow.Bar {\n  font-family: \"Comfortaa, sans-serif\";\n  background: transparent;\n  color: #E6E6E6;\n  font-weight: bold;\n  /* >centerbox { */\n  /*     background: $bg-color; */\n  /*     border-radius: 10px; */\n  /*     margin: 8px; */\n  /* } */\n}\nwindow.Bar .bar-button {\n  border-radius: 20px;\n  margin: 2px;\n  padding-left: 10px;\n  padding-right: 10px;\n  background-color: #141414;\n}\nwindow.Bar .bar-button button {\n  background-color: #141414;\n}\nwindow.Bar .quick-action-button {\n  border-radius: 20px;\n  margin: 2px;\n  padding-left: 10px;\n  padding-right: 10px;\n  background-color: #141414;\n}\nwindow.Bar button.workspace-button {\n  border-radius: 20px;\n  margin: 1px;\n}\nwindow.Bar button.workspace-button.focused-workspace-button {\n  color: #5F50A6;\n}\nwindow.Bar .tray-item {\n  margin: 0;\n  padding: 0;\n}\nwindow.Bar .tray-item button {\n  margin: 2px;\n  box-shadow: none;\n}\nwindow.Bar .time {\n  min-width: 11rem;\n  padding: 3px;\n}\nwindow.Bar .time button {\n  box-shadow: none;\n  padding: 0;\n}\n\nbox.players-box {\n  margin-top: 20px;\n}\n\nbox.player {\n  padding: 0.6rem;\n}\nbox.player .cover-art {\n  min-width: 100px;\n  min-height: 100px;\n  border-radius: 9px;\n  margin-right: 0.6rem;\n  background-size: contain;\n  background-position: center;\n}\nbox.player .title {\n  font-weight: bold;\n  font-size: 1.1em;\n}\nbox.player scale {\n  padding: 0;\n  margin: 0.4rem 0;\n  border-radius: 20px;\n}\nbox.player scale trough {\n  min-height: 8px;\n  border-radius: 20px;\n}\nbox.player scale highlight {\n  background-color: @theme_fg_color;\n  border-radius: 20px;\n}\nbox.player scale slider {\n  all: unset;\n  border-radius: 20px;\n}\nbox.player centerbox.actions {\n  min-width: 220px;\n}\nbox.player centerbox.actions button {\n  min-width: 0;\n  min-height: 0;\n  padding: 0.4rem;\n  margin: 0 0.2rem;\n}\n\n.audio-box {\n  min-width: 320px;\n}\n\n.quick-actions-wrapper {\n  min-width: 520px;\n}\n\nbox.quick-actions {\n  padding: 10px;\n}\n\npopover * {\n  border-radius: 20px;\n}\n\nbutton {\n  margin: 4px;\n}\n\n.button-no-margin {\n  margin-top: 0;\n  margin-bottom: 0;\n}\n\n.devices-list {\n  margin-bottom: 20px;\n}\n\nbutton.toggle-button {\n  min-width: 220px;\n  border-radius: 50px;\n}\nbutton.toggle-button.toggle-on {\n  min-width: 190px;\n  margin-right: 0;\n  border-top-right-radius: 0;\n  border-bottom-right-radius: 0;\n  background-color: #B27BD1;\n}\n\nbutton.actions-button {\n  margin-left: 0;\n  border-radius: 0;\n  background-color: #B27BD1;\n  border-top-right-radius: 50px;\n  border-bottom-right-radius: 50px;\n}\n\n.avatar-icon {\n  border-radius: 100px;\n  min-height: 40px;\n  min-width: 40px;\n  margin-right: 10px;\n}\n\n* {\n  font-size: 1rem;\n}\n\nempty {\n  min-width: 0;\n  background-color: transparent;\n}\n\n.title {\n  font-size: 1.5rem;\n  font-weight: bold;\n}\n\n.title-2 {\n  font-size: 1.2rem;\n  font-weight: bold;\n}", "import AstalTray from \"gi://AstalTray\";\nimport { bind, GObject } from \"astal\";\nimport AstalHyprland from \"gi://AstalHyprland\";\nimport { Gtk } from \"astal/gtk4\";\n\nconst hypr = AstalHyprland.get_default();\nconst SYNC = GObject.BindingFlags.SYNC_CREATE;\n\nconst SysTray = () => {\n    const trayBox = new Gtk.Box({ cssClasses: [\"bar-button\"] });\n    const tray = AstalTray.get_default();\n\n    const trayItems = new Map<string, Gtk.MenuButton>();\n    const trayAddedHandler = tray.connect(\"item-added\", (_, id) => {\n        const item = tray.get_item(id);\n        const popover = Gtk.PopoverMenu.new_from_model(item.menu_model);\n        const icon = new Gtk.Image();\n        const button = new Gtk.MenuButton({\n            popover,\n            child: icon,\n            cssClasses: [\"tray-item\"],\n        });\n\n        item.bind_property(\"gicon\", icon, \"gicon\", SYNC);\n        popover.insert_action_group(\"dbusmenu\", item.action_group);\n        item.connect(\"notify::action-group\", () => {\n            popover.insert_action_group(\"dbusmenu\", item.action_group);\n        });\n\n        trayItems.set(id, button);\n        trayBox.append(button);\n    });\n\n    const trayRemovedHandler = tray.connect(\"item-removed\", (_, id) => {\n        const button = trayItems.get(id);\n        if (button) {\n            trayBox.remove(button);\n            button.run_dispose();\n            trayItems.delete(id);\n        }\n    });\n\n    trayBox.connect(\"destroy\", () => {\n        tray.disconnect(trayAddedHandler);\n        tray.disconnect(trayRemovedHandler);\n    });\n\n    return trayBox;\n};\n\nconst Workspace = () => {\n    return (\n        <box>\n            {bind(hypr, \"workspaces\").as(wss =>\n                wss\n                    .filter(ws => !(ws.id >= -99 && ws.id <= -2)) // filter out special workspaces\n                    .sort((a, b) => a.id - b.id)\n                    .map(ws => (\n                        <button\n                            cssClasses={bind(hypr, \"focusedWorkspace\").as(fw =>\n                                ws === fw\n                                    ? [\n                                        \"focused-workspace-button\",\n                                        \"workspace-button\",\n                                    ]\n                                    : [\"workspace-button\"],\n                            )}\n                            onButtonPressed={() => ws.focus()}\n                            child={<label label={String(ws.id)}></label>}\n                        ></button>\n                    )),\n            )}\n        </box>\n    );\n};\n\n/**\n * Displays the name of the currently active window and provides a popover for\n * displaying all available clients\n */\nconst ActiveWindow = () => {\n    const focused = bind(hypr, \"focusedClient\");\n\n    const WindowPopover = (): Gtk.Popover => {\n        // Set up boxes + Popover\n        const popover = new Gtk.Popover();\n\n        const popoverBox = WindowPopoverBox();\n\n        popover.set_child(popoverBox);\n        return popover;\n    };\n\n    const windowPopover = WindowPopover();\n\n    // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // Return fully assembled HyprlandFocusedClient box\n    // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    return (\n        <box visible={focused.as(Boolean)}>\n            <button\n                onClicked={() => windowPopover.popup()}\n                cssClasses={[\"bar-button\"]}\n                child={\n                    focused.as(\n                        client =>\n                            client && (\n                                <label label={bind(client, \"title\").as(String)} />\n                            ),\n                    )\n                }></button>\n            {windowPopover}\n        </box >\n    );\n};\n\nconst WindowPopoverBox = () => {\n    return <box vertical>\n        <label label={\"Available Windows\"} cssClasses={['title-2']}></label>\n        <Gtk.Separator marginTop={5} marginBottom={5}></Gtk.Separator>\n        <box vertical>\n            {bind(hypr, 'clients').as(clients => {\n                return clients.map(client => {\n                    return <box>\n                        <label label={bind(client, 'workspace').as(w => `(WS ${w})`)}></label>\n                        <label label={bind(client, 'initialClass').as(c => `[${c}]`)}></label>\n                        <label label={bind(client, 'title')}></label>\n                    </box>\n                })\n            })}\n        </box>\n    </box>\n}\n\nexport default {\n    Workspace,\n    ActiveWindow,\n    SysTray,\n};\n", "import \"./overrides.js\"\nexport { default as AstalIO } from \"gi://AstalIO?version=0.1\"\nexport * from \"./process.js\"\nexport * from \"./time.js\"\nexport * from \"./file.js\"\nexport * from \"./gobject.js\"\nexport { Binding, bind } from \"./binding.js\"\nexport { Variable, derive } from \"./variable.js\"\n", "import Astal from \"gi://AstalIO\"\nimport Gio from \"gi://Gio?version=2.0\"\n\nexport { Gio }\n\nexport function readFile(path: string): string {\n    return Astal.read_file(path) || \"\"\n}\n\nexport function readFileAsync(path: string): Promise<string> {\n    return new Promise((resolve, reject) => {\n        Astal.read_file_async(path, (_, res) => {\n            try {\n                resolve(Astal.read_file_finish(res) || \"\")\n            } catch (error) {\n                reject(error)\n            }\n        })\n    })\n}\n\nexport function writeFile(path: string, content: string): void {\n    Astal.write_file(path, content)\n}\n\nexport function writeFileAsync(path: string, content: string): Promise<void> {\n    return new Promise((resolve, reject) => {\n        Astal.write_file_async(path, content, (_, res) => {\n            try {\n                resolve(Astal.write_file_finish(res))\n            } catch (error) {\n                reject(error)\n            }\n        })\n    })\n}\n\nexport function monitorFile(\n    path: string,\n    callback: (file: string, event: Gio.FileMonitorEvent) => void,\n): Gio.FileMonitor {\n    return Astal.monitor_file(path, (file: string, event: Gio.FileMonitorEvent) => {\n        callback(file, event)\n    })!\n}\n", "import GObject from \"gi://GObject\"\n\nexport { default as GLib } from \"gi://GLib?version=2.0\"\nexport { GObject, GObject as default }\n\nconst meta = Symbol(\"meta\")\nconst priv = Symbol(\"priv\")\n\nconst { ParamSpec, ParamFlags } = GObject\n\nconst kebabify = (str: string) => str\n    .replace(/([a-z])([A-Z])/g, \"$1-$2\")\n    .replaceAll(\"_\", \"-\")\n    .toLowerCase()\n\ntype SignalDeclaration = {\n    flags?: GObject.SignalFlags\n    accumulator?: GObject.AccumulatorType\n    return_type?: GObject.GType\n    param_types?: Array<GObject.GType>\n}\n\ntype PropertyDeclaration =\n    | InstanceType<typeof GObject.ParamSpec>\n    | { $gtype: GObject.GType }\n    | typeof String\n    | typeof Number\n    | typeof Boolean\n    | typeof Object\n\ntype GObjectConstructor = {\n    [meta]?: {\n        Properties?: { [key: string]: GObject.ParamSpec }\n        Signals?: { [key: string]: GObject.SignalDefinition }\n    }\n    new(...args: any[]): any\n}\n\ntype MetaInfo = GObject.MetaInfo<never, Array<{ $gtype: GObject.GType }>, never>\n\nexport function register(options: MetaInfo = {}) {\n    return function (cls: GObjectConstructor) {\n        const t = options.Template\n        if (typeof t === \"string\" && !t.startsWith(\"resource://\") && !t.startsWith(\"file://\")) {\n            // assume xml template\n            options.Template = new TextEncoder().encode(t)\n        }\n\n        GObject.registerClass({\n            Signals: { ...cls[meta]?.Signals },\n            Properties: { ...cls[meta]?.Properties },\n            ...options,\n        }, cls)\n\n        delete cls[meta]\n    }\n}\n\nexport function property(declaration: PropertyDeclaration = Object) {\n    return function (target: any, prop: any, desc?: PropertyDescriptor) {\n        target.constructor[meta] ??= {}\n        target.constructor[meta].Properties ??= {}\n\n        const name = kebabify(prop)\n\n        if (!desc) {\n            Object.defineProperty(target, prop, {\n                get() {\n                    return this[priv]?.[prop] ?? defaultValue(declaration)\n                },\n                set(v: any) {\n                    if (v !== this[prop]) {\n                        this[priv] ??= {}\n                        this[priv][prop] = v\n                        this.notify(name)\n                    }\n                },\n            })\n\n            Object.defineProperty(target, `set_${name.replace(\"-\", \"_\")}`, {\n                value(v: any) {\n                    this[prop] = v\n                },\n            })\n\n            Object.defineProperty(target, `get_${name.replace(\"-\", \"_\")}`, {\n                value() {\n                    return this[prop]\n                },\n            })\n\n            target.constructor[meta].Properties[kebabify(prop)] = pspec(name, ParamFlags.READWRITE, declaration)\n        } else {\n            let flags = 0\n            if (desc.get) flags |= ParamFlags.READABLE\n            if (desc.set) flags |= ParamFlags.WRITABLE\n\n            target.constructor[meta].Properties[kebabify(prop)] = pspec(name, flags, declaration)\n        }\n    }\n}\n\nexport function signal(...params: Array<{ $gtype: GObject.GType } | typeof Object>):\n(target: any, signal: any, desc?: PropertyDescriptor) => void\n\nexport function signal(declaration?: SignalDeclaration):\n(target: any, signal: any, desc?: PropertyDescriptor) => void\n\nexport function signal(\n    declaration?: SignalDeclaration | { $gtype: GObject.GType } | typeof Object,\n    ...params: Array<{ $gtype: GObject.GType } | typeof Object>\n) {\n    return function (target: any, signal: any, desc?: PropertyDescriptor) {\n        target.constructor[meta] ??= {}\n        target.constructor[meta].Signals ??= {}\n\n        const name = kebabify(signal)\n\n        if (declaration || params.length > 0) {\n            // @ts-expect-error TODO: type assert\n            const arr = [declaration, ...params].map(v => v.$gtype)\n            target.constructor[meta].Signals[name] = {\n                param_types: arr,\n            }\n        } else {\n            target.constructor[meta].Signals[name] = declaration || {\n                param_types: [],\n            }\n        }\n\n        if (!desc) {\n            Object.defineProperty(target, signal, {\n                value: function (...args: any[]) {\n                    this.emit(name, ...args)\n                },\n            })\n        } else {\n            const og: ((...args: any[]) => void) = desc.value\n            desc.value = function (...args: any[]) {\n                // @ts-expect-error not typed\n                this.emit(name, ...args)\n            }\n            Object.defineProperty(target, `on_${name.replace(\"-\", \"_\")}`, {\n                value: function (...args: any[]) {\n                    return og.apply(this, args)\n                },\n            })\n        }\n    }\n}\n\nfunction pspec(name: string, flags: number, declaration: PropertyDeclaration) {\n    if (declaration instanceof ParamSpec)\n        return declaration\n\n    switch (declaration) {\n        case String:\n            return ParamSpec.string(name, \"\", \"\", flags, \"\")\n        case Number:\n            return ParamSpec.double(name, \"\", \"\", flags, -Number.MAX_VALUE, Number.MAX_VALUE, 0)\n        case Boolean:\n            return ParamSpec.boolean(name, \"\", \"\", flags, false)\n        case Object:\n            return ParamSpec.jsobject(name, \"\", \"\", flags)\n        default:\n            // @ts-expect-error misstyped\n            return ParamSpec.object(name, \"\", \"\", flags, declaration.$gtype)\n    }\n}\n\nfunction defaultValue(declaration: PropertyDeclaration) {\n    if (declaration instanceof ParamSpec)\n        return declaration.get_default_value()\n\n    switch (declaration) {\n        case String:\n            return \"\"\n        case Number:\n            return 0\n        case Boolean:\n            return false\n        case Object:\n        default:\n            return null\n    }\n}\n", "import Gtk from \"gi://Gtk?version=4.0\"\nimport { type BindableChild } from \"./astalify.js\"\nimport { mergeBindings, jsx as _jsx } from \"../_astal.js\"\nimport * as Widget from \"./widget.js\"\n\nexport function Fragment({ children = [], child }: {\n    child?: BindableChild\n    children?: Array<BindableChild>\n}) {\n    if (child) children.push(child)\n    return mergeBindings(children)\n}\n\nexport function jsx(\n    ctor: keyof typeof ctors | typeof Gtk.Widget,\n    props: any,\n) {\n    return _jsx(ctors, ctor as any, props)\n}\n\nconst ctors = {\n    box: Widget.Box,\n    button: Widget.Button,\n    centerbox: Widget.CenterBox,\n    // circularprogress: Widget.CircularProgress,\n    // drawingarea: Widget.DrawingArea,\n    entry: Widget.Entry,\n    image: Widget.Image,\n    label: Widget.Label,\n    levelbar: Widget.LevelBar,\n    overlay: Widget.Overlay,\n    revealer: Widget.Revealer,\n    slider: Widget.Slider,\n    stack: Widget.Stack,\n    switch: Widget.Switch,\n    window: Widget.Window,\n    menubutton: Widget.MenuButton,\n    popover: Widget.Popover,\n}\n\ndeclare global {\n    // eslint-disable-next-line @typescript-eslint/no-namespace\n    namespace JSX {\n        type Element = Gtk.Widget\n        type ElementClass = Gtk.Widget\n        interface IntrinsicElements {\n            box: Widget.BoxProps\n            button: Widget.ButtonProps\n            centerbox: Widget.CenterBoxProps\n            // circularprogress: Widget.CircularProgressProps\n            // drawingarea: Widget.DrawingAreaProps\n            entry: Widget.EntryProps\n            image: Widget.ImageProps\n            label: Widget.LabelProps\n            levelbar: Widget.LevelBarProps\n            overlay: Widget.OverlayProps\n            revealer: Widget.RevealerProps\n            slider: Widget.SliderProps\n            stack: Widget.StackProps\n            switch: Widget.SwitchProps\n            window: Widget.WindowProps\n            menubutton: Widget.MenuButtonProps\n            popover: Widget.PopoverProps\n        }\n    }\n}\n\nexport const jsxs = jsx\n", "import { GLib, Variable } from \"astal\";\nimport { Gtk } from \"astal/gtk4\";\n\nconst Time = ({ format = \"%a, %e.%m %H:%M:%S\" }) => {\n    const time = Variable<string>(\"\").poll(\n        1000,\n        () => GLib.DateTime.new_now_local().format(format)!,\n    );\n\n    return (\n        <menubutton\n            cssClasses={[\"time\", \"bar-button\"]}\n            hexpand\n            halign={Gtk.Align.CENTER}\n        >\n            <label onDestroy={() => time.drop()} label={time()} halign={Gtk.Align.CENTER}></label>\n            <popover>\n                <Gtk.Calendar />\n            </popover>\n        </menubutton>\n    );\n};\n\nexport default {\n    Time,\n};\n", "import { bind } from \"astal\";\nimport AstalBattery from \"gi://AstalBattery\";\nimport AstalBluetooth from \"gi://AstalBluetooth\";\nimport AstalNetwork from \"gi://AstalNetwork\";\nimport AstalWp from \"gi://AstalWp\";\nimport { Gtk } from \"astal/gtk4\";\nimport Brightness from \"../../../util/brightness\";\nimport QuickActions from \"../../QuickActions/QuickActions\";\n\nconst STATE = AstalNetwork.DeviceState;\n\nconst QuickView = () => {\n    const qa = QuickActions.QuickActions();\n    const showQuickActions = () => {\n        qa.popup();\n    };\n\n    return (\n        <button\n            onClicked={() => showQuickActions()}\n            cssClasses={[\"quick-action-button\"]}\n            child={\n                <box>\n                    <BatteryWidget></BatteryWidget>\n                    <Audio></Audio>\n                    <BluetoothWidget></BluetoothWidget>\n                    <NetworkWidget></NetworkWidget>\n                    <BrightnessWidget></BrightnessWidget>\n                    <image iconName={\"system-shutdown-symbolic\"}></image>\n                    {qa}\n                </box>\n            }\n        ></button>\n    );\n};\n\nconst NetworkWidget = () => {\n    const network = AstalNetwork.get_default();\n\n    return (\n        <box>\n            <image\n                iconName={bind(network, \"state\").as(state => {\n                    if (state === AstalNetwork.State.CONNECTING) {\n                        return \"chronometer-reset-symbolic\";\n                    } else if (\n                        state === AstalNetwork.State.CONNECTED_LOCAL ||\n                        state === AstalNetwork.State.CONNECTED_SITE ||\n                        state === AstalNetwork.State.CONNECTED_GLOBAL\n                    ) {\n                        return \"network-wired-activated-symbolic\";\n                    } else {\n                        return \"paint-unknown-symbolic\";\n                    }\n                })}\n                cssClasses={[\"network-widget\", \"quick-view-symbol\"]}\n                visible={bind(network.wifi, \"state\").as(\n                    state => state !== STATE.ACTIVATED,\n                )}\n            ></image>\n            <image\n                iconName={bind(network.wifi, \"state\").as(state => {\n                    if (state === STATE.ACTIVATED) {\n                        return network.wifi.iconName;\n                    } else {\n                        return \"\";\n                    }\n                })}\n                cssClasses={[\"network-widget\", \"quick-view-symbol\"]}\n                visible={bind(network.wifi, \"state\").as(\n                    state => state === STATE.ACTIVATED,\n                )}\n            ></image>\n        </box>\n    );\n};\n\nconst BluetoothWidget = () => {\n    const bluetooth = AstalBluetooth.get_default();\n    const enabled = bind(bluetooth.adapter, \"powered\");\n    const connected = bind(bluetooth, \"isConnected\");\n\n    // For each connected BT device, render status\n    return (\n        <box>\n            <box visible={enabled.as(e => e)}>\n                <image\n                    iconName={\"bluetooth-active-symbolic\"}\n                    visible={connected.as(c => c)}\n                ></image>\n                <image\n                    iconName={\"bluetooth-disconnected-symbolic\"}\n                    visible={connected.as(c => !c)}\n                ></image>\n            </box>\n            <image\n                iconName={\"bluetooth-disabled-symbolic\"}\n                visible={enabled.as(e => !e)}\n            ></image>\n            <box>\n                {bind(bluetooth, \"devices\").as(devices => {\n                    return devices.map(device => {\n                        return (\n                            <box visible={bind(device, \"connected\").as(c => c)}>\n                                <image\n                                    iconName={bind(device, \"icon\").as(\n                                        icon => icon,\n                                    )}\n                                ></image>\n                                <label\n                                    label={bind(device, \"batteryPercentage\").as(\n                                        n => {\n                                            return n + \"%\";\n                                        },\n                                    )}\n                                ></label>\n                            </box>\n                        );\n                    });\n                })}\n            </box>\n        </box>\n    );\n};\n\nconst BatteryWidget = () => {\n    const battery = AstalBattery.get_default();\n    if (battery.get_is_present()) {\n        return (\n            <image\n                iconName={bind(battery, \"iconName\").as(icon => icon)}\n                cssClasses={[\"quick-view-symbol\"]}\n            ></image>\n        );\n    } else {\n        return <box></box>;\n    }\n    // Else, no battery available -> Don't show the widget\n};\n\nconst BrightnessWidget = () => {\n    const brightness = Brightness.get_default();\n    const screen_brightness = bind(brightness, \"screen\");\n\n    return (\n        <label\n            label={\"\uD83C\uDF23\" + screen_brightness}\n            visible={bind(brightness, \"screenAvailable\")}\n            cssClasses={[\"quick-view-symbol\"]}\n        ></label>\n    );\n};\n\nconst Audio = () => {\n    const wireplumber = AstalWp.get_default();\n    if (wireplumber) {\n        return (\n            <box orientation={Gtk.Orientation.HORIZONTAL}>\n                <image\n                    iconName={bind(wireplumber.defaultSpeaker, \"volumeIcon\").as(\n                        icon => icon,\n                    )}\n                    cssClasses={[\"quick-view-symbol\"]}\n                ></image>\n                <image\n                    iconName={bind(\n                        wireplumber.defaultMicrophone,\n                        \"volumeIcon\",\n                    ).as(icon => icon)}\n                    cssClasses={[\"quick-view-symbol\"]}\n                ></image>\n            </box>\n        );\n    } else {\n        print(\n            \"[ WirePlumber ] Could not connect, Audio support in bar will be missing\",\n        );\n        return <image iconName={\"action-unavailable-symbolic\"}></image>;\n    }\n};\n\n// cssClasses={[ 'quick-view-symbol' ]}\n\nexport default {\n    QuickView,\n};\n", "import GObject, { register, property } from \"astal/gobject\"\nimport { monitorFile, readFileAsync } from \"astal/file\"\nimport { exec, execAsync } from \"astal/process\"\n\nconst get = (args: string) => Number(exec(`brightnessctl ${args}`))\nconst screen = exec(`bash -c \"ls -w1 /sys/class/backlight | head -1\"`)\nconst kbd = exec(`bash -c \"ls -w1 /sys/class/leds | head -1\"`)\n\n@register({ GTypeName: \"Brightness\" })\nexport default class Brightness extends GObject.Object {\n    static instance: Brightness\n    static get_default() {\n        if (!this.instance)\n            this.instance = new Brightness()\n        \n        return this.instance\n    }\n\n    #kbdMax = get(`--device ${kbd} max`)\n    #kbd = get(`--device ${kbd} get`)\n    #screenMax = get(\"max\")\n    #screen = get(\"get\") / (get(\"max\") || 1)\n    #screenAvailable = false\n\n    @property(Boolean)\n    get screenAvailable() { return this.#screenAvailable }\n\n    @property(Number)\n    get kbd() { return this.#kbd }\n\n    set kbd(value) {\n        if (value < 0 || value > this.#kbdMax)\n            return\n\n        execAsync(`brightnessctl -d ${kbd} s ${value} -q`).then(() => {\n            this.#kbd = value\n            this.notify(\"kbd\")\n        })\n    }\n\n    @property(Number)\n    get screen() { return this.#screen }\n\n    set screen(percent) {\n        if (percent < 0)\n            percent = 0\n\n        if (percent > 1)\n            percent = 1\n\n        execAsync(`brightnessctl set ${Math.floor(percent * 100)}% -q`).then(() => {\n            this.#screen = percent\n            this.notify(\"screen\")\n        })\n    }\n\n    constructor() {\n        super()\n\n        const screenPath = `/sys/class/backlight/${screen}/brightness`\n        const kbdPath = `/sys/class/leds/${kbd}/brightness`\n\n        monitorFile(screenPath, async f => {\n            const v = await readFileAsync(f)\n            this.#screen = Number(v) / this.#screenMax\n            this.notify(\"screen\")\n        })\n\n        monitorFile(kbdPath, async f => {\n            const v = await readFileAsync(f)\n            this.#kbd = Number(v) / this.#kbdMax\n            this.notify(\"kbd\")\n        })\n\n        // Check if there is a screen available\n        try {\n            get( 'g -c backlight' );\n        } catch ( _ ) {\n            this.#screenAvailable = false;\n        }\n    }\n}\n", "import { exec } from \"astal\";\nimport { Gtk } from \"astal/gtk4\";\n\nconst PowerMenu = (): Gtk.Popover => {\n    const popover = new Gtk.Popover({ cssClasses: [\"PowerMenu\"] });\n\n    const powerMenuBox = () => {\n        return (\n            <box>\n                <button\n                    cssClasses={[\"power-button\"]}\n                    child={\n                        <image iconName={\"system-shutdown-symbolic\"}></image>\n                    }\n                    onClicked={() => exec(\"/bin/sh -c 'shutdown now'\")}\n                ></button>\n                <button\n                    cssClasses={[\"power-button\"]}\n                    child={<image iconName={\"system-reboot-symbolic\"}></image>}\n                    onClicked={() => exec(\"/bin/sh -c 'reboot'\")}\n                ></button>\n                <button\n                    cssClasses={[\"power-button\"]}\n                    child={<image iconName={\"system-suspend-symbolic\"}></image>}\n                    onClicked={() => exec(\"/bin/sh -c 'systemctl suspend'\")}\n                ></button>\n            </box>\n        );\n    };\n\n    popover.set_child(powerMenuBox());\n    return popover;\n};\n\nconst Power = () => {\n    const pm = PowerMenu();\n    return (\n        <button\n            widthRequest={0}\n            hexpand={false}\n            vexpand={false}\n            cssClasses={[\"power-menu-button\"]}\n            child={\n                <box>\n                    <image iconName={\"system-shutdown-symbolic\"}></image>\n                    {pm}\n                </box>\n            }\n            onClicked={() => pm.popup()}\n        />\n    );\n};\n\nconst UserMenu = (): Gtk.Popover => {\n    const popover = new Gtk.Popover();\n\n    const powerMenuBox = () => {\n        return (\n            <box>\n                <button\n                    cssClasses={[\"power-button\"]}\n                    child={\n                        <image iconName={\"system-lock-screen-symbolic\"}></image>\n                    }\n                    onClicked={() => exec(\"/bin/sh -c 'hyprlock'\")}\n                ></button>\n                <button\n                    cssClasses={[\"power-button\"]}\n                    child={<image iconName={\"system-log-out-symbolic\"}></image>}\n                    onClicked={() =>\n                        exec(\"/bin/sh -c 'hyprctl dispatch exit 0'\")\n                    }\n                ></button>\n            </box>\n        );\n    };\n\n    popover.set_child(powerMenuBox());\n    return popover;\n};\n\nexport default {\n    Power,\n    UserMenu\n};\n", "import { bind, Binding } from \"astal\";\nimport { Gtk } from \"astal/gtk4\";\nimport AstalWp from \"gi://AstalWp\";\n\nconst wp = AstalWp.get_default()!;\n\nconst AudioModule = () => {\n    const setVolumeSpeaker = (volume: number) => {\n        wp.defaultSpeaker.set_volume(volume / 100);\n    };\n\n    const setVolumeMicrophone = (volume: number) => {\n        wp.defaultMicrophone.set_volume(volume / 100);\n    };\n\n    const speakerSelector = SinkSelectPopover(AstalWp.MediaClass.AUDIO_SPEAKER);\n    const micSelector = SinkSelectPopover(AstalWp.MediaClass.AUDIO_MICROPHONE);\n\n    return (\n        <box cssClasses={[\"audio-box\"]} vertical>\n            <box hexpand vexpand>\n                <button\n                    onClicked={() =>\n                        wp.defaultSpeaker.set_mute(\n                            !wp.defaultSpeaker.get_mute(),\n                        )\n                    }\n                    tooltipText={\"Mute audio output\"}\n                    child={\n                        <image\n                            iconName={bind(wp.defaultSpeaker, \"volumeIcon\")}\n                            marginEnd={3}\n                        ></image>\n                    }\n                ></button>\n                <label\n                    label={bind(wp.defaultSpeaker, \"volume\").as(\n                        v => Math.round(100 * v) + \"%\",\n                    )}\n                ></label>\n                <slider\n                    value={bind(wp.defaultSpeaker, \"volume\").as(v => 100 * v)}\n                    max={100}\n                    min={0}\n                    step={1}\n                    hexpand\n                    vexpand\n                    onChangeValue={self => setVolumeSpeaker(self.value)}\n                ></slider>\n                <button\n                    cssClasses={[\"sink-select-button\"]}\n                    tooltipText={\"Pick audio output\"}\n                    child={\n                        <box>\n                            <image iconName={\"speaker-symbolic\"}></image>\n                            {speakerSelector}\n                        </box>\n                    }\n                    onClicked={() => speakerSelector.popup()}\n                ></button>\n            </box>\n            <box hexpand vexpand>\n                <button\n                    onClicked={() =>\n                        wp.defaultMicrophone.set_mute(\n                            !wp.defaultMicrophone.get_mute(),\n                        )\n                    }\n                    tooltipText={\"Mute audio input\"}\n                    child={\n                        <image\n                            iconName={bind(wp.defaultMicrophone, \"volumeIcon\")}\n                            marginEnd={3}\n                        ></image>\n                    }\n                ></button>\n                <label\n                    label={bind(wp.defaultMicrophone, \"volume\").as(\n                        v => Math.round(100 * v) + \"%\",\n                    )}\n                ></label>\n                <slider\n                    value={bind(wp.defaultMicrophone, \"volume\").as(\n                        v => 100 * v,\n                    )}\n                    max={100}\n                    min={0}\n                    step={1}\n                    hexpand\n                    vexpand\n                    onChangeValue={self => setVolumeMicrophone(self.value)}\n                ></slider>\n                <button\n                    cssClasses={[\"sink-select-button\"]}\n                    tooltipText={\"Select audio input\"}\n                    child={\n                        <box>\n                            <image iconName={\"microphone\"}></image>\n                            {micSelector}\n                        </box>\n                    }\n                    onClicked={() => micSelector.popup()}\n                ></button>\n            </box>\n        </box>\n    );\n};\n\nconst SinkPicker = (type: AstalWp.MediaClass) => {\n    const devices = bind(wp, \"endpoints\");\n\n    return (\n        <box vertical>\n            <label\n                label={`Available Audio ${type === AstalWp.MediaClass.AUDIO_SPEAKER ? \"Output\" : type === AstalWp.MediaClass.AUDIO_MICROPHONE ? \"Input\" : \"\"} Devices`}\n            ></label>\n            <Gtk.Separator marginBottom={5} marginTop={3}></Gtk.Separator>\n            <box vertical cssClasses={[\"sink-picker\"]}>\n                {devices.as(d => {\n                    return d.map(device => {\n                        if (device.get_media_class() !== type) {\n                            return <box cssClasses={[ 'empty' ]}></box>;\n                        }\n                        return (\n                            <button\n                                cssClasses={bind(device, \"id\").as(id => {\n                                    if (\n                                        id ===\n                                        (type ===\n                                        AstalWp.MediaClass.AUDIO_SPEAKER\n                                            ? wp.defaultSpeaker.id\n                                            : type ===\n                                                AstalWp.MediaClass\n                                                    .AUDIO_MICROPHONE\n                                              ? wp.defaultMicrophone.id\n                                              : \"\")\n                                    ) {\n                                        return [\n                                            \"sink-option\",\n                                            \"currently-selected-sink-option\",\n                                        ];\n                                    } else {\n                                        return [\"sink-option\"];\n                                    }\n                                })}\n                                child={\n                                    <box halign={Gtk.Align.START}>\n                                        <image\n                                            iconName={bind(device, \"icon\").as(\n                                                icon => icon,\n                                            )}\n                                            marginEnd={3}\n                                        ></image>\n                                        <label\n                                            label={bind(\n                                                device,\n                                                \"description\",\n                                            ).as(t => t ?? \"\")}\n                                        ></label>\n                                    </box>\n                                }\n                                onClicked={() => {\n                                    device.set_is_default(true);\n                                }}\n                            ></button>\n                        );\n                    });\n                })}\n            </box>\n        </box>\n    );\n};\n\nconst SinkSelectPopover = (type: AstalWp.MediaClass) => {\n    const popover = new Gtk.Popover();\n\n    popover.set_child(SinkPicker(type));\n\n    return popover;\n};\n\nexport default {\n    AudioModule,\n};\n", "import { bind, readFile, writeFile } from \"astal\";\nimport { Gtk } from \"astal/gtk4\";\nimport AstalBluetooth from \"gi://AstalBluetooth\";\nimport BTDevice from \"./Device\";\nconst ALIGN = Gtk.Align;\n\nconst bt = AstalBluetooth.get_default();\n\nconst BluetoothModule = () => {\n    return (\n        <box>\n            <button\n                cssClasses={bind(bt.adapter, \"powered\").as(powered =>\n                    powered\n                        ? [\"toggle-button\", \"toggle-on\"]\n                        : [\"toggle-button\"],\n                )}\n                onClicked={() =>\n                    bt.adapter.set_powered(!bt.adapter.get_powered())\n                }\n                child={\n                    <box vertical>\n                        <label\n                            cssClasses={[\"title-2\"]}\n                            label={\"Bluetooth\"}\n                            halign={ALIGN.CENTER}\n                            valign={ALIGN.CENTER}\n                        ></label>\n                        <box halign={ALIGN.CENTER} valign={ALIGN.CENTER}>\n                            <label\n                                visible={bind(bt.adapter, \"powered\").as(\n                                    p => !p,\n                                )}\n                                label=\"Disabled\"\n                            ></label>\n                            <label\n                                visible={bind(bt.adapter, \"powered\")}\n                                label={bind(bt, \"devices\").as(devices => {\n                                    let count = 0;\n                                    devices.forEach(device => {\n                                        if (device.connected) {\n                                            count++;\n                                        }\n                                    });\n                                    return `On (${count} ${count === 1 ? \"client\" : \"clients\"} connected)`;\n                                })}\n                            ></label>\n                        </box>\n                        <label></label>\n                    </box>\n                }\n            ></button>\n            <button\n                cssClasses={[\"actions-button\"]}\n                visible={bind(bt.adapter, \"powered\")}\n                child={\n                    <box>\n                        <image iconName={\"arrow-right-symbolic\"}></image>\n                        {picker}\n                    </box>\n                }\n                tooltipText={\"View available devices\"}\n                onClicked={() => openBTPicker()}\n            ></button>\n        </box>\n    );\n};\n\nconst openBTPicker = () => {\n    picker.popup();\n    try {\n        bt.adapter.start_discovery();\n    } catch (_) {}\n};\n\nconst BluetoothPickerList = () => {\n    let btEnableState = readFile(`${DATADIR}./btconf`) === \"true\" ? true : false;\n    bt.adapter.set_powered(btEnableState);\n\n    const updateState = () => {\n        btEnableState = !btEnableState;\n        writeFile(\"./btconf\", \"\" + btEnableState);\n    };\n\n    return (\n        <box\n            vertical\n            onDestroy={() => bt.adapter.stop_discovery()}\n            cssClasses={[\"popover-box\"]}\n        >\n            <label cssClasses={[\"title\"]} label={\"Bluetooth\"}></label>\n            <Gtk.Separator marginTop={3} marginBottom={5}></Gtk.Separator>\n            <centerbox\n                startWidget={<label label={\"Turn on at startup\"}></label>}\n                endWidget={\n                    <switch\n                        valign={ALIGN.END}\n                        halign={ALIGN.END}\n                        active={btEnableState}\n                        onButtonPressed={() => updateState()}\n                    ></switch>\n                }\n            ></centerbox>\n            <label\n                marginTop={10}\n                label={\"Connected & Trusted devices\"}\n                cssClasses={[\"title-2\"]}\n            ></label>\n            <Gtk.Separator marginTop={3} marginBottom={5}></Gtk.Separator>\n            <box vertical cssClasses={[\"devices-list\"]}>\n                {bind(bt, \"devices\").as(devices => {\n                    return devices\n                        .filter(device => {\n                            if (device.get_connected() || device.get_paired()) {\n                                return device;\n                            }\n                        })\n                        .map(device => {\n                            return <BTDevice device={device}></BTDevice>;\n                        });\n                })}\n            </box>\n            <label\n                visible={bind(bt, \"devices\").as(devices => {\n                    return (\n                        devices.filter(device => {\n                            if (device.get_connected() || device.get_paired()) {\n                                return device;\n                            }\n                        }).length === 0\n                    );\n                })}\n                label={\"No connected / trusted devices\"}\n                cssClasses={[\"bt-no-found\", \"bt-conn-list\"]}\n            ></label>\n            <label\n                label={\"Discovered bluetooth devices\"}\n                cssClasses={[\"title-2\"]}\n            ></label>\n            <Gtk.Separator marginBottom={5} marginTop={3}></Gtk.Separator>\n            <box vertical>\n                {bind(bt, \"devices\").as(devices => {\n                    return devices\n                        .filter(data => {\n                            if (!data.get_connected() && !data.get_paired()) {\n                                return data;\n                            }\n                        })\n                        .map(device => {\n                            return <BTDevice device={device}></BTDevice>;\n                        });\n                })}\n            </box>\n            <label\n                visible={bind(bt, \"devices\").as(devices => {\n                    return (\n                        devices.filter(device => {\n                            if (\n                                !device.get_connected() &&\n                                !device.get_paired()\n                            ) {\n                                return device;\n                            }\n                        }).length === 0\n                    );\n                })}\n                label={\"No discovered devices\"}\n                cssClasses={[\"bt-no-found\"]}\n            ></label>\n        </box>\n    );\n};\n\nconst BluetoothPicker = () => {\n    const popover = new Gtk.Popover();\n\n    popover.set_child(BluetoothPickerList());\n    popover.connect(\"closed\", () => bt.adapter.stop_discovery());\n\n    return popover;\n};\n\nconst picker = BluetoothPicker();\n\nexport default {\n    BluetoothModule,\n};\n", "import { bind } from \"astal\";\nimport AstalBluetooth from \"gi://AstalBluetooth\";\n\nconst BTDevice = ({ device }: { device: AstalBluetooth.Device }) => {\n    return (\n        <button\n            visible={bind(device, \"name\").as(n => n !== null)}\n            child={\n                <centerbox\n                    startWidget={\n                        <box>\n                            <image\n                                iconName={\"chronometer-reset\"}\n                                tooltipText={\"Device is currently connecting\"}\n                                visible={bind(device, \"connecting\")}\n                            ></image>\n                            <image\n                                iconName={bind(device, \"icon\")}\n                                marginEnd={3}\n                            ></image>\n                        </box>\n                    }\n                    centerWidget={\n                        <label\n                            label={bind(device, \"name\").as(n => n ?? \"No name\")}\n                            marginEnd={5}\n                        ></label>\n                    }\n                    endWidget={\n                        <box>\n                            <label\n                                label={bind(device, \"batteryPercentage\").as(\n                                    bat => (bat >= 0 ? bat + \"%\" : \"?%\"),\n                                )}\n                                tooltipText={\"Device's battery percentage\"}\n                                marginEnd={3}\n                            ></label>\n                            <image\n                                iconName={bind(device, \"paired\").as(v =>\n                                    v ? \"network-bluetooth-activated-symbolic\" : \"bluetooth-disconnected-symbolic\",\n                                )}\n                            ></image>\n                            <button tooltipText={\"Device trusted status\"} child={\n                                <image\n                                    iconName={bind(device, \"trusted\").as(v =>\n                                        v ? \"checkbox\" : \"window-close-symbolic\",\n                                    )}\n                                ></image>\n                            } onClicked={() => device.set_trusted( !device.get_trusted() )}\n                            cssClasses={[ 'button-no-margin' ]}\n                            ></button>\n                        </box>\n                    }\n                ></centerbox>\n            }\n            onClicked={() => {\n                connectOrPair( device );\n            }}\n        ></button>\n    );\n};\n\nconst connectOrPair = (device: AstalBluetooth.Device) => {\n    if ( device.get_paired() ) {\n        device.connect_device(() => { });\n        // Show failed message if tried to connect and failed\n    } else {\n        device.pair();\n    }\n};\n\nexport default BTDevice;\n", "import { bind } from \"astal\";\nimport Brightness from \"../../../../util/brightness\";\n\nconst brightness = Brightness.get_default();\n\nconst BrightnessModule = () => {\n    return (\n        <box visible={bind(brightness, 'screenAvailable')}>\n            <image iconName={\"brightness-high-symbolic\"}></image>\n            <label label={bind(brightness, \"screen\").as(b => b + \"%\")}></label>\n            <slider></slider>\n        </box>\n    );\n};\n\nexport default {\n    BrightnessModule\n};\n", "import { bind } from \"astal\";\nimport { Gtk } from \"astal/gtk4\";\nimport AstalMpris from \"gi://AstalMpris\";\nimport Pango from \"gi://Pango?version=1.0\";\nconst ALIGN = Gtk.Align;\n\nconst mpris = AstalMpris.get_default();\nmpris.connect(\"player-added\", p => {\n    print(\"Player added:\", p);\n});\n\nconst PlayerModule = () => {\n    return (\n        <box vertical cssClasses={ [ 'players-box' ] }>\n            <label label={\"Music Players\"} halign={ALIGN.CENTER} cssClasses={[ 'title-2' ]}></label>\n            <Gtk.Separator marginTop={3} marginBottom={5}></Gtk.Separator>\n            <box cssClasses={[\"players\"]}>\n                {bind(mpris, \"players\").as(players => {\n                    return players.map(player => {\n                        return <PlayerItem player={player}></PlayerItem>;\n                    });\n                })}\n            </box>\n            <label label={\"No playback active\"} visible={bind(mpris, \"players\").as( players => players.length === 0 )}></label>\n        </box>\n    );\n};\n\n// TODO: Update widths\nconst pbStatus = AstalMpris.PlaybackStatus;\nconst PlayerItem = ({ player }: { player: AstalMpris.Player }) => {\n    return (\n        <box cssClasses={[\"player\"]}>\n            <image\n                cssClasses={[\"cover-art\"]}\n                file={bind(player, \"coverArt\")}\n                hexpand\n                vexpand\n            ></image>\n            <box vertical>\n                <label\n                    label={bind(player, \"title\").as(\n                        title => title ?? \"Unknown title\",\n                    )}\n                    cssClasses={[\"title\"]}\n                    halign={ALIGN.START}\n                    valign={ALIGN.START}\n                    maxWidthChars={30}\n                    ellipsize={Pango.EllipsizeMode.END}\n                ></label>\n                <label\n                    label={bind(player, \"artist\").as(\n                        artist => artist ?? \"Unknown artist\",\n                    )}\n                    halign={ALIGN.START}\n                    valign={ALIGN.START}\n                    maxWidthChars={30}\n                    ellipsize={Pango.EllipsizeMode.END}\n                ></label>\n                <slider\n                    visible={bind(player, \"length\").as(l => l > 0)}\n                    value={bind(player, \"position\")}\n                    min={0}\n                    max={bind(player, \"length\")}\n                    onChangeValue={v =>\n                        player.set_position(v.get_value())\n                    }\n                ></slider>\n                <centerbox\n                    cssClasses={[\"actions\"]}\n                    startWidget={\n                        <label\n                            label={bind(player, \"position\").as(v =>\n                                secondsToFriendlyTime(v),\n                            )}\n                            hexpand\n                            cssClasses={[\"position\"]}\n                        ></label>\n                    }\n                    centerWidget={\n                        <box>\n                            <button\n                                visible={bind(player, \"canGoPrevious\")}\n                                child={\n                                    <image\n                                        iconName={\n                                            \"media-skip-backward-symbolic\"\n                                        }\n                                    ></image>\n                                }\n                                onClicked={() => player.previous()}\n                            ></button>\n                            <button\n                                visible={bind(player, \"canControl\")}\n                                child={\n                                    <image\n                                        iconName={bind(\n                                            player,\n                                            \"playbackStatus\",\n                                        ).as(status => {\n                                            if (status === pbStatus.PLAYING) {\n                                                return \"media-playback-pause-symbolic\";\n                                            } else {\n                                                return \"media-playback-start-symbolic\";\n                                            }\n                                        })}\n                                    ></image>\n                                }\n                                onClicked={() => player.play_pause()}\n                            ></button>\n                            <button\n                                visible={bind(player, \"canGoNext\")}\n                                child={\n                                    <image\n                                        iconName={\"media-skip-forward-symbolic\"}\n                                    ></image>\n                                }\n                                onClicked={() => player.next()}\n                            ></button>\n                        </box>\n                    }\n                    endWidget={\n                        <label\n                            cssClasses={[\"length\"]}\n                            hexpand\n                            label={bind(player, \"length\").as(v =>\n                                secondsToFriendlyTime(v),\n                            )}\n                        ></label>\n                    }\n                ></centerbox>\n            </box>\n        </box>\n    );\n};\n\nconst secondsToFriendlyTime = (time: number) => {\n    const minutes = Math.floor(time / 60);\n    const hours = Math.floor(minutes / 60);\n    const seconds = Math.floor(time % 60);\n    if (hours > 0) {\n        return `${hours}:${expandTime(minutes)}:${expandTime(seconds)}`;\n    } else {\n        return `${minutes}:${expandTime(seconds)}`;\n    }\n};\n\nconst expandTime = (time: number): string => {\n    return time < 10 ? `0${time}` : \"\" + time;\n};\n\nexport default {\n    PlayerModule,\n};\n", "import { bind } from \"astal\";\nimport Battery from \"gi://AstalBattery\";\nimport { Gtk } from \"astal/gtk4\";\n\nexport const BatteryBox = () => {\n    const battery = Battery.get_default();\n    const batteryEnergy = (energyRate: number) => {\n        return energyRate > 0.1 ? `${Math.round(energyRate * 10) / 10} W ` : \"\";\n    };\n    return (\n        <box\n            cssClasses={[\"battery-info\"]}\n            visible={bind(battery, \"isBattery\")}\n        >\n            <box cssClasses={[\"battery-box\"]}>\n                <image\n                    iconName={bind(battery, \"batteryIconName\")}\n                    tooltipText={bind(battery, \"energyRate\").as(er =>\n                        batteryEnergy(er),\n                    )}\n                />\n                <label\n                    label={bind(battery, \"percentage\").as(\n                        p => ` ${Math.round(p * 100)}%`,\n                    )}\n                />\n                <label\n                    cssClasses={[\"time\"]}\n                    hexpand={true}\n                    halign={Gtk.Align.END}\n                    visible={bind(battery, \"charging\").as(c => !c)}\n                    label={bind(battery, \"timeToEmpty\").as(t => toTime(t))}\n                />\n            </box>\n        </box>\n    );\n};\n\nconst toTime = (time: number) => {\n    const MINUTE = 60;\n    const HOUR = MINUTE * 60;\n\n    if (time > 24 * HOUR) return \"\";\n\n    const hours = Math.round(time / HOUR);\n    const minutes = Math.round((time - hours * HOUR) / MINUTE);\n\n    const hoursDisplay = hours > 0 ? `${hours}h ` : \"\";\n    const minutesDisplay = minutes > 0 ? `${minutes}m ` : \"\";\n\n    return `${hoursDisplay}${minutesDisplay}`;\n};\n", "import { bind } from \"astal\";\nimport { Gtk } from \"astal/gtk4\";\nimport AstalNetwork from \"gi://AstalNetwork\";\nimport networkHelper from \"./network-helper\";\nimport NetworkMenu from \"./NetworkMenu\";\n\nconst net = AstalNetwork.get_default();\nconst STATE = AstalNetwork.DeviceState;\n\nconst Network = () => {\n    const netMenu = NetworkMenu.NetworkMenu();\n    return (\n        <box>\n            <button\n                cssClasses={networkHelper.networkEnabled(en => {\n                    if (en) return [\"toggle-button\", \"toggle-on\"];\n                    else return [\"toggle-button\"];\n                })}\n                onClicked={() =>\n                    networkHelper.setNetworking(\n                        !networkHelper.networkEnabled.get(),\n                    )\n                }\n                child={\n                    <box vertical>\n                        <label\n                            label={bind(net.wifi, \"enabled\").as(\n                                stat => `Network (${stat ? \"WiFi\" : \"Wired\"})`,\n                            )}\n                            cssClasses={[\"title-2\"]}\n                        ></label>\n                        <label\n                            label={bind(net.wired, \"state\").as(state => {\n                                if (state === STATE.ACTIVATED) {\n                                    return (\n                                        \"Wired. IP: \" + networkHelper.getIP()\n                                    );\n                                } else if (state === STATE.DISCONNECTED) {\n                                    return \"Disconnected\";\n                                } else if (state === STATE.FAILED) {\n                                    return \"Error\";\n                                } else if (\n                                    state === STATE.PREPARE ||\n                                    state === STATE.CONFIG ||\n                                    state === STATE.IP_CHECK ||\n                                    state === STATE.IP_CONFIG\n                                ) {\n                                    return \"Connecting...\";\n                                } else {\n                                    return \"Unavailable\";\n                                }\n                            })}\n                            visible={bind(net.wifi, \"enabled\").as(v => !v)}\n                        ></label>\n                        <label\n                            label={bind(net.wifi, \"state\").as(state => {\n                                if (state === STATE.ACTIVATED) {\n                                    return `${net.wifi.get_ssid()} (${networkHelper.getIP()})`;\n                                } else if (state === STATE.DISCONNECTED) {\n                                    return \"Disconnected\";\n                                } else if (state === STATE.FAILED) {\n                                    return \"Error\";\n                                } else if (\n                                    state === STATE.PREPARE ||\n                                    state === STATE.CONFIG ||\n                                    state === STATE.IP_CHECK ||\n                                    state === STATE.IP_CONFIG\n                                ) {\n                                    return \"Connecting...\";\n                                } else {\n                                    return \"Unavailable\";\n                                }\n                            })}\n                            visible={bind(net.wifi, \"enabled\")}\n                        ></label>\n                    </box>\n                }\n            ></button>\n            <button\n                cssClasses={[\"actions-button\"]}\n                visible={networkHelper.networkEnabled()}\n                onClicked={() => netMenu.popup()}\n                child={\n                    <box>\n                        <image iconName={\"arrow-right-symbolic\"}></image>\n                        { netMenu }\n                    </box>\n                }\n                tooltipText={\"View available devices\"}\n            ></button>\n        </box>\n    );\n};\n\nexport default {\n    Network,\n};\n", "import { exec, Variable } from \"astal\";\nimport AstalNetwork from \"gi://AstalNetwork\";\n\nconst networkEnabled = Variable( exec( 'nmcli networking connectivity' ) !== 'none' );\nconst network = AstalNetwork.get_default();\n\n\nconst setNetworking = ( status: boolean ) => {\n    if ( status === true ) {\n        exec( 'nmcli networking on' );\n        networkEnabled.set( true );\n    } else {\n        exec( 'nmcli networking off' );\n        networkEnabled.set( false );\n    }\n}\n\n\nconst getIP = () => {\n    return exec( `/bin/bash -c \"ip addr show | grep 'inet ' | awk '{print $2}' | grep -v '127'\"` ).split( '/' )[ 0 ];\n}\n\n\nexport default {\n    networkEnabled,\n    setNetworking,\n    getIP\n}\n", "import { Gtk } from \"astal/gtk4\";\n\nconst NetworkMenu = () => {\n    const popover = new Gtk.Popover();\n    popover.set_child( renderMenu() );\n    return popover;\n};\n\nconst renderMenu = () => {\n    return <box vertical>\n        <image iconName={\"appointment-soon-symbolic\"} iconSize={Gtk.IconSize.LARGE}></image>\n        <label label={\"Coming later\"}></label>\n    </box>;\n};\n\nexport default {\n    NetworkMenu,\n};\n", "import { Gtk } from \"astal/gtk4\";\nimport Power from \"./modules/Power\";\nimport Audio from \"./modules/Audio/Audio\";\nimport Bluetooth from \"./modules/Bluetooth/Bluetooth\";\nimport Brightness from \"./modules/Brightness/Brightness\";\nimport Player from \"./modules/Player/Player\";\nimport { BatteryBox } from \"./modules/Battery\";\nimport { exec } from \"astal\";\nimport Network from \"./modules/Networking/Network\";\n\nconst QuickActions = () => {\n    const popover = new Gtk.Popover({ cssClasses: [\"quick-actions-wrapper\"] });\n    popover.set_child(renderQuickActions());\n    return popover;\n};\n\nconst renderQuickActions = () => {\n    const user = exec(\"/bin/sh -c whoami\");\n    const profile = exec(\"/bin/fish -c get-profile-picture\");\n    const cwd = exec(\"pwd\");\n    const um = Power.UserMenu();\n\n    return (\n        <box visible cssClasses={[\"quick-actions\", \"popover-box\"]} vertical>\n            <centerbox\n                startWidget={\n                    <button\n                        onClicked={() => um.popup()}\n                        cssClasses={[\"stealthy-button\"]}\n                        child={\n                            <box>\n                                {um}\n                                <Gtk.Frame\n                                    cssClasses={[\"avatar-icon\"]}\n                                    child={\n                                        <image\n                                            file={\n                                                profile !== \"\"\n                                                    ? profile\n                                                    : cwd +\n                                                      \"/no-avatar-icon.jpg\"\n                                            }\n                                        ></image>\n                                    }\n                                ></Gtk.Frame>\n                                <label label={user}></label>\n                            </box>\n                        }\n                    ></button>\n                }\n                endWidget={\n                    <box>\n                        <BatteryBox></BatteryBox>\n                        <Power.Power></Power.Power>\n                    </box>\n                }\n            ></centerbox>\n            <Gtk.Separator marginTop={10} marginBottom={20}></Gtk.Separator>\n            <box>\n                <Bluetooth.BluetoothModule></Bluetooth.BluetoothModule>\n                <Network.Network></Network.Network>\n            </box>\n            <Gtk.Separator marginTop={10} marginBottom={10}></Gtk.Separator>\n            <Brightness.BrightnessModule></Brightness.BrightnessModule>\n            <Audio.AudioModule></Audio.AudioModule>\n            <Player.PlayerModule></Player.PlayerModule>\n        </box>\n    );\n};\n\n// TODO: Expose additional functions to be usable through CLI\nexport default {\n    QuickActions,\n};\n", "import { exec, execAsync, GLib, interval, Variable } from \"astal\";\nimport { Gtk } from \"astal/gtk4\";\nimport AstalBattery from \"gi://AstalBattery?version=0.1\";\n\nconst FETCH_INTERVAL = 2000;\n\nconst cpuUtil = Variable(\"0%\");\nconst ramUtil = Variable(\"0%\");\nconst ramUsed = Variable(\"0MiB\");\nconst gpuUtil = Variable(\"0%\");\nlet gpuName = \"card1\";\nlet enabled = false;\n\nconst refreshStats = (): Stats => {\n    gpuName = exec(`/bin/bash -c \"ls /sys/class/drm/ | grep '^card[0-9]*$'\"`);\n    const cpuNameInSensors = \"CPUTIN\";\n    const stats = {\n        kernel: exec(\"uname -sr\"),\n        netSpeed: exec(\n            `/bin/bash -c \"interface=$(ip route get 8.8.8.8 | awk '{print $5; exit}') && cat \\\"/sys/class/net/$interface/speed\\\"\"`,\n        ),\n        cpuTemp: exec(\n            `/bin/bash -c \"sensors | grep -m1 ${cpuNameInSensors} | awk '{print $2}'\"`,\n        ),\n        cpuClk: exec(\n            `awk '/cpu MHz/ {sum+=$4; ++n} END {print sum/n \" MHz\"}' /proc/cpuinfo`,\n        ),\n        gpuTemp: exec(\n            `/bin/bash -c \"sensors | grep -E 'edge' | awk '{print $2}'\"`,\n        ),\n        gpuClk: exec(\n            `/bin/bash -c \"cat /sys/class/drm/${gpuName}/device/pp_dpm_sclk | grep '\\\\*' | awk '{print $2 $3}'\"`,\n        ),\n        vram:\n            Math.round(\n                parseInt(\n                    exec(\n                        `cat /sys/class/drm/${gpuName}/device/mem_info_vram_used`,\n                    ),\n                ) /\n                    1024 /\n                    1024,\n            ) + \"MiB\",\n        availableVRAM:\n            Math.round(\n                parseInt(\n                    exec(\n                        `cat /sys/class/drm/${gpuName}/device/mem_info_vram_total`,\n                    ),\n                ) /\n                    1024 /\n                    1024,\n            ) + \"MiB\",\n    };\n\n    return stats;\n};\n\nconst systemStats: Variable<Stats> = Variable(refreshStats());\n\nconst availableFeatures = {\n    cpu: true,\n    ram: true,\n};\n\nconst featureTest = () => {\n    // Check if awk & sed are available\n    try {\n        exec(\"awk -V\");\n        exec(\"sed --version\");\n        enabled = true;\n    } catch (e) {\n        printerr(\n            \"[ SysInfo ] AWK or SED missing! No system info will be available\",\n        );\n        enabled = false;\n        return;\n    }\n\n    // Check if mpstat is available\n    try {\n        exec(\"mpstat -V\");\n    } catch (e) {\n        availableFeatures.cpu = false;\n        printerr(\n            \"[ SysInfo ] Feature Test for CPU info failed. mpstat from the sysstat package missing!\",\n        );\n    }\n};\n\nconst info = () => {\n    return (\n        <box vertical>\n            <label\n                label={\"System Information\"}\n                cssClasses={[\"title-2\"]}\n            ></label>\n            <Gtk.Separator marginTop={5} marginBottom={10}></Gtk.Separator>\n            <label\n                vexpand\n                halign={Gtk.Align.START}\n                hexpand\n                label={ramUsed(used => {\n                    return \"RAM: \" + used + ` (${ramUtil.get()}%)`;\n                })}\n            ></label>\n            <label\n                label={systemStats(stats => {\n                    return `CPU: ${stats.cpuTemp}, ${stats.cpuClk}\nGPU: ${stats.gpuTemp}, ${stats.gpuClk} (${stats.vram} / ${stats.availableVRAM})\nNetwork: ${stats.netSpeed} mb/s\nKernel: ${stats.kernel}`;\n                })}\n            ></label>\n            <Gtk.Separator marginTop={10}></Gtk.Separator>\n            <button\n                onClicked={() => exec( `/bin/sh -c \"kitty --hold fish -c 'fastfetch'\"` )}\n                child={\n                    <label label={\"View FastFetch\"}></label>\n                }></button>\n        </box>\n    );\n};\n\nconst SystemInformationPanel = () => {\n    const popover = new Gtk.Popover();\n\n    popover.set_child(info());\n\n    return popover;\n};\n\nconst sysInfoFetcher = () => {\n    if (enabled) {\n        if (availableFeatures.cpu) {\n            cpuUtil.set(\n                \"\" +\n                    Math.round(\n                        parseFloat(exec(`/bin/fish -c cpu-utilization`)),\n                    ),\n            );\n        }\n        if (availableFeatures.ram) {\n            ramUtil.set(\n                \"\" +\n                    Math.round(\n                        parseFloat(\n                            exec(\n                                `/bin/bash -c \"free | awk '/Mem/ { printf(\\\\\"%.2f\\\\\\\\n\\\\\", ($3/$2)*100) }'\"`,\n                            ),\n                        ),\n                    ),\n            );\n            ramUsed.set(\n                exec(\n                    `/bin/bash -c \\\"free -h | awk '/^Mem:/ {print $3 \\\\\" used of \\\\\" $2}'\\\"`,\n                )\n                    .replaceAll(\"Gi\", \"GiB\")\n                    .replaceAll(\"Mi\", \"MiB\"),\n            );\n        }\n        gpuUtil.set(exec(\"cat /sys/class/drm/card1/device/gpu_busy_percent\"));\n    }\n};\n\nconst panel = SystemInformationPanel();\n\nconst SystemInfo = () => {\n    featureTest();\n\n    const openSysInfo = async () => {\n        panel.popup();\n        systemStats.set(refreshStats());\n    };\n\n    if (enabled) {\n        sysInfoFetcher();\n        interval(FETCH_INTERVAL, sysInfoFetcher);\n\n        return (\n            <button\n                onClicked={() => openSysInfo()}\n                child={\n                    <box tooltipText={ramUsed(v => v)}>\n                        <image\n                            iconName={\"power-profile-performance-symbolic\"}\n                            marginEnd={1}\n                        ></image>\n                        <label\n                            label={cpuUtil(util => util)}\n                            marginEnd={5}\n                        ></label>\n                        <image iconName={\"histogram-symbolic\"}></image>\n                        <label label={ramUtil(util => util)}></label>\n                        <image iconName={\"show-gpu-effects-symbolic\"}></image>\n                        <label label={gpuUtil(util => util)}></label>\n                        {panel}\n                    </box>\n                }\n                cssClasses={[\"bar-button\"]}\n            ></button>\n        );\n    } else {\n        return <image iconName={\"action-unavailable-symbolic\"}></image>;\n    }\n};\n\nexport default {\n    SystemInfo,\n    panel,\n};\n", "import { App, Astal, Gdk, Gtk } from \"astal/gtk4\";\nimport Hyprland from \"./modules/Hyprland\";\nimport Calendar from \"./modules/Calendar\";\nimport QuickView from \"./modules/QuickView\";\nimport SystemInfo from \"./modules/SystemInfo\";\nimport { CenterBox } from \"astal/gtk4/widget\";\n\nconst Bar = ( { gdkmonitor, name }: { gdkmonitor: Gdk.Monitor, name: string } ) => {\n    const { TOP, LEFT, RIGHT } = Astal.WindowAnchor;\n\n    return (\n        <window\n            gdkmonitor={gdkmonitor}\n            cssClasses={[\"Bar\"]}\n            name={name}\n            namespace={\"bar\"}\n            exclusivity={Astal.Exclusivity.EXCLUSIVE}\n            anchor={TOP | LEFT | RIGHT}\n            visible\n            application={App}\n            child={\n                <CenterBox\n                    orientation={Gtk.Orientation.HORIZONTAL}\n                    start_widget={\n                        <box\n                            hexpand\n                            halign={Gtk.Align.START}\n                        >\n                            <Calendar.Time />\n                            <SystemInfo.SystemInfo />\n                            <Hyprland.Workspace />\n                        </box>\n                    }\n                    centerWidget={<Hyprland.ActiveWindow />}\n                    endWidget={\n                        <box\n                            hexpand\n                            halign={Gtk.Align.END}\n                            cssClasses={[\"BarRight\"]}\n                        >\n                            <Hyprland.SysTray />\n                            <QuickView.QuickView />\n                        </box>\n                    }\n                ></CenterBox>\n            }\n        ></window>\n    );\n};\n\nconst cliHandler = (args: string[]): string => {\n    return \"Not implemented\";\n};\n\nconst BarLauncher = ( monitor: Gdk.Monitor ) =>  {\n    const windowName = `bar-${monitor.get_connector()}`\n    const createBar = () => {\n        return <Bar gdkmonitor={monitor} name={windowName}></Bar>\n    }\n\n    // Actually start the bar\n    createBar();\n\n    return windowName;\n}\n\nexport default {\n    BarLauncher,\n    cliHandler,\n};\n", "import { App } from \"astal/gtk4\"\nimport style from \"./style.scss\"\nimport Bar from \"./components/bar/Bar\";\nimport AstalHyprland from \"gi://AstalHyprland?version=0.1\";\nimport { hyprToGdk } from \"./util/hyprland\";\n\nApp.start({\n    instanceName: \"runner\",\n    css: style,\n    main() {\n        const hypr = AstalHyprland.get_default();\n        const bars = new Map<number, string>();\n\n        const barCreator = ( monitor: AstalHyprland.Monitor ) => {\n            const gdkMonitor = hyprToGdk( monitor );\n            if ( gdkMonitor ) {\n                print( 'Bar added for screen ' + monitor.get_id() );\n                bars.set( monitor.get_id(), Bar.BarLauncher( gdkMonitor ) );\n            }\n        }\n\n        for (const monitor of hypr.monitors) {\n            barCreator( monitor );\n        }\n\n        hypr.connect( 'monitor-added', ( _, monitor ) => {\n            barCreator( monitor );\n        } );\n\n        hypr.connect( 'monitor-removed', ( _, monitor ) => {\n            const windowName = bars.get( monitor );\n            if ( windowName ) {\n                const win = App.get_window( windowName );\n                if ( win ) {\n                    App.toggle_window( windowName );\n                    win.set_child( null );\n                    App.remove_window( win );\n                    print( 'Bar removed for screen', monitor );\n                }\n                bars.delete( monitor );\n            }\n        } );\n    },\n    requestHandler(request, res) {\n        const args = request.trimStart().split( ' ' );\n\n        if ( args[ 0 ] === 'notifier' ) {\n            res( 'Not available here yet, run astal -i notifier ' + args[ 1 ] );\n            // res( notifications.cliHandler( args ) );\n        } else if ( args[ 0 ] === 'bar' ) {\n            res( Bar.cliHandler( args ) );\n        }\n    },\n})\n\n", "// \u250C                                               \u2510\n// \u2502  From https://github.com/Neurarian/matshell   \u2502\n// \u2514                                               \u2518\nimport { App, Gdk } from \"astal/gtk4\";\nimport Hyprland from \"gi://AstalHyprland\";\n\n/* Match Hyprland monitor to GDK monitor\nTHIS MAY NOT WORK AS INTENDED IF YOU HAVE MONITORS OF THE SAME MODEL\nI did not find a more elegant solution to this. \nOn my setup GDK coordinates and hyprland coordinates are flipped,\nso I cant match by coordinates. */\n\nexport function hyprToGdk(monitor: Hyprland.Monitor): Gdk.Monitor | null {\n    const monitors = App.get_monitors();\n    if (!monitors || monitors.length === 0) return null;\n\n    for (let gdkmonitor of monitors) {\n        if (\n            monitor &&\n            gdkmonitor &&\n            monitor.get_name() === gdkmonitor.get_connector()\n        )\n            return gdkmonitor;\n    }\n\n    // Default monitor with null safety\n    return monitors.length > 0 ? monitors[0] : null;\n}\n"],
  "mappings": "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",
  "names": ["Astal", "Gtk", "Gdk", "Astal", "bind", "interval", "Astal", "Astal", "v", "interval", "exec", "ctors", "Gtk", "Astal", "snakeify", "patch", "Workspace", "Audio", "Gtk", "Astal", "Astal", "Gtk", "Gtk", "Astal", "ch", "default", "Astal", "Astal", "Astal", "GObject", "default", "GObject", "kebabify", "jsx", "GObject", "Gtk", "jsx", "Time", "default", "Gtk", "jsx", "AstalBluetooth", "AstalNetwork", "AstalWp", "GObject", "Gtk", "jsx", "jsx", "type", "Gtk", "jsx", "Gtk", "jsx", "jsx", "ALIGN", "Gtk", "jsx", "jsx", "Gtk", "AstalNetwork", "Gtk", "jsx", "AstalNetwork", "jsx", "Gtk", "jsx", "STATE", "AstalNetwork", "jsx", "network", "AstalBluetooth", "enabled", "brightness", "AstalWp", "Gtk", "jsx", "Gtk", "Astal", "jsx", "Gtk", "AstalHyprland", "hypr", "AstalHyprland"]
}
 diff --git a/config/astal/wrapper.sh b/config/astal/wrapper.sh new file mode 100755 index 0000000..0ef6be2 --- /dev/null +++ b/config/astal/wrapper.sh @@ -0,0 +1,2 @@ +#!/bin/bash +LD_PRELOAD="@LAYER_SHELL_LIBDIR@/libgtk4-layer-shell.so" @MAIN_PROGRAM@ $@ diff --git a/config/hypr/hyprland/general.conf b/config/hypr/hyprland/general.conf index 5584f28..1080fe1 100644 --- a/config/hypr/hyprland/general.conf +++ b/config/hypr/hyprland/general.conf @@ -5,17 +5,17 @@ # ──────────────────────────────────────────────────────────────────── source = ./colors.conf -exec-once = ags run ~/projects/active/dotfiles/config/ags/notifications/ exec-once = ~/.config/hypr/xdg-portal-hyprland exec-once = dbus-update-activation-environment --systemd WAYLAND_DISPLAY XDG_CURRENT_DESKTOP XAUTHORITY DISPLAY exec-once = systemctl --user import-environment WAYLAND_DISPLAY XDG_CURRENT_DESKTOP exec-once = /usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1 # exec-once = waybar -exec-once = /bin/bash -c "ags run ~/projects/active/dotfiles/config/astal --gtk4" exec-once = hypridle - exec-once = nm-applet exec-once = nextcloud --background +exec = ags run ~/projects/active/dotfiles/config/astal/ --gtk4 +exec = ags run ~/projects/active/dotfiles/config/ags/notifications/ + exec = hyprctl setcursor oreo_spark_blue_cursors 24 diff --git a/setup b/setup index a5dd634..8f04e37 100755 --- a/setup +++ b/setup @@ -68,6 +68,16 @@ cp -r ./config/wlogout/ ~/.config/ cp -r ./config/yazi ~/.config/ cp -r ./config/zathura ~/.config/ +echo " + => Bundling Astal projects +" + +cd ./config/astal +ags bundle app.ts runner + +cd ../ags/notifications +ags bundle app.ts notifier + echo " => Installing yazi plugins "