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

package/dist/es/ui/breakpoints.js

@@ -0,0 +1,194 @@
+var u = Object.defineProperty;
+var p = (s, t, e) => t in s ? u(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var r = (s, t, e) => p(s, typeof t != "symbol" ? t + "" : t, e);
+import { removeArrayElement as c } from "@ulu/utils/array.js";
+import { isBrowser as g } from "@ulu/utils/browser/dom.js";
+import { getCoreEventName as v } from "../core/events.js";
+import { wrapSettingString as b } from "../core/settings.js";
+import { getCustomProperty as k } from "../utils/css.js";
+import { log as d, logError as f } from "../utils/class-logger.js";
+const y = (s) => k(s, "breakpoint"), i = class i {
+  static _initializeGlobals() {
+    i.globalsInitialized || !g() || (window.addEventListener(v("pageResized"), () => {
+      i.instances.forEach((t) => t.update());
+    }), i.globalsInitialized = !0);
+  }
+  /**
+   * @param {Object} config Configuration object
+   * @param {Array} config.order Array of strings that correspond to the breakpoints setup in the styles, Breakpoints from smallest to largest, defaults to [small, medium, large]
+   * @param {Array} config.customProperty Property to grab breakpoint from (default is --breakpoint)
+   * @param {Array} config.valueFromPseudo Use the legacy method of grabbing breakpoint from pseudo element, default uses custom property
+   * @param {Node} config.element The element to retrieve active breakpoint from stylesheet. (default is html) For using the old pseudo method, adjust this to document.body
+   * @param {String} config.pseudoSelector Change pseudo selector used to get the breakpoint from the pseudo's content property
+   */
+  constructor(t) {
+    i._initializeGlobals(), Object.assign(this, i.defaults, t), this.active = null, this.previous = null, this.activeIndex = null, this.resizeDirection = null, this.previousIndex = null, this.breakpoints = {}, this.onChangeCallbacks = [], this.order.forEach((e) => this.breakpoints[e] = new x(e, this)), d(this, this), this.update(), i.instances.push(this);
+  }
+  /**
+   * Add a callback for every time a breakpoint changes
+   * - Not recommended, possibly use to watch for changes, etc
+   * - For more control use instance.at(name) with breakpoint methods
+   * @param {Function} callback Function to call, passed one argument current instance which can be used to get information about breakpoints
+   */
+  onChange(t) {
+    this.onChangeCallbacks.push(t);
+  }
+  /**
+   * Remove change callback
+   * @param {Function} callback Function to remove
+   */
+  removeOnChange(t) {
+    c(this.onChangeCallbacks, t);
+  }
+  /**
+   * Get breakpoint from a pseudo element
+   */
+  getBreakpointInPseudo() {
+    return window.getComputedStyle(this.element, this.pseudoSelector).content.replace(/^"|"$/g, "");
+  }
+  /**
+   * Get breakpoint from a custom property
+   */
+  getBreakpointInProperty() {
+    return getComputedStyle(this.element).getPropertyValue(this.customProperty).trim();
+  }
+  /**
+   * Get breakpoint from element (design note: user could override prototype)
+   */
+  getBreakpoint() {
+    return this.valueFromPseudo ? this.getBreakpointInPseudo() : this.getBreakpointInProperty();
+  }
+  /**
+   * Updates the active breakpoint by checking the element and executes handlers on change
+   */
+  update() {
+    const t = this.getBreakpoint();
+    if (!t) {
+      f(this, "Unable to get current breakpoint, maybe order is incorrect? Breakpoint check skipped!");
+      return;
+    }
+    if (t === this.active) return;
+    this.previous = this.active, this.previousIndex = this.activeIndex;
+    const e = this.order.indexOf(t);
+    this.active = t, this.activeIndex = e, this.order.forEach((o, n) => {
+      const a = this.breakpoints[o], h = this.activeIndex;
+      a._setDirection("min", n <= h), a._setDirection("max", n > h), a._setDirection("only", n === h);
+    }), this.previousIndex !== null && (this.resizeDirection = this.previousIndex < e ? "up" : "down"), this.onChangeCallbacks.forEach((o) => o(this));
+  }
+  /**
+   * Get a breakpoint by key
+   * @param {String} name The name of the breakpoint to get
+   * @return {Breakpoint} Breakpoint to act on (see Breakpoint class)
+   */
+  at(t) {
+    const e = this.breakpoints[t];
+    return t || f(this, "Unable to find breakpoint for:", e), e;
+  }
+};
+r(i, "instances", []), r(i, "globalsInitialized", !1), r(i, "defaults", {
+  element: document == null ? void 0 : document.documentElement,
+  valueFromPseudo: !1,
+  customProperty: "--breakpoint",
+  customProperty: b("cssvarPrefix", y),
+  pseudoSelector: ":before",
+  order: ["none", "small", "medium", "large"],
+  debug: !1
+});
+let m = i;
+class l {
+  constructor(t, e) {
+    this.direction = t, this.active = !1, this.on = [], this.off = [], this.breakpoint = e;
+  }
+  /**
+   * Change the state of the direction
+   */
+  change(t) {
+    this.active !== t && (t ? this._call(!0) : this.active && this._call(!1), this.active = t);
+  }
+  /**
+   * Calls all functions in handlers or
+   */
+  _call(t) {
+    (t ? this.on : this.off).forEach((o) => o()), d(this.breakpoint._manager, `Handlers called (${t ? "on" : "off"}): ${this.direction}`);
+  }
+  /**
+   * Returns handlers in normalized object format on/off
+   */
+  getHandlers(t) {
+    return typeof t != "object" ? { on: t } : t;
+  }
+  /**
+   * Adds a handler for the direction, optionally use object to add off state handler
+   * @param {Function|Object} handler Function to be executed when direction is active, read object description for on/off
+   * @param {Function|Object} handler.on Function to be executed when direction is active
+   * @param {Function|Object} handler.off Function to be executed when direction was active and is now changed to inactive
+   */
+  add(t) {
+    const e = this.getHandlers(t);
+    e.on && this.on.push(e.on), e.off && this.off.push(e.off), this.active && e.on && (e.on(), d(this.breakpoint._manager, `Handler called immediately: ${this.direction}`, e.on));
+  }
+  /**
+   * Removes a handler
+   */
+  remove(t) {
+    const e = this.getHandlers(t);
+    e.on && c(this.on, e.on), e.off && c(this.off, e.off);
+  }
+}
+class x {
+  constructor(t, e) {
+    this.directions = {
+      max: new l("max", this),
+      min: new l("min", this),
+      only: new l("only", this)
+    }, this._manager = e, this.name = t;
+  }
+  /**
+   * Private method used inrternally for managing direction activation
+   * - Each direction manages it's own state and handlers
+   * @param {String} direction The directional key
+   * @param {Boolean} active State of that direction to set
+   */
+  _setDirection(t, e) {
+    this.directions[t].change(e);
+  }
+  /**
+   * Attach handler to be executed from the breakpoint and to all breakpoints below (inclusive).
+   * This corresponds to a `max-width` media query in SCSS.
+   * @param {Function} handler Handler to be executed
+   */
+  max(t) {
+    this.directions.max.add(t);
+  }
+  /**
+   * Attach handler to be executed from the breakpoint and to all breakpoints above (inclusive).
+   * This corresponds to a `min-width` media query in SCSS.
+   * @param {Function} handler Handler to be executed
+   */
+  min(t) {
+    this.directions.min.add(t);
+  }
+  /**
+   * Attach a handler to fire when the breakpoint is within the key
+   * @param {Function} handler Handler to be executed
+   */
+  only(t) {
+    this.directions.only.add(t);
+  }
+  /**
+   * Remove handler
+   * @param {Function} handler Handler to be removed, extended on/off object style can be used
+   * @param {String} direction Remove handler only from specified direction, else search all directions
+   */
+  remove(t, e) {
+    (e ? [e] : ["max", "min", "only"]).forEach((n) => {
+      this.directions[n] && this.directions[n].remove(t);
+    });
+  }
+  log(...t) {
+    t.unshift(`Breakpoint (${this.name}):`), this._manager.log.apply(this._manager, t);
+  }
+}
+export {
+  m as BreakpointManager
+};

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

@@ -34,17 +34,38 @@ export class Collapsible {
     constructor(elements: {
         trigger: Node;
         content: Node;
-    }, config: any);
+    }, config: Object);
     elements: {
         trigger: Node;
         content: Node;
-    };
-    options: any;
-    isOpen: boolean;
-    handlers: {};
+    } | undefined;
+    options: ({
+        clickOutsideCloses: boolean;
+        focusoutCloses: boolean;
+        escapeCloses: boolean;
+        /**
+         * The module won't attach the handlers (you need to do it yourself)
+         */
+        selfManaged: boolean;
+        /**
+         * This collapsible starts in open state
+         */
+        startOpen: boolean;
+        /**
+         * Open/active state class
+         */
+        openClass: string;
+        /**
+         * Output debug info
+         */
+        debug: boolean;
+        onChange(_ctx: any): void;
+    } & Object) | undefined;
+    isOpen: boolean | undefined;
+    handlers: {} | undefined;
     attachHandlers(): void;
