cbvirtua 1.0.6 → 1.0.7

package/v2/components/TooltipDirective.vue

@@ -1,171 +0,0 @@
-<template>
-  <Popper
-    ref="popper"
-    v-slot="{
-      popperId,
-      isShown,
-      shouldMountContent,
-      skipTransition,
-      autoHide,
-      hide,
-      handleResize,
-      onResize,
-      classes,
-      result,
-    }"
-    v-bind="$attrs"
-    :theme="theme"
-    :popper-node="() => $refs.popperContent.$el"
-    v-on="$listeners"
-    @apply-show="onShow"
-    @apply-hide="onHide"
-  >
-    <PopperContent
-      ref="popperContent"
-      :class="{
-        'v-popper--tooltip-loading': loading,
-      }"
-      :popper-id="popperId"
-      :theme="theme"
-      :shown="isShown"
-      :mounted="shouldMountContent"
-      :skip-transition="skipTransition"
-      :auto-hide="autoHide"
-      :handle-resize="handleResize"
-      :classes="classes"
-      :result="result"
-      @hide="hide"
-      @resize="onResize"
-    >
-      <div
-        v-if="html"
-        v-html="finalContent"
-      />
-      <div
-        v-else
-        v-text="finalContent"
-      />
-    </PopperContent>
-  </Popper>
-</template>
-
-<script lang="ts">
-import Popper from './Popper'
-import PopperContent from './PopperContent.vue'
-import { getDefaultConfig } from '../config'
-import PopperMethods from './PopperMethods'
-
-export default {
-  name: 'VTooltipDirective',
-
-  components: {
-    Popper: Popper(),
-    PopperContent,
-  },
-
-  mixins: [
-    PopperMethods,
-  ],
-
-  inheritAttrs: false,
-
-  props: {
-    theme: {
-      type: String,
-      default: 'tooltip',
-    },
-
-    html: {
-      type: Boolean,
-      default () {
-        return getDefaultConfig(this.theme, 'html')
-      },
-    },
-
-    content: {
-      type: [String, Number, Function],
-      default: null,
-    },
-
-    loadingContent: {
-      type: String,
-      default () {
-        return getDefaultConfig(this.theme, 'loadingContent')
-      },
-    },
-  },
-
-  data () {
-    return {
-      asyncContent: null,
-    }
-  },
-
-  computed: {
-    isContentAsync () {
-      return typeof this.content === 'function'
-    },
-
-    loading () {
-      return this.isContentAsync && this.asyncContent == null
-    },
-
-    finalContent () {
-      if (this.isContentAsync) {
-        return this.loading ? this.loadingContent : this.asyncContent
-      }
-      return this.content
-    },
-  },
-
-  watch: {
-    content: {
-      handler () {
-        this.fetchContent(true)
-      },
-      immediate: true,
-    },
-
-    async finalContent (value) {
-      await this.$nextTick()
-      this.$refs.popper.onResize()
-    },
-  },
-
-  created () {
-    this.$_fetchId = 0
-  },
-
-  methods: {
-    fetchContent (force) {
-      if (typeof this.content === 'function' && this.$_isShown &&
-        (force || (!this.$_loading && this.asyncContent == null))) {
-        this.asyncContent = null
-        this.$_loading = true
-        const fetchId = ++this.$_fetchId
-        const result = this.content(this)
-        if (result.then) {
-          result.then(res => this.onResult(fetchId, res))
-        } else {
-          this.onResult(fetchId, result)
-        }
-      }
-    },
-
-    onResult (fetchId, result) {
-      if (fetchId !== this.$_fetchId) return
-      this.$_loading = false
-      this.asyncContent = result
-    },
-
-    onShow () {
-      this.$_isShown = true
-      this.fetchContent()
-    },
-
-    onHide () {
-      this.$_isShown = false
-    },
-  },
-}
-</script>

package/v2/config.js

