Implement framework for custom modules and out of the box custom modules as well. (#213)

* Create declarative module scaffolding

* Added ram module (WIP)

* Updates to options, styling and more.

* Added function for styling custom modules.

* Added utility functions and cleaned up code

* Type and fn name updates.

* Update module utils to handle absent values.

* Added icon color in style2 that was missing.

* Linted utils.ts

* Add CPU module and update RAM module to use /proc/meminfo.

* Added disk storage module.

* Consolidate code

* Added netstat module and removed elements from systray default ignore list.

* Added keyboard layout module.

* Fix hook types and move module to customModules directory

* Added updates modules.

* Spacing updates

* Added weather module.

* Added power menu and power module in bar. Increased update default interval to 6 ours.

* Updated styling of bar buttons, made power menu label toggleable, etc.

* Consolidate code and add dynamic tooltips based on data being used.

* Make default custom mogules matugen compatible

* Update base theme

* Fix custom module background coloring

* Remove testing opacity.

* Update themes to account for new modules

* Update nix stuff for libgtop (Need someone to test this)

* Update nix

* Update fractions to multiplications

* Move styling in style directory

* Implement a polling framework for variables that can dynamically adjust polling intervals.

* Netstat module updates when interface name is changed.

* Readme update

customModules/ram/computeRam.ts

@@ -0,0 +1,42 @@
+const GLib = imports.gi.GLib;
+
+import { divide } from 'customModules/utils';
+import { Variable as VariableType } from 'types/variable';
+
+export const calculateRamUsage = (round: VariableType<boolean>) => {
+    try {
+        const [success, meminfoBytes] = GLib.file_get_contents('/proc/meminfo');
+
+        if (!success || !meminfoBytes) {
+            throw new Error('Failed to read /proc/meminfo or file content is null.');
+        }
+
+        const meminfo = new TextDecoder('utf-8').decode(meminfoBytes);
+
+        const totalMatch = meminfo.match(/MemTotal:\s+(\d+)/);
+        const availableMatch = meminfo.match(/MemAvailable:\s+(\d+)/);
+
+        if (!totalMatch || !availableMatch) {
+            throw new Error('Failed to parse /proc/meminfo for memory values.');
+        }
+
+        const totalRamInBytes = parseInt(totalMatch[1], 10) * 1024;
+        const availableRamInBytes = parseInt(availableMatch[1], 10) * 1024;
+
+        let usedRam = totalRamInBytes - availableRamInBytes;
+        usedRam = isNaN(usedRam) || usedRam < 0 ? 0 : usedRam;
+
+
+        return {
+            percentage: divide([totalRamInBytes, usedRam], round.value),
+            total: totalRamInBytes,
+            used: usedRam,
+            free: availableRamInBytes,
+        };
+
+    } catch (error) {
+        console.error('Error calculating RAM usage:', error);
+        return { total: 0, used: 0, percentage: 0 };
+    }
+};
+

customModules/ram/index.ts

@@ -0,0 +1,88 @@
+import options from "options";
+
+// Module initializer
+import { module } from "../module"
+
+// Types
+import { GenericResourceData } from "lib/types/customModules/generic";
+import Button from "types/widgets/button";
+import Gtk from "types/@girs/gtk-3.0/gtk-3.0";
+
+// Helper Methods
+import { calculateRamUsage } from "./computeRam";
+
+// Utility Methods
+import { formatTooltip, inputHandler, renderResourceLabel } from "customModules/utils";
+import { ResourceLabelType } from "lib/types/bar";
+
+// Global Constants
+import { LABEL_TYPES } from "lib/types/defaults/bar";
+import { pollVariable } from "customModules/PollVar";
+
+// All the user configurable options for the ram module that are needed
+const {
+    label,
+    labelType,
+    round,
+    leftClick,
+    rightClick,
+    middleClick,
+    pollingInterval
+} = options.bar.customModules.ram;
+
+const defaultRamData: GenericResourceData = { total: 0, used: 0, percentage: 0, free: 0 };
+const ramUsage = Variable(defaultRamData);
+
+pollVariable(
+    ramUsage,
+    [round.bind('value')],
+    pollingInterval.bind('value'),
+    calculateRamUsage,
+    round,
+);
+
+export const Ram = () => {
+
+    const ramModule = module({
+        textIcon: "",
+        label: Utils.merge(
+            [ramUsage.bind("value"), labelType.bind("value"), round.bind("value")],
+            (rmUsg: GenericResourceData, lblTyp: ResourceLabelType, round: boolean) => {
+                const returnValue = renderResourceLabel(lblTyp, rmUsg, round);
+
+                return returnValue;
+            }),
+        tooltipText: labelType.bind("value").as(lblTyp => {
+            return formatTooltip('RAM', lblTyp);
+        }),
+        boxClass: "ram",
+        showLabelBinding: label.bind("value"),
+        props: {
+            setup: (self: Button<Gtk.Widget, Gtk.Widget>) => {
+                inputHandler(self, {
+                    onPrimaryClick: {
+                        cmd: leftClick,
+                    },
+                    onSecondaryClick: {
+                        cmd: rightClick,
+                    },
+                    onMiddleClick: {
+                        cmd: middleClick,
+                    },
+                    onScrollUp: {
+                        fn: () => {
+                            labelType.value = LABEL_TYPES[(LABEL_TYPES.indexOf(labelType.value) + 1) % LABEL_TYPES.length] as ResourceLabelType;
+                        }
+                    },
+                    onScrollDown: {
+                        fn: () => {
+                            labelType.value = LABEL_TYPES[(LABEL_TYPES.indexOf(labelType.value) - 1 + LABEL_TYPES.length) % LABEL_TYPES.length] as ResourceLabelType;
+                        }
+                    },
+                });
+            },
+        }
+    });
+
+    return ramModule;
+}