@eodash/eodash 5.0.0-alpha.2.19 → 5.0.0-alpha.2.21

package/dist/client/eo-dash.js

@@ -1,6 +1,2 @@
-import { bN as a, bO as e, bP as o } from "./asWebComponent-CHqY8A1z.js";
-export {
-  a as Eodash,
-  e as register,
-  o as store
-};
+export { aM as Eodash, aN as register, aO as store } from './asWebComponent-6g8pz2_C.js';
+import 'vue';

package/dist/client/forwardRefs-DnXzPqIo.js

@@ -0,0 +1,245 @@
+import { shallowRef, computed, watch } from 'vue';
+import { p as propsFactory, ax as getCurrentInstance } from './asWebComponent-6g8pz2_C.js';
+
+class Box {
+  constructor(_ref) {
+    let {
+      x,
+      y,
+      width,
+      height
+    } = _ref;
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+  }
+  get top() {
+    return this.y;
+  }
+  get bottom() {
+    return this.y + this.height;
+  }
+  get left() {
+    return this.x;
+  }
+  get right() {
+    return this.x + this.width;
+  }
+}
+function getOverflow(a, b) {
+  return {
+    x: {
+      before: Math.max(0, b.left - a.left),
+      after: Math.max(0, a.right - b.right)
+    },
+    y: {
+      before: Math.max(0, b.top - a.top),
+      after: Math.max(0, a.bottom - b.bottom)
+    }
+  };
+}
+function getTargetBox(target) {
+  if (Array.isArray(target)) {
+    return new Box({
+      x: target[0],
+      y: target[1],
+      width: 0,
+      height: 0
+    });
+  } else {
+    return target.getBoundingClientRect();
+  }
+}
+
+// Utilities
+/** @see https://stackoverflow.com/a/57876601/2074736 */
+function nullifyTransforms(el) {
+  const rect = el.getBoundingClientRect();
+  const style = getComputedStyle(el);
+  const tx = style.transform;
+  if (tx) {
+    let ta, sx, sy, dx, dy;
+    if (tx.startsWith('matrix3d(')) {
+      ta = tx.slice(9, -1).split(/, /);
+      sx = +ta[0];
+      sy = +ta[5];
+      dx = +ta[12];
+      dy = +ta[13];
+    } else if (tx.startsWith('matrix(')) {
+      ta = tx.slice(7, -1).split(/, /);
+      sx = +ta[0];
+      sy = +ta[3];
+      dx = +ta[4];
+      dy = +ta[5];
+    } else {
+      return new Box(rect);
+    }
+    const to = style.transformOrigin;
+    const x = rect.x - dx - (1 - sx) * parseFloat(to);
+    const y = rect.y - dy - (1 - sy) * parseFloat(to.slice(to.indexOf(' ') + 1));
+    const w = sx ? rect.width / sx : el.offsetWidth + 1;
+    const h = sy ? rect.height / sy : el.offsetHeight + 1;
+    return new Box({
+      x,
+      y,
+      width: w,
+      height: h
+    });
+  } else {
+    return new Box(rect);
+  }
+}
+function animate(el, keyframes, options) {
+  if (typeof el.animate === 'undefined') return {
+    finished: Promise.resolve()
+  };
+  let animation;
+  try {
+    animation = el.animate(keyframes, options);
+  } catch (err) {
+    return {
+      finished: Promise.resolve()
+    };
+  }
+  if (typeof animation.finished === 'undefined') {
+    animation.finished = new Promise(resolve => {
+      animation.onfinish = () => {
+        resolve(animation);
+      };
+    });
+  }
+  return animation;
+}
+
+const standardEasing = 'cubic-bezier(0.4, 0, 0.2, 1)';
+const deceleratedEasing = 'cubic-bezier(0.0, 0, 0.2, 1)'; // Entering
+const acceleratedEasing = 'cubic-bezier(0.4, 0, 1, 1)'; // Leaving
+
+// Utilities
+const makeLazyProps = propsFactory({
+  eager: Boolean
+}, 'lazy');
+function useLazy(props, active) {
+  const isBooted = shallowRef(false);
+  const hasContent = computed(() => isBooted.value || props.eager || active.value);
+  watch(active, () => isBooted.value = true);
+  function onAfterLeave() {
+    if (!props.eager) isBooted.value = false;
+  }
+  return {
+    isBooted,
+    hasContent,
+    onAfterLeave
+  };
+}
+
+// Utilities
+function useScopeId() {
+  const vm = getCurrentInstance('useScopeId');
+  const scopeId = vm.vnode.scopeId;
+  return {
+    scopeId: scopeId ? {
+      [scopeId]: ''
+    } : undefined
+  };
+}
+
+// Types
+
+const Refs = Symbol('Forwarded refs');
+
+/** Omit properties starting with P */
+
+/** Omit keyof $props from T */
+
+function getDescriptor(obj, key) {
+  let currentObj = obj;
+  while (currentObj) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key);
+    if (descriptor) return descriptor;
+    currentObj = Object.getPrototypeOf(currentObj);
+  }
+  return undefined;
+}
+function forwardRefs(target) {
+  for (var _len = arguments.length, refs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    refs[_key - 1] = arguments[_key];
+  }
+  target[Refs] = refs;
+  return new Proxy(target, {
+    get(target, key) {
+      if (Reflect.has(target, key)) {
+        return Reflect.get(target, key);
+      }
+
+      // Skip internal properties
+      if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return;
+      for (const ref of refs) {
+        if (ref.value && Reflect.has(ref.value, key)) {
+          const val = Reflect.get(ref.value, key);
+          return typeof val === 'function' ? val.bind(ref.value) : val;
+        }
+      }
+    },
+    has(target, key) {
+      if (Reflect.has(target, key)) {
+        return true;
+      }
+
+      // Skip internal properties
+      if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return false;
+      for (const ref of refs) {
+        if (ref.value && Reflect.has(ref.value, key)) {
+          return true;
+        }
+      }
+      return false;
+    },
+    set(target, key, value) {
+      if (Reflect.has(target, key)) {
+        return Reflect.set(target, key, value);
+      }
+
+      // Skip internal properties
+      if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return false;
+      for (const ref of refs) {
+        if (ref.value && Reflect.has(ref.value, key)) {
+          return Reflect.set(ref.value, key, value);
+        }
+      }
+      return false;
+    },
+    getOwnPropertyDescriptor(target, key) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+      if (descriptor) return descriptor;
+
+      // Skip internal properties
+      if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return;
+
+      // Check each ref's own properties
+      for (const ref of refs) {
+        if (!ref.value) continue;
+        const descriptor = getDescriptor(ref.value, key) ?? ('_' in ref.value ? getDescriptor(ref.value._?.setupState, key) : undefined);
+        if (descriptor) return descriptor;
+      }
+
+      // Recursive search up each ref's prototype
+      for (const ref of refs) {
+        const childRefs = ref.value && ref.value[Refs];
+        if (!childRefs) continue;
+        const queue = childRefs.slice();
+        while (queue.length) {
+          const ref = queue.shift();
+          const descriptor = getDescriptor(ref.value, key);
+          if (descriptor) return descriptor;
+          const childRefs = ref.value && ref.value[Refs];
+          if (childRefs) queue.push(...childRefs);
+        }
+      }
+      return undefined;
+    }
+  });
+}
+
+export { Box as B, animate as a, useScopeId as b, acceleratedEasing as c, deceleratedEasing as d, getOverflow as e, forwardRefs as f, getTargetBox as g, makeLazyProps as m, nullifyTransforms as n, standardEasing as s, useLazy as u };

