@ulu/frontend 0.1.0-beta.99 → 0.2.0-beta.10

package/dist/es/ui/print-details.js

@@ -0,0 +1,22 @@
+import { getCoreEventName as n } from "../core/events.js";
+const o = {
+  opened: "data-ulu-print-details-opened"
+}, c = (t) => `[${o[t]}]`, d = {
+  selector: "details:not([open])"
+};
+function i(t) {
+  const r = Object.assign({}, d, t);
+  document.addEventListener(n("beforePrint"), () => {
+    document.querySelectorAll(r.selector).forEach((e) => {
+      e.open || (e.setAttribute(o.opened, !0), e.open = !0);
+    });
+  }), document.addEventListener(n("afterPrint"), () => {
+    document.querySelectorAll(c("opened")).forEach((e) => {
+      e.removeAttribute(o.opened), e.open = !1;
+    });
+  });
+}
+export {
+  o as attrs,
+  i as init
+};

package/dist/es/ui/print.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/print.js"],"names":[],"mappings":"AAuBA;;;GAGG;AACH,6BASC"}

package/dist/es/ui/print.js

@@ -0,0 +1,34 @@
+import { ComponentInitializer as o } from "../core/component.js";
+import { getElement as r } from "@ulu/utils/browser/dom.js";
+import { printElement as l } from "@ulu/utils/browser/print.js";
+const s = new o({
+  type: "print",
+  baseAttribute: "data-ulu-print"
+}), m = {
+  /**
+   * Print element/selector
+   */
+  element: null
+};
+function u() {
+  s.init({
+    withData: !0,
+    coreEvents: ["pageModified"],
+    setup({ element: t, data: n, initialize: e }) {
+      p(t, n), e();
+    }
+  });
+}
+function p(t, n) {
+  const e = Object.assign({}, m, n);
+  t.addEventListener("click", () => {
+    if (e.element) {
+      const i = r(e.element);
+      i ? l(i) : console.error("Unable to find element to print", t, e);
+    } else
+      window.print();
+  });
+}
+export {
+  u as init
+};

package/{types → dist/es}/ui/programmatic-modal.d.ts

@@ -13,8 +13,8 @@ export class ProgrammaticModalManager {
     destroy(): void;
     createAndOpen(config: any, afterCreate: any): {
         trigger: any;
-        modal: Element;
+        modal: any;
         config: any;
-    };
+    } | undefined;
 }
 //# sourceMappingURL=programmatic-modal.d.ts.map

package/dist/es/ui/programmatic-modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"programmatic-modal.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/programmatic-modal.js"],"names":[],"mappings":"AAUA;IACE;;;MAGE;IACF,gCAeC;IAbC,aAAsB;IACtB,cAAoB;IACpB,mBAAyB;IAEzB,qCAGC;IACD,2BAEC;IAIH,sBAMC;IACD,gBAMC;IACD;;;;kBAkDC;CACF"}

package/dist/es/ui/programmatic-modal.js

