@venite/components 0.16.33 → 0.16.36

package/dist/esm/index-7a608887.js

@@ -0,0 +1,312 @@
+import { MENU_BACK_BUTTON_PRIORITY } from './hardware-back-button-fa04d6e9.js';
+import { c as componentOnReady } from './helpers-af86adf0.js';
+import { g as getIonMode } from './ionic-global-24253941.js';
+import { c as createAnimation } from './animation-fa1c28fc.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-ac6e5d74.js

@@ -0,0 +1,34 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Logs a warning to the console with an Ionic prefix
+ * to indicate the library that is warning the developer.
+ *
+ * @param message - The string message to be logged to the console.
+ */
+const printIonWarning = (message, ...params) => {
+  return console.warn(`[Ionic Warning]: ${message}`, ...params);
+};
+/*
+ * Logs an error to the console with an Ionic prefix
+ * to indicate the library that is warning the developer.
+ *
+ * @param message - The string message to be logged to the console.
+ * @param params - Additional arguments to supply to the console.error.
+ */
+const printIonError = (message, ...params) => {
+  return console.error(`[Ionic Error]: ${message}`, ...params);
+};
+/**
+ * Prints an error informing developers that an implementation requires an element to be used
+ * within a specific selector.
+ *
+ * @param el The web component element this is requiring the element.
+ * @param targetSelectors The selector or selectors that were not found.
+ */
+const printRequiredElementError = (el, ...targetSelectors) => {
+  return console.error(`<${el.tagName.toLowerCase()}> must be used inside ${targetSelectors.join(' or ')}.`);
+};
+
+export { printRequiredElementError as a, printIonWarning as b, printIonError as p };

package/dist/esm/index-be6112f8.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-ef8020d2.js

