cbvirtua 1.0.4 → 1.0.6

package/v2/floating-ui/dom/utils/contains.js

@@ -0,0 +1,22 @@
+import { isShadowRoot } from './is';
+export function contains(parent, child) {
+    var _a;
+    const rootNode = (_a = child.getRootNode) === null || _a === void 0 ? void 0 : _a.call(child);
+    // First, attempt with faster native method
+    if (parent.contains(child)) {
+        return true;
+    }
+    // then fallback to custom implementation with Shadow DOM support
+    else if (rootNode && isShadowRoot(rootNode)) {
+        let next = child;
+        do {
+            // use `===` replace node.isSameNode()
+            if (next && parent === next) {
+                return true;
+            }
+            // @ts-ignore: need a better way to handle this...
+            next = next.parentNode || next.host;
+        } while (next);
+    }
+    return false;
+}

package/v2/floating-ui/dom/utils/convertOffsetParentRelativeRectToViewportRelativeRect.js

@@ -0,0 +1,35 @@
+import { getBoundingClientRect } from './getBoundingClientRect';
+import { getNodeScroll } from './getNodeScroll';
+import { getNodeName } from './getNodeName';
+import { getDocumentElement } from './getDocumentElement';
+import { isHTMLElement, isScrollParent } from './is';
+export function convertOffsetParentRelativeRectToViewportRelativeRect({ rect, offsetParent, strategy, }) {
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    const documentElement = getDocumentElement(offsetParent);
+    if (offsetParent === documentElement) {
+        return rect;
+    }
+    let scroll = { scrollLeft: 0, scrollTop: 0 };
+    const offsets = { x: 0, y: 0 };
+    if (isOffsetParentAnElement ||
+        (!isOffsetParentAnElement && strategy !== 'fixed')) {
+        if (getNodeName(offsetParent) !== 'body' ||
+            isScrollParent(documentElement)) {
+            scroll = getNodeScroll(offsetParent);
+        }
+        if (isHTMLElement(offsetParent)) {
+            const offsetRect = getBoundingClientRect(offsetParent, true);
+            offsets.x = offsetRect.x + offsetParent.clientLeft;
+            offsets.y = offsetRect.y + offsetParent.clientTop;
+        }
+        // This doesn't appear to be need to be negated.
+        // else if (documentElement) {
+        //   offsets.x = getWindowScrollBarX(documentElement);
+        // }
+    }
+    return {
+        ...rect,
+        x: rect.x - scroll.scrollLeft + offsets.x,
+        y: rect.y - scroll.scrollTop + offsets.y,
+    };
+}

package/v2/floating-ui/dom/utils/getBoundingClientRect.js

@@ -0,0 +1,27 @@
+import { isHTMLElement } from './is';
+import { round } from './math';
+export function getBoundingClientRect(element, includeScale = false) {
+    const clientRect = element.getBoundingClientRect();
+    let scaleX = 1;
+    let scaleY = 1;
+    if (includeScale && isHTMLElement(element)) {
+        scaleX =
+            element.offsetWidth > 0
+                ? round(clientRect.width) / element.offsetWidth || 1
+                : 1;
+        scaleY =
+            element.offsetHeight > 0
+                ? round(clientRect.height) / element.offsetHeight || 1
+                : 1;
+    }
+    return {
+        width: clientRect.width / scaleX,
+        height: clientRect.height / scaleY,
+        top: clientRect.top / scaleY,
+        right: clientRect.right / scaleX,
+        bottom: clientRect.bottom / scaleY,
+        left: clientRect.left / scaleX,
+        x: clientRect.left / scaleX,
+        y: clientRect.top / scaleY,
+    };
+}

package/v2/floating-ui/dom/utils/getClippingClientRect.js