-    clickHandler: (event: any) => void;
-    focusoutHandler: (event: any) => void;
+    clickHandler: ((event: any) => void) | undefined;
+    focusoutHandler: ((event: any) => void) | undefined;
     removeHandlers(): void;
     onClick(event: any): void;
     destroy(): void;

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

@@ -0,0 +1 @@
+{"version":3,"file":"collapsible.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/collapsible.js"],"names":[],"mappings":"AAQA;;GAEG;AACH;IACE;;;;QAME;;WAEG;;QAGH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;;MAKH;IACF;;;;;;OAMG;IACH,sBALG;QAAuB,OAAO,EAAtB,IAAI;QACW,OAAO,EAAtB,IAAI;KACZ,UAAQ,MAAM,EAqBhB;IAXC;iBAZS,IAAI;iBACJ,IAAI;kBAWW;IACxB;;;;QApCA;;WAEG;;QAGH;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;;4BAqBmB;IACtB,4BAAmB;IACnB,yBAAkB;IASpB,uBAoBC;IAjBC,iDAEC;IACD,oDAWC;IAIH,uBAIC;IACD,0BAEC;IACD,gBAGC;IACD,+BAIC;IACD,cAOC;IACD,sDAEC;IACD,wCAqBC;IACD;;OAEG;IACH,+BAoBC;IACD;;OAEG;IACH,iCAQC;IACD,uBAEC;IACD,wBAEC;IACD,yBAEC;CAqBF"}