@@ -0,0 +1,184 @@
+import { u as now, q as pointerCoord } from './helpers-af86adf0.js';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const startTapClick = (config) => {
+  let lastTouch = -MOUSE_WAIT * 10;
+  let lastActivated = 0;
+  let activatableEle;
+  let activeRipple;
+  let activeDefer;
+  const useRippleEffect = config.getBoolean('animated', true) && config.getBoolean('rippleEffect', true);
+  const clearDefers = new WeakMap();
+  // Touch Events
+  const onTouchStart = (ev) => {
+    lastTouch = now(ev);
+    pointerDown(ev);
+  };
+  const onTouchEnd = (ev) => {
+    lastTouch = now(ev);
+    pointerUp(ev);
+  };
+  const onMouseDown = (ev) => {
+    // Ignore right clicks
+    if (ev.button === 2) {
+      return;
+    }
+    const t = now(ev) - MOUSE_WAIT;
+    if (lastTouch < t) {
+      pointerDown(ev);
+    }
+  };
+  const onMouseUp = (ev) => {
+    const t = now(ev) - MOUSE_WAIT;
+    if (lastTouch < t) {
+      pointerUp(ev);
+    }
+  };
+  const cancelActive = () => {
+    clearTimeout(activeDefer);
+    activeDefer = undefined;
+    if (activatableEle) {
+      removeActivated(false);
+      activatableEle = undefined;
+    }
+  };
+  const pointerDown = (ev) => {
+    if (activatableEle) {
+      return;
+    }
+    setActivatedElement(getActivatableTarget(ev), ev);
+  };
+  const pointerUp = (ev) => {
+    setActivatedElement(undefined, ev);
+  };
+  const setActivatedElement = (el, ev) => {
+    // do nothing
+    if (el && el === activatableEle) {
+      return;
+    }
+    clearTimeout(activeDefer);
+    activeDefer = undefined;
+    const { x, y } = pointerCoord(ev);
+    // deactivate selected
+    if (activatableEle) {
+      if (clearDefers.has(activatableEle)) {
+        throw new Error('internal error');
+      }
+      if (!activatableEle.classList.contains(ACTIVATED)) {
+        addActivated(activatableEle, x, y);
+      }
+      removeActivated(true);
+    }
+    // activate
+    if (el) {
+      const deferId = clearDefers.get(el);
+      if (deferId) {
+        clearTimeout(deferId);
+        clearDefers.delete(el);
+      }
+      const delay = isInstant(el) ? 0 : ADD_ACTIVATED_DEFERS;
+      el.classList.remove(ACTIVATED);
+      activeDefer = setTimeout(() => {
+        addActivated(el, x, y);
+        activeDefer = undefined;
+      }, delay);
+    }
+    activatableEle = el;
+  };
+  const addActivated = (el, x, y) => {
+    lastActivated = Date.now();
+    el.classList.add(ACTIVATED);
+    const rippleEffect = useRippleEffect && getRippleEffect(el);
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (rippleEffect && rippleEffect.addRipple) {
+      removeRipple();
+      activeRipple = rippleEffect.addRipple(x, y);
+    }
+  };
+  const removeRipple = () => {
+    if (activeRipple !== undefined) {
+      activeRipple.then((remove) => remove());
+      activeRipple = undefined;
+    }
+  };
+  const removeActivated = (smooth) => {
+    removeRipple();
+    const active = activatableEle;
+    if (!active) {
+      return;
+    }
+    const time = CLEAR_STATE_DEFERS - Date.now() + lastActivated;
+    if (smooth && time > 0 && !isInstant(active)) {
+      const deferId = setTimeout(() => {
+        active.classList.remove(ACTIVATED);
+        clearDefers.delete(active);
+      }, CLEAR_STATE_DEFERS);
+      clearDefers.set(active, deferId);
+    }
+    else {
+      active.classList.remove(ACTIVATED);
+    }
+  };
+  const doc = document;
+  doc.addEventListener('ionGestureCaptured', cancelActive);
+  doc.addEventListener('touchstart', onTouchStart, true);
+  doc.addEventListener('touchcancel', onTouchEnd, true);
+  doc.addEventListener('touchend', onTouchEnd, true);
+  /**
+   * Tap click effects such as the ripple effect should
+   * not happen when scrolling. For example, if a user scrolls
+   * the page but also happens to do a touchstart on a button
+   * as part of the scroll, the ripple effect should not
+   * be dispatched. The ripple effect should only happen
+   * if the button is activated and the page is not scrolling.
+   *
+   * pointercancel is dispatched on a gesture when scrolling
+   * starts, so this lets us avoid having to listen for
+   * ion-content's scroll events.
+   */
+  doc.addEventListener('pointercancel', cancelActive, true);
+  doc.addEventListener('mousedown', onMouseDown, true);
+  doc.addEventListener('mouseup', onMouseUp, true);
+};
+const getActivatableTarget = (ev) => {
+  if (ev.composedPath) {
+    /**
+     * composedPath returns EventTarget[]. However,
+     * objects other than Element can be targets too.
+     * For example, AudioContext can be a target. In this
+     * case, we know that the event is a UIEvent so we
+     * can assume that the path will contain either Element
+     * or ShadowRoot.
+     */
+    const path = ev.composedPath();
+    for (let i = 0; i < path.length - 2; i++) {
+      const el = path[i];
+      if (!(el instanceof ShadowRoot) && el.classList.contains('ion-activatable')) {
+        return el;
+      }
+    }
+  }
+  else {
+    return ev.target.closest('.ion-activatable');
+  }
+};
+const isInstant = (el) => {
+  return el.classList.contains('ion-activatable-instant');
+};
+const getRippleEffect = (el) => {
+  if (el.shadowRoot) {
+    const ripple = el.shadowRoot.querySelector('ion-ripple-effect');
+    if (ripple) {
+      return ripple;
+    }
+  }
+  return el.querySelector('ion-ripple-effect');
+};
+const ACTIVATED = 'ion-activated';
+const ADD_ACTIVATED_DEFERS = 200;
+const CLEAR_STATE_DEFERS = 200;
+const MOUSE_WAIT = 2500;
+
+export { startTapClick };