@@ -0,0 +1,76 @@
+import { rectToClientRect, } from '../../core/';
+import { getViewportRect } from './getViewportRect';
+import { getDocumentRect } from './getDocumentRect';
+import { getScrollParents } from './getScrollParents';
+import { getOffsetParent } from './getOffsetParent';
+import { getDocumentElement } from './getDocumentElement';
+import { getComputedStyle } from './getComputedStyle';
+import { isElement, isHTMLElement } from './is';
+import { getBoundingClientRect } from './getBoundingClientRect';
+import { getParentNode } from './getParentNode';
+import { contains } from './contains';
+import { getNodeName } from './getNodeName';
+import { max, min } from './math';
+function getInnerBoundingClientRect(element) {
+    const clientRect = getBoundingClientRect(element);
+    const top = clientRect.top + element.clientTop;
+    const left = clientRect.left + element.clientLeft;
+    return {
+        top,
+        left,
+        x: left,
+        y: top,
+        right: left + element.clientWidth,
+        bottom: top + element.clientHeight,
+        width: element.clientWidth,
+        height: element.clientHeight,
+    };
+}
+function getClientRectFromClippingParent(element, clippingParent) {
+    if (clippingParent === 'viewport') {
+        return rectToClientRect(getViewportRect(element));
+    }
+    if (isElement(clippingParent)) {
+        return getInnerBoundingClientRect(clippingParent);
+    }
+    return rectToClientRect(getDocumentRect(getDocumentElement(element)));
+}
+// A "clipping parent" is an overflowable container with the characteristic of
+// clipping (or hiding) overflowing elements with a position different from
+// `initial`
+function getClippingParents(element) {
+    const clippingParents = getScrollParents(getParentNode(element));
+    const canEscapeClipping = ['absolute', 'fixed'].includes(getComputedStyle(element).position);
+    const clipperElement = canEscapeClipping && isHTMLElement(element)
+        ? getOffsetParent(element)
+        : element;
+    if (!isElement(clipperElement)) {
+        return [];
+    }
+    // @ts-ignore isElement check ensures we return Array<Element>
+    return clippingParents.filter((clippingParent) => isElement(clippingParent) &&
+        contains(clippingParent, clipperElement) &&
+        getNodeName(clippingParent) !== 'body');
+}
+// Gets the maximum area that the element is visible in due to any number of
+// clipping parents
+export function getClippingClientRect({ element, boundary, rootBoundary, }) {
+    const mainClippingParents = boundary === 'clippingParents'
+        ? getClippingParents(element)
+        : [].concat(boundary);
+    const clippingParents = [...mainClippingParents, rootBoundary];
+    const firstClippingParent = clippingParents[0];
+    const clippingRect = clippingParents.reduce((accRect, clippingParent) => {
+        const rect = getClientRectFromClippingParent(element, clippingParent);
+        accRect.top = max(rect.top, accRect.top);
+        accRect.right = min(rect.right, accRect.right);
+        accRect.bottom = min(rect.bottom, accRect.bottom);
+        accRect.left = max(rect.left, accRect.left);
+        return accRect;
+    }, getClientRectFromClippingParent(element, firstClippingParent));
+    clippingRect.width = clippingRect.right - clippingRect.left;
+    clippingRect.height = clippingRect.bottom - clippingRect.top;
+    clippingRect.x = clippingRect.left;
+    clippingRect.y = clippingRect.top;
+    return clippingRect;
+}

package/v2/floating-ui/dom/utils/getComputedStyle.js

@@ -0,0 +1,4 @@
+import { getWindow } from './window';
+export function getComputedStyle(element) {
+    return getWindow(element).getComputedStyle(element);
+}

package/v2/floating-ui/dom/utils/getDimensions.js

@@ -0,0 +1,6 @@
+export function getDimensions(element) {
+    return {
+        width: element.offsetWidth,
+        height: element.offsetHeight,
+    };
+}

package/v2/floating-ui/dom/utils/getDocumentElement.js

@@ -0,0 +1,4 @@
+import { isNode } from './is';
+export function getDocumentElement(node) {
+    return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+}

package/v2/floating-ui/dom/utils/getDocumentRect.js