@@ -1,133 +0,0 @@
-export const config = {
-    // Disable popper components
-    disabled: false,
-    // Default position offset along main axis (px)
-    distance: 5,
-    // Default position offset along cross axis (px)
-    skidding: 0,
-    // Default container where the tooltip will be appended
-    container: 'body',
-    // Element used to compute position and size boundaries
-    boundary: undefined,
-    // Skip delay & CSS transitions when another popper is shown, so that the popper appear to instanly move to the new position.
-    instantMove: false,
-    // Auto destroy tooltip DOM nodes (ms)
-    disposeTimeout: 5000,
-    // Triggers on the popper itself
-    popperTriggers: [],
-    // Positioning strategy
-    strategy: 'absolute',
-    // Prevent overflow
-    preventOverflow: true,
-    // Flip to the opposite placement if needed
-    flip: true,
-    // Shift on the cross axis to prevent the popper from overflowing
-    shift: true,
-    // Overflow padding (px)
-    overflowPadding: 0,
-    // Arrow padding (px)
-    arrowPadding: 0,
-    // Compute arrow overflow (useful to hide it)
-    arrowOverflow: true,
-    // Themes
-    themes: {
-        tooltip: {
-            // Default tooltip placement relative to target element
-            placement: 'top',
-            // Default events that trigger the tooltip
-            triggers: ['hover', 'focus', 'touch'],
-            // Close tooltip on click on tooltip target
-            hideTriggers: events => [...events, 'click'],
-            // Delay (ms)
-            delay: {
-                show: 200,
-                hide: 0,
-            },
-            // Update popper on content resize
-            handleResize: false,
-            // Enable HTML content in directive
-            html: false,
-            // Displayed when tooltip content is loading
-            loadingContent: '...',
-        },
-        dropdown: {
-            // Default dropdown placement relative to target element
-            placement: 'bottom',
-            // Default events that trigger the dropdown
-            triggers: ['click'],
-            // Delay (ms)
-            delay: 0,
-            // Update popper on content resize
-            handleResize: true,
-            // Hide on clock outside
-            autoHide: true,
-        },
-        menu: {
-            $extend: 'dropdown',
-            triggers: ['hover', 'focus'],
-            popperTriggers: ['hover', 'focus'],
-            delay: {
-                show: 0,
-                hide: 400,
-            },
-        },
-    },
-};
-/**
- * Get default config value depending on theme
- */
-export function getDefaultConfig(theme, key) {
-    let themeConfig = config.themes[theme] || {};
-    let value;
-    do {
-        value = themeConfig[key];
-        if (typeof value === 'undefined') {
-            // Support theme extend
-            if (themeConfig.$extend) {
-                themeConfig = config.themes[themeConfig.$extend] || {};
-            }
-            else {
-                // Base config
-                themeConfig = null;
-                value = config[key];
-            }
-        }
-        else {
-            themeConfig = null;
-        }
-    } while (themeConfig);
-    return value;
-}
-/**
- * Theme CSS inheritance
- */
-export function getThemeClasses(theme) {
-    const result = [theme];
-    let themeConfig = config.themes[theme] || {};
-    do {
-        // Support theme extend
-        if (themeConfig.$extend && !themeConfig.$resetCss) {
-            result.push(themeConfig.$extend);
-            themeConfig = config.themes[themeConfig.$extend] || {};
-        }
-        else {
-            themeConfig = null;
-        }
-    } while (themeConfig);
-    return result.map(c => `v-popper--theme-${c}`);
-}
-export function getAllParentThemes(theme) {
-    const result = [theme];
-    let themeConfig = config.themes[theme] || {};
-    do {
-        // Support theme extend
-        if (themeConfig.$extend) {
-            result.push(themeConfig.$extend);
-            themeConfig = config.themes[themeConfig.$extend] || {};
-        }
-        else {
-            themeConfig = null;
-        }
-    } while (themeConfig);
-    return result;
-}

package/v2/directives/v-close-popper.js