@@ -0,0 +1,55 @@
+var p = Object.defineProperty;
+var v = (n, e, t) => e in n ? p(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var a = (n, e, t) => v(n, typeof e != "symbol" ? e + "" : e, t);
+import { getCoreEventName as T, dispatchCoreEvent as E } from "../core/events.js";
+import { newId as k } from "../utils/id.js";
+import { buildModal as C } from "./modal-builder.js";
+import { getElement as L } from "@ulu/utils/browser/dom.js";
+const c = class c {
+  constructor(e) {
+    const t = Object.assign({}, c.defaults, e);
+    this.options = t, this.triggers = null, this.cachedTrigger = null, this.triggerListener, this.onTriggerClick = (i) => {
+      const r = i.target.closest(t.triggerSelector);
+      r && (this.cachedTrigger = r);
+    }, this.onPageModified = () => {
+      this.setupTriggers();
+    }, document.addEventListener(T("pageModified"), this.onPageModified), this.setupTriggers();
+  }
+  setupTriggers() {
+    const { triggerSelector: e, triggerInitAttr: t } = this.options;
+    document.querySelectorAll(`${e}:not([${t}])`).forEach((r) => {
+      r.addEventListener("click", this.onTriggerClick);
+    });
+  }
+  destroy() {
+    const { triggerSelector: e } = this.options;
+    document.querySelectorAll(e).forEach((i) => {
+      i.removeEventListener("click", this.onTriggerClick);
+    });
+  }
+  createAndOpen(e, t) {
+    const { noClickTrigger: i, removeOnClose: r, element: u, classes: l } = e, g = L(u);
+    g.id || (g.id = k()), l && g.classList.add(...l);
+    let o;
+    if (i || (o = this.cachedTrigger, this.cachedTrigger = null), !g) {
+      console.error("No element found from config.element. ", e);
+      return;
+    }
+    const { modal: s } = C(g, e.modal), d = { trigger: o, modal: s, config: e };
+    t && t(d);
+    const m = () => {
+      r && s.remove(), o && o.focus();
+    };
+    return s.addEventListener("close", m, { once: !0 }), !r && o && o.addEventListener("click", (f) => {
+      f.preventDefault(), s.showModal();
+    }), E("pageModified", s), s.showModal(), d;
+  }
+};
+a(c, "defaults", {
+  triggerSelector: "[data-ulu-programmatic-modal-trigger]",
+  triggerInitAttr: "data-ulu-programmatic-modal-init"
+});
+let h = c;
+export {
+  h as ProgrammaticModalManager
+};

package/{types → dist/es}/ui/proxy-click.d.ts

@@ -1,7 +1,8 @@
+import { ComponentInitializer } from '../core/component.js';
 /**
  * @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;
+export function setDefaults(options: Object): void;
 /**
  * Initialize everything in document
  * - This will only initialize elements once, it is safe to call on page changes
@@ -12,14 +13,14 @@ export function init(): void;
  * @param {Node} proxy The container who's click should proxy the click of inner element with options.selector (defaults to [data-ulu-proxy-click-source])
  * @param {Object} userOptions Options to override defaults
  */
-export function setupProxy(proxy: Node, userOptions: any): void;
+export function setupProxy(proxy: Node, userOptions: Object): void;
 /**
  * Main function for attaching behaviors that enable proxy click
  * @param {Node} proxy The container who's click should proxy the click of inner element with options.selector (defaults to [data-ulu-proxy-click-source])
  * @param {Node} child The element who is being proxied and will get clicked if the proxy is clicked (as long as not an interactive element within proxy)
  * @param {Object} config Merged/final options object
  */
-export function attachHandlers(proxy: Node, child: Node, config: any): void;
+export function attachHandlers(proxy: Node, child: Node, config: Object): void;
 /**
  * Proxy Click Component Initializer
  */
@@ -30,5 +31,4 @@ export namespace defaults {
     let selectorPrevent: string;
     let mousedownDurationPrevent: number;
 }
-import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=proxy-click.d.ts.map

package/dist/es/ui/proxy-click.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-click.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/proxy-click.js"],"names":[],"mappings":"AAkCA;;GAEG;AACH,qCAFW,MAAM,QAIhB;AACD;;;GAGG;AACH,6BASC;AAED;;;;GAIG;AACH,kCAHW,IAAI,eACJ,MAAM,QAUhB;AAED;;;;;GAKG;AACH,sCAJW,IAAI,SACJ,IAAI,UACJ,MAAM,QAmBhB;AAhFD;;GAEG;AACH,+CAGG;;;;;;;qCARkC,sBAAsB"}

package/dist/es/ui/proxy-click.js

@@ -0,0 +1,44 @@
+import { ComponentInitializer as d } from "../core/component.js";
+const p = new d({
+  type: "proxy-click",
+  baseAttribute: "data-ulu-proxy-click"
+}), f = {
+  selector: "[data-ulu-proxy-click-source]",
+  selectorPreventBase: "input, select, textarea, button, a, [tabindex='-1']",
+  selectorPrevent: "",
+  mousedownDurationPrevent: 250
+};
+let c = { ...f };
+function m(e) {
+  c = Object.assign({}, c, e);
+}
+function x() {
+  p.init({
+    withData: !0,
+    coreEvents: ["pageModified"],
+    setup({ element: e, data: o, initialize: t }) {
+      v(e, o), t();
+    }
+  });
+}
+function v(e, o) {
+  const t = Object.assign({}, c, o), s = e.querySelector(t.selector);
+  s ? P(e, s, t) : console.error("Unable to locate proxy click source", t.selector);
+}
+function P(e, o, t) {
+  const { selectorPreventBase: s, selectorPrevent: i } = t, l = `${s}${i ? `, ${i}` : ""}`;
+  let a, n;
+  e.addEventListener("mousedown", ({ target: r, timeStamp: u }) => {
+    n = !1, r.matches(l) || (n = !0, a = u);
+  }), e.addEventListener("mouseup", ({ timeStamp: r }) => {
+    n && r - a < t.mousedownDurationPrevent && o.click();
+  }), e.style.cursor = "pointer";
+}
+export {
+  P as attachHandlers,
+  f as defaults,
+  x as init,
+  p as initializer,
+  m as setDefaults,
+  v as setupProxy
+};

package/{types → dist/es}/ui/resizer.d.ts

@@ -77,24 +77,24 @@ export class Resizer {
      * @param {boolean} [config.enableKeyboardResizing=true] If true, keyboard events will enable resizing.
      */
     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;
+        debug?: boolean | undefined;
+        multiplier?: boolean | undefined;
+        overrideMaxDimensions?: boolean | undefined;
+        fromX?: "left" | "right" | null | undefined;
+        fromY?: "top" | "bottom" | null | undefined;
+        keyboardStep?: number | undefined;
+        keyboardDebounceTime?: number | undefined;
+        manageEvents?: boolean | undefined;
+        manageAriaLabel?: boolean | undefined;
+        enablePointerResizing?: boolean | undefined;
+        enableKeyboardResizing?: boolean | undefined;
     });
