@pod-os/elements 0.7.1-92705ee.0 → 0.7.1-a71f01c.0

package/dist/esm/index-2be9a18b.js

@@ -0,0 +1,312 @@
+import { MENU_BACK_BUTTON_PRIORITY } from './hardware-back-button-242191a7.js';
+import { c as componentOnReady } from './helpers-aeff219b.js';
+import { g as getIonMode } from './ionic-global-6cd57191.js';
+import { c as createAnimation } from './animation-801a007a.js';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * baseAnimation
+ * Base class which is extended by the various types. Each
+ * type will provide their own animations for open and close
+ * and registers itself with Menu.
+ */
+const baseAnimation = (isIos) => {
+  // https://material.io/guidelines/motion/movement.html#movement-movement-in-out-of-screen-bounds
+  // https://material.io/guidelines/motion/duration-easing.html#duration-easing-natural-easing-curves
+  /**
+   * "Apply the sharp curve to items temporarily leaving the screen that may return
+   * from the same exit point. When they return, use the deceleration curve. On mobile,
+   * this transition typically occurs over 300ms" -- MD Motion Guide
+   */
+  return createAnimation().duration(isIos ? 400 : 300);
+};
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Menu Overlay Type
+ * The menu slides over the content. The content
+ * itself, which is under the menu, does not move.
+ */
+const menuOverlayAnimation = (menu) => {
+  let closedX;
+  let openedX;
+  const width = menu.width + 8;
+  const menuAnimation = createAnimation();
+  const backdropAnimation = createAnimation();
+  if (menu.isEndSide) {
+    // right side
+    closedX = width + 'px';
+    openedX = '0px';
+  }
+  else {
+    // left side
+    closedX = -width + 'px';
+    openedX = '0px';
+  }
+  menuAnimation.addElement(menu.menuInnerEl).fromTo('transform', `translateX(${closedX})`, `translateX(${openedX})`);
+  const mode = getIonMode(menu);
+  const isIos = mode === 'ios';
+  const opacity = isIos ? 0.2 : 0.25;
+  backdropAnimation.addElement(menu.backdropEl).fromTo('opacity', 0.01, opacity);
+  return baseAnimation(isIos).addAnimation([menuAnimation, backdropAnimation]);
+};
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Menu Push Type
+ * The content slides over to reveal the menu underneath.
+ * The menu itself also slides over to reveal its bad self.
+ */
+const menuPushAnimation = (menu) => {
+  let contentOpenedX;
+  let menuClosedX;
+  const mode = getIonMode(menu);
+  const width = menu.width;
+  if (menu.isEndSide) {
+    contentOpenedX = -width + 'px';
+    menuClosedX = width + 'px';
+  }
+  else {
+    contentOpenedX = width + 'px';
+    menuClosedX = -width + 'px';
+  }
+  const menuAnimation = createAnimation()
+    .addElement(menu.menuInnerEl)
+    .fromTo('transform', `translateX(${menuClosedX})`, 'translateX(0px)');
+  const contentAnimation = createAnimation()
+    .addElement(menu.contentEl)
+    .fromTo('transform', 'translateX(0px)', `translateX(${contentOpenedX})`);
+  const backdropAnimation = createAnimation().addElement(menu.backdropEl).fromTo('opacity', 0.01, 0.32);
+  return baseAnimation(mode === 'ios').addAnimation([menuAnimation, contentAnimation, backdropAnimation]);
+};
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Menu Reveal Type
+ * The content slides over to reveal the menu underneath.
+ * The menu itself, which is under the content, does not move.
+ */
+const menuRevealAnimation = (menu) => {
+  const mode = getIonMode(menu);
+  const openedX = menu.width * (menu.isEndSide ? -1 : 1) + 'px';
+  const contentOpen = createAnimation()
+    .addElement(menu.contentEl) // REVIEW
+    .fromTo('transform', 'translateX(0px)', `translateX(${openedX})`);
+  return baseAnimation(mode === 'ios').addAnimation(contentOpen);
+};
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const createMenuController = () => {
+  const menuAnimations = new Map();
+  const menus = [];
+  const open = async (menu) => {
+    const menuEl = await get(menu);
+    if (menuEl) {
+      return menuEl.open();
+    }
+    return false;
+  };
+  const close = async (menu) => {
+    const menuEl = await (menu !== undefined ? get(menu) : getOpen());
+    if (menuEl !== undefined) {
+      return menuEl.close();
+    }
+    return false;
+  };
+  const toggle = async (menu) => {
+    const menuEl = await get(menu);
+    if (menuEl) {
+      return menuEl.toggle();
+    }
+    return false;
+  };
+  const enable = async (shouldEnable, menu) => {
+    const menuEl = await get(menu);
+    if (menuEl) {
+      menuEl.disabled = !shouldEnable;
+    }
+    return menuEl;
+  };
+  const swipeGesture = async (shouldEnable, menu) => {
+    const menuEl = await get(menu);
+    if (menuEl) {
+      menuEl.swipeGesture = shouldEnable;
+    }
+    return menuEl;
+  };
+  const isOpen = async (menu) => {
+    if (menu != null) {
+      const menuEl = await get(menu);
+      // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+      return menuEl !== undefined && menuEl.isOpen();
+    }
+    else {
+      const menuEl = await getOpen();
+      return menuEl !== undefined;
+    }
+  };
+  const isEnabled = async (menu) => {
+    const menuEl = await get(menu);
+    if (menuEl) {
+      return !menuEl.disabled;
+    }
+    return false;
+  };
+  const get = async (menu) => {
+    await waitUntilReady();
+    if (menu === 'start' || menu === 'end') {
+      // there could be more than one menu on the same side
+      // so first try to get the enabled one
+      const menuRef = find((m) => m.side === menu && !m.disabled);
+      if (menuRef) {
+        return menuRef;
+      }
+      // didn't find a menu side that is enabled
+      // so try to get the first menu side found
+      return find((m) => m.side === menu);
+    }
+    else if (menu != null) {
+      // the menuId was not left or right
+      // so try to get the menu by its "id"
+      return find((m) => m.menuId === menu);
+    }
+    // return the first enabled menu
+    const menuEl = find((m) => !m.disabled);
+    if (menuEl) {
+      return menuEl;
+    }
+    // get the first menu in the array, if one exists
+    return menus.length > 0 ? menus[0].el : undefined;
+  };
+  /**
+   * Get the instance of the opened menu. Returns `null` if a menu is not found.
+   */
+  const getOpen = async () => {
+    await waitUntilReady();
+    return _getOpenSync();
+  };
+  /**
+   * Get all menu instances.
+   */
+  const getMenus = async () => {
+    await waitUntilReady();
+    return getMenusSync();
+  };
+  /**
+   * Get whether or not a menu is animating. Returns `true` if any
+   * menu is currently animating.
+   */
+  const isAnimating = async () => {
+    await waitUntilReady();
+    return isAnimatingSync();
+  };
+  const registerAnimation = (name, animation) => {
+    menuAnimations.set(name, animation);
+  };
+  const _register = (menu) => {
+    if (menus.indexOf(menu) < 0) {
+      if (!menu.disabled) {
+        _setActiveMenu(menu);
+      }
+      menus.push(menu);
+    }
+  };
+  const _unregister = (menu) => {
+    const index = menus.indexOf(menu);
+    if (index > -1) {
+      menus.splice(index, 1);
+    }
+  };
+  const _setActiveMenu = (menu) => {
+    // if this menu should be enabled
+    // then find all the other menus on this same side
+    // and automatically disable other same side menus
+    const side = menu.side;
+    menus.filter((m) => m.side === side && m !== menu).forEach((m) => (m.disabled = true));
+  };
+  const _setOpen = async (menu, shouldOpen, animated) => {
+    if (isAnimatingSync()) {
+      return false;
+    }
+    if (shouldOpen) {
+      const openedMenu = await getOpen();
+      if (openedMenu && menu.el !== openedMenu) {
+        await openedMenu.setOpen(false, false);
+      }
+    }
+    return menu._setOpen(shouldOpen, animated);
+  };
+  const _createAnimation = (type, menuCmp) => {
+    const animationBuilder = menuAnimations.get(type);
+    if (!animationBuilder) {
+      throw new Error('animation not registered');
+    }
+    const animation = animationBuilder(menuCmp);
+    return animation;
+  };
+  const _getOpenSync = () => {
+    return find((m) => m._isOpen);
+  };
+  const getMenusSync = () => {
+    return menus.map((menu) => menu.el);
+  };
+  const isAnimatingSync = () => {
+    return menus.some((menu) => menu.isAnimating);
+  };
+  const find = (predicate) => {
+    const instance = menus.find(predicate);
+    if (instance !== undefined) {
+      return instance.el;
+    }
+    return undefined;
+  };
+  const waitUntilReady = () => {
+    return Promise.all(Array.from(document.querySelectorAll('ion-menu')).map((menu) => new Promise((resolve) => componentOnReady(menu, resolve))));
+  };
+  registerAnimation('reveal', menuRevealAnimation);
+  registerAnimation('push', menuPushAnimation);
+  registerAnimation('overlay', menuOverlayAnimation);
+  if (typeof document !== 'undefined') {
+    document.addEventListener('ionBackButton', (ev) => {
+      const openMenu = _getOpenSync();
+      if (openMenu) {
+        ev.detail.register(MENU_BACK_BUTTON_PRIORITY, () => {
+          return openMenu.close();
+        });
+      }
+    });
+  }
+  return {
+    registerAnimation,
+    get,
+    getMenus,
+    getOpen,
+    isEnabled,
+    swipeGesture,
+    isAnimating,
+    isOpen,
+    enable,
+    toggle,
+    close,
+    open,
+    _getOpenSync,
+    _createAnimation,
+    _register,
+    _unregister,
+    _setOpen,
+    _setActiveMenu,
+  };
+};
+const menuController = /*@__PURE__*/ createMenuController();
+
+export { menuController as m };