package/dist/es/ui/collapsible.js

@@ -0,0 +1,140 @@
+var f = Object.defineProperty;
+var p = (r, t, e) => t in r ? f(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var d = (r, t, e) => p(r, typeof t != "symbol" ? t + "" : t, e);
+import { getUluEventName as v } from "../core/events.js";
+import { logError as k, log as E } from "../utils/class-logger.js";
+import { ensureId as h } from "../utils/id.js";
+const l = class l {
+  /**
+   * @param {Object} elements Elements object 
+   * @param {Node} elements.trigger Trigger button/element that opens/closes collapsible
+   * @param {Node} elements.content The content element that the trigger reveals
+   * @param {Object} config Configuration options (see defaults)
+   * @returns {Object} Collapsible instance
+   */
+  constructor(t, e) {
+    const { trigger: s, content: n } = t;
+    if (!s || !n) {
+      k(this, "missing required elements (trigger or content)");
+      return;
+    }
+    const i = Object.assign({}, l.defaults, e);
+    this.elements = t, this.options = i, this.isOpen = !1, this.handlers = {}, h(s), h(n), this.debugLog(this, this), i.selfManaged || this.attachHandlers(), this.setup();
+  }
+  attachHandlers() {
+    const { trigger: t, content: e } = this.elements, { focusoutCloses: s } = this.options;
+    this.clickHandler = (n) => {
+      this.onClick(n);
+    }, this.focusoutHandler = (n) => {
+      s && document.addEventListener("focusin", () => {
+        e.contains(document.activeElement) || this.close(n);
+      }, { once: !0 });
+    }, t.addEventListener("click", this.clickHandler), e.addEventListener("focusout", this.focusoutHandler);
+  }
+  removeHandlers() {
+    const { trigger: t, content: e } = this.elements;
+    t.removeEventListener("click", this.clickHandler), e.removeEventListener("focusout", this.focusoutHandler);
+  }
+  onClick(t) {
+    this.toggle(t);
+  }
+  destroy() {
+    this.removeHandlers(), this.destroyTemporaryHandlers();
+  }
+  debugLog(...t) {
+    this.options.debug && E(this, ...t);
+  }
+  setup() {
+    const { trigger: t, content: e } = this.elements, { startOpen: s } = this.options;
+    t.setAttribute("role", "button"), t.setAttribute("aria-controls", e.id), e.setAttribute("aria-labelledby", t.id), this.setState(s);
+  }
+  createEvent(t, e) {
+    return new CustomEvent(v("collapsible:" + t), { detail: e });
+  }
+  setState(t, e) {
+    const s = {
+      collapsible: this,
+      isOpen: t,
+      event: e
+    };
+    this.debugLog(this, "Set state", s);
+    const { trigger: n, content: i } = this.elements, { openClass: c } = this.options, o = (a) => a.classList[t ? "add" : "remove"](c);
+    n.setAttribute("aria-expanded", t ? "true" : "false"), o(n), o(i), this.isOpen = t, this.options.onChange(s), n.dispatchEvent(this.createEvent("change", s)), t ? this.setupTemporaryHandlers() : this.destroyTemporaryHandlers();
+  }
+  /**
+   * Setup handlers needed for closing once open
+   */
+  setupTemporaryHandlers() {
+    const { content: t, trigger: e } = this.elements, { clickOutsideCloses: s, escapeCloses: n } = this.options, i = (o) => {
+      const { target: a } = o, m = e.contains(a), g = t.contains(a);
+      s && !m && !g && this.close(o);
+    }, c = (o) => {
+      n && o.key === "Escape" && this.close(o);
+    };
+    document.addEventListener("click", i), document.addEventListener("keydown", c), this.handlers.onDocumentClick = i, this.handlers.onDocumentKeydown = c;
+  }
+  /**
+   * Destroy handlers attached for closing once open
+   */
+  destroyTemporaryHandlers() {
+    const { onDocumentClick: t, onDocumentKeydown: e } = this.handlers;
+    t && document.removeEventListener("click", t), t && document.removeEventListener("keydown", e);
+  }
+  open(t) {
+    this.setState(!0, t);
+  }
+  close(t) {
+    this.setState(!1, t);
+  }
+  toggle(t) {
+    this.setState(!this.isOpen, t);
+  }
+  // This is removed because I think it's not useful, users should keep references
+  // Static Methods for managing instances of this class
+  // static instances = [];
+  // /**
+  //  * Get collapsible instance by trigger element
+  //  * @param {Node|String} trigger Trigger node or trigger ID
+  //  */
+  // static getInstance(trigger) {
+  //   return Collapsible.instances.find(c => typeof trigger === "string" ? 
+  //     c.elements.trigger.id === trigger : 
+  //     c.elements.trigger === trigger
+  //   );
+  // }
+  // static removeInstance(instance) {
+  //   const index = Collapsible.instances.findIndex(c => c === instance);
+  //   if (index > -1) {
+  //     Collapsible.instances.splice(index, 1);
+  //   }
+  // }
+};
+d(l, "defaults", {
+  clickOutsideCloses: !1,
+  // oneOpenPerContext: false, // This should be another module that manages instances within a context (accordions)
+  // clickWithinCloses: false, // Not sure how this was used but seems like it should be separate
+  focusoutCloses: !1,
+  escapeCloses: !1,
+  /**
+   * The module won't attach the handlers (you need to do it yourself)
+   */
+  selfManaged: !1,
+  /**
+   * This collapsible starts in open state
+   */
+  startOpen: !1,
+  /**
+   * Open/active state class
+   */
+  openClass: "is-active",
+  /**
+   * Output debug info
+   */
+  debug: !0,
+  onChange(t) {
+  }
+});
+let u = l;
+export {
+  u as Collapsible
+};

package/{types → dist/es}/ui/details-group.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
@@ -34,5 +35,4 @@ export type DetailsGroupInstance = {
      */
     setupChildren: Function;
 };
-import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=details-group.d.ts.map

package/dist/es/ui/details-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"details-group.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/details-group.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,6BASC;AAED;;;;;GAKG;AAEH;;;;;GAKG;AACH,oCAJW,WAAW,qBAET,oBAAoB,CAgEhC;AAxGD;;GAEG;AACH,+CAGG;;;;;;;;;aA0BW,WAAW;;;;;;qCAlCY,sBAAsB"}

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

