@ulu/frontend 0.2.0-beta.1 → 0.2.0-beta.10

package/dist/es/ui/scrollpoint.js

@@ -0,0 +1,178 @@
+var m = Object.defineProperty;
+var f = (a, t, s) => t in a ? m(a, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : a[t] = s;
+var d = (a, t, s) => f(a, typeof t != "symbol" ? t + "" : t, s);
+import { ComponentInitializer as p } from "../core/component.js";
+import { logError as g } from "../utils/class-logger.js";
+import { getElement as b } from "@ulu/utils/browser/dom.js";
+const c = new p({
+  type: "scrollpoint",
+  baseAttribute: "data-ulu-scrollpoint"
+});
+function w() {
+  c.init({
+    withData: !0,
+    coreEvents: ["pageModified"],
+    setup({ element: a, data: t, initialize: s }) {
+      const e = Object.assign({}, t);
+      new h(a, e), s();
+    }
+  });
+}
+const l = class l {
+  /**
+   * Setup a new scrollpoint
+   * @param {Node} element The element to create the scrollpoint for
+   * @param {Object} config Options to configure the scrollpoint see Scrollpoint.defaults for more information on settings
+   */
+  constructor(t, s) {
+    const e = Object.assign({}, l.defaults, s);
+    if (!t) {
+      g(this, "Missing required element");
+      return;
+    }
+    e.rootSelector && (e.root = document.querySelector(e.rootSelector), delete e.rootSelector), this.options = e, this.observer = null, this.lastPosition = null, this.isActive = !1, this.element = t, this.syncedElements = [
+      t,
+      ...e.syncElements.map((i) => b(i))
+    ], this.classes = {
+      enter: this.getClassname("enter"),
+      enterForward: this.getClassname("enter--from-forward"),
+      enterReverse: this.getClassname("enter--from-reverse"),
+      exit: this.getClassname("exit"),
+      exitForward: this.getClassname("exit--from-forward"),
+      exitReverse: this.getClassname("exit--from-reverse")
+    }, this.setupObserver(), e.debug && c.log(this);
+  }
+  getClassname(t) {
+    return this.options.classPrefix + "-" + t;
+  }
+  getObserverOptions() {
+    const { root: t, marginStart: s, marginEnd: e, threshold: i, horizontal: r } = this.options, o = r ? `0px ${s} 0px ${e}` : `${s} 0px ${e} 0px`;
+    return { root: t, rootMargin: o, threshold: i };
+  }
+  /**
+   * IntersectionObserver Callback
+   * - Should set the state
+   */
+  onObserve(t) {
+    const s = this.getScrollY(), { lastPosition: e, isActive: i, options: r } = this, o = e === null ? null : e < s;
+    t.forEach((n) => {
+      const { isIntersecting: u } = n;
+      u && !i ? this.setState(!0, o) : !u && i && r.exit && (o && r.exitForward || !o && r.exitReverse) && this.setState(!1, o);
+    }), this.lastPosition = s;
+  }
+  setupObserver() {
+    const t = (e) => {
+      this.onObserve(e);
+    }, s = this.getObserverOptions();
+    this.options.debug && c.log("IntersectionObserver (options)", s), this.observer = new IntersectionObserver(t, s), this.observer.observe(this.element);
+  }
+  getScrollY() {
+    const { root: t } = this.options;
+    return t === null || t === document ? window.scrollY : t.scrollTop;
+  }
+  setState(t, s) {
+    const { element: e } = this, i = { isActive: t, isForward: s, element: e, instance: this }, { setClasses: r, setAttribute: o, onChange: n } = this.options;
+    r && this.updateClasses(t, s), o && this.updateStateAttribute(t, s), n && n(i), this.isActive = t;
+  }
+  getAllClasses() {
+    return Object.values(this.classes);
+  }
+  updateClasses(t, s) {
+    const { classes: e } = this, i = this.getAllClasses(), r = [
+      e.enter,
+      s ? e.enterForward : e.enterReverse
+    ], o = [
+      e.exit,
+      s ? e.exitForward : e.exitReverse
+    ];
+    this.syncedElements.forEach((n) => {
+      n.classList.remove(...i), t ? n.classList.add(...r) : n.classList.add(...o);
+    });
+  }
+  updateStateAttribute(t, s) {
+    const e = t ? "enter" : "exit", i = s ? "forward" : "reverse";
+    this.syncedElements.forEach((r) => {
+      r.setAttribute(this.options.attributeName, `${e}-${i}`);
+    });
+  }
+  destroy() {
+    this.observer.disconnect(), this.observer = null, this.options.setClasses && this.element.classList.remove(...this.getAllClasses()), this.options.setAttribute && this.element.removeAttribute(this.options.attributeName);
+  }
+};
+d(l, "defaults", {
+  /**
+   * Default observer root element
+   */
+  root: null,
+  /**
+   * Use a selector to select the observer root element
+   */
+  rootSelector: null,
+  /**
+   * Log debug info to console
+   */
+  debug: !1,
+  /**
+   * Change scroll orientation to horizontal
+   */
+  horizontal: !1,
+  /**
+   * Margin for observer top or left (depending on orientation)
+   */
+  marginStart: "-25%",
+  /**
+   * Margin for observer bottom or right (depending on orientation)
+   */
+  marginEnd: "-55%",
+  /**
+   * Threshold for observer
+   */
+  threshold: [0, 1],
+  /**
+   * The point can exited (else persists)
+   */
+  exit: !0,
+  /**
+   * The point can exit from the end
+   */
+  exitForward: !0,
+  /**
+   * The point can exit from the start
+   */
+  exitReverse: !0,
+  /**
+   * Set state classes
+   */
+  setClasses: !1,
+  /**
+   * Prefix for classes
+   */
+  classPrefix: "scrollpoint",
+  /**
+   * Set attribute for state (less verbose same info as classes)
+   */
+  setAttribute: !0,
+  /**
+   * Attribute name to set state info in
+   */
+  attributeName: "data-ulu-scrollpoint-state",
+  /**
+   * Group multiple points, one active at a time (scroll menus)
+   */
+  // groupName: null,
+  /**
+   * Elements that should also get active state info (classes or attributes)
+   */
+  syncElements: [],
+  /**
+   * Callback called when state changes
+   */
+  onChange(t) {
+  }
+});
+let h = l;
+export {
+  h as Scrollpoint,
+  w as init,
+  c as initializer
+};

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

@@ -1,3 +1,4 @@
+import { ComponentInitializer } from '../core/component.js';
 /**
  * Initialize all sliders based on data attribute selectors
  */
@@ -7,7 +8,7 @@ export function init(): void;
  * @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;
+export function setupSlider(container: Node, options: Object): void;
 /**
  * Slider Component Initializer
  */
@@ -17,6 +18,9 @@ export const initializer: ComponentInitializer;
  */
 export class Slider {
     static instances: any[];
+    static globalsInitialized: boolean;
+    static reduceMotion: boolean;
+    static _initializeGlobals(): void;
     /**
      * Default options for slider
      */
@@ -30,8 +34,8 @@ export class Slider {
         transitionDurationExit: number;
         transitionTimingFunction: string;
         buttonClasses: string[];
-        iconClassPrevious: any;
-        iconClassNext: any;
+        iconClassPrevious: Object;
+        iconClassNext: Object;
         swipeEnabled: boolean;
         swipeOptions: {
             preventScroll: boolean;
@@ -43,11 +47,11 @@ export class Slider {
         element: any;
         index: number;
         number: number;
-    };
+    } | null;
     index: any;
     swipeInstance: any;
-    swipeListener: (event: any) => void;
-    swipeImageListener: (event: any) => void;
+    swipeListener: ((event: any) => void) | null;
+    swipeImageListener: ((event: any) => void) | null;
     transitioning: boolean;
     slides: {
         element: any;
@@ -135,7 +139,7 @@ export class Slider {
     };
     createNav(container: any): {
         nav: HTMLUListElement;
-        navButtons: any[];
+        navButtons: HTMLButtonElement[];
         navItems: HTMLLIElement[];
     };
     createNavButton(slide: any, index: any): HTMLButtonElement;
@@ -143,5 +147,4 @@ export class Slider {
     getNavContent(slide: any): string;
     emit(name: any, args: any): void;
 }
-import { ComponentInitializer } from "../core/component.js";
 //# sourceMappingURL=slider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slider.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/slider.js"],"names":[],"mappings":"AAgEA;;GAEG;AACH,6BASC;AAED;;;;GAIG;AACH,uCAHW,IAAI,WACJ,MAAM,QAiBhB;AA1DD;;GAEG;AACH,+CAGG;AAsDH;;GAEG;AACH;IACE,wBAAsB;IACtB,mCAAkC;IAClC,6BAA4B;IAE5B,kCAYC;IACD;;OAEG;IACH;;;;;;;;;;;;;;;;MAgBC;IACD,wCAoCC;IAjCC,aAAsB;IACtB;;;;aAAiB;IACjB,WAAiB;IACjB,mBAAyB;IACzB,6CAAyB;IACzB,kDAA8B;IAC9B,uBAA0B;IAQ1B;;;;QAME;IACF,cAIC;IAED;;;wBACgF;IAMlF;;OAEG;IACH,qBAKC;IACD;;OAEG;IACH,2BAOC;IACD;;OAEG;IACH,uBAMC;IACD;;;;;;OAMG;IACH,8BAJW,MAAM,YACN,MAAM,2CAqChB;IACD;;OAEG;IACH,kDASC;IACD;;;OAGG;IACH,oDASC;IACD;;OAEG;IACH,kDAOC;IACD;;OAEG;IACH;;;;;;sBAoDC;IACD;;OAEG;IACH;;;sBAUC;IACD;;OAEG;IACH;;;sBAOC;IACD,qDA2CC;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;qCA1iBoC,sBAAsB"}

package/dist/es/ui/slider.js

@@ -0,0 +1,290 @@
+var w = Object.defineProperty;
+var T = (a, t, s) => t in a ? w(a, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : a[t] = s;
+var m = (a, t, s) => T(a, typeof t != "symbol" ? t + "" : t, s);
+import { ComponentInitializer as x } from "../core/component.js";
+import { wrapSettingString as b } from "../core/settings.js";
+import { hasRequiredProps as S } from "@ulu/utils/object.js";
+import { trimWhitespace as v } from "@ulu/utils/string.js";
+import { debounce as k } from "@ulu/utils/performance.js";
+import { logError as y, log as $, logWarning as L } from "../utils/class-logger.js";
+import I from "swipe-listener";
+const f = new x({
+  type: "slider",
+  baseAttribute: "data-ulu-slider"
+}), A = f.attributeSelector("track"), z = f.attributeSelector("track-container"), D = f.attributeSelector("control-context"), M = f.attributeSelector("slide"), B = [], h = { once: !0 }, E = (a) => `${a}ms`, N = [
+  "container",
+  "trackContainer",
+  "track",
+  "slides"
+];
+function W() {
+  f.init({
+    withData: !0,
+    coreEvents: ["pageModified"],
+    setup({ element: a, data: t, initialize: s }) {
+      q(a, t), s();
+    }
+  });
+}
+function q(a, t) {
+  const s = Object.assign({}, t), e = {
+    container: a,
+    track: a.querySelector(A),
+    trackContainer: a.querySelector(z),
+    controlContext: a.querySelector(D),
+    slides: a.querySelectorAll(M)
+  };
+  e.slides.length && B.push(new g(e, s, !1));
+}
+const l = class l {
+  static _initializeGlobals() {
+    l.globalsInitialized || (addEventListener("load", () => {
+      addEventListener("resize", k(() => {
+        l.instances.forEach((t) => t.handleResize());
+      }, 250));
+    }), l.reduceMotion = matchMedia("(prefers-reduced-motion: reduce)").matches, l.globalsInitialized = !0);
+  }
+  constructor(t, s) {
+    l._initializeGlobals();
+    const e = Object.assign({}, l.defaults, s);
+    this.options = e, this.slide = null, this.index = null, this.swipeInstance = null, this.swipeListener = null, this.swipeImageListener = null, this.transitioning = !1, S(N) || y(this, "Missing a required Element"), t.slides.length || y(this, "Missing slides"), this.slides = [...t.slides].map((i, n) => ({
+      element: i,
+      index: n,
+      number: n + 1
+    })), this.elements = {
+      ...t,
+      ...this.createControls(t.controlContext || t.container),
+      ...this.createNav(t.navContext || t.container)
+    }, this.transition = e.transition ? e.transitionFade || l.reduceMotion ? this.fadeTransition : this.slideTransition : this.noTransition, this.setup(), this.goto(0, null, "init"), $(this, "Slider Instance Created", this), l.instances.push(this);
+  }
+  /**
+   * Sliding mechanism needs translate updated on resize
+   */
+  handleResize() {
+    const { slide: t, transition: s, slideTransition: e } = this;
+    s === e && t && this.translateTo(t.element.offsetLeft, 0);
+  }
+  /**
+   * Goto to the previous slide
+   */
+  previous(t) {
+    const { index: s, slides: e } = this, i = e.length - 1, n = s - 1, o = n < 0 ? i : n;
+    this.emit("previous", [t, o]), this.goto(o, t, "previous");
+  }
+  /**
+   * Goto to the next slide
+   */
+  next(t) {
+    const { index: s, slides: e } = this, i = s + 1, n = i > e.length - 1 ? 0 : i;
+    this.emit("next", [t, n]), this.goto(n, t, "next");
+  }
+  /**
+   *  Makes sure that no matter what the callback is called if transition event
+   * doesn't start or fails to finish/cancel
+   * @param {number} element
+   * @param {number} duration Duration to wait for complete 
+   * @param {Function} beginTransition Css changes to begin/start transtion 
+   */
+  ensureTransitionEnds(t, s, e) {
+    return new Promise((i) => {
+      const n = {}, o = () => {
+        clearTimeout(n.start), n.end = setTimeout(r, s + 500);
+      }, r = () => {
+        clearTimeout(n.start), clearTimeout(n.end), t.removeEventListener("transitionrun", o, h), t.removeEventListener("transitionend", r, h), t.removeEventListener("transitioncancel", r, h), i();
+      };
+      t.addEventListener("transitionrun", o, h), t.addEventListener("transitionend", r, h), t.addEventListener("transitioncancel", r, h), n.start = setTimeout(r, s + 500), t.style.transitionDuration = E(s), e(), s || r();
+    });
+  }
+  /**
+   * Translate the track to X
+   */
+  translateTo(t, s) {
+    const { track: e } = this.elements, i = () => e.style.transform = `translateX(-${t}px)`;
+    return e.style.willChange = "transform", this.ensureTransitionEnds(e, s, i).then(() => {
+      e.style.willChange = "auto";
+    });
+  }
+  /**
+   * Show's a specifc slide and hides others, except when passing true to show all
+   * then all slides will visible
+   */
+  setVisibility(t, s) {
+    s || (t.element.style.visibility = "visible"), this.slides.forEach((e) => {
+      e !== t && (e.element.style.visibility = s ? "visible" : "hidden");
+    });
+  }
+  /**
+   * Perform a fade on a single slide
+   */
+  fadeSlide(t, s) {
+    const { options: e } = this, { element: i } = t, n = s ? e.transitionDuration : e.transitionDurationExit;
+    return this.ensureTransitionEnds(i, n, () => {
+      i.style.opacity = s ? "1" : "0";
+    });
+  }
+  /**
+   * Handler for the entire slide transtion
+   */
+  async slideTransition({ slide: t, index: s, old: e, oldIndex: i, triggerType: n }) {
+    const o = this.slides.length, r = n === "previous", C = o - 1, u = s === 0 && i === C, d = s === C && i === 0;
+    let c, p = this.options.transitionDuration;
+    i && !u && !d && (p = p * Math.abs(i - s)), o < 3 ? u && !r ? c = e : d && (c = r ? t : e) : u ? c = e : d && (c = t), this.setVisibility(null, !0), c && (c.element.style.order = "-1", await this.translateTo(u ? 0 : e.element.offsetLeft, 0)), await this.translateTo(t.element.offsetLeft, p), c && (c.element.style.order = "0", await this.translateTo(t.element.offsetLeft, 0)), this.setVisibility(t, !1);
+  }
+  /**
+   * Handler for the entire fade transtion
+   */
+  async fadeTransition({ slide: t, old: s }) {
+    this.setVisibility(null, !0), s && (await this.fadeSlide(s, !1), s.element.style.order = "0"), t.element.style.order = "-1", await this.fadeSlide(t, !0), this.setVisibility(t, !1);
+  }
+  /**
+   * Handler for the entire NO transtion
+   */
+  noTransition({ slide: t, old: s }) {
+    return this.setVisibility(t, !1), s && (s.element.style.order = "0"), t.element.style.order = "-1", Promise.resolve();
+  }
+  goto(t, s, e) {
+    const {
+      slide: i,
+      index: n,
+      slides: o,
+      elements: r
+    } = this, C = e === "init", u = o[t], d = this.getClass("nav-button--active"), c = this.getClass("transition", !0), p = { slide: u, index: t, old: i, oldIndex: n, triggerType: e };
+    if (t === n) {
+      L(this, "Could not goto slide, still performing transition");
+      return;
+    }
+    if (this.transitioning) {
+      L(this, "Cancel goto(), same slide index as current slide");
+      return;
+    }
+    this.elements.track.inert = !0, this.transitioning = !0, i && i.navButton.classList.remove(d), u.navButton.classList.add(d), r.container.classList.add(c), this.transition(p).then(() => {
+      this.index = t, this.slide = u, this.transitioning = !1, this.elements.track.inert = !1, r.container.classList.remove(c), C || (u.element.focus(), this.emit("goto", [s, t, u]));
+    });
+  }
+  setup() {
+    const { container: t, track: s, trackContainer: e } = this.elements, i = v(this.trackCss()), n = v(this.trackContainerStyles()), o = v(this.slideCss());
+    s.setAttribute("style", i), e.setAttribute("style", n), this.slides.forEach((r) => {
+      r.element.setAttribute("style", o), r.element.setAttribute("tabindex", "-1");
+    }), t.classList.add(this.getClass()), this.options.swipeEnabled && this.setupSwipe();
+  }
+  setupSwipe() {
+    const t = this.elements.track.querySelectorAll("img");
+    this.swipeListener = (s) => {
+      this.onSwipe(s);
+    }, this.swipeImageListener = (s) => {
+      s.preventDefault();
+    }, this.slides.forEach((s) => {
+      const { element: e } = s;
+      s.swipeInstance = I(e, this.options.swipeOptions), e.addEventListener("swipe", this.swipeListener);
+    }), t.forEach((s) => {
+      s.addEventListener("dragstart", this.swipeImageListener);
+    });
+  }
+  onSwipe(t) {
+    const { directions: s } = t.detail, e = s.left ? "next" : s.right ? "previous" : null;
+    e && this[e](t);
+  }
+  trackContainerStyles() {
+    return `
+      overflow: hidden;
+    `;
+  }
+  transitionCss(t) {
+    const { transitionTimingFunction: s, transitionDuration: e } = this.options;
+    return `
+      transition-property: ${t};
+      transition-duration: ${E(e)};
+      transition-timing-function: ${s};
+    `;
+  }
+  trackCss() {
+    return `
+      display: flex;
+      position: relative;
+      list-style: none;
+      ${this.transition === this.slideTransition ? this.transitionCss("transform") : ""}
+    `;
+  }
+  slideCss() {
+    const t = this.transition === this.fadeTransition;
+    return `
+      width: 100%;
+      flex: 0 0 100%;
+      ${t ? this.transitionCss("opacity") : ""}
+      opacity: ${t ? "0" : "1"}
+    `;
+  }
+  getClass(t, s) {
+    const { namespace: e } = this.options;
+    return s ? `${e}--${t}` : t ? `${e}__${t}` : e;
+  }
+  createControlButton(t) {
+    const s = document.createElement("button");
+    return s.classList.add(this.getClass("control-button")), s.classList.add(this.getClass(`control-button--${t}`)), s.classList.add(...this.options.buttonClasses), s.setAttribute("data-slider-control", t), s.setAttribute("type", "button"), s.innerHTML = this.getControlContent(t), s;
+  }
+  createControls(t) {
+    const s = document.createElement("ul"), e = document.createElement("li"), i = document.createElement("li"), n = this.createControlButton("previous"), o = this.createControlButton("next");
+    return s.classList.add(this.getClass("controls")), e.appendChild(n), i.appendChild(o), s.appendChild(e), s.appendChild(i), n.addEventListener("click", this.previous.bind(this)), o.addEventListener("click", this.next.bind(this)), t.appendChild(s), {
+      controls: s,
+      previousItem: e,
+      nextItem: i,
+      previous: n,
+      next: o
+    };
+  }
+  createNav(t) {
+    const s = document.createElement("ul"), e = this.slides.map(this.createNavButton.bind(this)), i = e.map((n) => {
+      const o = document.createElement("li");
+      return o.appendChild(n), s.appendChild(o), o;
+    });
+    return s.classList.add(this.getClass("nav")), t.appendChild(s), {
+      nav: s,
+      navButtons: e,
+      navItems: i
+    };
+  }
+  createNavButton(t, s) {
+    const e = document.createElement("button");
+    return e.classList.add(this.getClass("nav-button")), e.setAttribute("type", "button"), e.innerHTML = this.getNavContent(t), t.navButton = e, e.addEventListener("click", this.goto.bind(this, s)), e;
+  }
+  getControlContent(t) {
+    const s = this.options[t === "next" ? "iconClassNext" : "iconClassPrevious"];
+    return `
+      <span class="${this.options.classAccessiblyHidden}">${t}</span>
+      <span class="${this.getClass("control-icon")} ${s}" aria-hidden="true"></span>
+    `;
+  }
+  getNavContent(t) {
+    return `<span class="${this.options.classAccessiblyHidden}">Item ${t.number}</span>`;
+  }
+  emit(t, s) {
+    this.options.events[t] && this.options.events[t].apply(this, s);
+  }
+};
+m(l, "instances", []), m(l, "globalsInitialized", !1), m(l, "reduceMotion", !1), /**
+ * Default options for slider
+ */
+m(l, "defaults", {
+  classAccessiblyHidden: "hidden-visually",
+  namespace: "Slider",
+  events: {},
+  transition: !0,
+  transitionFade: !1,
+  transitionDuration: 700,
+  transitionDurationExit: 400,
+  transitionTimingFunction: "ease-in-out",
+  buttonClasses: ["button", "button--icon"],
+  iconClassPrevious: b("iconClassPrevious"),
+  iconClassNext: b("iconClassNext"),
+  swipeEnabled: !0,
+  swipeOptions: {
+    preventScroll: !0
+  }
+});
+let g = l;
+export {
+  g as Slider,
+  W as init,
+  f as initializer,
+  q as setupSlider
+};

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

@@ -1,3 +1,4 @@
+import { ComponentInitializer } from '../core/component.js';
 /**
  * Init all instances currently in document
  */
@@ -8,7 +9,7 @@ export function init(): void;
  * @param {Node} options Options to set as defaults (can be overridden by element dataset options)
  * @return {Object} Instance object
  */
-export function setup(element: Node, options?: Node): any;
+export function setup(element: Node, options?: Node): Object;
 /**
  * Array of current tab instances (exported if you need to interact with them)
  * @type {Array}
@@ -18,5 +19,4 @@ export const instances: any[];
  * Tabs Component Initializer
  */
 export const initializer: ComponentInitializer;
-import { ComponentInitializer } from "../core/component.js";
 //# sourceMappingURL=tabs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/tabs.js"],"names":[],"mappings":"AA2BA;;GAEG;AACH,6BAoBC;AAED;;;;;GAKG;AACH,+BAJW,IAAI,YACJ,IAAI,GACH,MAAM,CA0BjB;AArED;;;GAGG;AACH,8BAA4B;AAE5B;;GAEG;AACH,+CAGG;qCAdkC,sBAAsB"}

package/dist/es/ui/tabs.js

@@ -0,0 +1,64 @@
+import f from "aria-tablist";
+import { ComponentInitializer as u } from "../core/component.js";
+const l = [], p = new u({
+  type: "tabs",
+  baseAttribute: "data-ulu-tablist"
+});
+function E() {
+  const e = () => {
+    p.init({
+      coreEvents: ["pageModified"],
+      withData: !0,
+      setup({ element: n, data: t, initialize: o }) {
+        m(n, t), o();
+      }
+    }), l.forEach(b);
+  };
+  document.readyState === "complete" ? e() : window.addEventListener("load", e);
+}
+function m(e, n = {}) {
+  const t = Object.assign({}, n);
+  t.vertical && (t.allArrows = !0);
+  const o = { element: e, options: n };
+  return o.ariaTablist = f(e, {
+    onOpen(...a) {
+      a.unshift(o), g.apply(null, a);
+    },
+    ...t
+  }), l.push(o), t.equalHeights && w(e), o;
+}
+function b({ options: e, ariaTablist: n }) {
+  if (e.openByUrlHash) {
+    const { hash: t } = window.location;
+    if (t && t.length > 1) {
+      const o = t.substring(1);
+      n.tabs.forEach((a) => {
+        o === a.id && n.open(a);
+      });
+    }
+  }
+}
+function g({ options: e }, n, t) {
+  e.openByUrlHash && window.history && window.history.replaceState(null, "", `#${t.id}`);
+}
+function w(e) {
+  const t = [...e.children].map((i) => document.querySelector(`[aria-labelledby="${i.id}"]`)), h = [...t[0].parentElement.querySelectorAll("img")].map((i) => d(i));
+  function d(i) {
+    return new Promise((r) => {
+      i.complete ? r(i) : (i.onload = r, i.onerror = r);
+    });
+  }
+  Promise.all(h).then(() => {
+    const i = t.map((s) => {
+      let c = s.offsetHeight;
+      return s.hidden && (s.hidden = !1, c = s.offsetHeight, s.setAttribute("hidden", "hidden")), c;
+    }), r = Math.max(...i);
+    t.forEach((s) => s.style.minHeight = `${r}px`);
+  });
+}
+export {
+  E as init,
+  p as initializer,
+  l as instances,
+  m as setup
+};

package/dist/{types/js → es}/ui/theme-toggle.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
@@ -17,7 +18,7 @@ export function setupToggle(toggle: HTMLElement, userOptions: any): {
     options: any;
     toggleState: (event: any) => void;
     setState(themeKey: any): void;
-};
+} | undefined;
 /**
  * Theme Toggle Component Initializer
  */
@@ -43,7 +44,7 @@ export namespace defaults {
         }
     }
     let target: string;
-    let group: any;
+    let group: null;
     /**
      * Optional callback to do something when the state changes
      */
@@ -54,5 +55,4 @@ export namespace defaults {
     let storagePrefix: string;
     let debug: boolean;
 }
-import { ComponentInitializer } from "../core/component.js";
 //# sourceMappingURL=theme-toggle.d.ts.map

package/dist/es/ui/theme-toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-toggle.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/theme-toggle.js"],"names":[],"mappings":"AAmGA;;GAEG;AACH,qCAFW,MAAM,QAIhB;AAED;;;GAGG;AACH,6BASC;AAED;;;GAGG;AACH,oCAFW,WAAW;;;;;;cA+FrB;AAhND;;GAEG;AACH,+CAGG;;;;;;;;;;;;;;;;;;;;;;;IAmDD;;OAEG;IACH,mCAAiB;;;;;;;qCAlEkB,sBAAsB"}