@@ -1,67 +0,0 @@
-import { supportsPassive } from '../util/env';
-function addListeners(el) {
-    el.addEventListener('click', onClick);
-    el.addEventListener('touchstart', onTouchStart, supportsPassive
-        ? {
-            passive: true,
-        }
-        : false);
-}
-function removeListeners(el) {
-    el.removeEventListener('click', onClick);
-    el.removeEventListener('touchstart', onTouchStart);
-    el.removeEventListener('touchend', onTouchEnd);
-    el.removeEventListener('touchcancel', onTouchCancel);
-}
-function onClick(event) {
-    const el = event.currentTarget;
-    event.closePopover = !el.$_vclosepopover_touch;
-    event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;
-}
-function onTouchStart(event) {
-    if (event.changedTouches.length === 1) {
-        const el = event.currentTarget;
-        el.$_vclosepopover_touch = true;
-        const touch = event.changedTouches[0];
-        el.$_vclosepopover_touchPoint = touch;
-        el.addEventListener('touchend', onTouchEnd);
-        el.addEventListener('touchcancel', onTouchCancel);
-    }
-}
-function onTouchEnd(event) {
-    const el = event.currentTarget;
-    el.$_vclosepopover_touch = false;
-    if (event.changedTouches.length === 1) {
-        const touch = event.changedTouches[0];
-        const firstTouch = el.$_vclosepopover_touchPoint;
-        event.closePopover = (Math.abs(touch.screenY - firstTouch.screenY) < 20 &&
-            Math.abs(touch.screenX - firstTouch.screenX) < 20);
-        event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;
-    }
-}
-function onTouchCancel(event) {
-    const el = event.currentTarget;
-    el.$_vclosepopover_touch = false;
-}
-export default {
-    bind(el, { value, modifiers }) {
-        el.$_closePopoverModifiers = modifiers;
-        if (typeof value === 'undefined' || value) {
-            addListeners(el);
-        }
-    },
-    update(el, { value, oldValue, modifiers }) {
-        el.$_closePopoverModifiers = modifiers;
-        if (value !== oldValue) {
-            if (typeof value === 'undefined' || value) {
-                addListeners(el);
-            }
-            else {
-                removeListeners(el);
-            }
-        }
-    },
-    unbind(el) {
-        removeListeners(el);
-    },
-};

package/v2/directives/v-tooltip.js

@@ -1,116 +0,0 @@
-import Vue from 'vue';
-import TooltipDirective from '../components/TooltipDirective.vue';
-import { getDefaultConfig } from '../config';
-import PopperMethods from '../components/PopperMethods';
-import { placements } from '../util/popper';
-const TARGET_CLASS = 'v-popper--has-tooltip';
-/**
- * Support placement as directive modifier
- */
-export function getPlacement(options, modifiers) {
-    let result = options.placement;
-    if (!result && modifiers) {
-        for (const pos of placements) {
-            if (modifiers[pos]) {
-                result = pos;
-            }
-        }
-    }
-    if (!result) {
-        result = getDefaultConfig(options.theme || 'tooltip', 'placement');
-    }
-    return result;
-}
-export function getOptions(el, value, modifiers) {
-    let options;
-    const type = typeof value;
-    if (type === 'string') {
-        options = { content: value };
-    }
-    else if (value && type === 'object') {
-        options = value;
-    }
-    else {
-        options = { content: false };
-    }
-    options.placement = getPlacement(options, modifiers);
-    options.targetNodes = () => [el];
-    options.referenceNode = () => el;
-    return options;
-}
-export function createTooltip(el, value, modifiers) {
-    const options = getOptions(el, value, modifiers);
-    const tooltipApp = el.$_popper = new Vue({
-        mixins: [
-            PopperMethods,
-        ],
-        data() {
-            return {
-                options,
-            };
-        },
-        render(h) {
-            const { theme, html, content, loadingContent, ...otherOptions } = this.options;
-            return h(TooltipDirective, {
-                props: {
-                    theme,
-                    html,
-                    content,
-                    loadingContent,
-                },
-                attrs: otherOptions,
-                ref: 'popper',
-            });
-        },
-        // @ts-expect-error custom option
-        devtools: {
-            hide: true,
-        },
-    });
-    const mountTarget = document.createElement('div');
-    document.body.appendChild(mountTarget);
-    tooltipApp.$mount(mountTarget);
-    // Class on target
-    if (el.classList) {
-        el.classList.add(TARGET_CLASS);
-    }
-    return tooltipApp;
-}
-export function destroyTooltip(el) {
-    if (el.$_popper) {
-        el.$_popper.$destroy();
-        delete el.$_popper;
-        delete el.$_popperOldShown;
-    }
-    if (el.classList) {
-        el.classList.remove(TARGET_CLASS);
-    }
-}
-export function bind(el, { value, oldValue, modifiers }) {
-    const options = getOptions(el, value, modifiers);
-    if (!options.content || getDefaultConfig(options.theme || 'tooltip', 'disabled')) {
-        destroyTooltip(el);
-    }
-    else {
-        let tooltipApp;
-        if (el.$_popper) {
-            tooltipApp = el.$_popper;
-            tooltipApp.options = options;
-        }
-        else {
-            tooltipApp = createTooltip(el, value, modifiers);
-        }
-        // Manual show
-        if (typeof value.shown !== 'undefined' && value.shown !== el.$_popperOldShown) {
-            el.$_popperOldShown = value.shown;
-            value.shown ? tooltipApp.show() : tooltipApp.hide();
-        }
-    }
-}
-export default {
-    bind,
-    update: bind,
-    unbind(el) {
-        destroyTooltip(el);
-    },
-};