@@ -0,0 +1,49 @@
+import { ComponentInitializer as p } from "../core/component.js";
+const s = new p({
+  type: "details-group",
+  baseAttribute: "data-ulu-details-group"
+}), u = s.getAttribute("child-init"), f = {
+  onlyOneOpen: !0,
+  childSelector: ":scope > details"
+};
+function b() {
+  s.init({
+    withData: !0,
+    coreEvents: ["pageModified"],
+    setup({ element: e, data: n, initialize: r }) {
+      d(e, n), r();
+    }
+  });
+}
+function d(e, n) {
+  const r = Object.assign({}, f, n);
+  try {
+    c();
+  } catch (t) {
+    console.error(t);
+  }
+  function i() {
+    return e.querySelectorAll(r.childSelector);
+  }
+  function c() {
+    i().forEach((t) => {
+      t.hasAttribute(u) || (t.setAttribute(u, ""), t.addEventListener("toggle", a));
+    });
+  }
+  function a({ target: t }) {
+    r.onlyOneOpen && t.open && i().forEach((o) => {
+      o !== t && o.open && (o.open = !1);
+    });
+  }
+  function l() {
+    i().forEach((t) => {
+      t.removeEventListener("toggle", a), t.removeAttribute(u);
+    }), e.removeAttribute(s.getAttribute("init"));
+  }
+  return { destroy: l, element: e, setupChildren: c };
+}
+export {
+  b as init,
+  s as initializer,
+  d as setupGroup
+};

