Upgrade to Agsv2 + Astal (#533)

* migrate to astal

* Reorganize project structure.

* progress

* Migrate Dashboard and Window Title modules.

* Migrate clock and notification bar modules.

* Remove unused code

* Media menu

* Rework network and volume modules

* Finish custom modules.

* Migrate battery bar module.

* Update battery module and organize helpers.

* Migrate workspace module.

* Wrap up bar modules.

* Checkpoint before I inevitbly blow something up.

* Updates

* Fix event propagation logic.

* Type fixes

* More type fixes

* Fix padding for event boxes.

* Migrate volume menu and refactor scroll event handlers.

* network module WIP

* Migrate network service.

* Migrate bluetooth menu

* Updates

* Migrate notifications

* Update scrolling behavior for custom modules.

* Improve popup notifications and add timer functionality.

* Migration notifications menu header/controls.

* Migrate notifications menu and consolidate notifications menu code.

* Migrate power menu.

* Dashboard progress

* Migrate dashboard

* Migrate media menu.

* Reduce media menu nesting.

* Finish updating media menu bindings to navigate active player.

* Migrate battery menu

* Consolidate code

* Migrate calendar menu

* Fix workspace logic to update on client add/change/remove and consolidate code.

* Migrate osd

* Consolidate hyprland service connections.

* Implement startup dropdown menu position allocation.

* Migrate settings menu (WIP)

* Settings dialo menu fixes

* Finish Dashboard menu

* Type updates

* update submoldule for types

* update github ci

* ci

* Submodule update

* Ci updates

* Remove type checking for now.

* ci fix

* Fix a bunch of stuff, losing track... need rest. Brb coffee

* Validate dropdown menu before render.

* Consolidate code and add auto-hide functionality.

* Improve auto-hide behavior.

* Consolidate audio menu code

* Organize bluetooth code

* Improve active player logic

* Properly dismiss a notification on action button resolution.

* Implement CLI command engine and migrate CLI commands.

* Handle variable disposal

* Bar component fixes and add hyprland startup rules.

* Handle potentially null bindings network and bluetooth bindings.

* Handle potentially null wired adapter.

* Fix GPU stats

* Handle poller for GPU

* Fix gpu bar logic.

* Clean up logic for stat bars.

* Handle wifi and wired bar icon bindings.

* Fix battery percentages

* Fix switch behavior

* Wifi staging fixes

* Reduce redundant hyprland service calls.

* Code cleanup

* Document the option code and reduce redundant calls to optimize performance.

* Remove outdated comment.

* Add JSDocs

* Add meson to build hyprpanel

* Consistency updates

* Organize commands

* Fix images not showing up on notifications.

* Remove todo

* Move hyprpanel configuration to the ~/.config/hyprpanel directory and add utility commands.

* Handle SRC directory for the bundled/built hyprpanel.

* Add namespaces to all windows

* Migrate systray

* systray updates

* Update meson to include ts, tsx and scss files.

* Remove log from meson

* Fix file choose path and make it float.

* Added a command to check the dependency status

* Update dep names.

* Get scale directly from env

* Add todo

src/lib/shared/eventHandlers.ts

@@ -0,0 +1,95 @@
+import { GtkWidget } from 'src/lib/types/widget.js';
+import { Gdk } from 'astal/gtk3';
+import { ThrottleFn } from '../types/utils';
+
+/**
+ * Connects a primary click handler and returns a disconnect function.
+ */
+export function onPrimaryClick(widget: GtkWidget, handler: (self: GtkWidget, event: Gdk.Event) => void): () => void {
+    const id = widget.connect('button-press-event', (self: GtkWidget, event: Gdk.Event) => {
+        const eventButton = event.get_button()[1];
+        if (eventButton === Gdk.BUTTON_PRIMARY) {
+            handler(self, event);
+        }
+    });
+    return () => widget.disconnect(id);
+}
+
+/**
+ * Connects a secondary click handler and returns a disconnect function.
+ */
+export function onSecondaryClick(widget: GtkWidget, handler: (self: GtkWidget, event: Gdk.Event) => void): () => void {
+    const id = widget.connect('button-press-event', (self: GtkWidget, event: Gdk.Event) => {
+        const eventButton = event.get_button()[1];
+        if (eventButton === Gdk.BUTTON_SECONDARY) {
+            handler(self, event);
+        }
+    });
+    return () => widget.disconnect(id);
+}
+
+/**
+ * Connects a middle click handler and returns a disconnect function.
+ */
+export function onMiddleClick(widget: GtkWidget, handler: (self: GtkWidget, event: Gdk.Event) => void): () => void {
+    const id = widget.connect('button-press-event', (self: GtkWidget, event: Gdk.Event) => {
+        const eventButton = event.get_button()[1];
+        if (eventButton === Gdk.BUTTON_MIDDLE) {
+            handler(self, event);
+        }
+    });
+    return () => widget.disconnect(id);
+}
+
+/**
+ * Connects a scroll handler and returns a disconnect function.
+ */
+export function onScroll(
+    widget: GtkWidget,
+    throttledHandler: ThrottleFn,
+    scrollUpAction: string,
+    scrollDownAction: string,
+): () => void {
+    const id = widget.connect('scroll-event', (self: GtkWidget, event: Gdk.Event) => {
+        const [directionSuccess, direction] = event.get_scroll_direction();
+        const [deltasSuccess, , yScroll] = event.get_scroll_deltas();
+
+        if (directionSuccess) {
+            handleScrollDirection(direction, scrollUpAction, scrollDownAction, self, event, throttledHandler);
+        } else if (deltasSuccess) {
+            handleScrollDeltas(yScroll, scrollUpAction, scrollDownAction, self, event, throttledHandler);
+        }
+    });
+
+    return () => widget.disconnect(id);
+}
+
+function handleScrollDirection(
+    direction: Gdk.ScrollDirection,
+    scrollUpAction: string,
+    scrollDownAction: string,
+    self: GtkWidget,
+    event: Gdk.Event,
+    throttledHandler: ThrottleFn,
+): void {
+    if (direction === Gdk.ScrollDirection.UP) {
+        throttledHandler(scrollUpAction, { clicked: self, event });
+    } else if (direction === Gdk.ScrollDirection.DOWN) {
+        throttledHandler(scrollDownAction, { clicked: self, event });
+    }
+}
+
+function handleScrollDeltas(
+    yScroll: number,
+    scrollUpAction: string,
+    scrollDownAction: string,
+    self: GtkWidget,
+    event: Gdk.Event,
+    throttledHandler: ThrottleFn,
+): void {
+    if (yScroll > 0) {
+        throttledHandler(scrollDownAction, { clicked: self, event });
+    } else if (yScroll < 0) {
+        throttledHandler(scrollUpAction, { clicked: self, event });
+    }
+}

src/lib/shared/hookHandler.ts

@@ -0,0 +1,47 @@
+import { Connectable, Subscribable } from 'astal/binding';
+import { Widget } from 'astal/gtk3';
+
+/**
+ * A generic hook utility to manage setup and teardown based on dependencies.
+ *
+ * @param widget - The GtkWidget instance.
+ * @param hookTarget - The object to hook into (Connectable or Subscribable).
+ * @param setup - The setup function to execute, which returns a disconnect function.
+ * @param signal - (Optional) The signal name if hooking into a Connectable.
+ */
+export function useHook(
+    // eslint-disable-next-line  @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+    widget: any,
+    hookTarget: Connectable | Subscribable,
+    setup: (() => void) | (() => () => void),
+    signal?: string,
+): void {
+    const passedWidget: Widget.Box = widget;
+    let currentDisconnect: () => void = () => {};
+
+    const executeSetup = (): void => {
+        currentDisconnect();
+        if (typeof setup === 'function') {
+            currentDisconnect = setup() || ((): void => {});
+        }
+    };
+
+    const isConnectable = (target: Connectable | Subscribable): target is Connectable => {
+        return 'connect' in target;
+    };
+
+    const isSubscribable = (target: Connectable | Subscribable): target is Subscribable => {
+        return 'subscribe' in target;
+    };
+
+    const hookIntoTarget = (): void => {
+        if (signal && isConnectable(hookTarget)) {
+            passedWidget.hook(hookTarget, signal, executeSetup);
+        } else if (isSubscribable(hookTarget)) {
+            passedWidget.hook(hookTarget, executeSetup);
+        }
+    };
+
+    executeSetup();
+    hookIntoTarget();
+}

src/lib/shared/media.ts

@@ -0,0 +1,33 @@
+import AstalMpris from 'gi://AstalMpris?version=0.1';
+import { mprisService } from '../constants/services';
+
+export const getCurrentPlayer = (
+    activePlayer: AstalMpris.Player = mprisService.get_players()[0],
+): AstalMpris.Player => {
+    const statusOrder = {
+        [AstalMpris.PlaybackStatus.PLAYING]: 1,
+        [AstalMpris.PlaybackStatus.PAUSED]: 2,
+        [AstalMpris.PlaybackStatus.STOPPED]: 3,
+    };
+
+    const mprisPlayers = mprisService.get_players();
+    if (mprisPlayers.length === 0) {
+        return mprisPlayers[0];
+    }
+
+    const isPlaying = mprisPlayers.some(
+        (p: AstalMpris.Player) => p.playbackStatus === AstalMpris.PlaybackStatus.PLAYING,
+    );
+
+    const playerStillExists = mprisPlayers.some((p) => activePlayer.bus_name === p.bus_name);
+
+    const nextPlayerUp = mprisPlayers.sort(
+        (a: AstalMpris.Player, b: AstalMpris.Player) => statusOrder[a.playbackStatus] - statusOrder[b.playbackStatus],
+    )[0];
+
+    if (isPlaying || !playerStillExists) {
+        return nextPlayerUp;
+    }
+
+    return activePlayer;
+};

src/lib/shared/notifications.ts

@@ -0,0 +1,21 @@
+import AstalNotifd from 'gi://AstalNotifd?version=0.1';
+
+const normalizeName = (name: string): string => name.toLowerCase().replace(/\s+/g, '_');
+
+export const isNotificationIgnored = (notification: AstalNotifd.Notification, filter: string[]): boolean => {
+    const notificationFilters = new Set(filter.map(normalizeName));
+    const normalizedAppName = normalizeName(notification.app_name);
+
+    return notificationFilters.has(normalizedAppName);
+};
+
+export const filterNotifications = (
+    notifications: AstalNotifd.Notification[],
+    filter: string[],
+): AstalNotifd.Notification[] => {
+    const filteredNotifications = notifications.filter((notif: AstalNotifd.Notification) => {
+        return !isNotificationIgnored(notif, filter);
+    });
+
+    return filteredNotifications;
+};