@ulu/frontend 0.1.0-beta.1 → 0.1.0-beta.100

package/types/ui/resizer.d.ts

@@ -1,28 +1,128 @@
+/**
+ * Class for creating/controlling a container size with a handle/control
+ */
 export class Resizer {
     static defaults: {
         debug: boolean;
-        overrideMaxWidth: boolean;
-        fromLeft: boolean;
+        /**
+         * Amount to increase size by (ie. pointer movement * multiplier)
+         */
+        multiplier: number;
+        /**
+         * Remove max-width, max-height
+         */
+        overrideMaxDimensions: boolean;
+        /**
+         * @type {"left"|"right"|null}
+         * Specifies the horizontal edge from which resizing occurs.
+         * `null` means no horizontal resizing.
+         * - Default null
+         */
+        fromX: "left" | "right" | null;
+        /**
+         * @type {"top"|"bottom"|null}
+         * Specifies the vertical edge from which resizing occurs.
+         * - `null` means no vertical resizing.
+         * - Default null
+         */
+        fromY: "top" | "bottom" | null;
+        /**
+         * The step in pixels for keyboard resizing with arrow keys.
+         */
+        keyboardStep: number;
+        /**
+         * Debounce time in milliseconds for ending a keyboard resize.
+         */
+        keyboardDebounceTime: number;
+        /**
+         * If true, the Resizer instance will automatically bind its own DOM event listeners
+         * (pointerdown, keydown) to the control element. If `false`, the user is
+         * responsible for calling `resizerInstance.onPointerdown(event)` and
+         * `resizerInstance.onKeydown(event)` from their own listeners.
+         * Default: true
+         */
+        manageEvents: boolean;
+        /**
+         * If true, the Resizer instance will automatically manage the `aria-label`
+         * attribute of the control element. If `false`, the user is responsible
+         * for setting this attribute.
+         * Default: false
+         */
+        manageAriaLabel: boolean;
+        /**
+         * If true, pointer events (mouse/touch) will enable resizing.
+         * Default: true
+         */
+        enablePointerResizing: boolean;
+        /**
+         * If true, keyboard events (arrow keys) will enable resizing.
+         * Default: true
+         */
+        enableKeyboardResizing: boolean;
     };
     /**
-     *
-     * @param {Node} container Container to be resize
-     * @param {Node} control Resize handle element
-     * @param {Object} options Defualt can be changed on class
-     * @param {Boolean} options.debug Enable non-essential debugging logs
-     * @param {Boolean} options.overrideMaxWidth When script is activated by handle remove the elements max-width and allow the width of the resize to exceed the max (default false)
-     * @param {Boolean} options.fromLeft The script should assume the handle is on the left side of the element
+     * @param {Node} container Container to be resized
+     * @param {HTMLElement} control Resize handle element (should be focusable like a button)
+     * @param {Object} config Options to configure the resizer.
+     * @param {Boolean} [config.debug=false] Enable non-essential debugging logs.
+     * @param {Boolean} [config.multiplier=1] Amount to increase size by (ie. pointer movement * multiplier).
+     * @param {Boolean} [config.overrideMaxDimensions=false] When script is activated by handle, remove the element's max-width/max-height and allow the resize to exceed them.
+     * @param {"left"|"right"|null} [config.fromX=null] Horizontal resizing direction.
+     * @param {"top"|"bottom"|null} [config.fromY=null] Vertical resizing direction.
+     * @param {number} [config.keyboardStep=10] The step in pixels for keyboard resizing.
+     * @param {number} [config.keyboardDebounceTime=200] Debounce time for keyboard resize end.
+     * @param {boolean} [config.manageEvents=true] If true, the Resizer will automatically bind its own events.
+     * @param {boolean} [config.manageAriaLabel=false] If true, the Resizer will manage the control's aria-label.
+     * @param {boolean} [config.enablePointerResizing=true] If true, pointer events will enable resizing.
+     * @param {boolean} [config.enableKeyboardResizing=true] If true, keyboard events will enable resizing.
      */
-    constructor(container: Node, control: Node, options: {
-        debug: boolean;
-        overrideMaxWidth: boolean;
-        fromLeft: boolean;
+    constructor(container: Node, control: HTMLElement, config: {
+        debug?: boolean;
+        multiplier?: boolean;
+        overrideMaxDimensions?: boolean;
+        fromX?: "left" | "right" | null;
+        fromY?: "top" | "bottom" | null;
+        keyboardStep?: number;
+        keyboardDebounceTime?: number;
+        manageEvents?: boolean;
+        manageAriaLabel?: boolean;
+        enablePointerResizing?: boolean;
+        enableKeyboardResizing?: boolean;
     });
     options: any;
     container: Node;
-    control: Node;
-    handlerMousedown: any;
+    control: HTMLElement;
+    debug: any;
+    resizeHorizontal: boolean;
+    resizeVertical: boolean;
+    /**
+     * Cleans up event listeners and internal state to prevent memory leaks.
+     */
     destroy(): void;
-    onMousedown(e: any): void;
+    /**
+     * Public handler for pointerdown events. Call this method from your own event listeners
+     * if `manageEvents` is false. Its logic will only execute if `enablePointerResizing` is true.
+     * @param {PointerEvent} e The pointerdown event.
+     */
+    onPointerdown(e: PointerEvent): void;
+    /**
+     * Public handler for keydown events. Call this method from your own event listeners
+     * if `manageEvents` is false. Its logic will only execute if `enableKeyboardResizing` is true.
+     * @param {KeyboardEvent} e The keydown event.
+     */
+    onKeydown(e: KeyboardEvent): void;
+    /**
+     * Generates an accessible label for the resize control based on its configuration.
+     * This is a convenience function that can be used by the consumer if `manageAriaLabel` is false.
+     * @returns {string} The suggested aria-label for the control.
+     */
+    getAriaLabel(): string;
+    /**
+     * Dispatches a custom event on the container element.
+     * @param {string} type The event type (e.g., "resizer:start", "resizer:update", "resizer:end").
+     * @param {Object} [data={}] Optional data to attach to the event's detail property.
+     */
+    dispatchEvent(type: string, data?: any): void;
+    #private;
 }
 //# sourceMappingURL=resizer.d.ts.map

package/types/ui/resizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resizer.d.ts","sourceRoot":"","sources":["../../js/ui/resizer.js"],"names":[],"mappings":"AAeA;IACE;;;;MAIE;IACF;;;;;;;;OAQG;IACH,uBAPW,IAAI,WACJ,IAAI;QAEa,KAAK;QACL,gBAAgB;QAChB,QAAQ;OAWnC;IALC,aAA2D;IAC3D,gBAA0B;IAC1B,cAAsB;IACtB,sBAAmD;IAGrD,gBAEC;IACD,0BAkBC;CACF"}
+{"version":3,"file":"resizer.d.ts","sourceRoot":"","sources":["../../js/ui/resizer.js"],"names":[],"mappings":"AAUA;;GAEG;AACH;IACE;;QAEE;;WAEG;;QAEH;;WAEG;;QAEH;;;;;WAKG;eAJO,MAAM,GAAC,OAAO,GAAC,IAAI;QAM7B;;;;;WAKG;eAJO,KAAK,GAAC,QAAQ,GAAC,IAAI;QAM7B;;WAEG;;QAEH;;WAEG;;QAEH;;;;;;WAMG;;QAEH;;;;;WAKG;;QAEH;;;WAGG;;QAEH;;;WAGG;;MAEH;IAaF;;;;;;;;;;;;;;;OAeG;IACH,uBAfW,IAAI,WACJ,WAAW;QAEM,KAAK;QACL,UAAU;QACV,qBAAqB;QACT,KAAK,GAAlC,MAAM,GAAC,OAAO,GAAC,IAAI;QACU,KAAK,GAAlC,KAAK,GAAC,QAAQ,GAAC,IAAI;QACH,YAAY,GAA5B,MAAM;QACU,oBAAoB,GAApC,MAAM;QACW,YAAY,GAA7B,OAAO;QACU,eAAe,GAAhC,OAAO;QACU,qBAAqB,GAAtC,OAAO;QACU,sBAAsB,GAAvC,OAAO;OAmDjB;IA3CC,aAAsB;IACtB,gBAA0B;IAC1B,qBAAsB;IACtB,WAA0B;IAmB1B,0BAA8C;IAC9C,wBAA4C;IAqC9C;;OAEG;IACH,gBAsBC;IAwGD;;;;OAIG;IACH,iBAFW,YAAY,QAyCtB;IAED;;;;OAIG;IACH,aAFW,aAAa,QA4DvB;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAYlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,oBAKhB;;CACF"}

package/types/ui/scroll-slider.d.ts

@@ -3,11 +3,9 @@
  * - This will only initialize elements once, it is safe to call on page changes
  */
 export function init(): void;
-export function setup(): void;
-export namespace attrs {
-    let init: string;
-    let slider: string;
-    let track: string;
-    let controls: string;
-}
+/**
+ * Scroll Slider Component Initializer
+ */
+export const initializer: ComponentInitializer;
+import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=scroll-slider.d.ts.map

package/types/ui/scroll-slider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scroll-slider.d.ts","sourceRoot":"","sources":["../../js/ui/scroll-slider.js"],"names":[],"mappings":"AA+BA;;;GAGG;AACH,6BAGC;AAED,8BAGC"}
+{"version":3,"file":"scroll-slider.d.ts","sourceRoot":"","sources":["../../js/ui/scroll-slider.js"],"names":[],"mappings":"AAuBA;;;GAGG;AACH,6BASC;AA5BD;;GAEG;AACH,+CAGG;qCAVkC,oBAAoB"}

package/types/ui/scrollpoint.d.ts

@@ -4,15 +4,9 @@
  */
 export function init(): void;
 /**
- * Setup all points and groups
+ * Scrollpoint Component Initializer
  */
-export function setup(): void;
-export namespace attrs {
-    let init: string;
-    let point: string;
-    let group: string;
-    let groupAnchors: string;
-}
+export const initializer: ComponentInitializer;
 /**
  * Single scrollpoint
  * - Note "forward" and "reverse" refer to scroll directions
@@ -130,4 +124,5 @@ export class Scrollpoint {
     updateStateAttribute(isActive: any, isForward: any): void;
     destroy(): void;
 }
+import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=scrollpoint.d.ts.map

package/types/ui/scrollpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scrollpoint.d.ts","sourceRoot":"","sources":["../../js/ui/scrollpoint.js"],"names":[],"mappings":"AAyCA;;;GAGG;AACH,6BAGC;AAED;;GAEG;AACH,8BAqBC;;;;;;;AAID;;;;;;;GAOG;AACH;IACE;QACE;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;QAEH;;WAEG;;QAEH;;WAEG;;MAIH;IACF;;;;OAIG;IACH,qBAHW,IAAI,eAkCd;IArBC,aAAsB;IACtB,+BAAoB;IACpB,kBAAwB;IACxB,kBAAqB;IACrB,cAAsB;IACtB,sBAGC;IACD;;;;;;;MAOC;IAMH,kCAEC;IACD;;;;MAMC;IACD;;;OAGG;IACH,8BAkBC;IACD,sBAUC;IACD,kBAGC;IACD,8CAcC;IACD,qBAEC;IACD,mDAmBC;IACD,0DAMC;IACD,gBASC;CACF"}
+{"version":3,"file":"scrollpoint.d.ts","sourceRoot":"","sources":["../../js/ui/scrollpoint.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,6BAUC;AAtBD;;GAEG;AACH,+CAGG;AAkBH;;;;;;;GAOG;AACH;IACE;QACE;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;QAEH;;WAEG;;QAEH;;WAEG;;MAIH;IACF;;;;OAIG;IACH,qBAHW,IAAI,eAkCd;IArBC,aAAsB;IACtB,+BAAoB;IACpB,kBAAwB;IACxB,kBAAqB;IACrB,cAAsB;IACtB,sBAGC;IACD;;;;;;;MAOC;IAMH,kCAEC;IACD;;;;MAMC;IACD;;;OAGG;IACH,8BAkBC;IACD,sBAUC;IACD,kBAGC;IACD,8CAcC;IACD,qBAEC;IACD,mDAmBC;IACD,0DAMC;IACD,gBASC;CACF;qCAnQoC,oBAAoB"}

package/types/ui/slider.d.ts

@@ -1,15 +1,25 @@
+/**
+ * Initialize all sliders based on data attribute selectors
+ */
 export function init(): void;
-export function setup(): void;
-export function setupSlider(container: any): void;
-export namespace attrs {
-    let init: string;
-    let slider: string;
-    let track: string;
-    let trackContainer: string;
-    let controls: string;
-}
+/**
+ * Setup single slider instance from querying via data attribute selectors
+ * @param {Node} container The slide container to query children from
+ * @param {Object} options Options for slider class
+ */
+export function setupSlider(container: Node, options: any): void;
+/**
+ * Slider Component Initializer
+ */
+export const initializer: ComponentInitializer;
+/**
+ * Class that controls slider
+ */
 export class Slider {
     static instances: any[];
+    /**
+     * Default options for slider
+     */
     static defaults: {
         classAccessiblyHidden: string;
         namespace: string;
@@ -20,11 +30,14 @@ export class Slider {
         transitionDurationExit: number;
         transitionTimingFunction: string;
         buttonClasses: string[];
-        iconClassesPrevious: string[];
-        iconClassesNext: string[];
+        iconClassPrevious: any;
+        iconClassNext: any;
+        swipeEnabled: boolean;
+        swipeOptions: {
+            preventScroll: boolean;
+        };
     };
-    constructor(elements: any, config: any, debug?: boolean);
-    debug: boolean;
+    constructor(elements: any, config: any);
     options: any;
     slide: {
         element: any;
@@ -32,6 +45,9 @@ export class Slider {
         number: number;
     };
     index: any;
+    swipeInstance: any;
+    swipeListener: (event: any) => void;
+    swipeImageListener: (event: any) => void;
     transitioning: boolean;
     slides: {
         element: any;
@@ -102,6 +118,8 @@ export class Slider {
     }): any;
     goto(index: any, event: any, triggerType: any): void;
     setup(): void;
+    setupSwipe(): void;
+    onSwipe(event: any): void;
     trackContainerStyles(): string;
     transitionCss(property: any): string;
     trackCss(): string;
@@ -122,7 +140,8 @@ export class Slider {
     };
     createNavButton(slide: any, index: any): HTMLButtonElement;
     getControlContent(action: any): string;
-    getNavContent(number: any): string;
+    getNavContent(slide: any): string;
     emit(name: any, args: any): void;
 }
+import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=slider.d.ts.map

package/types/ui/slider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slider.d.ts","sourceRoot":"","sources":["../../js/ui/slider.js"],"names":[],"mappings":"AA8EA,6BAGC;AAED,8BAGC;AAED,kDAqBC;;;;;;;;AAED;IACE,wBAAsB;IACtB;;;;;;;;;;;;MAaC;IAED,yDAiCC;IA/BC,eAA+B;IAC/B,aAAsB;IACtB;;;;MAAiB;IACjB,WAAiB;IACjB,uBAA0B;IAQ1B;;;;QAME;IACF,cAIC;IAED;;;cACuF;IAMzF;;OAEG;IACH,qBAKC;IACD;;OAEG;IACH,2BAOC;IACD;;OAEG;IACH,uBAMC;IACD;;;;;;OAMG;IACH,8BAJW,MAAM,YACN,MAAM,kCAqChB;IACD;;OAEG;IACH,wCASC;IACD;;;OAGG;IACH,oDASC;IACD;;OAEG;IACH,yCAOC;IACD;;OAEG;IACH;;;;;;sBAoDC;IACD;;OAEG;IACH;;;sBAUC;IACD;;OAEG;IACH;;;YAOC;IACD,qDA0CC;IACD,cAYC;IACD,+BAKC;IACD,qCAOC;IACD,mBAQC;IACD,mBASC;IACD,yCASC;IACD,oDASC;IACD;;;;;;MAwBC;IACD;;;;MAmBC;IACD,2DAQC;IAED,uCAMC;IACD,mCAEC;IACD,iCAIC;CACF"}
+{"version":3,"file":"slider.d.ts","sourceRoot":"","sources":["../../js/ui/slider.js"],"names":[],"mappings":"AAyEA;;GAEG;AACH,6BASC;AAED;;;;GAIG;AACH,uCAHW,IAAI,sBAkBd;AAlED;;GAEG;AACH,+CAGG;AA8DH;;GAEG;AACH;IACE,wBAAsB;IACtB;;OAEG;IACH;;;;;;;;;;;;;;;;MAgBC;IACD,wCAmCC;IAjCC,aAAsB;IACtB;;;;MAAiB;IACjB,WAAiB;IACjB,mBAAyB;IACzB,oCAAyB;IACzB,yCAA8B;IAC9B,uBAA0B;IAQ1B;;;;QAME;IACF,cAIC;IAED;;;cACuF;IAMzF;;OAEG;IACH,qBAKC;IACD;;OAEG;IACH,2BAOC;IACD;;OAEG;IACH,uBAMC;IACD;;;;;;OAMG;IACH,8BAJW,MAAM,YACN,MAAM,kCAqChB;IACD;;OAEG;IACH,wCASC;IACD;;;OAGG;IACH,oDASC;IACD;;OAEG;IACH,yCAOC;IACD;;OAEG;IACH;;;;;;sBAoDC;IACD;;OAEG;IACH;;;sBAUC;IACD;;OAEG;IACH;;;YAOC;IACD,qDA0CC;IACD,cAmBC;IACD,mBAsBC;IACD,0BAMC;IACD,+BAKC;IACD,qCAOC;IACD,mBAQC;IACD,mBASC;IACD,yCASC;IACD,oDAUC;IACD;;;;;;MAwBC;IACD;;;;MAmBC;IACD,2DAQC;IACD,uCAMC;IACD,kCAEC;IACD,iCAIC;CACF;qCAjiBoC,oBAAoB"}

package/types/ui/tabs.d.ts

@@ -1,14 +1,7 @@
 /**
  * Init all instances currently in document
- * @param {Object} options Options to serve as defaults
  */
-export function init(options?: any): void;
-/**
- * Init all tabs within a certain context
- * @param {Node} context Element to init within
- * @param {Object} options Options to serve as defaults
- */
-export function initWithin(context: Node, options?: any): void;
+export function init(): void;
 /**
  *
  * @param {Node} element Tablist Element
@@ -21,4 +14,9 @@ export function setup(element: Node, options?: Node): any;
  * @type {Array}
  */
 export const instances: any[];
+/**
+ * Tabs Component Initializer
+ */
+export const initializer: ComponentInitializer;
+import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=tabs.d.ts.map

package/types/ui/tabs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tabs.d.ts","sourceRoot":"","sources":["../../js/ui/tabs.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH,0CAcC;AAED;;;;GAIG;AACH,oCAHW,IAAI,uBAUd;AAED;;;;;GAKG;AACH,+BAJW,IAAI,YACJ,IAAI,OAuCd;AAlFD;;;GAGG;AACH,8BAA4B"}
+{"version":3,"file":"tabs.d.ts","sourceRoot":"","sources":["../../js/ui/tabs.js"],"names":[],"mappings":"AA2BA;;GAEG;AACH,6BAoBC;AAED;;;;;GAKG;AACH,+BAJW,IAAI,YACJ,IAAI,OA2Bd;AArED;;;GAGG;AACH,8BAA4B;AAE5B;;GAEG;AACH,+CAGG;qCAdkC,oBAAoB"}

package/types/ui/theme-toggle.d.ts

@@ -1,14 +1,58 @@
+/**
+ * @param {Object} options Change options used as default for dialogs, can then be overridden by data attribute settings on element
+ */
+export function setDefaults(options: any): void;
 /**
  * Initialize everything in document
  * - This will only initialize elements once, it is safe to call on page changes
  */
 export function init(): void;
-export function setup(context?: Document): void;
-export namespace options {
-    let darkTheme: string;
-    let lightTheme: string;
-    let defaultTheme: string;
-    let darkIcon: string;
-    let lightIcon: string;
+/**
+ * Sets up a single toggle
+ * @param {HTMLElement} toggle A toggle to be setup
+ */
+export function setupToggle(toggle: HTMLElement, userOptions: any): {
+    destroy: () => void;
+    toggle: HTMLElement;
+    options: any;
+    toggleState: (event: any) => void;
+    setState(themeKey: any): void;
+};
+/**
+ * Theme Toggle Component Initializer
+ */
+export const initializer: ComponentInitializer;
+export namespace defaults {
+    namespace themes {
+        namespace light {
+            let label: string;
+            let value: string;
+            let iconClass: string;
+            let targetClass: string;
+            let mediaQuery: string;
+        }
+        namespace dark {
+            let label_1: string;
+            export { label_1 as label };
+            let iconClass_1: string;
+            export { iconClass_1 as iconClass };
+            let targetClass_1: string;
+            export { targetClass_1 as targetClass };
+            let mediaQuery_1: string;
+            export { mediaQuery_1 as mediaQuery };
+        }
+    }
+    let target: string;
+    let group: any;
+    /**
+     * Optional callback to do something when the state changes
+     */
+    function onChange(_ctx: any): void;
+    let initialState: string;
+    let checkMediaQuery: boolean;
+    let savePreference: boolean;
+    let storagePrefix: string;
+    let debug: boolean;
 }
+import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=theme-toggle.d.ts.map

package/types/ui/theme-toggle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme-toggle.d.ts","sourceRoot":"","sources":["../../js/ui/theme-toggle.js"],"names":[],"mappings":"AA6BA;;;GAGG;AACH,6BAOC;AAED,gDAeC"}
+{"version":3,"file":"theme-toggle.d.ts","sourceRoot":"","sources":["../../js/ui/theme-toggle.js"],"names":[],"mappings":"AAmGA;;GAEG;AACH,gDAEC;AAED;;;GAGG;AACH,6BASC;AAED;;;GAGG;AACH,oCAFW,WAAW;;;;;;EA+FrB;AAhND;;GAEG;AACH,+CAGG;;;;;;;;;;;;;;;;;;;;;;;IAmDD;;OAEG;IACH,mCAAiB;;;;;;;qCAlEkB,oBAAoB"}

package/types/ui/tooltip.d.ts

@@ -3,12 +3,9 @@
  */
 export function init(): void;
 /**
- * Query all popovers on current page and set them up
- * - Use this manually if needed
- * - Won't setup a popover more than once
+ * Tooltip Component Initializer
  */
-export function setup(): void;
-export function setupTrigger(trigger: any): Tooltip;
+export const initializer: ComponentInitializer;
 /**
  * Tooltip
  * - Provides basic tooltip functionality
@@ -95,4 +92,5 @@ export class Tooltip {
     show(event: any): void;
     hide(event: any): void;
 }
+import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=tooltip.d.ts.map

package/types/ui/tooltip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../js/ui/tooltip.js"],"names":[],"mappings":"AAmBA;;GAEG;AACH,6BAGC;AAED;;;;GAIG;AACH,8BAGC;AAED,oDAOC;AAED;;;;GAIG;AACH;IACE;;OAEG;IACH;QACE;;;;WAIG;;QAEH;;;WAGG;;;;;QAKH;;;WAGG;qBADO,SAAO,IAAI;QAGrB;;WAEG;;QAEH;;;WAGG;;QAEH;;;WAGG;oBADO,aAAc;QAGxB;;;WAGG;oBADO,aAAc;QAGxB;;;WAGG;;QAEH;;WAEG;;QAUH;;;WAGG;;MAIH;IACF,kCAEE;IACF,mEAaC;IAPC,aAA+D;IAC/D,qBAAyF;IACzF,cAA+B;IAC/B,aAAkB;IAClB,gBAAmB;IAIrB,cAIC;IACD,2BAKC;IACD,gBAGC;IACD,uBAcC;IACD,gCASC;IACD,6BAkBC;IACD,uBAiCC;IACD,wBAiBC;IACD,wCAmBC;IACD,sDAEC;IACD,+BAEC;IADC,0BAA4E;IAE9E,gCAKC;IACD,uBAEC;IACD,uBAEC;CACF"}
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../js/ui/tooltip.js"],"names":[],"mappings":"AAuBA;;GAEG;AACH,6BAaC;AA5BD;;GAEG;AACH,+CAGG;AAwBH;;;;GAIG;AACH;IACE;;OAEG;IACH;QACE;;;;WAIG;;QAEH;;;WAGG;;;;;QAKH;;;WAGG;qBADO,SAAO,IAAI;QAGrB;;WAEG;;QAEH;;;WAGG;;QAEH;;;WAGG;oBADO,aAAc;QAGxB;;;WAGG;oBADO,aAAc;QAGxB;;;WAGG;;QAEH;;WAEG;;QAUH;;;WAGG;;MAIH;IACF,kCAEE;IACF,mEAaC;IAPC,aAA+D;IAC/D,qBAAyF;IACzF,cAA+B;IAC/B,aAAkB;IAClB,gBAAmB;IAIrB,cAIC;IACD,2BAKC;IACD,gBAGC;IACD,uBAcC;IACD,gCASC;IACD,6BAkBC;IACD,uBAiCC;IACD,wBAiBC;IACD,wCAmBC;IACD,sDAEC;IACD,+BAEC;IADC,0BAA4E;IAE9E,gCAKC;IACD,uBAEC;IACD,uBAEC;CACF;qCApRoC,oBAAoB"}

package/types/utils/css.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module utils/css
+ */
+/**
+ * Generates a CSS custom property name with a given prefix.
+ * @param {string} prefix The prefix to apply to the custom property name.
+ * @param {string} propertyName The base name of the custom property.
+ * @returns {string} The fully formed CSS custom property name (e.g., "--prefix-propertyName").
+ */
+export function getCustomProperty(prefix: string, propertyName: string): string;
+//# sourceMappingURL=css.d.ts.map

package/types/utils/css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../js/utils/css.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,0CAJW,MAAM,gBACN,MAAM,GACJ,MAAM,CAIlB"}

package/types/utils/dom.d.ts

@@ -1,22 +1,9 @@
 /**
- * Get an elements JSON dataset value
- * @param {Node} element
- * @param {String} key key in dataset object for element
- * @returns {Object} Empty object or JSON object from dataset
+ * Converts a data attribute name to its corresponding dataset property name.
+ * @param {string} dataAttribute - The data attribute name (e.g., "data-ulu-dialog").
+ * @returns {string} - The dataset property name (e.g., "uluDialog").
  */
-export function getDatasetJson(element: Node, key: string): any;
-/**
- * Get an elements JSON dataset value that could potentially just be a single string
- * - If JSON it will return the object else it will return the value directly
- * @param {Node} element
- * @param {String} key key in dataset object for element
- * @returns {Object|String} JSON object or current dataset value (string or empty string if no value)
- */
-export function getDatasetOptionalJson(element: Node, key: string): any | string;
-/**
- * Check if a pointer event x/y was outside an elements bounding box
- */
-export function wasClickOutside(element: any, event: any): boolean;
+export function dataAttributeToDatasetKey(attribute: any): string;
 /**
  *   Sets up the positional classes that would come from the equal
  *   height module. Needs to be rerun by user when layout changes
@@ -29,20 +16,13 @@ export function wasClickOutside(element: any, event: any): boolean;
  */
 export function setPositionClasses(parent: Node, classes?: any): void;
 /**
- * Resolve a target to Element
- * @param {String|Node} target The selector or node/element
- * @param {Object} context [document] The context to query possible selectors from
- */
-export function getElement(target: string | Node, context?: any): any;
-/**
- * Sets a CSS custom property equal to the scrollbar width
- * @param {Node} element The element that is the child of a scrollabel container
- * @param {Node} container The container that can be scrolled
- * @param {Stirng} propName Custom property to set
- */
-export function addScrollbarProperty(element?: Node, container?: Node, propName?: Stirng): void;
-/**
- * @module utils/dom
+ * Resolves a class input (string or array) into a consistent array of class names.
+ * @param {string|string[]} input - The class input, which can be a string, an array of strings, or any other value.
+ * @returns {string[]} An array of class names. Returns an empty array for invalid or falsy input.
+ * @example
+ * resolveClassArray("fas fa-check  my-class"); // Returns ["fas", "fa-check", "my-class"]
+ * resolveClassArray(["another-class", "yet-another-class"]); // Returns ["another-class", "yet-another-class"]
+ * resolveClassArray("single-class"); // Returns ["single-class"]
  */
-export const regexJsonString: RegExp;
+export function resolveClasses(classes: any): string[];
 //# sourceMappingURL=dom.d.ts.map

package/types/utils/dom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../js/utils/dom.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wCAJW,IAAI,oBAYd;AAED;;;;;;GAMG;AACH,gDAJW,IAAI,gBAEF,YAAa,CASzB;AAED;;GAEG;AACH,mEAMC;AAGD;;;;;;;;;GASG;AACH,2CAHa,IAAI,uBAoChB;AAED;;;;GAIG;AACH,mCAHW,SAAO,IAAI,sBAYrB;AAED;;;;;GAKG;AACH,+CAJW,IAAI,cACJ,IAAI,2BAMd;AAzHD;;GAEG;AAGH,qCAAqD"}
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../js/utils/dom.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,2DAFa,MAAM,CAIlB;AAED;;;;;;;;;GASG;AACH,2CAHa,IAAI,uBAoChB;AAED;;;;;;;;GAQG;AACH,8CANa,MAAM,EAAE,CAiBpB"}

package/types/utils/font-awesome.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sets icon settings to Font Awesome icons
+ */
+export function configureIcons(): void;
+//# sourceMappingURL=font-awesome.d.ts.map

package/types/utils/font-awesome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-awesome.d.ts","sourceRoot":"","sources":["../../js/utils/font-awesome.js"],"names":[],"mappings":"AAOA;;GAEG;AACH,uCAQC"}

package/types/utils/index.d.ts

@@ -5,5 +5,6 @@ export * as id from "./id.js";
 export * as index from "./index.js";
 export * as pauseYoutubeVideo from "./pause-youtube-video.js";
 export * as fileSave from "./file-save.js";
-declare namespace ___Users_joescherben_Personal_Projects_ULU_frontend_js_utils_index_ { }
+export * as fontAwesome from "./font-awesome.js";
+declare namespace ___Users_joe_Projects_Personal_Github_frontend_js_utils_index_ { }
 //# sourceMappingURL=index.d.ts.map

package/types/utils/system.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Class serves as a utility for UI modules, handling the selection of elements and the initialization of corresponding component instances, ensuring consistent setup within the module
+ */
+export class ComponentInitializer {
+    static defaults: {
+        type: any;
+        baseAttribute: any;
+    };
+    static requiredOptions: string[];
+    static hasRequiredOptions: Function;
+    /**
+     * Create a new instance of ComponentInitializer
+     * @param {Object} options Options for configuring the component initializer.
+     * @param {String} options.type Type of component (used for logs).
+     * @param {String} options.baseAttribute Prefix and base attribute name (used for base attribute and further element attribute names).
+     */
+    constructor(options: {
+        type: string;
+        baseAttribute: string;
+    });
+    options: any;
+    logTitle: string;
+    /**
+     * Initializes the component based on the provided configuration.
+     * @param {Object} config The initialization configuration.
+     * @param {Function} config.setup The setup function to call for each element.
+     * @param {String} config.key [null] The optional key to use with attribute selector.
+     * @param {Boolean} config.withData [null] Whether to retrieve element data.
+     * @param {Array} config.events [null] Ulu events that should call setup when dispatched (ie. pageModified, pageResized)
+     * @param {Boolean} config.onPageResized [null] Whether to bind event listener for page resize end
+     * @param {HTMLElement} config.context [document] The context to query within.
+     */
+    init(config: {
+        setup: Function;
+        key: string;
+        withData: boolean;
+        events: any[];
+        onPageResized: boolean;
+        context: HTMLElement;
+    }): void;
+    /**
+     * Processes the elements based on the provided configuration.
+     * @param {object} config The initialization configuration.
+     * @param {function} config.setup The setup function to call for each element.
+     * @param {string} config.key The optional key to use with attribute selector.
+     * @param {boolean} config.withData [false] Whether to retrieve element data.
+     * @param {boolean} config.onPageModified [true] Whether to bind event listener for page modifications.
+     * @param {HTMLElement} config.context [document] The context to query within.
+     */
+    setupElements(config: {
+        setup: Function;
+        key: string;
+        withData: boolean;
+        onPageModified: boolean;
+        context: HTMLElement;
+    }): void;
+    /**
+     * Get an attribute name
+     * @param {String} key Optional key, if no key will return baseAttribute if key will return key added to base
+     * @returns {String} String like data-ulu-dialog or data-ulu-dialog-element
+     */
+    getAttribute(key: string): string;
+    /**
+     * Create an attribute selector
+     * @param {String} key Optional key (see getAttribute)
+     */
+    attributeSelector(key: string): string;
+    /**
+     * Create an attribute selector for initial
+     * @return {String}
+     */
+    attributeSelectorInitial(key: any): string;
+    /**
+     * Queries all main elements of a component that have not been initialized and extracts their data attributes.
+     * @param {HTMLElement} context The context to query within.
+     * @param {Boolean} withData Include dataset from element (as optional JSON)
+     * @param {Node} context Element to query elements from
+     * @returns {Array<{element: HTMLElement, data: object, initialize: Function}>} An array of objects containing the elements, their data, and convenience function initialize() which when called will set the init attribute on the element
+     */
+    queryAllInitial(key: any, withData: boolean, context?: HTMLElement): Array<{
+        element: HTMLElement;
+        data: object;
+        initialize: Function;
+    }>;
+    /**
+     * Sets the init attribute on an element, marking it as initialized.
+     * @param {HTMLElement} element The element to initialize.
+     */
+    initializeElement(element: HTMLElement): void;
+    /**
+     * Get an elements dataset value as JSON or other value
+     * @return {*} The value of the dataset, if JSON will return object else will return string value or undefined
+     */
+    getData(element: any, key: any): any;
+    /**
+     * Will output namespaced console logs for the given initializer
+     */
+    log(...msgs: any[]): void;
+    /**
+     * Will output namespaced console warnings for the given initializer
+     */
+    warn(...msgs: any[]): void;
+    /**
+     * Will output namespaced console error for the given initializer
+     */
+    logError(...msgs: any[]): void;
+}
+/**
+ * Class serves as a base for representing individual occurrences of a UI component, providing a consistent structure for each
+ */
+export class ComponentInstance {
+}
+//# sourceMappingURL=system.d.ts.map

package/types/utils/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../js/utils/system.js"],"names":[],"mappings":"AAUA;;GAEG;AACH;IACE;;;MAGE;IACF,iCAGE;IACF,oCAEE;IAEF;;;;;OAKG;IACH;QAH2B,IAAI;QACJ,aAAa;OAUvC;IAFC,aAAwE;IACxE,iBAAgD;IAElD;;;;;;;;;OASG;IACH;QAP4B,KAAK;QACP,GAAG;QACF,QAAQ;QACV,MAAM;QACJ,aAAa;QACT,OAAO,EAA3B,WAAW;aAYrB;IACD;;;;;;;;OAQG;IACH;QAN4B,KAAK;QACP,GAAG,EAAlB,MAAM;QACU,QAAQ,EAAxB,OAAO;QACS,cAAc,EAA9B,OAAO;QACa,OAAO,EAA3B,WAAW;aAMrB;IACD;;;;OAIG;IACH,kCAGC;IACD;;;OAGG;IACH,uCAEC;IACD;;;OAGG;IACH,2CAEC;IACD;;;;;;OAMG;IACH,uDALW,WAAW,GAGT,MAAM;QAAC,OAAO,EAAE,WAAW,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,WAAU;KAAC,CAAC,CAS7E;IACD;;;OAGG;IACH,2BAFW,WAAW,QAIrB;IACD;;;OAGG;IACH,qCAGC;IACD;;OAEG;IACH,0BAEC;IACD;;OAEG;IACH,2BAEC;IACD;;OAEG;IACH,+BAEC;CACF;AAED;;GAEG;AACH;CAEC"}