diff --git a/flake.nix b/flake.nix index 2697d9f..ad24e7c 100644 --- a/flake.nix +++ b/flake.nix @@ -24,7 +24,33 @@ lib = nixpkgs.lib; system = "x86_64-linux"; pkgs = nixpkgs.legacyPackages.${system}; + in { + + # TODO: migrate to another nix file. + # packages.${system}.default = pkgs.stdenvNoCC.mkDerivation rec { + # name = "my-shell"; + # src = ./.; + # + # nativeBuildInputs = [ + # ags.packages.${system}.default + # pkgs.wrapGAppsHook + # pkgs.gobject-introspection + # ]; + # + # buildInputs = with astal.packages.${system}; [ + # astal3 + # astal-hyprland + # io + # # hyprland + # ]; + # installPhase = '' + # mkdir -p $out/bin + # ags bundle app.ts $out/bin/${name} + # ''; + # }; + # END TODO + nixosConfigurations = { biscuit = lib.nixosSystem { specialArgs = { inherit inputs system; }; diff --git a/modules/wayland.nix b/modules/wayland.nix index 9c51bf7..391e4dd 100644 --- a/modules/wayland.nix +++ b/modules/wayland.nix @@ -4,5 +4,6 @@ ../packages/hyprland/default.nix ../packages/waybar/default.nix ../packages/hyprpanel/default.nix + ../packages/ags/default.nix ]; } diff --git a/nixos/configuration.nix b/nixos/configuration.nix index f05d7cc..e21966f 100644 --- a/nixos/configuration.nix +++ b/nixos/configuration.nix @@ -63,6 +63,7 @@ zsh p7zip gcc + astal.hyprland ]; environment.sessionVariables = { diff --git a/packages/ags/custom/my-shell b/packages/ags/custom/my-shell new file mode 100644 index 0000000..a97e1b9 --- /dev/null +++ b/packages/ags/custom/my-shell @@ -0,0 +1,1085 @@ +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/index.ts +import Astal7 from "gi://Astal?version=3.0"; +import Gtk4 from "gi://Gtk?version=3.0"; +import Gdk from "gi://Gdk?version=3.0"; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/variable.ts +import Astal3 from "gi://AstalIO"; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/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; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/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?.()); +} + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/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 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); + } + }); + } + }); +} + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/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, exec, transform = (out) => out) { + this.stopPoll(); + this.pollInterval = interval2; + this.pollTransform = transform; + if (typeof exec === "function") { + this.pollFn = exec; + delete this.pollExec; + } else { + this.pollExec = exec; + delete this.pollFn; + } + this.startPoll(); + return this; + } + watch(exec, transform = (out) => out) { + this.stopWatch(); + this.watchExec = exec; + 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; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/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 hook(widget, object, signalOrCallback, callback) { + if (typeof object.connect === "function" && callback) { + const id = object.connect(signalOrCallback, (_, ...args) => { + return callback(widget, ...args); + }); + widget.connect("destroy", () => { + object.disconnect(id); + }); + } else if (typeof object.subscribe === "function" && typeof signalOrCallback === "function") { + const unsub = object.subscribe((...args) => { + signalOrCallback(widget, ...args); + }); + widget.connect("destroy", unsub); + } +} +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); +} + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/astalify.ts +import Astal4 from "gi://Astal?version=3.0"; +import Gtk from "gi://Gtk?version=3.0"; +import GObject from "gi://GObject"; +function astalify(cls, clsName = cls.name) { + class Widget extends cls { + get css() { + return Astal4.widget_get_css(this); + } + set css(css) { + Astal4.widget_set_css(this, css); + } + get_css() { + return this.css; + } + set_css(css) { + this.css = css; + } + get className() { + return Astal4.widget_get_class_names(this).join(" "); + } + set className(className) { + Astal4.widget_set_class_names(this, className.split(/\s+/)); + } + get_class_name() { + return this.className; + } + set_class_name(className) { + this.className = className; + } + get cursor() { + return Astal4.widget_get_cursor(this); + } + set cursor(cursor) { + Astal4.widget_set_cursor(this, cursor); + } + get_cursor() { + return this.cursor; + } + set_cursor(cursor) { + this.cursor = cursor; + } + get clickThrough() { + return Astal4.widget_get_click_through(this); + } + set clickThrough(clickThrough) { + Astal4.widget_set_click_through(this, clickThrough); + } + get_click_through() { + return this.clickThrough; + } + set_click_through(clickThrough) { + this.clickThrough = clickThrough; + } + get noImplicitDestroy() { + return this[noImplicitDestroy]; + } + set noImplicitDestroy(value) { + this[noImplicitDestroy] = value; + } + set actionGroup([prefix, group]) { + this.insert_action_group(prefix, group); + } + set_action_group(actionGroup) { + this.actionGroup = actionGroup; + } + getChildren() { + if (this instanceof Gtk.Bin) { + return this.get_child() ? [this.get_child()] : []; + } else if (this instanceof Gtk.Container) { + return this.get_children(); + } + return []; + } + setChildren(children) { + children = children.flat(Infinity).map((ch) => ch instanceof Gtk.Widget ? ch : new Gtk.Label({ visible: true, label: String(ch) })); + if (this instanceof Gtk.Container) { + for (const ch of children) + this.add(ch); + } else { + throw Error(`can not add children to ${this.constructor.name}`); + } + } + [setChildren](children) { + if (this instanceof Gtk.Container) { + for (const ch of this.getChildren()) { + this.remove(ch); + if (!children.includes(ch) && !this.noImplicitDestroy) + ch?.destroy(); + } + } + this.setChildren(children); + } + toggleClassName(cn, cond = true) { + Astal4.widget_toggle_class_name(this, cn, cond); + } + hook(object, signalOrCallback, callback) { + hook(this, object, signalOrCallback, callback); + return this; + } + constructor(...params) { + super(); + const props = params[0] || {}; + props.visible ??= true; + construct(this, props); + } + } + GObject.registerClass({ + GTypeName: `Astal_${clsName}`, + Properties: { + "class-name": GObject.ParamSpec.string( + "class-name", + "", + "", + GObject.ParamFlags.READWRITE, + "" + ), + "css": GObject.ParamSpec.string( + "css", + "", + "", + GObject.ParamFlags.READWRITE, + "" + ), + "cursor": GObject.ParamSpec.string( + "cursor", + "", + "", + GObject.ParamFlags.READWRITE, + "default" + ), + "click-through": GObject.ParamSpec.boolean( + "click-through", + "", + "", + GObject.ParamFlags.READWRITE, + false + ), + "no-implicit-destroy": GObject.ParamSpec.boolean( + "no-implicit-destroy", + "", + "", + GObject.ParamFlags.READWRITE, + false + ) + } + }, Widget); + return Widget; +} + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/app.ts +import Gtk2 from "gi://Gtk?version=3.0"; +import Astal5 from "gi://Astal?version=3.0"; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/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: Hyprland2, Monitor, Workspace }) => { + patch(Hyprland2.prototype, "binds"); + patch(Hyprland2.prototype, "monitors"); + patch(Hyprland2.prototype, "workspaces"); + patch(Hyprland2.prototype, "clients"); + patch(Monitor.prototype, "availableModes"); + patch(Monitor.prototype, "available_modes"); + patch(Workspace.prototype, "clients"); +}); +await suppress(import("gi://AstalMpris"), ({ Mpris: Mpris2, Player }) => { + patch(Mpris2.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: Wifi2 }) => { + patch(Wifi2.prototype, "access_points"); + patch(Wifi2.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: Wp2, Audio, Video }) => { + patch(Wp2.prototype, "endpoints"); + patch(Wp2.prototype, "devices"); + patch(Audio.prototype, "streams"); + patch(Audio.prototype, "recorders"); + patch(Audio.prototype, "microphones"); + patch(Audio.prototype, "speakers"); + patch(Audio.prototype, "devices"); + patch(Video.prototype, "streams"); + patch(Video.prototype, "recorders"); + patch(Video.prototype, "sinks"); + patch(Video.prototype, "sources"); + patch(Video.prototype, "devices"); +}); + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/_app.ts +import { setConsoleLogDomain } from "console"; +import { exit, programArgs } from "system"; +import IO from "gi://AstalIO"; +import GObject2 from "gi://GObject"; +function mkApp(App) { + return new class AstalJS extends App { + static { + GObject2.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([]); + } + }(); +} + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/app.ts +Gtk2.init(null); +var app_default = mkApp(Astal5.Application); + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/widget.ts +import Astal6 from "gi://Astal?version=3.0"; +import Gtk3 from "gi://Gtk?version=3.0"; +import GObject3 from "gi://GObject"; +function filter(children) { + return children.flat(Infinity).map((ch) => ch instanceof Gtk3.Widget ? ch : new Gtk3.Label({ visible: true, label: String(ch) })); +} +Object.defineProperty(Astal6.Box.prototype, "children", { + get() { + return this.get_children(); + }, + set(v) { + this.set_children(v); + } +}); +var Box = class extends astalify(Astal6.Box) { + static { + GObject3.registerClass({ GTypeName: "Box" }, this); + } + constructor(props, ...children) { + super({ children, ...props }); + } + setChildren(children) { + this.set_children(filter(children)); + } +}; +var Button = class extends astalify(Astal6.Button) { + static { + GObject3.registerClass({ GTypeName: "Button" }, this); + } + constructor(props, child) { + super({ child, ...props }); + } +}; +var CenterBox = class extends astalify(Astal6.CenterBox) { + static { + GObject3.registerClass({ GTypeName: "CenterBox" }, this); + } + constructor(props, ...children) { + super({ children, ...props }); + } + setChildren(children) { + const ch = filter(children); + this.startWidget = ch[0] || new Gtk3.Box(); + this.centerWidget = ch[1] || new Gtk3.Box(); + this.endWidget = ch[2] || new Gtk3.Box(); + } +}; +var CircularProgress = class extends astalify(Astal6.CircularProgress) { + static { + GObject3.registerClass({ GTypeName: "CircularProgress" }, this); + } + constructor(props, child) { + super({ child, ...props }); + } +}; +var DrawingArea = class extends astalify(Gtk3.DrawingArea) { + static { + GObject3.registerClass({ GTypeName: "DrawingArea" }, this); + } + constructor(props) { + super(props); + } +}; +var Entry = class extends astalify(Gtk3.Entry) { + static { + GObject3.registerClass({ GTypeName: "Entry" }, this); + } + constructor(props) { + super(props); + } +}; +var EventBox = class extends astalify(Astal6.EventBox) { + static { + GObject3.registerClass({ GTypeName: "EventBox" }, this); + } + constructor(props, child) { + super({ child, ...props }); + } +}; +var Icon = class extends astalify(Astal6.Icon) { + static { + GObject3.registerClass({ GTypeName: "Icon" }, this); + } + constructor(props) { + super(props); + } +}; +var Label = class extends astalify(Astal6.Label) { + static { + GObject3.registerClass({ GTypeName: "Label" }, this); + } + constructor(props) { + super(props); + } + setChildren(children) { + this.label = String(children); + } +}; +var LevelBar = class extends astalify(Astal6.LevelBar) { + static { + GObject3.registerClass({ GTypeName: "LevelBar" }, this); + } + constructor(props) { + super(props); + } +}; +var MenuButton = class extends astalify(Gtk3.MenuButton) { + static { + GObject3.registerClass({ GTypeName: "MenuButton" }, this); + } + constructor(props, child) { + super({ child, ...props }); + } +}; +Object.defineProperty(Astal6.Overlay.prototype, "overlays", { + get() { + return this.get_overlays(); + }, + set(v) { + this.set_overlays(v); + } +}); +var Overlay = class extends astalify(Astal6.Overlay) { + static { + GObject3.registerClass({ GTypeName: "Overlay" }, this); + } + constructor(props, ...children) { + super({ children, ...props }); + } + setChildren(children) { + const [child, ...overlays] = filter(children); + this.set_child(child); + this.set_overlays(overlays); + } +}; +var Revealer = class extends astalify(Gtk3.Revealer) { + static { + GObject3.registerClass({ GTypeName: "Revealer" }, this); + } + constructor(props, child) { + super({ child, ...props }); + } +}; +var Scrollable = class extends astalify(Astal6.Scrollable) { + static { + GObject3.registerClass({ GTypeName: "Scrollable" }, this); + } + constructor(props, child) { + super({ child, ...props }); + } +}; +var Slider = class extends astalify(Astal6.Slider) { + static { + GObject3.registerClass({ GTypeName: "Slider" }, this); + } + constructor(props) { + super(props); + } +}; +var Stack = class extends astalify(Astal6.Stack) { + static { + GObject3.registerClass({ GTypeName: "Stack" }, this); + } + constructor(props, ...children) { + super({ children, ...props }); + } + setChildren(children) { + this.set_children(filter(children)); + } +}; +var Switch = class extends astalify(Gtk3.Switch) { + static { + GObject3.registerClass({ GTypeName: "Switch" }, this); + } + constructor(props) { + super(props); + } +}; +var Window = class extends astalify(Astal6.Window) { + static { + GObject3.registerClass({ GTypeName: "Window" }, this); + } + constructor(props, child) { + super({ child, ...props }); + } +}; + +// sass:/home/biscuit/Nixos/packages/ags/custom/style.scss +var style_default = "window.Bar {\n border: none;\n box-shadow: none;\n background-color: #212223;\n color: #f1f1f1;\n font-size: 1.1em;\n font-weight: bold;\n}\nwindow.Bar label {\n margin: 0 8px;\n}\nwindow.Bar .Workspaces button {\n all: unset;\n background-color: transparent;\n}\nwindow.Bar .Workspaces button:hover label {\n background-color: rgba(241, 241, 241, 0.16);\n border-color: rgba(55, 141, 247, 0.2);\n}\nwindow.Bar .Workspaces button:active label {\n background-color: rgba(241, 241, 241, 0.2);\n}\nwindow.Bar .Workspaces label {\n transition: 200ms;\n padding: 0 8px;\n margin: 2px;\n border-radius: 7px;\n border: 1pt solid transparent;\n}\nwindow.Bar .Workspaces .focused label {\n color: #378DF7;\n border-color: #378DF7;\n}\nwindow.Bar .SysTray {\n margin-right: 8px;\n}\nwindow.Bar .SysTray button {\n padding: 0 4px;\n}\nwindow.Bar .FocusedClient {\n color: #378DF7;\n}\nwindow.Bar .Media .Cover {\n min-height: 1.2em;\n min-width: 1.2em;\n border-radius: 7px;\n background-position: center;\n background-size: contain;\n}\nwindow.Bar .Battery label {\n padding-left: 0;\n margin-left: 0;\n}\nwindow.Bar .AudioSlider * {\n all: unset;\n}\nwindow.Bar .AudioSlider icon {\n margin-right: 0.6em;\n}\nwindow.Bar .AudioSlider {\n margin: 0 1em;\n}\nwindow.Bar .AudioSlider trough {\n background-color: rgba(241, 241, 241, 0.2);\n border-radius: 7px;\n}\nwindow.Bar .AudioSlider highlight {\n background-color: #378DF7;\n min-height: 0.8em;\n border-radius: 7px;\n}\nwindow.Bar .AudioSlider slider {\n background-color: #f1f1f1;\n border-radius: 7px;\n min-height: 1em;\n min-width: 1em;\n margin: -0.2em;\n}"; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/index.ts +import { default as default3 } from "gi://AstalIO?version=0.1"; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/file.ts +import Astal8 from "gi://AstalIO"; +import Gio from "gi://Gio?version=2.0"; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gobject.ts +import GObject4 from "gi://GObject"; +import { default as default2 } from "gi://GLib?version=2.0"; +var meta = Symbol("meta"); +var priv = Symbol("priv"); +var { ParamSpec, ParamFlags } = GObject4; + +// widget/Bar.tsx +import Hyprland from "gi://AstalHyprland"; +import Mpris from "gi://AstalMpris"; +import Battery from "gi://AstalBattery"; +import Wp from "gi://AstalWp"; +import Network from "gi://AstalNetwork"; +import Tray from "gi://AstalTray"; + +// ../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/jsx-runtime.ts +function jsx2(ctor, props) { + return jsx(ctors, ctor, props); +} +var ctors = { + box: Box, + button: Button, + centerbox: CenterBox, + circularprogress: CircularProgress, + drawingarea: DrawingArea, + entry: Entry, + eventbox: EventBox, + // TODO: fixed + // TODO: flowbox + icon: Icon, + label: Label, + levelbar: LevelBar, + // TODO: listbox + menubutton: MenuButton, + overlay: Overlay, + revealer: Revealer, + scrollable: Scrollable, + slider: Slider, + stack: Stack, + switch: Switch, + window: Window +}; +var jsxs = jsx2; + +// widget/Bar.tsx +function SysTray() { + const tray = Tray.get_default(); + return /* @__PURE__ */ jsx2("box", { className: "SysTray", children: bind(tray, "items").as((items) => items.map((item) => /* @__PURE__ */ jsx2( + "menubutton", + { + tooltipMarkup: bind(item, "tooltipMarkup"), + usePopover: false, + actionGroup: bind(item, "actionGroup").as((ag) => ["dbusmenu", ag]), + menuModel: bind(item, "menuModel"), + children: /* @__PURE__ */ jsx2("icon", { gicon: bind(item, "gicon") }) + } + ))) }); +} +function Wifi() { + const network = Network.get_default(); + const wifi = bind(network, "wifi"); + return /* @__PURE__ */ jsx2("box", { visible: wifi.as(Boolean), children: wifi.as((wifi2) => wifi2 && /* @__PURE__ */ jsx2( + "icon", + { + tooltipText: bind(wifi2, "ssid").as(String), + className: "Wifi", + icon: bind(wifi2, "iconName") + } + )) }); +} +function AudioSlider() { + const speaker = Wp.get_default()?.audio.defaultSpeaker; + return /* @__PURE__ */ jsxs("box", { className: "AudioSlider", css: "min-width: 140px", children: [ + /* @__PURE__ */ jsx2("icon", { icon: bind(speaker, "volumeIcon") }), + /* @__PURE__ */ jsx2( + "slider", + { + hexpand: true, + onDragged: ({ value }) => speaker.volume = value, + value: bind(speaker, "volume") + } + ) + ] }); +} +function BatteryLevel() { + const bat = Battery.get_default(); + return /* @__PURE__ */ jsxs( + "box", + { + className: "Battery", + visible: bind(bat, "isPresent"), + children: [ + /* @__PURE__ */ jsx2("icon", { icon: bind(bat, "batteryIconName") }), + /* @__PURE__ */ jsx2("label", { label: bind(bat, "percentage").as( + (p) => `${Math.floor(p * 100)} %` + ) }) + ] + } + ); +} +function Media() { + const mpris = Mpris.get_default(); + return /* @__PURE__ */ jsx2("box", { className: "Media", children: bind(mpris, "players").as((ps) => ps[0] ? /* @__PURE__ */ jsxs("box", { children: [ + /* @__PURE__ */ jsx2( + "box", + { + className: "Cover", + valign: Gtk4.Align.CENTER, + css: bind(ps[0], "coverArt").as( + (cover) => `background-image: url('${cover}');` + ) + } + ), + /* @__PURE__ */ jsx2( + "label", + { + label: bind(ps[0], "metadata").as( + () => `${ps[0].title} - ${ps[0].artist}` + ) + } + ) + ] }) : /* @__PURE__ */ jsx2("label", { label: "Nothing Playing" })) }); +} +function Workspaces() { + const hypr = Hyprland.get_default(); + return /* @__PURE__ */ jsx2("box", { className: "Workspaces", 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", + { + className: bind(hypr, "focusedWorkspace").as((fw) => ws === fw ? "focused" : ""), + onClicked: () => ws.focus(), + children: ws.id + } + )) + ) }); +} +function FocusedClient() { + const hypr = Hyprland.get_default(); + const focused = bind(hypr, "focusedClient"); + return /* @__PURE__ */ jsx2( + "box", + { + className: "Focused", + visible: focused.as(Boolean), + children: focused.as((client) => client && /* @__PURE__ */ jsx2("label", { label: bind(client, "title").as(String) })) + } + ); +} +function Time2({ format = "%H:%M - %A %e." }) { + const time = Variable("").poll(1e3, () => default2.DateTime.new_now_local().format(format)); + return /* @__PURE__ */ jsx2( + "label", + { + className: "Time", + onDestroy: () => time.drop(), + label: time() + } + ); +} +function Bar(monitor) { + const { TOP, LEFT, RIGHT } = Astal7.WindowAnchor; + return /* @__PURE__ */ jsx2( + "window", + { + className: "Bar", + gdkmonitor: monitor, + exclusivity: Astal7.Exclusivity.EXCLUSIVE, + anchor: TOP | LEFT | RIGHT, + children: /* @__PURE__ */ jsxs("centerbox", { children: [ + /* @__PURE__ */ jsxs("box", { hexpand: true, halign: Gtk4.Align.START, children: [ + /* @__PURE__ */ jsx2(Workspaces, {}), + /* @__PURE__ */ jsx2(FocusedClient, {}) + ] }), + /* @__PURE__ */ jsx2("box", { children: /* @__PURE__ */ jsx2(Media, {}) }), + /* @__PURE__ */ jsxs("box", { hexpand: true, halign: Gtk4.Align.END, children: [ + /* @__PURE__ */ jsx2(SysTray, {}), + /* @__PURE__ */ jsx2(Wifi, {}), + /* @__PURE__ */ jsx2(AudioSlider, {}), + /* @__PURE__ */ jsx2(BatteryLevel, {}), + /* @__PURE__ */ jsx2(Time2, {}) + ] }) + ] }) + } + ); +} + +// app.ts +app_default.start({ + css: style_default, + instanceName: "js", + requestHandler(request, res) { + print(request); + res("ok"); + }, + main: () => app_default.get_monitors().map(Bar) +}); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/index.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/variable.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/binding.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/time.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/process.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/_astal.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/astalify.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/app.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/overrides.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/_app.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/widget.ts", "sass:/home/biscuit/Nixos/packages/ags/custom/style.scss", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/index.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/file.ts", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gobject.ts", "widget/Bar.tsx", "../../../../../../nix/store/qcvx468clwcipgk9vh0qb5rzr4k23g6p-astal-gjs/share/astal/gjs/gtk3/jsx-runtime.ts", "app.ts"],
  "sourcesContent": ["import Astal from \"gi://Astal?version=3.0\"\nimport Gtk from \"gi://Gtk?version=3.0\"\nimport Gdk from \"gi://Gdk?version=3.0\"\nimport astalify, { type ConstructProps, type BindableProps } from \"./astalify.js\"\n\nexport { Astal, Gtk, Gdk }\nexport { default as App } from \"./app.js\"\nexport { astalify, ConstructProps, BindableProps }\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 { hook, noImplicitDestroy, setChildren, mergeBindings, type BindableProps, construct } from \"../_astal.js\"\nimport Astal from \"gi://Astal?version=3.0\"\nimport Gtk from \"gi://Gtk?version=3.0\"\nimport Gdk from \"gi://Gdk?version=3.0\"\nimport GObject from \"gi://GObject\"\nimport Gio from \"gi://Gio?version=2.0\"\nimport Binding, { type Connectable, type Subscribable } from \"../binding.js\"\n\nexport { BindableProps, mergeBindings }\n\nexport default function astalify<\n    C extends { new(...args: any[]): Gtk.Widget },\n>(cls: C, clsName = cls.name) {\n    class Widget extends cls {\n        get css(): string { return Astal.widget_get_css(this) }\n        set css(css: string) { Astal.widget_set_css(this, css) }\n        get_css(): string { return this.css }\n        set_css(css: string) { this.css = css }\n\n        get className(): string { return Astal.widget_get_class_names(this).join(\" \") }\n        set className(className: string) { Astal.widget_set_class_names(this, className.split(/\\s+/)) }\n        get_class_name(): string { return this.className }\n        set_class_name(className: string) { this.className = className }\n\n        get cursor(): Cursor { return Astal.widget_get_cursor(this) as Cursor }\n        set cursor(cursor: Cursor) { Astal.widget_set_cursor(this, cursor) }\n        get_cursor(): Cursor { return this.cursor }\n        set_cursor(cursor: Cursor) { this.cursor = cursor }\n\n        get clickThrough(): boolean { return Astal.widget_get_click_through(this) }\n        set clickThrough(clickThrough: boolean) { Astal.widget_set_click_through(this, clickThrough) }\n        get_click_through(): boolean { return this.clickThrough }\n        set_click_through(clickThrough: boolean) { this.clickThrough = clickThrough }\n\n        declare private [noImplicitDestroy]: boolean\n        get noImplicitDestroy(): boolean { return this[noImplicitDestroy] }\n        set noImplicitDestroy(value: boolean) { this[noImplicitDestroy] = value }\n\n        set actionGroup([prefix, group]: ActionGroup) { this.insert_action_group(prefix, group) }\n        set_action_group(actionGroup: ActionGroup) { this.actionGroup = actionGroup }\n\n        protected getChildren(): Array<Gtk.Widget> {\n            if (this instanceof Gtk.Bin) {\n                return this.get_child() ? [this.get_child()!] : []\n            } else if (this instanceof Gtk.Container) {\n                return this.get_children()\n            }\n            return []\n        }\n\n        protected setChildren(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            if (this instanceof Gtk.Container) {\n                for (const ch of children)\n                    this.add(ch)\n            } else {\n                throw Error(`can not add children to ${this.constructor.name}`)\n            }\n        }\n\n        [setChildren](children: any[]) {\n            // remove\n            if (this instanceof Gtk.Container) {\n                for (const ch of this.getChildren()) {\n                    this.remove(ch)\n                    if (!children.includes(ch) && !this.noImplicitDestroy)\n                        ch?.destroy()\n                }\n            }\n\n            // append\n            this.setChildren(children)\n        }\n\n        toggleClassName(cn: string, cond = true) {\n            Astal.widget_toggle_class_name(this, cn, cond)\n        }\n\n        hook(\n            object: Connectable,\n            signal: string,\n            callback: (self: this, ...args: any[]) => void,\n        ): this\n        hook(\n            object: Subscribable,\n            callback: (self: this, ...args: any[]) => void,\n        ): this\n        hook(\n            object: Connectable | Subscribable,\n            signalOrCallback: string | ((self: this, ...args: any[]) => void),\n            callback?: (self: this, ...args: any[]) => void,\n        ) {\n            hook(this, object, signalOrCallback, callback)\n            return this\n        }\n\n        constructor(...params: any[]) {\n            super()\n            const props = params[0] || {}\n            props.visible ??= true\n            construct(this, props)\n        }\n    }\n\n    GObject.registerClass({\n        GTypeName: `Astal_${clsName}`,\n        Properties: {\n            \"class-name\": GObject.ParamSpec.string(\n                \"class-name\", \"\", \"\", GObject.ParamFlags.READWRITE, \"\",\n            ),\n            \"css\": GObject.ParamSpec.string(\n                \"css\", \"\", \"\", GObject.ParamFlags.READWRITE, \"\",\n            ),\n            \"cursor\": GObject.ParamSpec.string(\n                \"cursor\", \"\", \"\", GObject.ParamFlags.READWRITE, \"default\",\n            ),\n            \"click-through\": GObject.ParamSpec.boolean(\n                \"click-through\", \"\", \"\", GObject.ParamFlags.READWRITE, false,\n            ),\n            \"no-implicit-destroy\": GObject.ParamSpec.boolean(\n                \"no-implicit-destroy\", \"\", \"\", GObject.ParamFlags.READWRITE, false,\n            ),\n        },\n    }, Widget)\n\n    return Widget\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 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}> & BindableProps<Partial<Props & {\n    className?: string\n    css?: string\n    cursor?: string\n    clickThrough?: boolean\n    actionGroup?: ActionGroup\n}>> & Partial<{\n    onDestroy: (self: Self) => unknown\n    onDraw: (self: Self) => unknown\n    onKeyPressEvent: (self: Self, event: Gdk.Event) => unknown\n    onKeyReleaseEvent: (self: Self, event: Gdk.Event) => unknown\n    onButtonPressEvent: (self: Self, event: Gdk.Event) => unknown\n    onButtonReleaseEvent: (self: Self, event: Gdk.Event) => unknown\n    onRealize: (self: Self) => unknown\n    setup: (self: Self) => void\n}>\n\ntype Cursor =\n    | \"default\"\n    | \"help\"\n    | \"pointer\"\n    | \"context-menu\"\n    | \"progress\"\n    | \"wait\"\n    | \"cell\"\n    | \"crosshair\"\n    | \"text\"\n    | \"vertical-text\"\n    | \"alias\"\n    | \"copy\"\n    | \"no-drop\"\n    | \"move\"\n    | \"not-allowed\"\n    | \"grab\"\n    | \"grabbing\"\n    | \"all-scroll\"\n    | \"col-resize\"\n    | \"row-resize\"\n    | \"n-resize\"\n    | \"e-resize\"\n    | \"s-resize\"\n    | \"w-resize\"\n    | \"ne-resize\"\n    | \"nw-resize\"\n    | \"sw-resize\"\n    | \"se-resize\"\n    | \"ew-resize\"\n    | \"ns-resize\"\n    | \"nesw-resize\"\n    | \"nwse-resize\"\n    | \"zoom-in\"\n    | \"zoom-out\"\n\ntype ActionGroup = [prefix: string, actionGroup: Gio.ActionGroup]\n", "import Gtk from \"gi://Gtk?version=3.0\"\nimport Astal from \"gi://Astal?version=3.0\"\nimport { mkApp } from \"../_app\"\n\nGtk.init(null)\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", "/* eslint-disable max-len */\nimport Astal from \"gi://Astal?version=3.0\"\nimport Gtk from \"gi://Gtk?version=3.0\"\nimport GObject from \"gi://GObject\"\nimport astalify, { type ConstructProps, type BindableChild } 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<Box, Astal.Box.ConstructorProps>\nexport class Box extends astalify(Astal.Box) {\n    static { GObject.registerClass({ GTypeName: \"Box\" }, this) }\n    constructor(props?: BoxProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }\n    protected setChildren(children: any[]): void { this.set_children(filter(children)) }\n}\n\n// Button\nexport type ButtonProps = ConstructProps<Button, Astal.Button.ConstructorProps, {\n    onClicked: []\n    onClick: [event: Astal.ClickEvent]\n    onClickRelease: [event: Astal.ClickEvent]\n    onHover: [event: Astal.HoverEvent]\n    onHoverLost: [event: Astal.HoverEvent]\n    onScroll: [event: Astal.ScrollEvent]\n}>\nexport class Button extends astalify(Astal.Button) {\n    static { GObject.registerClass({ GTypeName: \"Button\" }, this) }\n    constructor(props?: ButtonProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// CenterBox\nexport type CenterBoxProps = ConstructProps<CenterBox, Astal.CenterBox.ConstructorProps>\nexport class CenterBox extends astalify(Astal.CenterBox) {\n    static { GObject.registerClass({ GTypeName: \"CenterBox\" }, this) }\n    constructor(props?: CenterBoxProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }\n    protected setChildren(children: any[]): void {\n        const ch = filter(children)\n        this.startWidget = ch[0] || new Gtk.Box\n        this.centerWidget = ch[1] || new Gtk.Box\n        this.endWidget = ch[2] || new Gtk.Box\n    }\n}\n\n// CircularProgress\nexport type CircularProgressProps = ConstructProps<CircularProgress, Astal.CircularProgress.ConstructorProps>\nexport class CircularProgress extends astalify(Astal.CircularProgress) {\n    static { GObject.registerClass({ GTypeName: \"CircularProgress\" }, this) }\n    constructor(props?: CircularProgressProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// DrawingArea\nexport type DrawingAreaProps = ConstructProps<DrawingArea, Gtk.DrawingArea.ConstructorProps, {\n    onDraw: [cr: any] // TODO: cairo types\n}>\nexport class DrawingArea extends astalify(Gtk.DrawingArea) {\n    static { GObject.registerClass({ GTypeName: \"DrawingArea\" }, this) }\n    constructor(props?: DrawingAreaProps) { super(props as any) }\n}\n\n// Entry\nexport type EntryProps = ConstructProps<Entry, Gtk.Entry.ConstructorProps, {\n    onChanged: []\n    onActivate: []\n}>\nexport class Entry extends astalify(Gtk.Entry) {\n    static { GObject.registerClass({ GTypeName: \"Entry\" }, this) }\n    constructor(props?: EntryProps) { super(props as any) }\n}\n\n// EventBox\nexport type EventBoxProps = ConstructProps<EventBox, Astal.EventBox.ConstructorProps, {\n    onClick: [event: Astal.ClickEvent]\n    onClickRelease: [event: Astal.ClickEvent]\n    onHover: [event: Astal.HoverEvent]\n    onHoverLost: [event: Astal.HoverEvent]\n    onScroll: [event: Astal.ScrollEvent]\n}>\nexport class EventBox extends astalify(Astal.EventBox) {\n    static { GObject.registerClass({ GTypeName: \"EventBox\" }, this) }\n    constructor(props?: EventBoxProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// // TODO: Fixed\n// // TODO: FlowBox\n//\n// Icon\nexport type IconProps = ConstructProps<Icon, Astal.Icon.ConstructorProps>\nexport class Icon extends astalify(Astal.Icon) {\n    static { GObject.registerClass({ GTypeName: \"Icon\" }, this) }\n    constructor(props?: IconProps) { super(props as any) }\n}\n\n// Label\nexport type LabelProps = ConstructProps<Label, Astal.Label.ConstructorProps>\nexport class Label extends astalify(Astal.Label) {\n    static { GObject.registerClass({ GTypeName: \"Label\" }, this) }\n    constructor(props?: LabelProps) { super(props as any) }\n    protected setChildren(children: any[]): void { this.label = String(children) }\n}\n\n// LevelBar\nexport type LevelBarProps = ConstructProps<LevelBar, Astal.LevelBar.ConstructorProps>\nexport class LevelBar extends astalify(Astal.LevelBar) {\n    static { GObject.registerClass({ GTypeName: \"LevelBar\" }, this) }\n    constructor(props?: LevelBarProps) { super(props as any) }\n}\n\n// TODO: ListBox\n\n// MenuButton\nexport type MenuButtonProps = ConstructProps<MenuButton, Gtk.MenuButton.ConstructorProps>\nexport class MenuButton extends astalify(Gtk.MenuButton) {\n    static { GObject.registerClass({ GTypeName: \"MenuButton\" }, this) }\n    constructor(props?: MenuButtonProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// Overlay\nObject.defineProperty(Astal.Overlay.prototype, \"overlays\", {\n    get() { return this.get_overlays() },\n    set(v) { this.set_overlays(v) },\n})\n\nexport type OverlayProps = ConstructProps<Overlay, Astal.Overlay.ConstructorProps>\nexport class Overlay extends astalify(Astal.Overlay) {\n    static { GObject.registerClass({ GTypeName: \"Overlay\" }, this) }\n    constructor(props?: OverlayProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }\n    protected setChildren(children: any[]): void {\n        const [child, ...overlays] = filter(children)\n        this.set_child(child)\n        this.set_overlays(overlays)\n    }\n}\n\n// Revealer\nexport type RevealerProps = ConstructProps<Revealer, Gtk.Revealer.ConstructorProps>\nexport class Revealer extends astalify(Gtk.Revealer) {\n    static { GObject.registerClass({ GTypeName: \"Revealer\" }, this) }\n    constructor(props?: RevealerProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// Scrollable\nexport type ScrollableProps = ConstructProps<Scrollable, Astal.Scrollable.ConstructorProps>\nexport class Scrollable extends astalify(Astal.Scrollable) {\n    static { GObject.registerClass({ GTypeName: \"Scrollable\" }, this) }\n    constructor(props?: ScrollableProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n\n// Slider\nexport type SliderProps = ConstructProps<Slider, Astal.Slider.ConstructorProps, {\n    onDragged: []\n}>\nexport class Slider extends astalify(Astal.Slider) {\n    static { GObject.registerClass({ GTypeName: \"Slider\" }, this) }\n    constructor(props?: SliderProps) { super(props as any) }\n}\n\n// Stack\nexport type StackProps = ConstructProps<Stack, Astal.Stack.ConstructorProps>\nexport class Stack extends astalify(Astal.Stack) {\n    static { GObject.registerClass({ GTypeName: \"Stack\" }, this) }\n    constructor(props?: StackProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }\n    protected setChildren(children: any[]): void { this.set_children(filter(children)) }\n}\n\n// Switch\nexport type SwitchProps = ConstructProps<Switch, Gtk.Switch.ConstructorProps>\nexport class Switch extends astalify(Gtk.Switch) {\n    static { GObject.registerClass({ GTypeName: \"Switch\" }, this) }\n    constructor(props?: SwitchProps) { super(props as any) }\n}\n\n// Window\nexport type WindowProps = ConstructProps<Window, Astal.Window.ConstructorProps>\nexport class Window extends astalify(Astal.Window) {\n    static { GObject.registerClass({ GTypeName: \"Window\" }, this) }\n    constructor(props?: WindowProps, child?: BindableChild) { super({ child, ...props } as any) }\n}\n", "window.Bar {\n  border: none;\n  box-shadow: none;\n  background-color: #212223;\n  color: #f1f1f1;\n  font-size: 1.1em;\n  font-weight: bold;\n}\nwindow.Bar label {\n  margin: 0 8px;\n}\nwindow.Bar .Workspaces button {\n  all: unset;\n  background-color: transparent;\n}\nwindow.Bar .Workspaces button:hover label {\n  background-color: rgba(241, 241, 241, 0.16);\n  border-color: rgba(55, 141, 247, 0.2);\n}\nwindow.Bar .Workspaces button:active label {\n  background-color: rgba(241, 241, 241, 0.2);\n}\nwindow.Bar .Workspaces label {\n  transition: 200ms;\n  padding: 0 8px;\n  margin: 2px;\n  border-radius: 7px;\n  border: 1pt solid transparent;\n}\nwindow.Bar .Workspaces .focused label {\n  color: #378DF7;\n  border-color: #378DF7;\n}\nwindow.Bar .SysTray {\n  margin-right: 8px;\n}\nwindow.Bar .SysTray button {\n  padding: 0 4px;\n}\nwindow.Bar .FocusedClient {\n  color: #378DF7;\n}\nwindow.Bar .Media .Cover {\n  min-height: 1.2em;\n  min-width: 1.2em;\n  border-radius: 7px;\n  background-position: center;\n  background-size: contain;\n}\nwindow.Bar .Battery label {\n  padding-left: 0;\n  margin-left: 0;\n}\nwindow.Bar .AudioSlider * {\n  all: unset;\n}\nwindow.Bar .AudioSlider icon {\n  margin-right: 0.6em;\n}\nwindow.Bar .AudioSlider {\n  margin: 0 1em;\n}\nwindow.Bar .AudioSlider trough {\n  background-color: rgba(241, 241, 241, 0.2);\n  border-radius: 7px;\n}\nwindow.Bar .AudioSlider highlight {\n  background-color: #378DF7;\n  min-height: 0.8em;\n  border-radius: 7px;\n}\nwindow.Bar .AudioSlider slider {\n  background-color: #f1f1f1;\n  border-radius: 7px;\n  min-height: 1em;\n  min-width: 1em;\n  margin: -0.2em;\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 { App } from \"astal/gtk3\"\nimport { Variable, GLib, bind } from \"astal\"\nimport { Astal, Gtk, Gdk } from \"astal/gtk3\"\nimport Hyprland from \"gi://AstalHyprland\"\nimport Mpris from \"gi://AstalMpris\"\nimport Battery from \"gi://AstalBattery\"\nimport Wp from \"gi://AstalWp\"\nimport Network from \"gi://AstalNetwork\"\nimport Tray from \"gi://AstalTray\"\n\nfunction SysTray() {\n    const tray = Tray.get_default()\n\n    return <box className=\"SysTray\">\n        {bind(tray, \"items\").as(items => items.map(item => (\n            <menubutton\n                tooltipMarkup={bind(item, \"tooltipMarkup\")}\n                usePopover={false}\n                actionGroup={bind(item, \"actionGroup\").as(ag => [\"dbusmenu\", ag])}\n                menuModel={bind(item, \"menuModel\")}>\n                <icon gicon={bind(item, \"gicon\")} />\n            </menubutton>\n        )))}\n    </box>\n}\n\nfunction Wifi() {\n    const network = Network.get_default()\n    const wifi = bind(network, \"wifi\")\n\n    return <box visible={wifi.as(Boolean)}>\n        {wifi.as(wifi => wifi && (\n            <icon\n                tooltipText={bind(wifi, \"ssid\").as(String)}\n                className=\"Wifi\"\n                icon={bind(wifi, \"iconName\")}\n            />\n        ))}\n    </box>\n\n}\n\nfunction AudioSlider() {\n    const speaker = Wp.get_default()?.audio.defaultSpeaker!\n\n    return <box className=\"AudioSlider\" css=\"min-width: 140px\">\n        <icon icon={bind(speaker, \"volumeIcon\")} />\n        <slider\n            hexpand\n            onDragged={({ value }) => speaker.volume = value}\n            value={bind(speaker, \"volume\")}\n        />\n    </box>\n}\n\nfunction BatteryLevel() {\n    const bat = Battery.get_default()\n\n    return <box className=\"Battery\"\n        visible={bind(bat, \"isPresent\")}>\n        <icon icon={bind(bat, \"batteryIconName\")} />\n        <label label={bind(bat, \"percentage\").as(p =>\n            `${Math.floor(p * 100)} %`\n        )} />\n    </box>\n}\n\nfunction Media() {\n    const mpris = Mpris.get_default()\n\n    return <box className=\"Media\">\n        {bind(mpris, \"players\").as(ps => ps[0] ? (\n            <box>\n                <box\n                    className=\"Cover\"\n                    valign={Gtk.Align.CENTER}\n                    css={bind(ps[0], \"coverArt\").as(cover =>\n                        `background-image: url('${cover}');`\n                    )}\n                />\n                <label\n                    label={bind(ps[0], \"metadata\").as(() =>\n                        `${ps[0].title} - ${ps[0].artist}`\n                    )}\n                />\n            </box>\n        ) : (\n            <label label=\"Nothing Playing\" />\n        ))}\n    </box>\n}\n\nfunction Workspaces() {\n    const hypr = Hyprland.get_default()\n\n    return <box className=\"Workspaces\">\n        {bind(hypr, \"workspaces\").as(wss => 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                    className={bind(hypr, \"focusedWorkspace\").as(fw =>\n                        ws === fw ? \"focused\" : \"\")}\n                    onClicked={() => ws.focus()}>\n                    {ws.id}\n                </button>\n            ))\n        )}\n    </box>\n}\n\nfunction FocusedClient() {\n    const hypr = Hyprland.get_default()\n    const focused = bind(hypr, \"focusedClient\")\n\n    return <box\n        className=\"Focused\"\n        visible={focused.as(Boolean)}>\n        {focused.as(client => (\n            client && <label label={bind(client, \"title\").as(String)} />\n        ))}\n    </box>\n}\n\nfunction Time({ format = \"%H:%M - %A %e.\" }) {\n    const time = Variable<string>(\"\").poll(1000, () =>\n        GLib.DateTime.new_now_local().format(format)!)\n\n    return <label\n        className=\"Time\"\n        onDestroy={() => time.drop()}\n        label={time()}\n    />\n}\n\nexport default function Bar(monitor: Gdk.Monitor) {\n    const { TOP, LEFT, RIGHT } = Astal.WindowAnchor\n\n    return <window\n        className=\"Bar\"\n        gdkmonitor={monitor}\n        exclusivity={Astal.Exclusivity.EXCLUSIVE}\n        anchor={TOP | LEFT | RIGHT}>\n        <centerbox>\n            <box hexpand halign={Gtk.Align.START}>\n                <Workspaces />\n                <FocusedClient />\n            </box>\n            <box>\n                <Media />\n            </box>\n            <box hexpand halign={Gtk.Align.END} >\n                <SysTray />\n                <Wifi />\n                <AudioSlider />\n                <BatteryLevel />\n                <Time />\n            </box>\n        </centerbox>\n    </window>\n}\n", "import Gtk from \"gi://Gtk?version=3.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    eventbox: Widget.EventBox,\n    // TODO: fixed\n    // TODO: flowbox\n    icon: Widget.Icon,\n    label: Widget.Label,\n    levelbar: Widget.LevelBar,\n    // TODO: listbox\n    menubutton: Widget.MenuButton,\n    overlay: Widget.Overlay,\n    revealer: Widget.Revealer,\n    scrollable: Widget.Scrollable,\n    slider: Widget.Slider,\n    stack: Widget.Stack,\n    switch: Widget.Switch,\n    window: Widget.Window,\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            eventbox: Widget.EventBoxProps\n            // TODO: fixed\n            // TODO: flowbox\n            icon: Widget.IconProps\n            label: Widget.LabelProps\n            levelbar: Widget.LevelBarProps\n            // TODO: listbox\n            menubutton: Widget.MenuButtonProps\n            overlay: Widget.OverlayProps\n            revealer: Widget.RevealerProps\n            scrollable: Widget.ScrollableProps\n            slider: Widget.SliderProps\n            stack: Widget.StackProps\n            switch: Widget.SwitchProps\n            window: Widget.WindowProps\n        }\n    }\n}\n\nexport const jsxs = jsx\n", "import { App } from \"astal/gtk3\"\nimport style from \"./style.scss\"\nimport Bar from \"./widget/Bar\"\n\nApp.start({\n    css: style,\n    instanceName: \"js\",\n    requestHandler(request, res) {\n        print(request)\n        res(\"ok\")\n    },\n    main: () => App.get_monitors().map(Bar),\n})\n"],
  "mappings": "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",
  "names": ["Astal", "Gtk", "Astal", "bind", "interval", "Astal", "Astal", "Astal", "v", "interval", "ctors", "Astal", "Astal", "Gtk", "Astal", "snakeify", "patch", "Hyprland", "Mpris", "Wifi", "Wp", "GObject", "Gtk", "Astal", "Astal", "Gtk", "GObject", "Gtk", "Astal", "GObject", "default", "Astal", "GObject", "default", "GObject", "jsx", "jsx", "wifi", "Gtk", "Time", "default", "Astal"]
}
 diff --git a/packages/ags/default.nix b/packages/ags/default.nix index 946f1d2..360d10d 100644 --- a/packages/ags/default.nix +++ b/packages/ags/default.nix @@ -6,7 +6,7 @@ ]; home.packages = [ - inputs.astal.packages.${system}.default + # inputs.astal.packages.${system}.default ]; programs.ags = { diff --git a/packages/hyprpanel/default.nix b/packages/hyprpanel/default.nix index 157cf9a..3f1df61 100644 --- a/packages/hyprpanel/default.nix +++ b/packages/hyprpanel/default.nix @@ -15,7 +15,7 @@ # Fix the overwrite issue with HyprPanel. # See below for more information. # Default: false - overwrite.enable = true; + overwrite.enable = false; # Import a theme from './themes/*.json'. # Default: "" diff --git a/packages/kitty/default.nix b/packages/kitty/default.nix index 32e943e..fa71997 100644 --- a/packages/kitty/default.nix +++ b/packages/kitty/default.nix @@ -5,4 +5,10 @@ ]; programs.kitty.enable = true; + programs.kitty.settings = { + confirm_os_window_close = 0; + window_padding_width = 10; + font_size = 12.0; + }; + }