package/v2/floating-ui/core/computeCoordsFromPlacement.js

@@ -1,39 +0,0 @@
-import { getBasePlacement } from './utils/getBasePlacement';
-import { getAlignment } from './utils/getAlignment';
-import { getMainAxisFromPlacement } from './utils/getMainAxisFromPlacement';
-import { getLengthFromAxis } from './utils/getLengthFromAxis';
-export function computeCoordsFromPlacement({ reference, floating, placement, }) {
-    const commonX = reference.x + reference.width / 2 - floating.width / 2;
-    const commonY = reference.y + reference.height / 2 - floating.height / 2;
-    let coords;
-    switch (getBasePlacement(placement)) {
-        case 'top':
-            coords = { x: commonX, y: reference.y - floating.height };
-            break;
-        case 'bottom':
-            coords = { x: commonX, y: reference.y + reference.height };
-            break;
-        case 'right':
-            coords = { x: reference.x + reference.width, y: commonY };
-            break;
-        case 'left':
-            coords = { x: reference.x - floating.width, y: commonY };
-            break;
-        default:
-            coords = { x: reference.x, y: reference.y };
-    }
-    const mainAxis = getMainAxisFromPlacement(placement);
-    const length = getLengthFromAxis(mainAxis);
-    switch (getAlignment(placement)) {
-        case 'start':
-            coords[mainAxis] =
-                coords[mainAxis] - (reference[length] / 2 - floating[length] / 2);
-            break;
-        case 'end':
-            coords[mainAxis] =
-                coords[mainAxis] + (reference[length] / 2 - floating[length] / 2);
-            break;
-        default:
-    }
-    return coords;
-}

package/v2/floating-ui/core/computePosition.js

@@ -1,52 +0,0 @@
-import { computeCoordsFromPlacement } from './computeCoordsFromPlacement';
-export const computePosition = async (reference, floating, config) => {
-    const { placement = 'bottom', strategy = 'absolute', middleware = [], platform, } = config;
-    let rects = await platform.getElementRects({ reference, floating, strategy });
-    let { x, y } = computeCoordsFromPlacement({ ...rects, placement });
-    let statefulPlacement = placement;
-    let middlewareData = {};
-    let _debug_loop_count_ = 0;
-    for (let i = 0; i < middleware.length; i++) {
-        const { name, fn } = middleware[i];
-        const { x: nextX, y: nextY, data, reset, } = await fn({
-            x,
-            y,
-            initialPlacement: placement,
-            placement: statefulPlacement,
-            strategy,
-            middlewareData,
-            rects,
-            platform,
-            elements: { reference, floating },
-        });
-        x = nextX !== null && nextX !== void 0 ? nextX : x;
-        y = nextY !== null && nextY !== void 0 ? nextY : y;
-        middlewareData = { ...middlewareData, [name]: data !== null && data !== void 0 ? data : {} };
-        if (reset) {
-            if (typeof reset === 'object') {
-                if (reset.placement) {
-                    statefulPlacement = reset.placement;
-                }
-                if (reset.rects) {
-                    rects =
-                        reset.rects === true
-                            ? await platform.getElementRects({ reference, floating, strategy })
-                            : reset.rects;
-                }
-                ({ x, y } = computeCoordsFromPlacement({
-                    ...rects,
-                    placement: statefulPlacement,
-                }));
-            }
-            i = -1;
-            continue;
-        }
-    }
-    return {
-        x,
-        y,
-        placement: statefulPlacement,
-        strategy,
-        middlewareData,
-    };
-};

package/v2/floating-ui/core/detectOverflow.js