package/dist/esm/index-51e4a829.js

@@ -0,0 +1,137 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Does a simple sanitization of all elements
+ * in an untrusted string
+ */
+const sanitizeDOMString = (untrustedString) => {
+  try {
+    if (untrustedString instanceof IonicSafeString) {
+      return untrustedString.value;
+    }
+    if (!isSanitizerEnabled() || typeof untrustedString !== 'string' || untrustedString === '') {
+      return untrustedString;
+    }
+    /**
+     * Create a document fragment
+     * separate from the main DOM,
+     * create a div to do our work in
+     */
+    const documentFragment = document.createDocumentFragment();
+    const workingDiv = document.createElement('div');
+    documentFragment.appendChild(workingDiv);
+    workingDiv.innerHTML = untrustedString;
+    /**
+     * Remove any elements
+     * that are blocked
+     */
+    blockedTags.forEach((blockedTag) => {
+      const getElementsToRemove = documentFragment.querySelectorAll(blockedTag);
+      for (let elementIndex = getElementsToRemove.length - 1; elementIndex >= 0; elementIndex--) {
+        const element = getElementsToRemove[elementIndex];
+        if (element.parentNode) {
+          element.parentNode.removeChild(element);
+        }
+        else {
+          documentFragment.removeChild(element);
+        }
+        /**
+         * We still need to sanitize
+         * the children of this element
+         * as they are left behind
+         */
+        const childElements = getElementChildren(element);
+        /* eslint-disable-next-line */
+        for (let childIndex = 0; childIndex < childElements.length; childIndex++) {
+          sanitizeElement(childElements[childIndex]);
+        }
+      }
+    });
+    /**
+     * Go through remaining elements and remove
+     * non-allowed attribs
+     */
+    // IE does not support .children on document fragments, only .childNodes
+    const dfChildren = getElementChildren(documentFragment);
+    /* eslint-disable-next-line */
+    for (let childIndex = 0; childIndex < dfChildren.length; childIndex++) {
+      sanitizeElement(dfChildren[childIndex]);
+    }
+    // Append document fragment to div
+    const fragmentDiv = document.createElement('div');
+    fragmentDiv.appendChild(documentFragment);
+    // First child is always the div we did our work in
+    const getInnerDiv = fragmentDiv.querySelector('div');
+    return getInnerDiv !== null ? getInnerDiv.innerHTML : fragmentDiv.innerHTML;
+  }
+  catch (err) {
+    console.error(err);
+    return '';
+  }
+};
+/**
+ * Clean up current element based on allowed attributes
+ * and then recursively dig down into any child elements to
+ * clean those up as well
+ */
+const sanitizeElement = (element) => {
+  // IE uses childNodes, so ignore nodes that are not elements
+  if (element.nodeType && element.nodeType !== 1) {
+    return;
+  }
+  for (let i = element.attributes.length - 1; i >= 0; i--) {
+    const attribute = element.attributes.item(i);
+    const attributeName = attribute.name;
+    // remove non-allowed attribs
+    if (!allowedAttributes.includes(attributeName.toLowerCase())) {
+      element.removeAttribute(attributeName);
+      continue;
+    }
+    // clean up any allowed attribs
+    // that attempt to do any JS funny-business
+    const attributeValue = attribute.value;
+    /* eslint-disable-next-line */
+    if (attributeValue != null && attributeValue.toLowerCase().includes('javascript:')) {
+      element.removeAttribute(attributeName);
+    }
+  }
+  /**
+   * Sanitize any nested children
+   */
+  const childElements = getElementChildren(element);
+  /* eslint-disable-next-line */
+  for (let i = 0; i < childElements.length; i++) {
+    sanitizeElement(childElements[i]);
+  }
+};
+/**
+ * IE doesn't always support .children
+ * so we revert to .childNodes instead
+ */
+const getElementChildren = (el) => {
+  return el.children != null ? el.children : el.childNodes;
+};
+const isSanitizerEnabled = () => {
+  var _a;
+  const win = window;
+  const config = (_a = win === null || win === void 0 ? void 0 : win.Ionic) === null || _a === void 0 ? void 0 : _a.config;
+  if (config) {
+    if (config.get) {
+      return config.get('sanitizerEnabled', true);
+    }
+    else {
+      return config.sanitizerEnabled === true || config.sanitizerEnabled === undefined;
+    }
+  }
+  return true;
+};
+const allowedAttributes = ['class', 'id', 'href', 'src', 'name', 'slot'];
+const blockedTags = ['script', 'style', 'iframe', 'meta', 'link', 'object', 'embed'];
+class IonicSafeString {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+export { sanitizeDOMString as s };

package/dist/esm/index-6048aed6.js

@@ -0,0 +1,224 @@
+import { w as writeTask, B as Build } from './index-cb938ffb.js';
+import { c as componentOnReady, r as raf } from './helpers-aeff219b.js';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const LIFECYCLE_WILL_ENTER = 'ionViewWillEnter';
+const LIFECYCLE_DID_ENTER = 'ionViewDidEnter';
+const LIFECYCLE_WILL_LEAVE = 'ionViewWillLeave';
+const LIFECYCLE_DID_LEAVE = 'ionViewDidLeave';
+const LIFECYCLE_WILL_UNLOAD = 'ionViewWillUnload';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const iosTransitionAnimation = () => import('./ios.transition-bbd952f2.js');
+const mdTransitionAnimation = () => import('./md.transition-5170a6d3.js');
+const transition = (opts) => {
+  return new Promise((resolve, reject) => {
+    writeTask(() => {
+      beforeTransition(opts);
+      runTransition(opts).then((result) => {
+        if (result.animation) {
+          result.animation.destroy();
+        }
+        afterTransition(opts);
+        resolve(result);
+      }, (error) => {
+        afterTransition(opts);
+        reject(error);
+      });
+    });
+  });
+};
+const beforeTransition = (opts) => {
+  const enteringEl = opts.enteringEl;
+  const leavingEl = opts.leavingEl;
+  setZIndex(enteringEl, leavingEl, opts.direction);
+  if (opts.showGoBack) {
+    enteringEl.classList.add('can-go-back');
+  }
+  else {
+    enteringEl.classList.remove('can-go-back');
+  }
+  setPageHidden(enteringEl, false);
+  /**
+   * When transitioning, the page should not
+   * respond to click events. This resolves small
+   * issues like users double tapping the ion-back-button.
+   * These pointer events are removed in `afterTransition`.
+   */
+  enteringEl.style.setProperty('pointer-events', 'none');
+  if (leavingEl) {
+    setPageHidden(leavingEl, false);
+    leavingEl.style.setProperty('pointer-events', 'none');
+  }
+};
+const runTransition = async (opts) => {
+  const animationBuilder = await getAnimationBuilder(opts);
+  const ani = animationBuilder && Build.isBrowser ? animation(animationBuilder, opts) : noAnimation(opts); // fast path for no animation
+  return ani;
+};
+const afterTransition = (opts) => {
+  const enteringEl = opts.enteringEl;
+  const leavingEl = opts.leavingEl;
+  enteringEl.classList.remove('ion-page-invisible');
+  enteringEl.style.removeProperty('pointer-events');
+  if (leavingEl !== undefined) {
+    leavingEl.classList.remove('ion-page-invisible');
+    leavingEl.style.removeProperty('pointer-events');
+  }
+};
+const getAnimationBuilder = async (opts) => {
+  if (!opts.leavingEl || !opts.animated || opts.duration === 0) {
+    return undefined;
+  }
+  if (opts.animationBuilder) {
+    return opts.animationBuilder;
+  }
+  const getAnimation = opts.mode === 'ios'
+    ? (await iosTransitionAnimation()).iosTransitionAnimation
+    : (await mdTransitionAnimation()).mdTransitionAnimation;
+  return getAnimation;
+};
+const animation = async (animationBuilder, opts) => {
+  await waitForReady(opts, true);
+  const trans = animationBuilder(opts.baseEl, opts);
+  fireWillEvents(opts.enteringEl, opts.leavingEl);
+  const didComplete = await playTransition(trans, opts);
+  if (opts.progressCallback) {
+    opts.progressCallback(undefined);
+  }
+  if (didComplete) {
+    fireDidEvents(opts.enteringEl, opts.leavingEl);
+  }
+  return {
+    hasCompleted: didComplete,
+    animation: trans,
+  };
+};
+const noAnimation = async (opts) => {
+  const enteringEl = opts.enteringEl;
+  const leavingEl = opts.leavingEl;
+  await waitForReady(opts, false);
+  fireWillEvents(enteringEl, leavingEl);
+  fireDidEvents(enteringEl, leavingEl);
+  return {
+    hasCompleted: true,
+  };
+};
+const waitForReady = async (opts, defaultDeep) => {
+  const deep = opts.deepWait !== undefined ? opts.deepWait : defaultDeep;
+  const promises = deep
+    ? [deepReady(opts.enteringEl), deepReady(opts.leavingEl)]
+    : [shallowReady(opts.enteringEl), shallowReady(opts.leavingEl)];
+  await Promise.all(promises);
+  await notifyViewReady(opts.viewIsReady, opts.enteringEl);
+};
+const notifyViewReady = async (viewIsReady, enteringEl) => {
+  if (viewIsReady) {
+    await viewIsReady(enteringEl);
+  }
+};
+const playTransition = (trans, opts) => {
+  const progressCallback = opts.progressCallback;
+  const promise = new Promise((resolve) => {
+    trans.onFinish((currentStep) => resolve(currentStep === 1));
+  });
+  // cool, let's do this, start the transition
+  if (progressCallback) {
+    // this is a swipe to go back, just get the transition progress ready
+    // kick off the swipe animation start
+    trans.progressStart(true);
+    progressCallback(trans);
+  }
+  else {
+    // only the top level transition should actually start "play"
+    // kick it off and let it play through
+    // ******** DOM WRITE ****************
+    trans.play();
+  }
+  // create a callback for when the animation is done
+  return promise;
+};
+const fireWillEvents = (enteringEl, leavingEl) => {
+  lifecycle(leavingEl, LIFECYCLE_WILL_LEAVE);
+  lifecycle(enteringEl, LIFECYCLE_WILL_ENTER);
+};
+const fireDidEvents = (enteringEl, leavingEl) => {
+  lifecycle(enteringEl, LIFECYCLE_DID_ENTER);
+  lifecycle(leavingEl, LIFECYCLE_DID_LEAVE);
+};
+const lifecycle = (el, eventName) => {
+  if (el) {
+    const ev = new CustomEvent(eventName, {
+      bubbles: false,
+      cancelable: false,
+    });
+    el.dispatchEvent(ev);
+  }
+};
+const shallowReady = (el) => {
+  if (el) {
+    return new Promise((resolve) => componentOnReady(el, resolve));
+  }
+  return Promise.resolve();
+};
+const deepReady = async (el) => {
+  const element = el;
+  if (element) {
+    if (element.componentOnReady != null) {
+      // eslint-disable-next-line custom-rules/no-component-on-ready-method
+      const stencilEl = await element.componentOnReady();
+      if (stencilEl != null) {
+        return;
+      }
+      /**
+       * Custom elements in Stencil will have __registerHost.
+       */
+    }
+    else if (element.__registerHost != null) {
+      /**
+       * Non-lazy loaded custom elements need to wait
+       * one frame for component to be loaded.
+       */
+      const waitForCustomElement = new Promise((resolve) => raf(resolve));
+      await waitForCustomElement;
+      return;
+    }
+    await Promise.all(Array.from(element.children).map(deepReady));
+  }
+};
+const setPageHidden = (el, hidden) => {
+  if (hidden) {
+    el.setAttribute('aria-hidden', 'true');
+    el.classList.add('ion-page-hidden');
+  }
+  else {
+    el.hidden = false;
+    el.removeAttribute('aria-hidden');
+    el.classList.remove('ion-page-hidden');
+  }
+};
+const setZIndex = (enteringEl, leavingEl, direction) => {
+  if (enteringEl !== undefined) {
+    enteringEl.style.zIndex = direction === 'back' ? '99' : '101';
+  }
+  if (leavingEl !== undefined) {
+    leavingEl.style.zIndex = '100';
+  }
+};
+const getIonPageElement = (element) => {
+  if (element.classList.contains('ion-page')) {
+    return element;
+  }
+  const ionPage = element.querySelector(':scope > .ion-page, :scope > ion-nav, :scope > ion-tabs');
+  if (ionPage) {
+    return ionPage;
+  }
+  // idk, return the original element so at least something animates and we don't have a null pointer
+  return element;
+};
+
+export { LIFECYCLE_WILL_UNLOAD as L, LIFECYCLE_WILL_LEAVE as a, LIFECYCLE_DID_LEAVE as b, deepReady as d, getIonPageElement as g, lifecycle as l, setPageHidden as s, transition as t };