-    options: any;
-    container: Node;
-    control: HTMLElement;
+    options: never;
+    container: Node | undefined;
+    control: HTMLElement | undefined;
     debug: any;
-    resizeHorizontal: boolean;
-    resizeVertical: boolean;
+    resizeHorizontal: boolean | undefined;
+    resizeVertical: boolean | undefined;
     /**
      * Cleans up event listeners and internal state to prevent memory leaks.
      */
@@ -122,7 +122,7 @@ export class Resizer {
      * @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;
+    dispatchEvent(type: string, data?: Object): void;
     #private;
 }
 //# sourceMappingURL=resizer.d.ts.map

package/dist/es/ui/resizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizer.d.ts","sourceRoot":"","sources":["../../../lib/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,UAEnB;QAAyB,KAAK;QACL,UAAU;QACV,qBAAqB;QACT,KAAK;QACL,KAAK;QAClB,YAAY;QACZ,oBAAoB;QACnB,YAAY;QACZ,eAAe;QACf,qBAAqB;QACrB,sBAAsB;KACjD,EAkDA;IA3CC,eAAsB;IACtB,4BAA0B;IAC1B,iCAAsB;IACtB,WAA0B;IAmB1B,sCAA8C;IAC9C,oCAA4C;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,SACN,MAAM,QAIhB;;CACF"}

package/dist/es/ui/resizer.js