package/dist/client/index-14PHPf-A.js

@@ -0,0 +1,199 @@
+import { TransitionGroup, Transition, h, camelize } from 'vue';
+import { g as genericComponent, p as propsFactory } from './asWebComponent-6g8pz2_C.js';
+
+// Utilities
+const makeTransitionProps = propsFactory({
+  disabled: Boolean,
+  group: Boolean,
+  hideOnLeave: Boolean,
+  leaveAbsolute: Boolean,
+  mode: String,
+  origin: String
+}, 'transition');
+function createCssTransition(name, origin, mode) {
+  return genericComponent()({
+    name,
+    props: makeTransitionProps({
+      mode,
+      origin
+    }),
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const functions = {
+        onBeforeEnter(el) {
+          if (props.origin) {
+            el.style.transformOrigin = props.origin;
+          }
+        },
+        onLeave(el) {
+          if (props.leaveAbsolute) {
+            const {
+              offsetTop,
+              offsetLeft,
+              offsetWidth,
+              offsetHeight
+            } = el;
+            el._transitionInitialStyles = {
+              position: el.style.position,
+              top: el.style.top,
+              left: el.style.left,
+              width: el.style.width,
+              height: el.style.height
+            };
+            el.style.position = 'absolute';
+            el.style.top = `${offsetTop}px`;
+            el.style.left = `${offsetLeft}px`;
+            el.style.width = `${offsetWidth}px`;
+            el.style.height = `${offsetHeight}px`;
+          }
+          if (props.hideOnLeave) {
+            el.style.setProperty('display', 'none', 'important');
+          }
+        },
+        onAfterLeave(el) {
+          if (props.leaveAbsolute && el?._transitionInitialStyles) {
+            const {
+              position,
+              top,
+              left,
+              width,
+              height
+            } = el._transitionInitialStyles;
+            delete el._transitionInitialStyles;
+            el.style.position = position || '';
+            el.style.top = top || '';
+            el.style.left = left || '';
+            el.style.width = width || '';
+            el.style.height = height || '';
+          }
+        }
+      };
+      return () => {
+        const tag = props.group ? TransitionGroup : Transition;
+        return h(tag, {
+          name: props.disabled ? '' : name,
+          css: !props.disabled,
+          ...(props.group ? undefined : {
+            mode: props.mode
+          }),
+          ...(props.disabled ? {} : functions)
+        }, slots.default);
+      };
+    }
+  });
+}
+function createJavascriptTransition(name, functions) {
+  let mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'in-out';
+  return genericComponent()({
+    name,
+    props: {
+      mode: {
+        type: String,
+        default: mode
+      },
+      disabled: Boolean,
+      group: Boolean
+    },
+    setup(props, _ref2) {
+      let {
+        slots
+      } = _ref2;
+      const tag = props.group ? TransitionGroup : Transition;
+      return () => {
+        return h(tag, {
+          name: props.disabled ? '' : name,
+          css: !props.disabled,
+          // mode: props.mode, // TODO: vuejs/vue-next#3104
+          ...(props.disabled ? {} : functions)
+        }, slots.default);
+      };
+    }
+  });
+}
+
+// Utilities
+function ExpandTransitionGenerator () {
+  let expandedParentClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  const sizeProperty = x ? 'width' : 'height';
+  const offsetProperty = camelize(`offset-${sizeProperty}`);
+  return {
+    onBeforeEnter(el) {
+      el._parent = el.parentNode;
+      el._initialStyle = {
+        transition: el.style.transition,
+        overflow: el.style.overflow,
+        [sizeProperty]: el.style[sizeProperty]
+      };
+    },
+    onEnter(el) {
+      const initialStyle = el._initialStyle;
+      el.style.setProperty('transition', 'none', 'important');
+      // Hide overflow to account for collapsed margins in the calculated height
+      el.style.overflow = 'hidden';
+      const offset = `${el[offsetProperty]}px`;
+      el.style[sizeProperty] = '0';
+      void el.offsetHeight; // force reflow
+
+      el.style.transition = initialStyle.transition;
+      if (expandedParentClass && el._parent) {
+        el._parent.classList.add(expandedParentClass);
+      }
+      requestAnimationFrame(() => {
+        el.style[sizeProperty] = offset;
+      });
+    },
+    onAfterEnter: resetStyles,
+    onEnterCancelled: resetStyles,
+    onLeave(el) {
+      el._initialStyle = {
+        transition: '',
+        overflow: el.style.overflow,
+        [sizeProperty]: el.style[sizeProperty]
+      };
+      el.style.overflow = 'hidden';
+      el.style[sizeProperty] = `${el[offsetProperty]}px`;
+      void el.offsetHeight; // force reflow
+
+      requestAnimationFrame(() => el.style[sizeProperty] = '0');
+    },
+    onAfterLeave,
+    onLeaveCancelled: onAfterLeave
+  };
+  function onAfterLeave(el) {
+    if (expandedParentClass && el._parent) {
+      el._parent.classList.remove(expandedParentClass);
+    }
+    resetStyles(el);
+  }
+  function resetStyles(el) {
+    const size = el._initialStyle[sizeProperty];
+    el.style.overflow = el._initialStyle.overflow;
+    if (size != null) el.style[sizeProperty] = size;
+    delete el._initialStyle;
+  }
+}
+
+createCssTransition('fab-transition', 'center center', 'out-in');
+
+// Generic transitions
+createCssTransition('dialog-bottom-transition');
+createCssTransition('dialog-top-transition');
+const VFadeTransition = createCssTransition('fade-transition');
+createCssTransition('scale-transition');
+createCssTransition('scroll-x-transition');
+createCssTransition('scroll-x-reverse-transition');
+createCssTransition('scroll-y-transition');
+createCssTransition('scroll-y-reverse-transition');
+createCssTransition('slide-x-transition');
+createCssTransition('slide-x-reverse-transition');
+createCssTransition('slide-y-transition');
+createCssTransition('slide-y-reverse-transition');
+
+// Javascript transitions
+const VExpandTransition = createJavascriptTransition('expand-transition', ExpandTransitionGenerator());
+createJavascriptTransition('expand-x-transition', ExpandTransitionGenerator('', true));
+
+export { VFadeTransition as V, VExpandTransition as a };

package/dist/client/ssrBoot-BP7SYRyC.js

@@ -0,0 +1,22 @@
+import { shallowRef, onMounted, computed, readonly } from 'vue';
+
+// Utilities
+
+// Composables
+function useSsrBoot() {
+  const isBooted = shallowRef(false);
+  onMounted(() => {
+    window.requestAnimationFrame(() => {
+      isBooted.value = true;
+    });
+  });
+  const ssrBootStyles = computed(() => !isBooted.value ? {
+    transition: 'none !important'
+  } : undefined);
+  return {
+    ssrBootStyles,
+    isBooted: readonly(isBooted)
+  };
+}
+
+export { useSsrBoot as u };