@@ -0,0 +1,21 @@
+import { getDocumentElement } from './getDocumentElement';
+import { getComputedStyle } from './getComputedStyle';
+import getWindowScrollBarX from './getWindowScrollBarX';
+import { getNodeScroll } from './getNodeScroll';
+import { max } from './math';
+// Gets the entire size of the scrollable document area, even extending outside
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable
+export function getDocumentRect(element) {
+    var _a;
+    const html = getDocumentElement(element);
+    const scroll = getNodeScroll(element);
+    const body = (_a = element.ownerDocument) === null || _a === void 0 ? void 0 : _a.body;
+    const width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+    const height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+    const y = -scroll.scrollTop;
+    if (getComputedStyle(body || html).direction === 'rtl') {
+        x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+    }
+    return { width, height, x, y };
+}

package/v2/floating-ui/dom/utils/getNodeName.js

@@ -0,0 +1,4 @@
+import { isWindow } from './window';
+export function getNodeName(node) {
+    return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : '';
+}

package/v2/floating-ui/dom/utils/getNodeScroll.js

@@ -0,0 +1,13 @@
+import { isWindow } from './window';
+export function getNodeScroll(element) {
+    if (isWindow(element)) {
+        return {
+            scrollLeft: element.pageXOffset,
+            scrollTop: element.pageYOffset,
+        };
+    }
+    return {
+        scrollLeft: element.scrollLeft,
+        scrollTop: element.scrollTop,
+    };
+}

package/v2/floating-ui/dom/utils/getOffsetParent.js

@@ -0,0 +1,43 @@
+import { getNodeName } from './getNodeName';
+import { getParentNode } from './getParentNode';
+import { getWindow } from './window';
+import { isContainingBlock, isHTMLElement, isTableElement } from './is';
+function getTrueOffsetParent(element) {
+    if (!isHTMLElement(element) ||
+        getComputedStyle(element).position === 'fixed') {
+        return null;
+    }
+    return element.offsetParent;
+}
+function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+    while (isHTMLElement(currentNode) &&
+        !['html', 'body'].includes(getNodeName(currentNode))) {
+        if (isContainingBlock(currentNode)) {
+            return currentNode;
+        }
+        else {
+            currentNode = currentNode.parentNode;
+        }
+    }
+    return null;
+}
+// Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+export function getOffsetParent(element) {
+    const window = getWindow(element);
+    let offsetParent = getTrueOffsetParent(element);
+    while (offsetParent &&
+        isTableElement(offsetParent) &&
+        getComputedStyle(offsetParent).position === 'static') {
+        offsetParent = getTrueOffsetParent(offsetParent);
+    }
+    if (offsetParent &&
+        (getNodeName(offsetParent) === 'html' ||
+            (getNodeName(offsetParent) === 'body' &&
+                getComputedStyle(offsetParent).position === 'static' &&
+                !isContainingBlock(offsetParent)))) {
+        return window;
+    }
+    return offsetParent || getContainingBlock(element) || window;
+}

package/v2/floating-ui/dom/utils/getParentNode.js

@@ -0,0 +1,16 @@
+import { getNodeName } from './getNodeName';
+import { getDocumentElement } from './getDocumentElement';
+import { isShadowRoot } from './is';
+export function getParentNode(node) {
+    if (getNodeName(node) === 'html') {
+        return node;
+    }
+    return (
+    // this is a quicker (but less type safe) way to save quite some bytes from the bundle
+    // @ts-ignore
+    node.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+        node.parentNode || // DOM Element detected
+        (isShadowRoot(node) ? node.host : null) || // ShadowRoot detected
+        getDocumentElement(node) // fallback
+    );
+}

package/v2/floating-ui/dom/utils/getRectRelativeToOffsetParent.js