package/{types → dist/es}/ui/dialog.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
@@ -23,7 +24,7 @@ export function setupDialog(dialog: Node, userOptions: any): void;
  * @param {Node} dialog
  * @returns {Object}
  */
-export function getDialogOptions(dialog: Node): any;
+export function getDialogOptions(dialog: Node): Object;
 /**
  * Base attribute for a dialog
  */
@@ -44,5 +45,4 @@ export namespace defaults {
     let preventScroll: boolean;
     let preventScrollShift: boolean;
 }
-import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=dialog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dialog.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/dialog.js"],"names":[],"mappings":"AA6DA;;GAEG;AACH,qCAFW,MAAM,QAIhB;AAED;;;GAGG;AACH,6BAqBC;AAED;;;;GAIG;AACH,sCAHW,IAAI,0BA2Bd;AAED;;;GAGG;AACH,oCAFW,IAAI,0BA6Dd;AAED;;;;GAIG;AACH,yCAHW,IAAI,GACF,MAAM,CAIlB;AA7LD;;GAEG;AACH,4BAA6B,iBAAiB,CAAC;AAE/C;;GAEG;AACH,+CAAuF;AAEvF;;GAEG;AACH,oCAAgE;;;;;;;;;qCAjB3B,sBAAsB"}

package/dist/es/ui/dialog.js

