@vc-shell/framework 1.1.46 → 1.1.48

package/dist/vendor-floating-ui-utils-OMIFy1QU.js

@@ -1,296 +0,0 @@
-/**
- * Custom positioning reference element.
- * @see https://floating-ui.com/docs/virtual-elements
- */
-
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const floor = Math.floor;
-const createCoords = v => ({
-  x: v,
-  y: v
-});
-const oppositeSideMap = {
-  left: 'right',
-  right: 'left',
-  bottom: 'top',
-  top: 'bottom'
-};
-const oppositeAlignmentMap = {
-  start: 'end',
-  end: 'start'
-};
-function clamp(start, value, end) {
-  return max(start, min(value, end));
-}
-function evaluate(value, param) {
-  return typeof value === 'function' ? value(param) : value;
-}
-function getSide(placement) {
-  return placement.split('-')[0];
-}
-function getAlignment(placement) {
-  return placement.split('-')[1];
-}
-function getOppositeAxis(axis) {
-  return axis === 'x' ? 'y' : 'x';
-}
-function getAxisLength(axis) {
-  return axis === 'y' ? 'height' : 'width';
-}
-const yAxisSides = /*#__PURE__*/new Set(['top', 'bottom']);
-function getSideAxis(placement) {
-  return yAxisSides.has(getSide(placement)) ? 'y' : 'x';
-}
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
-}
-function getAlignmentSides(placement, rects, rtl) {
-  if (rtl === void 0) {
-    rtl = false;
-  }
-  const alignment = getAlignment(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const length = getAxisLength(alignmentAxis);
-  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
-  if (rects.reference[length] > rects.floating[length]) {
-    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-  }
-  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
-}
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-function getOppositeAlignmentPlacement(placement) {
-  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
-}
-const lrPlacement = ['left', 'right'];
-const rlPlacement = ['right', 'left'];
-const tbPlacement = ['top', 'bottom'];
-const btPlacement = ['bottom', 'top'];
-function getSideList(side, isStart, rtl) {
-  switch (side) {
-    case 'top':
-    case 'bottom':
-      if (rtl) return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
-    case 'left':
-    case 'right':
-      return isStart ? tbPlacement : btPlacement;
-    default:
-      return [];
-  }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list = getSideList(getSide(placement), direction === 'start', rtl);
-  if (alignment) {
-    list = list.map(side => side + "-" + alignment);
-    if (flipAlignment) {
-      list = list.concat(list.map(getOppositeAlignmentPlacement));
-    }
-  }
-  return list;
-}
-function getOppositePlacement(placement) {
-  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
-}
-function expandPaddingObject(padding) {
-  return {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0,
-    ...padding
-  };
-}
-function getPaddingObject(padding) {
-  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
-  };
-}
-function rectToClientRect(rect) {
-  const {
-    x,
-    y,
-    width,
-    height
-  } = rect;
-  return {
-    width,
-    height,
-    top: y,
-    left: x,
-    right: x + width,
-    bottom: y + height,
-    x,
-    y
-  };
-}
-
-function hasWindow() {
-  return typeof window !== 'undefined';
-}
-function getNodeName(node) {
-  if (isNode(node)) {
-    return (node.nodeName || '').toLowerCase();
-  }
-  // Mocked nodes in testing environments may not be instances of Node. By
-  // returning `#document` an infinite loop won't occur.
-  // https://github.com/floating-ui/floating-ui/issues/2317
-  return '#document';
-}
-function getWindow(node) {
-  var _node$ownerDocument;
-  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
-}
-function getDocumentElement(node) {
-  var _ref;
-  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
-}
-function isNode(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Node || value instanceof getWindow(value).Node;
-}
-function isElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Element || value instanceof getWindow(value).Element;
-}
-function isHTMLElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
-}
-function isShadowRoot(value) {
-  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
-    return false;
-  }
-  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
-}
-const invalidOverflowDisplayValues = /*#__PURE__*/new Set(['inline', 'contents']);
-function isOverflowElement(element) {
-  const {
-    overflow,
-    overflowX,
-    overflowY,
-    display
-  } = getComputedStyle(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
-}
-const tableElements = /*#__PURE__*/new Set(['table', 'td', 'th']);
-function isTableElement(element) {
-  return tableElements.has(getNodeName(element));
-}
-const topLayerSelectors = [':popover-open', ':modal'];
-function isTopLayer(element) {
-  return topLayerSelectors.some(selector => {
-    try {
-      return element.matches(selector);
-    } catch (_e) {
-      return false;
-    }
-  });
-}
-const transformProperties = ['transform', 'translate', 'scale', 'rotate', 'perspective'];
-const willChangeValues = ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'];
-const containValues = ['paint', 'layout', 'strict', 'content'];
-function isContainingBlock(elementOrCss) {
-  const webkit = isWebKit();
-  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
-
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
-  return transformProperties.some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || willChangeValues.some(value => (css.willChange || '').includes(value)) || containValues.some(value => (css.contain || '').includes(value));
-}
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    if (isContainingBlock(currentNode)) {
-      return currentNode;
-    } else if (isTopLayer(currentNode)) {
-      return null;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  return null;
-}
-function isWebKit() {
-  if (typeof CSS === 'undefined' || !CSS.supports) return false;
-  return CSS.supports('-webkit-backdrop-filter', 'none');
-}
-const lastTraversableNodeNames = /*#__PURE__*/new Set(['html', 'body', '#document']);
-function isLastTraversableNode(node) {
-  return lastTraversableNodeNames.has(getNodeName(node));
-}
-function getComputedStyle(element) {
-  return getWindow(element).getComputedStyle(element);
-}
-function getNodeScroll(element) {
-  if (isElement(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.scrollX,
-    scrollTop: element.scrollY
-  };
-}
-function getParentNode(node) {
-  if (getNodeName(node) === 'html') {
-    return node;
-  }
-  const result =
-  // Step into the shadow DOM of the parent of a slotted node.
-  node.assignedSlot ||
-  // DOM Element detected.
-  node.parentNode ||
-  // ShadowRoot detected.
-  isShadowRoot(node) && node.host ||
-  // Fallback.
-  getDocumentElement(node);
-  return isShadowRoot(result) ? result.host : result;
-}
-function getNearestOverflowAncestor(node) {
-  const parentNode = getParentNode(node);
-  if (isLastTraversableNode(parentNode)) {
-    return node.ownerDocument ? node.ownerDocument.body : node.body;
-  }
-  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
-    return parentNode;
-  }
-  return getNearestOverflowAncestor(parentNode);
-}
-function getOverflowAncestors(node, list, traverseIframes) {
-  var _node$ownerDocument2;
-  if (list === void 0) {
-    list = [];
-  }
-  if (traverseIframes === void 0) {
-    traverseIframes = true;
-  }
-  const scrollableAncestor = getNearestOverflowAncestor(node);
-  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
-  const win = getWindow(scrollableAncestor);
-  if (isBody) {
-    const frameElement = getFrameElement(win);
-    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
-  }
-  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
-}
-function getFrameElement(win) {
-  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
-}
-
-export { floor as A, isTopLayer as B, getParentNode as C, isLastTraversableNode as D, isTableElement as E, isContainingBlock as F, getContainingBlock as G, getNodeName as H, isOverflowElement as I, getNodeScroll as J, isNode as K, getAlignment as a, getSideAxis as b, getAlignmentAxis as c, getAxisLength as d, evaluate as e, getPaddingObject as f, getSide as g, getOppositeAxis as h, getOppositePlacement as i, getExpandedPlacements as j, getOppositeAxisPlacements as k, getAlignmentSides as l, clamp as m, getOverflowAncestors as n, getDocumentElement as o, isElement as p, createCoords as q, rectToClientRect as r, getWindow as s, getFrameElement as t, getComputedStyle as u, max as v, isHTMLElement as w, isWebKit as x, min as y, round as z };

package/dist/vendor-floating-ui-vue-D-tCDAMm.js

@@ -1,167 +0,0 @@
-import { c as computePosition } from './vendor-floating-ui-dom-DDnRPs17.js';
-import { K as isNode, H as getNodeName } from './vendor-floating-ui-utils-OMIFy1QU.js';
-import { computed, ref, shallowRef, watch, getCurrentScope, onScopeDispose, shallowReadonly, unref } from 'vue';
-
-function isComponentPublicInstance(target) {
-  return target != null && typeof target === 'object' && '$el' in target;
-}
-function unwrapElement(target) {
-  if (isComponentPublicInstance(target)) {
-    const element = target.$el;
-    return isNode(element) && getNodeName(element) === '#comment' ? null : element;
-  }
-  return target;
-}
-
-function toValue(source) {
-  return typeof source === 'function' ? source() : unref(source);
-}
-
-function getDPR(element) {
-  if (typeof window === 'undefined') {
-    return 1;
-  }
-  const win = element.ownerDocument.defaultView || window;
-  return win.devicePixelRatio || 1;
-}
-
-function roundByDPR(element, value) {
-  const dpr = getDPR(element);
-  return Math.round(value * dpr) / dpr;
-}
-
-/**
- * Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
- * @param reference The reference template ref.
- * @param floating The floating template ref.
- * @param options The floating options.
- * @see https://floating-ui.com/docs/vue
- */
-function useFloating(reference, floating, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  const whileElementsMountedOption = options.whileElementsMounted;
-  const openOption = computed(() => {
-    var _toValue;
-    return (_toValue = toValue(options.open)) != null ? _toValue : true;
-  });
-  const middlewareOption = computed(() => toValue(options.middleware));
-  const placementOption = computed(() => {
-    var _toValue2;
-    return (_toValue2 = toValue(options.placement)) != null ? _toValue2 : 'bottom';
-  });
-  const strategyOption = computed(() => {
-    var _toValue3;
-    return (_toValue3 = toValue(options.strategy)) != null ? _toValue3 : 'absolute';
-  });
-  const transformOption = computed(() => {
-    var _toValue4;
-    return (_toValue4 = toValue(options.transform)) != null ? _toValue4 : true;
-  });
-  const referenceElement = computed(() => unwrapElement(reference.value));
-  const floatingElement = computed(() => unwrapElement(floating.value));
-  const x = ref(0);
-  const y = ref(0);
-  const strategy = ref(strategyOption.value);
-  const placement = ref(placementOption.value);
-  const middlewareData = shallowRef({});
-  const isPositioned = ref(false);
-  const floatingStyles = computed(() => {
-    const initialStyles = {
-      position: strategy.value,
-      left: '0',
-      top: '0'
-    };
-    if (!floatingElement.value) {
-      return initialStyles;
-    }
-    const xVal = roundByDPR(floatingElement.value, x.value);
-    const yVal = roundByDPR(floatingElement.value, y.value);
-    if (transformOption.value) {
-      return {
-        ...initialStyles,
-        transform: "translate(" + xVal + "px, " + yVal + "px)",
-        ...(getDPR(floatingElement.value) >= 1.5 && {
-          willChange: 'transform'
-        })
-      };
-    }
-    return {
-      position: strategy.value,
-      left: xVal + "px",
-      top: yVal + "px"
-    };
-  });
-  let whileElementsMountedCleanup;
-  function update() {
-    if (referenceElement.value == null || floatingElement.value == null) {
-      return;
-    }
-    const open = openOption.value;
-    computePosition(referenceElement.value, floatingElement.value, {
-      middleware: middlewareOption.value,
-      placement: placementOption.value,
-      strategy: strategyOption.value
-    }).then(position => {
-      x.value = position.x;
-      y.value = position.y;
-      strategy.value = position.strategy;
-      placement.value = position.placement;
-      middlewareData.value = position.middlewareData;
-      /**
-       * The floating element's position may be recomputed while it's closed
-       * but still mounted (such as when transitioning out). To ensure
-       * `isPositioned` will be `false` initially on the next open, avoid
-       * setting it to `true` when `open === false` (must be specified).
-       */
-      isPositioned.value = open !== false;
-    });
-  }
-  function cleanup() {
-    if (typeof whileElementsMountedCleanup === 'function') {
-      whileElementsMountedCleanup();
-      whileElementsMountedCleanup = undefined;
-    }
-  }
-  function attach() {
-    cleanup();
-    if (whileElementsMountedOption === undefined) {
-      update();
-      return;
-    }
-    if (referenceElement.value != null && floatingElement.value != null) {
-      whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
-      return;
-    }
-  }
-  function reset() {
-    if (!openOption.value) {
-      isPositioned.value = false;
-    }
-  }
-  watch([middlewareOption, placementOption, strategyOption, openOption], update, {
-    flush: 'sync'
-  });
-  watch([referenceElement, floatingElement], attach, {
-    flush: 'sync'
-  });
-  watch(openOption, reset, {
-    flush: 'sync'
-  });
-  if (getCurrentScope()) {
-    onScopeDispose(cleanup);
-  }
-  return {
-    x: shallowReadonly(x),
-    y: shallowReadonly(y),
-    strategy: shallowReadonly(strategy),
-    placement: shallowReadonly(placement),
-    middlewareData: shallowReadonly(middlewareData),
-    isPositioned: shallowReadonly(isPositioned),
-    floatingStyles,
-    update
-  };
-}
-
-export { useFloating as u };