@@ -0,0 +1,40 @@
+import { getBoundingClientRect } from './getBoundingClientRect';
+import { getDocumentElement } from './getDocumentElement';
+import { getNodeName } from './getNodeName';
+import { getNodeScroll } from './getNodeScroll';
+import getWindowScrollBarX from './getWindowScrollBarX';
+import { isHTMLElement, isScrollParent } from './is';
+import { round } from './math';
+function isScaled(element) {
+    const rect = getBoundingClientRect(element);
+    return (round(rect.width) !== element.offsetWidth ||
+        round(rect.height) !== element.offsetHeight);
+}
+export function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    const documentElement = getDocumentElement(offsetParent);
+    const rect = getBoundingClientRect(element, isOffsetParentAnElement && isScaled(offsetParent));
+    let scroll = { scrollLeft: 0, scrollTop: 0 };
+    const offsets = { x: 0, y: 0 };
+    if (isOffsetParentAnElement ||
+        (!isOffsetParentAnElement && strategy !== 'fixed')) {
+        if (getNodeName(offsetParent) !== 'body' ||
+            isScrollParent(documentElement)) {
+            scroll = getNodeScroll(offsetParent);
+        }
+        if (isHTMLElement(offsetParent)) {
+            const offsetRect = getBoundingClientRect(offsetParent, true);
+            offsets.x = offsetRect.x + offsetParent.clientLeft;
+            offsets.y = offsetRect.y + offsetParent.clientTop;
+        }
+        else if (documentElement) {
+            offsets.x = getWindowScrollBarX(documentElement);
+        }
+    }
+    return {
+        x: rect.left + scroll.scrollLeft - offsets.x,
+        y: rect.top + scroll.scrollTop - offsets.y,
+        width: rect.width,
+        height: rect.height,
+    };
+}

package/v2/floating-ui/dom/utils/getScrollParent.js

@@ -0,0 +1,13 @@
+import { getParentNode } from './getParentNode';
+import { getNodeName } from './getNodeName';
+import { isScrollParent, isHTMLElement } from './is';
+export function getScrollParent(node) {
+    if (['html', 'body', '#document'].includes(getNodeName(node))) {
+        // @ts-ignore assume body is always available
+        return node.ownerDocument.body;
+    }
+    if (isHTMLElement(node) && isScrollParent(node)) {
+        return node;
+    }
+    return getScrollParent(getParentNode(node));
+}

package/v2/floating-ui/dom/utils/getScrollParents.js

@@ -0,0 +1,18 @@
+import { getScrollParent } from './getScrollParent';
+import { getParentNode } from './getParentNode';
+import { getWindow } from './window';
+import { isScrollParent } from './is';
+export function getScrollParents(node, list = []) {
+    var _a;
+    const scrollParent = getScrollParent(node);
+    const isBody = scrollParent === ((_a = node.ownerDocument) === null || _a === void 0 ? void 0 : _a.body);
+    const win = getWindow(scrollParent);
+    const target = isBody
+        ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : [])
+        : scrollParent;
+    const updatedList = list.concat(target);
+    return isBody
+        ? updatedList
+        : // @ts-ignore: isBody tells us target will be an HTMLElement here
+            updatedList.concat(getScrollParents(getParentNode(target)));
+}

package/v2/floating-ui/dom/utils/getViewportRect.js

@@ -0,0 +1,25 @@
+import { getWindow } from './window';
+import { getDocumentElement } from './getDocumentElement';
+export function getViewportRect(element) {
+    const win = getWindow(element);
+    const html = getDocumentElement(element);
+    const visualViewport = win.visualViewport;
+    let width = html.clientWidth;
+    let height = html.clientHeight;
+    let x = 0;
+    let y = 0;
+    if (visualViewport) {
+        width = visualViewport.width;
+        height = visualViewport.height;
+        // Uses Layout Viewport (like Chrome; Safari does not currently)
+        // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
+        // errors due to floating point numbers, so we need to check precision.
+        // Safari returns a number <= 0, usually < -1 when pinch-zoomed
+        if (Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
+            0.01) {
+            x = visualViewport.offsetLeft;
+            y = visualViewport.offsetTop;
+        }
+    }
+    return { width, height, x, y };
+}

package/v2/floating-ui/dom/utils/getWindowScrollBarX.js

