hyprpanel

ags/HyprPanel/globals/dropdown.ts

@@ -0,0 +1,6 @@
+import { Variable as VariableType } from 'types/variable';
+
+type GlobalEventBoxes = {
+    [key: string]: unknown;
+};
+export const globalEventBoxes: VariableType<GlobalEventBoxes> = Variable({});

ags/HyprPanel/globals/network.ts

@@ -0,0 +1,15 @@
+export const WIFI_STATUS_MAP = {
+    unknown: 'Status Unknown',
+    unmanaged: 'Unmanaged',
+    unavailable: 'Unavailable',
+    disconnected: 'Disconnected',
+    prepare: 'Preparing Connecting',
+    config: 'Connecting',
+    need_auth: 'Needs Authentication',
+    ip_config: 'Requesting IP',
+    ip_check: 'Checking Access',
+    secondaries: 'Waiting on Secondaries',
+    activated: 'Connected',
+    deactivating: 'Disconnecting',
+    failed: 'Connection Failed',
+} as const;

ags/HyprPanel/globals/notification.ts

@@ -0,0 +1,37 @@
+import icons from 'modules/icons/index';
+import { Notification } from 'types/service/notifications';
+
+export const removingNotifications = Variable<boolean>(false);
+
+export const getNotificationIcon = (app_name: string, app_icon: string, app_entry: string): string => {
+    let icon: string = icons.fallback.notification;
+
+    if (Utils.lookUpIcon(app_name) || Utils.lookUpIcon(app_name.toLowerCase() || '')) {
+        icon = Utils.lookUpIcon(app_name)
+            ? app_name
+            : Utils.lookUpIcon(app_name.toLowerCase())
+              ? app_name.toLowerCase()
+              : '';
+    }
+
+    if (Utils.lookUpIcon(app_icon) && icon === '') {
+        icon = app_icon;
+    }
+
+    if (Utils.lookUpIcon(app_entry || '') && icon === '') {
+        icon = app_entry || '';
+    }
+
+    return icon;
+};
+
+export const closeNotifications = async (notifications: Notification[], delay: number): Promise<void> => {
+    removingNotifications.value = true;
+    for (const notif of notifications) {
+        notif.close();
+        await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    removingNotifications.value = false;
+};
+
+globalThis['removingNotifications'] = removingNotifications;

ags/HyprPanel/globals/useTheme.ts

@@ -0,0 +1,43 @@
+import Gio from 'gi://Gio';
+import { bash, Notify } from 'lib/utils';
+import icons from 'lib/icons';
+import { filterConfigForThemeOnly, loadJsonFile, saveConfigToFile } from 'widget/settings/shared/FileChooser';
+
+export const hexColorPattern = /^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/;
+
+globalThis.useTheme = (filePath: string): void => {
+    const importedConfig = loadJsonFile(filePath);
+
+    if (!importedConfig) {
+        return;
+    }
+
+    Notify({
+        summary: `Importing Theme`,
+        body: `Importing: ${filePath}`,
+        iconName: icons.ui.info,
+        timeout: 7000,
+    });
+
+    const tmpConfigFile = Gio.File.new_for_path(`${TMP}/config.json`);
+    const optionsConfigFile = Gio.File.new_for_path(OPTIONS);
+
+    const [tmpSuccess, tmpContent] = tmpConfigFile.load_contents(null);
+    const [optionsSuccess, optionsContent] = optionsConfigFile.load_contents(null);
+
+    if (!tmpSuccess || !optionsSuccess) {
+        console.error('Failed to read existing configuration files.');
+        return;
+    }
+
+    let tmpConfig = JSON.parse(new TextDecoder('utf-8').decode(tmpContent));
+    let optionsConfig = JSON.parse(new TextDecoder('utf-8').decode(optionsContent));
+
+    const filteredConfig = filterConfigForThemeOnly(importedConfig);
+    tmpConfig = { ...tmpConfig, ...filteredConfig };
+    optionsConfig = { ...optionsConfig, ...filteredConfig };
+
+    saveConfigToFile(tmpConfig, `${TMP}/config.json`);
+    saveConfigToFile(optionsConfig, OPTIONS);
+    bash('pkill ags && ags');
+};

ags/HyprPanel/globals/utilities.ts

@@ -0,0 +1,8 @@
+globalThis.isWindowVisible = (windowName: string): boolean => {
+    const appWindow = App.getWindow(windowName);
+
+    if (appWindow === undefined) {
+        return false;
+    }
+    return appWindow.visible;
+};

ags/HyprPanel/globals/variables.ts

@@ -0,0 +1,29 @@
+import { Opt } from 'lib/option';
+import { HexColor, MatugenTheme, RecursiveOptionsObject } from 'lib/types/options';
+
+export const isOpt = <T>(value: unknown): value is Opt<T> =>
+    typeof value === 'object' && value !== null && 'value' in value && value instanceof Opt;
+
+export const isOptString = (value: unknown): value is Opt<string> => {
+    return value instanceof Opt && typeof value.value === 'string';
+};
+
+export const isOptNumber = (value: unknown): value is Opt<number> => {
+    return value instanceof Opt && typeof value.value === 'number';
+};
+
+export const isOptBoolean = (value: unknown): value is Opt<boolean> => {
+    return value instanceof Opt && typeof value.value === 'boolean';
+};
+
+export const isOptMatugenTheme = (value: unknown): value is Opt<MatugenTheme> => {
+    return value instanceof Opt && typeof value.value === 'object' && 'specificProperty' in value.value; // Replace 'specificProperty' with an actual property of MatugenTheme
+};
+
+export const isRecursiveOptionsObject = (value: unknown): value is RecursiveOptionsObject => {
+    return typeof value === 'object' && value !== null && !(value instanceof Opt);
+};
+
+export const isHexColor = (val: unknown): val is HexColor => {
+    return typeof val === 'string' && /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(val);
+};

ags/HyprPanel/globals/weather.ts

@@ -0,0 +1,122 @@
+import options from 'options';
+import { UnitType, Weather, WeatherIconTitle, WeatherIcon } from 'lib/types/weather.js';
+import { DEFAULT_WEATHER } from 'lib/types/defaults/weather.js';
+import GLib from 'gi://GLib?version=2.0';
+import { weatherIcons } from 'modules/icons/weather.js';
+
+const { key, interval, location } = options.menus.clock.weather;
+
+export const globalWeatherVar = Variable<Weather>(DEFAULT_WEATHER);
+
+let weatherIntervalInstance: null | number = null;
+
+const weatherIntervalFn = (weatherInterval: number, loc: string, weatherKey: string): void => {
+    if (weatherIntervalInstance !== null) {
+        GLib.source_remove(weatherIntervalInstance);
+    }
+
+    const formattedLocation = loc.replace(' ', '%20');
+
+    weatherIntervalInstance = Utils.interval(weatherInterval, () => {
+        Utils.execAsync(
+            `curl "https://api.weatherapi.com/v1/forecast.json?key=${weatherKey}&q=${formattedLocation}&days=1&aqi=no&alerts=no"`,
+        )
+            .then((res) => {
+                try {
+                    if (typeof res !== 'string') {
+                        return (globalWeatherVar.value = DEFAULT_WEATHER);
+                    }
+
+                    const parsedWeather = JSON.parse(res);
+
+                    if (Object.keys(parsedWeather).includes('error')) {
+                        return (globalWeatherVar.value = DEFAULT_WEATHER);
+                    }
+
+                    return (globalWeatherVar.value = parsedWeather);
+                } catch (error) {
+                    globalWeatherVar.value = DEFAULT_WEATHER;
+                    console.warn(`Failed to parse weather data: ${error}`);
+                }
+            })
+            .catch((err) => {
+                console.error(`Failed to fetch weather: ${err}`);
+                globalWeatherVar.value = DEFAULT_WEATHER;
+            });
+    });
+};
+
+Utils.merge([key.bind('value'), interval.bind('value'), location.bind('value')], (weatherKey, weatherInterval, loc) => {
+    if (!weatherKey) {
+        return (globalWeatherVar.value = DEFAULT_WEATHER);
+    }
+    weatherIntervalFn(weatherInterval, loc, weatherKey);
+});
+
+export const getTemperature = (wthr: Weather, unt: UnitType): string => {
+    if (unt === 'imperial') {
+        return `${Math.ceil(wthr.current.temp_f)}° F`;
+    } else {
+        return `${Math.ceil(wthr.current.temp_c)}° C`;
+    }
+};
+
+export const getWeatherIcon = (fahren: number): Record<string, string> => {
+    const icons = {
+        100: '',
+        75: '',
+        50: '',
+        25: '',
+        0: '',
+    } as const;
+    const colors = {
+        100: 'weather-color red',
+        75: 'weather-color orange',
+        50: 'weather-color lavender',
+        25: 'weather-color blue',
+        0: 'weather-color sky',
+    } as const;
+
+    type IconKeys = keyof typeof icons;
+
+    const threshold: IconKeys =
+        fahren < 0 ? 0 : ([100, 75, 50, 25, 0] as IconKeys[]).find((threshold) => threshold <= fahren) || 0;
+
+    const icon = icons[threshold || 50];
+    const color = colors[threshold || 50];
+
+    return {
+        icon,
+        color,
+    };
+};
+
+export const getWindConditions = (wthr: Weather, unt: UnitType): string => {
+    if (unt === 'imperial') {
+        return `${Math.floor(wthr.current.wind_mph)} mph`;
+    }
+    return `${Math.floor(wthr.current.wind_kph)} kph`;
+};
+
+export const getRainChance = (wthr: Weather): string => `${wthr.forecast.forecastday[0].day.daily_chance_of_rain}%`;
+
+export const isValidWeatherIconTitle = (title: string): title is WeatherIconTitle => {
+    return title in weatherIcons;
+};
+
+export const getWeatherStatusTextIcon = (wthr: Weather): WeatherIcon => {
+    let iconQuery = wthr.current.condition.text.trim().toLowerCase().replaceAll(' ', '_');
+
+    if (!wthr.current.is_day && iconQuery === 'partly_cloudy') {
+        iconQuery = 'partly_cloudy_night';
+    }
+
+    if (isValidWeatherIconTitle(iconQuery)) {
+        return weatherIcons[iconQuery];
+    } else {
+        console.warn(`Unknown weather icon title: ${iconQuery}`);
+        return weatherIcons['warning'];
+    }
+};
+
+globalThis['globalWeatherVar'] = globalWeatherVar;

ags/HyprPanel/globals/window.ts

@@ -0,0 +1,10 @@
+export const WINDOW_LAYOUTS: string[] = [
+    'center',
+    'top',
+    'top-right',
+    'top-center',
+    'top-left',
+    'bottom-left',
+    'bottom-center',
+    'bottom-right',
+];