@@ -0,0 +1,242 @@
+var S = Object.defineProperty;
+var P = (n) => {
+  throw TypeError(n);
+};
+var T = (n, t, e) => t in n ? S(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var k = (n, t, e) => T(n, typeof t != "symbol" ? t + "" : t, e), L = (n, t, e) => t.has(n) || P("Cannot " + e);
+var i = (n, t, e) => (L(n, t, "read from private field"), e ? e.call(n) : t.get(n)), u = (n, t, e) => t.has(n) ? P("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(n) : t.set(n, e), a = (n, t, e, r) => (L(n, t, "write to private field"), r ? r.call(n, e) : t.set(n, e), e), p = (n, t, e) => (L(n, t, "access private method"), e);
+import { createUluEvent as M } from "../core/events.js";
+import { logError as I, log as b } from "../utils/class-logger.js";
+var z, v, f, d, y, w, g, E, R, l, X, x, A, D;
+const Y = class Y {
+  /**
+   * @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(t, e, r) {
+    u(this, l);
+    // Declare private fields without initial assignments
+    u(this, z);
+    u(this, v);
+    u(this, f);
+    u(this, d);
+    u(this, y);
+    u(this, w);
+    u(this, g);
+    u(this, E);
+    u(this, R);
+    if (!e || !t) {
+      I(this, "Missing required elements: control, container");
+      return;
+    }
+    const s = Object.assign({}, Y.defaults, r);
+    this.options = s, this.container = t, this.control = e, this.debug = s.debug;
+    const o = ["left", "right"], c = ["top", "bottom"], { fromX: h, fromY: m } = s;
+    if (!o.includes(h) && h !== null) {
+      I(this, `Invalid fromX: ${h} (left|right|null)`);
+      return;
+    }
+    if (!c.includes(m) && m !== null) {
+      I(this, `Invalid fromY: ${m} (top|bottom|null)`);
+      return;
+    }
+    if (!h && !m) {
+      I(this, "Invalid fromX/fromY, failed to setup resizer (at least one of fromX or fromY must be set)");
+      return;
+    }
+    this.resizeHorizontal = s.fromX !== null, this.resizeVertical = s.fromY !== null, s.manageEvents && (a(this, z, this.onPointerdown.bind(this)), a(this, v, this.onKeydown.bind(this)), s.enablePointerResizing && e.addEventListener("pointerdown", i(this, z)), s.enableKeyboardResizing && e.addEventListener("keydown", i(this, v))), p(this, l, X).call(this), s.manageAriaLabel && e.setAttribute("aria-label", this.getAriaLabel());
+  }
+  /**
+   * Cleans up event listeners and internal state to prevent memory leaks.
+   */
+  destroy() {
+    const { control: t, options: e } = this;
+    e.manageEvents && (e.enablePointerResizing && t.removeEventListener("pointerdown", i(this, z)), e.enableKeyboardResizing && t.removeEventListener("keydown", i(this, v))), i(this, f) && clearTimeout(i(this, f)), p(this, l, X).call(this), e.manageAriaLabel && t.removeAttribute("aria-label"), b(this, "Resizer destroyed.");
+  }
+  /**
+   * 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(t) {
+    if (!this.options.enablePointerResizing) {
+      b(this, "Pointer resizing disabled. Ignoring pointerdown event.");
+      return;
+    }
+    t.preventDefault();
+    const e = document.documentElement;
+    a(this, E, t.clientX), a(this, R, t.clientY), p(this, l, x).call(this, {
+      inputType: "pointer",
+      startX: t.clientX,
+      startY: t.clientY,
+      pointerId: t.pointerId
+    }), this.control.setPointerCapture(t.pointerId);
+    const r = (o) => {
+      const c = o.clientX - i(this, E), h = o.clientY - i(this, R);
+      p(this, l, D).call(this, c, h, o);
+    }, s = (o) => {
+      e.removeEventListener("pointermove", r, !1), e.removeEventListener("pointerup", s, { capture: !0, once: !0 }), this.control.hasPointerCapture(o.pointerId) && this.control.releasePointerCapture(o.pointerId), p(this, l, A).call(this);
+    };
+    e.addEventListener("pointermove", r, !1), e.addEventListener("pointerup", s, { capture: !0, once: !0 });
+  }
+  /**
+   * 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(t) {
+    if (!this.options.enableKeyboardResizing) {
+      b(this, "Keyboard resizing disabled. Ignoring keydown event.");
+      return;
+    }
+    const { key: e } = t, { keyboardStep: r, keyboardDebounceTime: s } = this.options;
+    let o = 0, c = 0, h = !1;
+    this.resizeHorizontal && (e === "ArrowLeft" ? (o = -r, h = !0) : e === "ArrowRight" && (o = r, h = !0)), this.resizeVertical && (e === "ArrowUp" ? (c = -r, h = !0) : e === "ArrowDown" && (c = r, h = !0)), h && (t.preventDefault(), t.stopPropagation(), (!i(this, g) || i(this, f) === null) && p(this, l, x).call(this, { inputType: "keyboard", keyboardKey: e }), a(this, y, i(this, y) + o), a(this, w, i(this, w) + c), p(this, l, D).call(this, i(this, y), i(this, w), t), i(this, f) && clearTimeout(i(this, f)), a(this, f, setTimeout(() => {
+      p(this, l, A).call(this), a(this, f, null);
+    }, s)));
+  }
+  /**
+   * 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() {
+    const { fromY: t, fromX: e } = this.options, r = [t, e].filter((s) => s);
+    return r.length === 0 ? "Resize control" : `Resize from ${r.join(" ")} edge`;
+  }
+  /**
+   * 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(t, e = {}) {
+    this.container.dispatchEvent(M(t, e));
+  }
+};
+z = new WeakMap(), v = new WeakMap(), f = new WeakMap(), d = new WeakMap(), y = new WeakMap(), w = new WeakMap(), g = new WeakMap(), E = new WeakMap(), R = new WeakMap(), l = new WeakSet(), /**
+ * Resets all internal state properties to their default/inactive values.
+ * This centralizes state cleanup and initial setup.
+ * @private
+ */
+X = function() {
+  a(this, f, null), a(this, d, { width: 0, height: 0 }), a(this, y, 0), a(this, w, 0), a(this, g, !1), a(this, E, 0), a(this, R, 0);
+}, /**
+ * Initiates a resize operation.
+ * This sets initial dimensions and dispatches the 'resizer:start' event.
+ * @param {Object} eventDetails Additional details about the initiating event.
+ * @private
+ */
+x = function(t) {
+  const { container: e, options: r } = this;
+  if (i(this, g)) {
+    r.overrideMaxDimensions && (this.resizeHorizontal && (e.style.maxWidth = "none"), this.resizeVertical && (e.style.maxHeight = "none"));
+    return;
+  }
+  const o = document.defaultView.getComputedStyle(e);
+  i(this, d).width = parseInt(o.width, 10), i(this, d).height = parseInt(o.height, 10), r.overrideMaxDimensions && (this.resizeHorizontal && (e.style.maxWidth = "none"), this.resizeVertical && (e.style.maxHeight = "none")), a(this, g, !0), this.dispatchEvent("resizer:start", t), b(this, "Resize started.", {
+    initialWidth: i(this, d).width,
+    initialHeight: i(this, d).height,
+    ...t
+  });
+}, /**
+ * Ends a resize operation.
+ * Dispatches 'resizer:end' event and resets internal state.
+ * @private
+ */
+A = function() {
+  i(this, g) && (this.dispatchEvent("resizer:end"), p(this, l, X).call(this), b(this, "Resize ended."));
+}, /**
+ * Core logic for calculating and applying the new size of the container.
+ * This method is called by both pointer and keyboard event handlers.
+ *
+ * @param {number} totalDeltaX The total horizontal displacement from the start of the resize.
+ * @param {number} totalDeltaY The total vertical displacement from the start of the resize.
+ * @param {Event} originalEvent The original DOM event (PointerEvent or KeyboardEvent) that triggered the update.
+ * @private
+ */
+D = function(t, e, r) {
+  let s = i(this, d).width, o = i(this, d).height;
+  const { fromX: c, fromY: h, multiplier: m } = this.options;
+  this.resizeHorizontal && (c === "right" ? s = i(this, d).width + t * m : c === "left" && (s = i(this, d).width - t * m), this.container.style.width = `${Math.max(0, s)}px`), this.resizeVertical && (h === "bottom" ? o = i(this, d).height + e * m : h === "top" && (o = i(this, d).height - e * m), this.container.style.height = `${Math.max(0, o)}px`);
+  const K = {
+    newWidth: s,
+    newHeight: o,
+    totalDeltaX: t,
+    totalDeltaY: e,
+    event: r
+  };
+  this.dispatchEvent("resizer:update", K), b(this, "Resizing update.", K);
+}, k(Y, "defaults", {
+  debug: !1,
+  /**
+   * Amount to increase size by (ie. pointer movement * multiplier)
+   */
+  multiplier: 1,
+  /**
+   * Remove max-width, max-height
+   */
+  overrideMaxDimensions: !1,
+  /**
+   * @type {"left"|"right"|null}
+   * Specifies the horizontal edge from which resizing occurs.
+   * `null` means no horizontal resizing.
+   * - Default null
+   */
+  fromX: null,
+  /**
+   * @type {"top"|"bottom"|null}
+   * Specifies the vertical edge from which resizing occurs.
+   * - `null` means no vertical resizing.
+   * - Default null
+   */
+  fromY: null,
+  /**
+   * The step in pixels for keyboard resizing with arrow keys.
+   */
+  keyboardStep: 10,
+  /**
+   * Debounce time in milliseconds for ending a keyboard resize.
+   */
+  keyboardDebounceTime: 200,
+  /**
+   * 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: !0,
+  /**
+   * 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: !1,
+  /**
+   * If true, pointer events (mouse/touch) will enable resizing.
+   * Default: true
+   */
+  enablePointerResizing: !0,
+  /**
+   * If true, keyboard events (arrow keys) will enable resizing.
+   * Default: true
+   */
+  enableKeyboardResizing: !0
+});
+let H = Y;
+export {
+  H as Resizer
+};

package/{types → dist/es}/ui/scroll-slider.d.ts

@@ -1,3 +1,4 @@
+import { ComponentInitializer } from '../core/component.js';
 /**
  * Initialize everything in document
  * - This will only initialize elements once, it is safe to call on page changes
@@ -7,5 +8,4 @@ export function init(): void;
  * Scroll Slider Component Initializer
  */
 export const initializer: ComponentInitializer;
-import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=scroll-slider.d.ts.map

package/dist/es/ui/scroll-slider.d.ts.map

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

package/dist/es/ui/scroll-slider.js

@@ -0,0 +1,29 @@
+import { ComponentInitializer as n } from "../core/component.js";
+import { OverflowScroller as i } from "./overflow-scroller.js";
+import { createPager as l } from "./overflow-scroller-pager.js";
+const o = new n({
+  type: "scroll-slider",
+  baseAttribute: "data-ulu-scroll-slider"
+}), s = o.attributeSelector("track"), a = o.attributeSelector("control-context"), u = [], p = {
+  amount: l()
+};
+function b() {
+  o.init({
+    withData: !0,
+    coreEvents: ["pageModified"],
+    setup({ element: t, data: e, initialize: r }) {
+      f(t, e), r();
+    }
+  });
+}
+function f(t, e) {
+  const r = Object.assign({}, p, e), c = {
+    track: t.querySelector(s),
+    controls: t.querySelector(a)
+  };
+  u.push(new i(c, r));
+}
+export {
+  b as init,
+  o as initializer
+};