@@ -1,36 +0,0 @@
-import { getSideObjectFromPadding } from './utils/getPaddingObject';
-import { rectToClientRect } from './utils/rectToClientRect';
-export async function detectOverflow(middlewareArguments, options = {}) {
-    const { x, y, platform, rects, elements, strategy } = middlewareArguments;
-    const { boundary = 'clippingParents', rootBoundary = 'viewport', elementContext = 'floating', altBoundary = false, padding = 0, } = options;
-    const paddingObject = getSideObjectFromPadding(padding);
-    const altContext = elementContext === 'floating' ? 'reference' : 'floating';
-    const element = elements[altBoundary ? altContext : elementContext];
-    const clippingClientRect = await platform.getClippingClientRect({
-        element: (await platform.isElement(element))
-            ? element
-            : element.contextElement ||
-                (await platform.getDocumentElement({ element: elements.floating })),
-        boundary,
-        rootBoundary,
-    });
-    const elementClientRect = rectToClientRect(await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
-        rect: elementContext === 'floating'
-            ? { ...rects.floating, x, y }
-            : rects.reference,
-        offsetParent: await platform.getOffsetParent({
-            element: elements.floating,
-        }),
-        strategy,
-    }));
-    // positive = overflowing the clipping rect
-    // 0 or negative = within the clipping rect
-    return {
-        top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
-        bottom: elementClientRect.bottom -
-            clippingClientRect.bottom +
-            paddingObject.bottom,
-        left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
-        right: elementClientRect.right - clippingClientRect.right + paddingObject.right,
-    };
-}

package/v2/floating-ui/core/enums.js

@@ -1,7 +0,0 @@
-export const basePlacements = [
-    'top',
-    'right',
-    'bottom',
-    'left',
-];
-export const allPlacements = basePlacements.reduce((acc, basePlacement) => acc.concat(basePlacement, `${basePlacement}-start`, `${basePlacement}-end`), []);

package/v2/floating-ui/core/index.js

@@ -1,11 +0,0 @@
-export { computePosition } from './computePosition';
-export { detectOverflow } from './detectOverflow';
-export { arrow } from './middleware/arrow';
-export { autoPlacement } from './middleware/autoPlacement';
-export { flip } from './middleware/flip';
-export { hide } from './middleware/hide';
-export { offset } from './middleware/offset';
-export { shift, limitShift } from './middleware/shift';
-export { size } from './middleware/size';
-export { inline } from './middleware/inline';
-export { rectToClientRect } from './utils/rectToClientRect';

package/v2/floating-ui/core/middleware/arrow.js

@@ -1,52 +0,0 @@
-import { getBasePlacement } from '../utils/getBasePlacement';
-import { getLengthFromAxis } from '../utils/getLengthFromAxis';
-import { getMainAxisFromPlacement } from '../utils/getMainAxisFromPlacement';
-import { getSideObjectFromPadding } from '../utils/getPaddingObject';
-import { within } from '../utils/within';
-export const arrow = (options) => ({
-    name: 'arrow',
-    options,
-    async fn(middlewareArguments) {
-        // Since `element` is required, we don't Partial<> the type
-        const { element, padding = 0 } = options !== null && options !== void 0 ? options : {};
-        const { x, y, placement, rects, platform } = middlewareArguments;
-        if (element == null) {
-            if (__DEV__) {
-                console.warn('Floating UI: No `element` was passed to the `arrow` middleware.');
-            }
-            return {};
-        }
-        const paddingObject = getSideObjectFromPadding(padding);
-        const coords = { x, y };
-        const basePlacement = getBasePlacement(placement);
-        const axis = getMainAxisFromPlacement(basePlacement);
-        const length = getLengthFromAxis(axis);
-        const arrowDimensions = await platform.getDimensions({ element });
-        const minProp = axis === 'y' ? 'top' : 'left';
-        const maxProp = axis === 'y' ? 'bottom' : 'right';
-        const endDiff = rects.reference[length] +
-            rects.reference[axis] -
-            coords[axis] -
-            rects.floating[length];
-        const startDiff = coords[axis] - rects.reference[axis];
-        const arrowOffsetParent = await platform.getOffsetParent({ element });
-        const clientSize = arrowOffsetParent
-            ? axis === 'y'
-                ? arrowOffsetParent.clientHeight || 0
-                : arrowOffsetParent.clientWidth || 0
-            : 0;
-        const centerToReference = endDiff / 2 - startDiff / 2;
-        // Make sure the arrow doesn't overflow the floating element if the center
-        // point is outside of the floating element's bounds
-        const min = paddingObject[minProp];
-        const max = clientSize - arrowDimensions[length] - paddingObject[maxProp];
-        const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-        const offset = within(min, center, max);
-        return {
-            data: {
-                [axis]: offset,
-                centerOffset: center - offset,
-            },
-        };
-    },
-});