@@ -0,0 +1,112 @@
+import { getUluEventName as f } from "../core/events.js";
+import { ComponentInitializer as v } from "../core/component.js";
+import { preventScroll as h, wasClickOutside as E } from "@ulu/utils/browser/dom.js";
+import { prepVideos as O, pauseVideos as S } from "../utils/pause-youtube-video.js";
+const b = "data-ulu-dialog", i = new v({ type: "dialog", baseAttribute: b }), F = i.getAttribute("close"), V = {
+  /**
+   * Use non-modal interface for dialog
+   */
+  nonModal: !1,
+  /**
+   * Move the dialog to the document end (hoist out of content)
+   * - helpful if dialogs are within editor body, etc
+   */
+  documentEnd: !1,
+  /**
+   * Requires styling that reduces any padding/border on dialog
+   */
+  clickOutsideCloses: !0,
+  /**
+   * Whether or not to pause videos when dialog closes (currently just youtube and native)
+   */
+  pauseVideos: !0,
+  /**
+   * When open and not non-modal, the body is prevented from scrolling (defaults to true).
+   */
+  preventScroll: !0,
+  /**
+   * Compensate for layout shift when preventing scroll. Which adds padding equal to scrollbars 
+   * width while dialog is open
+   */
+  preventScrollShift: !0
+};
+let a = { ...V };
+function R(e) {
+  a = Object.assign({}, a, e);
+}
+function T() {
+  i.init({
+    coreEvents: ["pageModified"],
+    withData: !0,
+    setup({ element: e, initialize: s, data: t }) {
+      C(e, t), s();
+    }
+  }), i.init({
+    key: "trigger",
+    coreEvents: ["pageModified"],
+    withData: !0,
+    setup({ element: e, initialize: s, data: t }) {
+      w(e, t), s();
+    }
+  });
+}
+function w(e, s) {
+  e.addEventListener("click", t);
+  function t(r) {
+    var c;
+    r.target.closest("a") && r.preventDefault();
+    const o = document.getElementById(s);
+    if (!o) {
+      console.error("Could not locate dialog (id)", s);
+      return;
+    }
+    if (((c = o == null ? void 0 : o.tagName) == null ? void 0 : c.toLowerCase()) !== "dialog") {
+      console.error("Attempted to trigger non <dialog> element. Did you mean to use modal builder?");
+      return;
+    }
+    const u = D(o);
+    o[u.nonModal ? "show" : "showModal"]();
+  }
+}
+function C(e, s) {
+  const t = Object.assign({}, a, s), r = document.body, { preventScrollShift: d } = t;
+  let o;
+  if (e.addEventListener(f("resizer:start"), c), e.addEventListener(f("resizer:end"), m), e.addEventListener("click", u), t.documentEnd && r.appendChild(e), t.pauseVideos && k(e), !t.nonModal && t.preventScroll) {
+    let n;
+    e.addEventListener("toggle", (l) => {
+      l.newState === "open" ? n = h({ preventShift: d }) : n && n();
+    });
+  }
+  function u(n) {
+    const { target: l } = n, p = l === e, g = l.closest(i.attributeSelector("close"));
+    (!o && t.clickOutsideCloses && p && E(e, n) || g) && (t.pauseVideos && L(e), e.close());
+  }
+  function c(n) {
+    o = n.pointerId;
+  }
+  function m(n) {
+    o === n.pointerId && setTimeout(() => {
+      o = null;
+    }, 0);
+  }
+}
+function D(e) {
+  return Object.assign({}, a, i.getData(e));
+}
+function k(e) {
+  O(e);
+}
+function L(e) {
+  S(e), e.querySelectorAll("video").forEach((t) => t.pause());
+}
+export {
+  b as baseAttribute,
+  F as closeAttribute,
+  V as defaults,
+  D as getDialogOptions,
+  T as init,
+  i as initializer,
+  R as setDefaults,
+  C as setupDialog,
+  w as setupTrigger
+};

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

@@ -1,3 +1,4 @@
+import { ComponentInitializer } from '../core/component.js';
 /**
  * Initialize flipcards using data-ulu-flipcard attribute
  */
@@ -47,5 +48,4 @@ export class Flipcard {
     containerCss(): string;
     panelCss(zIndex?: number): string;
 }
-import { ComponentInitializer } from "../utils/system.js";
 //# sourceMappingURL=flipcard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flipcard.d.ts","sourceRoot":"","sources":["../../../lib/js/ui/flipcard.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,6BAYC;AAvBD;;GAEG;AACH,+CAGG;AAmBH;;GAEG;AACH;IACE,wBAAsB;IACtB;;OAEG;IACH;;;;;;;MAOE;IACF,gEAgBC;IAZC,aAA2D;IAK3D;;;;MAA0C;IAC1C,gBAAmB;IACnB,YAA6D;IAC7D,kBAA0D;IAK5D,eAEC;IACD,cAqCC;IACD;;;OAGG;IACH;;aAQC;IACD,0BAGC;IACD,+BAIC;IACD,kCASC;IACD,uBAWC;IACD,kCAKC;CACF;qCAzJoC,sBAAsB"}