@@ -0,0 +1,9 @@
+import { getBoundingClientRect } from './getBoundingClientRect';
+import { getDocumentElement } from './getDocumentElement';
+import { getNodeScroll } from './getNodeScroll';
+export default function getWindowScrollBarX(element) {
+    // If <html> has a CSS width greater than the viewport, then this will be
+    // incorrect for RTL.
+    return (getBoundingClientRect(getDocumentElement(element)).left +
+        getNodeScroll(element).scrollLeft);
+}

package/v2/floating-ui/dom/utils/is.js

@@ -0,0 +1,38 @@
+import { getComputedStyle } from './getComputedStyle';
+import { getNodeName } from './getNodeName';
+import { getWindow } from './window';
+export function isHTMLElement(value) {
+    return value instanceof getWindow(value).HTMLElement;
+}
+export function isElement(value) {
+    return value instanceof getWindow(value).Element;
+}
+export function isNode(value) {
+    return value instanceof getWindow(value).Node;
+}
+export function isShadowRoot(node) {
+    const OwnElement = getWindow(node).ShadowRoot;
+    return node instanceof OwnElement || node instanceof ShadowRoot;
+}
+export function isScrollParent(element) {
+    // Firefox wants us to check `-x` and `-y` variations as well
+    const { overflow, overflowX, overflowY } = getComputedStyle(element);
+    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+export function isTableElement(element) {
+    return ['table', 'td', 'th'].includes(getNodeName(element));
+}
+export function isContainingBlock(element) {
+    // TODO: Try and use feature detection here instead
+    const isFirefox = navigator.userAgent.toLowerCase().includes('firefox');
+    const css = getComputedStyle(element);
+    // This is non-exhaustive but covers the most common CSS properties that
+    // create a containing block.
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    return (css.transform !== 'none' ||
+        css.perspective !== 'none' ||
+        css.contain === 'paint' ||
+        ['transform', 'perspective'].includes(css.willChange) ||
+        (isFirefox && css.willChange === 'filter') ||
+        (isFirefox && (css.filter ? css.filter !== 'none' : false)));
+}

package/v2/floating-ui/dom/utils/math.js

@@ -0,0 +1,3 @@
+export const min = Math.min;
+export const max = Math.max;
+export const round = Math.round;

package/v2/floating-ui/dom/utils/window.js

@@ -0,0 +1,13 @@
+export function isWindow(value) {
+    return (value === null || value === void 0 ? void 0 : value.toString()) === '[object Window]';
+}
+export function getWindow(node) {
+    if (node == null) {
+        return window;
+    }
+    if (!isWindow(node)) {
+        const ownerDocument = node.ownerDocument;
+        return ownerDocument ? ownerDocument.defaultView || window : window;
+    }
+    return node;
+}

package/v2/index.js

@@ -0,0 +1,75 @@
+import { assign } from './util/assign-deep';
+import { config } from './config';
+import 'vue-resize/dist/vue-resize.css';
+// Components
+import PrivateDropdown from './components/Dropdown.vue';
+import PrivateMenu from './components/Menu.vue';
+import PrivatePopper from './components/Popper';
+import PrivatePopperContent from './components/PopperContent.vue';
+import PrivatePopperMethods from './components/PopperMethods';
+import PrivatePopperWrapper from './components/PopperWrapper.vue';
+import PrivateThemeClass from './components/ThemeClass';
+import PrivateTooltip from './components/Tooltip.vue';
+import PrivateTooltipDirective from './components/TooltipDirective.vue';
+// Directives
+import PrivateVTooltip from './directives/v-tooltip';
+import PrivateVClosePopper from './directives/v-close-popper';
+/* Exports */
+export const options = config;
+// Directive
+export const VTooltip = PrivateVTooltip;
+export { createTooltip, destroyTooltip } from './directives/v-tooltip';
+export const VClosePopper = PrivateVClosePopper;
+console.log(PrivateVClosePopper)
+// Components
+export const Dropdown = PrivateDropdown;
+export const Menu = PrivateMenu;
+export const Popper = PrivatePopper;
+export const PopperContent = PrivatePopperContent;
+export const PopperMethods = PrivatePopperMethods;
+export const PopperWrapper = PrivatePopperWrapper;
+export const ThemeClass = PrivateThemeClass;
+export const Tooltip = PrivateTooltip;
+export const TooltipDirective = PrivateTooltipDirective;
+// Utils
+export { hideAllPoppers } from './components/Popper';
+export * from './util/events';
+export { placements } from './util/popper';
+/* Vue plugin */
+export function install(app, options = {}) {
+    if (app.$_vTooltipInstalled)
+        return;
+    app.$_vTooltipInstalled = true;
+    assign(config, options);
+    // Directive
+    app.directive('tooltip', PrivateVTooltip);
+    app.directive('close-popper', PrivateVClosePopper);
+    // Components
+    // eslint-disable-next-line vue/component-definition-name-casing
+    app.component('v-tooltip', PrivateTooltip);
+    app.component('VTooltip', PrivateTooltip);
+    // eslint-disable-next-line vue/component-definition-name-casing
+    app.component('v-dropdown', PrivateDropdown);
+    app.component('VDropdown', PrivateDropdown);
+    // eslint-disable-next-line vue/component-definition-name-casing
+    app.component('v-menu', PrivateMenu);
+    app.component('VMenu', PrivateMenu);
+}
+const plugin = {
+    // eslint-disable-next-line no-undef
+    //version: VERSION,
+    install,
+    options: config,
+};
+// Auto-install
+let GlobalVue = null;
+if (typeof window !== 'undefined') {
+    GlobalVue = window.Vue;
+}
+else if (typeof global !== 'undefined') {
+    GlobalVue = global.Vue;
+}
+if (GlobalVue) {
+    GlobalVue.use(plugin);
+}
+export default plugin;

package/v2/util/assign-deep.js

@@ -0,0 +1,12 @@
+export function assign(to, from) {
+    for (const key in from) {
+        if (Object.prototype.hasOwnProperty.call(from, key)) {
+            if (typeof from[key] === 'object' && to[key]) {
+                assign(to[key], from[key]);
+            }
+            else {
+                to[key] = from[key];
+            }
+        }
+    }
+}

package/v2/util/env.js

@@ -0,0 +1,18 @@
+export let supportsPassive = false;
+if (typeof window !== 'undefined') {
+    supportsPassive = false;
+    try {
+        const opts = Object.defineProperty({}, 'passive', {
+            get() {
+                supportsPassive = true;
+            },
+        });
+        window.addEventListener('test', null, opts);
+    }
+    catch (e) { }
+}
+export let isIOS = false;
+if (typeof window !== 'undefined' && typeof navigator !== 'undefined') {
+    // @ts-expect-error MSStream is missing in window type
+    isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+}

package/v2/util/events.js

@@ -0,0 +1,12 @@
+export const SHOW_EVENT_MAP = {
+    hover: 'mouseenter',
+    focus: 'focus',
+    click: 'click',
+    touch: 'touchstart',
+};
+export const HIDE_EVENT_MAP = {
+    hover: 'mouseleave',
+    focus: 'blur',
+    click: 'click',
+    touch: 'touchend',
+};

package/v2/util/frame.js

@@ -0,0 +1,5 @@
+export function nextFrame() {
+    return new Promise(resolve => requestAnimationFrame(() => {
+        requestAnimationFrame(resolve);
+    }));
+}

package/v2/util/lang.js

@@ -0,0 +1,6 @@
+export function removeFromArray(array, item) {
+    const index = array.indexOf(item);
+    if (index !== -1) {
+        array.splice(index, 1);
+    }
+}

package/v2/util/popper.js

@@ -0,0 +1,5 @@
+export const placements = ['auto', 'top', 'bottom', 'left', 'right'].reduce((acc, base) => acc.concat([
+    base,
+    `${base}-start`,
+    `${base}-end`,
+]), []);