@gitlab/ui 132.0.0 → 132.0.2

package/dist/vendor/bootstrap-vue/src/constants/config.js

@@ -0,0 +1,11 @@
+const NAME = 'BvConfig';
+const PROP_NAME = '$bvConfig';
+const DEFAULT_BREAKPOINT = ['xs', 'sm', 'md', 'lg', 'xl'];
+
+// in milliseconds
+const TOOLTIP_DELAY = Object.freeze({
+  show: 500,
+  hide: 0
+});
+
+export { DEFAULT_BREAKPOINT, NAME, PROP_NAME, TOOLTIP_DELAY };

package/dist/vendor/bootstrap-vue/src/constants/env.js

@@ -0,0 +1,36 @@
+const HAS_WINDOW_SUPPORT = typeof window !== 'undefined';
+const HAS_DOCUMENT_SUPPORT = typeof document !== 'undefined';
+const HAS_NAVIGATOR_SUPPORT = typeof navigator !== 'undefined';
+/* istanbul ignore next: JSDOM always returns false */
+const HAS_MUTATION_OBSERVER_SUPPORT = typeof MutationObserver !== 'undefined' || typeof WebKitMutationObserver !== 'undefined' || typeof MozMutationObserver !== 'undefined';
+const IS_BROWSER = HAS_WINDOW_SUPPORT && HAS_DOCUMENT_SUPPORT && HAS_NAVIGATOR_SUPPORT;
+const WINDOW = HAS_WINDOW_SUPPORT ? window : {};
+const DOCUMENT = HAS_DOCUMENT_SUPPORT ? document : {};
+const NAVIGATOR = HAS_NAVIGATOR_SUPPORT ? navigator : {};
+const USER_AGENT = (NAVIGATOR.userAgent || '').toLowerCase();
+const IS_JSDOM = USER_AGENT.indexOf('jsdom') > 0;
+
+// Determine if the browser supports the option passive for events
+const HAS_PASSIVE_EVENT_SUPPORT = (() => {
+  let passiveEventSupported = false;
+  if (IS_BROWSER) {
+    try {
+      const options = {
+        // This function will be called when the browser
+        // attempts to access the passive property
+        get passive() {
+          /* istanbul ignore next: will never be called in JSDOM */
+          passiveEventSupported = true;
+        }
+      };
+      WINDOW.addEventListener('test', options, options);
+      WINDOW.removeEventListener('test', options, options);
+    } catch {
+      /* istanbul ignore next: will never be called in JSDOM */
+      passiveEventSupported = false;
+    }
+  }
+  return passiveEventSupported;
+})();
+
+export { DOCUMENT, HAS_DOCUMENT_SUPPORT, HAS_MUTATION_OBSERVER_SUPPORT, HAS_NAVIGATOR_SUPPORT, HAS_PASSIVE_EVENT_SUPPORT, HAS_WINDOW_SUPPORT, IS_BROWSER, IS_JSDOM, NAVIGATOR, USER_AGENT, WINDOW };

package/dist/vendor/bootstrap-vue/src/constants/events.js

@@ -0,0 +1,56 @@
+const EVENT_NAME_ACTIVATE_TAB = 'activate-tab';
+const EVENT_NAME_BLUR = 'blur';
+const EVENT_NAME_CANCEL = 'cancel';
+const EVENT_NAME_CHANGE = 'change';
+const EVENT_NAME_CHANGED = 'changed';
+const EVENT_NAME_CLICK = 'click';
+const EVENT_NAME_CLOSE = 'close';
+const EVENT_NAME_CONTEXT = 'context';
+const EVENT_NAME_CONTEXT_CHANGED = 'context-changed';
+const EVENT_NAME_DESTROYED = 'destroyed';
+const EVENT_NAME_DISABLE = 'disable';
+const EVENT_NAME_DISABLED = 'disabled';
+const EVENT_NAME_ENABLE = 'enable';
+const EVENT_NAME_ENABLED = 'enabled';
+const EVENT_NAME_FILTERED = 'filtered';
+const EVENT_NAME_FIRST = 'first';
+const EVENT_NAME_FOCUS = 'focus';
+const EVENT_NAME_FOCUSIN = 'focusin';
+const EVENT_NAME_FOCUSOUT = 'focusout';
+const EVENT_NAME_HEAD_CLICKED = 'head-clicked';
+const EVENT_NAME_HIDDEN = 'hidden';
+const EVENT_NAME_HIDE = 'hide';
+const EVENT_NAME_INPUT = 'input';
+const EVENT_NAME_LAST = 'last';
+const EVENT_NAME_MOUSEENTER = 'mouseenter';
+const EVENT_NAME_MOUSELEAVE = 'mouseleave';
+const EVENT_NAME_NEXT = 'next';
+const EVENT_NAME_OK = 'ok';
+const EVENT_NAME_OPEN = 'open';
+const EVENT_NAME_PREV = 'prev';
+const EVENT_NAME_REFRESH = 'refresh';
+const EVENT_NAME_REFRESHED = 'refreshed';
+const EVENT_NAME_ROW_CLICKED = 'row-clicked';
+const EVENT_NAME_ROW_CONTEXTMENU = 'row-contextmenu';
+const EVENT_NAME_ROW_DBLCLICKED = 'row-dblclicked';
+const EVENT_NAME_ROW_HOVERED = 'row-hovered';
+const EVENT_NAME_ROW_MIDDLE_CLICKED = 'row-middle-clicked';
+const EVENT_NAME_ROW_SELECTED = 'row-selected';
+const EVENT_NAME_ROW_UNHOVERED = 'row-unhovered';
+const EVENT_NAME_SHOW = 'show';
+const EVENT_NAME_SHOWN = 'shown';
+const EVENT_NAME_SORT_CHANGED = 'sort-changed';
+const EVENT_NAME_TOGGLE = 'toggle';
+const EVENT_NAME_UPDATE = 'update';
+const MODEL_EVENT_NAME_PREFIX = 'update:';
+const ROOT_EVENT_NAME_PREFIX = 'bv';
+const ROOT_EVENT_NAME_SEPARATOR = '::';
+const EVENT_OPTIONS_PASSIVE = {
+  passive: true
+};
+const EVENT_OPTIONS_NO_CAPTURE = {
+  passive: true,
+  capture: false
+};
+
+export { EVENT_NAME_ACTIVATE_TAB, EVENT_NAME_BLUR, EVENT_NAME_CANCEL, EVENT_NAME_CHANGE, EVENT_NAME_CHANGED, EVENT_NAME_CLICK, EVENT_NAME_CLOSE, EVENT_NAME_CONTEXT, EVENT_NAME_CONTEXT_CHANGED, EVENT_NAME_DESTROYED, EVENT_NAME_DISABLE, EVENT_NAME_DISABLED, EVENT_NAME_ENABLE, EVENT_NAME_ENABLED, EVENT_NAME_FILTERED, EVENT_NAME_FIRST, EVENT_NAME_FOCUS, EVENT_NAME_FOCUSIN, EVENT_NAME_FOCUSOUT, EVENT_NAME_HEAD_CLICKED, EVENT_NAME_HIDDEN, EVENT_NAME_HIDE, EVENT_NAME_INPUT, EVENT_NAME_LAST, EVENT_NAME_MOUSEENTER, EVENT_NAME_MOUSELEAVE, EVENT_NAME_NEXT, EVENT_NAME_OK, EVENT_NAME_OPEN, EVENT_NAME_PREV, EVENT_NAME_REFRESH, EVENT_NAME_REFRESHED, EVENT_NAME_ROW_CLICKED, EVENT_NAME_ROW_CONTEXTMENU, EVENT_NAME_ROW_DBLCLICKED, EVENT_NAME_ROW_HOVERED, EVENT_NAME_ROW_MIDDLE_CLICKED, EVENT_NAME_ROW_SELECTED, EVENT_NAME_ROW_UNHOVERED, EVENT_NAME_SHOW, EVENT_NAME_SHOWN, EVENT_NAME_SORT_CHANGED, EVENT_NAME_TOGGLE, EVENT_NAME_UPDATE, EVENT_OPTIONS_NO_CAPTURE, EVENT_OPTIONS_PASSIVE, MODEL_EVENT_NAME_PREFIX, ROOT_EVENT_NAME_PREFIX, ROOT_EVENT_NAME_SEPARATOR };

package/dist/vendor/bootstrap-vue/src/constants/key-codes.js

@@ -0,0 +1,11 @@
+const CODE_DOWN = 40;
+const CODE_END = 35;
+const CODE_ENTER = 13;
+const CODE_ESC = 27;
+const CODE_HOME = 36;
+const CODE_LEFT = 37;
+const CODE_RIGHT = 39;
+const CODE_SPACE = 32;
+const CODE_UP = 38;
+
+export { CODE_DOWN, CODE_END, CODE_ENTER, CODE_ESC, CODE_HOME, CODE_LEFT, CODE_RIGHT, CODE_SPACE, CODE_UP };

package/dist/vendor/bootstrap-vue/src/constants/popper.js

@@ -0,0 +1,10 @@
+const PLACEMENT_TOP_START = 'top-start';
+const PLACEMENT_TOP_END = 'top-end';
+const PLACEMENT_BOTTOM_START = 'bottom-start';
+const PLACEMENT_BOTTOM_END = 'bottom-end';
+const PLACEMENT_RIGHT_START = 'right-start';
+const PLACEMENT_RIGHT_END = 'right-end';
+const PLACEMENT_LEFT_START = 'left-start';
+const PLACEMENT_LEFT_END = 'left-end';
+
+export { PLACEMENT_BOTTOM_END, PLACEMENT_BOTTOM_START, PLACEMENT_LEFT_END, PLACEMENT_LEFT_START, PLACEMENT_RIGHT_END, PLACEMENT_RIGHT_START, PLACEMENT_TOP_END, PLACEMENT_TOP_START };

package/dist/vendor/bootstrap-vue/src/constants/props.js

@@ -0,0 +1,24 @@
+// General types
+const PROP_TYPE_ANY = undefined;
+const PROP_TYPE_ARRAY = Array;
+const PROP_TYPE_BOOLEAN = Boolean;
+const PROP_TYPE_FUNCTION = Function;
+const PROP_TYPE_NUMBER = Number;
+const PROP_TYPE_OBJECT = Object;
+const PROP_TYPE_REG_EXP = RegExp;
+const PROP_TYPE_STRING = String;
+
+// Multiple types
+const PROP_TYPE_ARRAY_FUNCTION = [PROP_TYPE_ARRAY, PROP_TYPE_FUNCTION];
+const PROP_TYPE_ARRAY_OBJECT = [PROP_TYPE_ARRAY, PROP_TYPE_OBJECT];
+const PROP_TYPE_ARRAY_OBJECT_STRING = [PROP_TYPE_ARRAY, PROP_TYPE_OBJECT, PROP_TYPE_STRING];
+const PROP_TYPE_ARRAY_STRING = [PROP_TYPE_ARRAY, PROP_TYPE_STRING];
+const PROP_TYPE_BOOLEAN_NUMBER = [PROP_TYPE_BOOLEAN, PROP_TYPE_NUMBER];
+const PROP_TYPE_BOOLEAN_NUMBER_STRING = [PROP_TYPE_BOOLEAN, PROP_TYPE_NUMBER, PROP_TYPE_STRING];
+const PROP_TYPE_BOOLEAN_STRING = [PROP_TYPE_BOOLEAN, PROP_TYPE_STRING];
+const PROP_TYPE_NUMBER_STRING = [PROP_TYPE_NUMBER, PROP_TYPE_STRING];
+const PROP_TYPE_NUMBER_OBJECT_STRING = [PROP_TYPE_NUMBER, PROP_TYPE_OBJECT, PROP_TYPE_STRING];
+const PROP_TYPE_OBJECT_FUNCTION = [PROP_TYPE_OBJECT, PROP_TYPE_FUNCTION];
+const PROP_TYPE_OBJECT_STRING = [PROP_TYPE_OBJECT, PROP_TYPE_STRING];
+
+export { PROP_TYPE_ANY, PROP_TYPE_ARRAY, PROP_TYPE_ARRAY_FUNCTION, PROP_TYPE_ARRAY_OBJECT, PROP_TYPE_ARRAY_OBJECT_STRING, PROP_TYPE_ARRAY_STRING, PROP_TYPE_BOOLEAN, PROP_TYPE_BOOLEAN_NUMBER, PROP_TYPE_BOOLEAN_NUMBER_STRING, PROP_TYPE_BOOLEAN_STRING, PROP_TYPE_FUNCTION, PROP_TYPE_NUMBER, PROP_TYPE_NUMBER_OBJECT_STRING, PROP_TYPE_NUMBER_STRING, PROP_TYPE_OBJECT, PROP_TYPE_OBJECT_FUNCTION, PROP_TYPE_OBJECT_STRING, PROP_TYPE_REG_EXP, PROP_TYPE_STRING };

package/dist/vendor/bootstrap-vue/src/constants/regex.js

@@ -0,0 +1,35 @@
+// --- General ---
+
+const RX_ARRAY_NOTATION = /\[(\d+)]/g;
+const RX_BV_PREFIX = /^(BV?)/;
+const RX_DIGITS = /^\d+$/;
+const RX_HASH = /^#/;
+const RX_HASH_ID = /^#[A-Za-z]+[\w\-:.]*$/;
+const RX_HTML_TAGS = /(<([^>]+)>)/gi;
+const RX_HYPHENATE = /\B([A-Z])/g;
+const RX_LOWER_UPPER = /([a-z])([A-Z])/g;
+const RX_NUMBER = /^[0-9]*\.?[0-9]+$/;
+const RX_PLUS = /\+/g;
+const RX_REGEXP_REPLACE = /[-/\\^$*+?.()|[\]{}]/g;
+const RX_SPACES = /[\s\uFEFF\xA0]+/g;
+const RX_SPACE_SPLIT = /\s+/;
+const RX_START_SPACE_WORD = /(\s|^)(\w)/g;
+const RX_TRIM_LEFT = /^\s+/;
+const RX_TRIM_RIGHT = /\s+$/;
+const RX_UNDERSCORE = /_/g;
+
+// --- URL ---
+
+const RX_ENCODED_COMMA = /%2C/g;
+const RX_ENCODE_REVERSE = /[!'()*]/g;
+const RX_QUERY_START = /^(\?|#|&)/;
+
+// --- Grid ---
+
+const RX_COL_CLASS = /^col-/;
+
+// --- Locale ---
+
+const RX_STRIP_LOCALE_MODS = /-u-.+/;
+
+export { RX_ARRAY_NOTATION, RX_BV_PREFIX, RX_COL_CLASS, RX_DIGITS, RX_ENCODED_COMMA, RX_ENCODE_REVERSE, RX_HASH, RX_HASH_ID, RX_HTML_TAGS, RX_HYPHENATE, RX_LOWER_UPPER, RX_NUMBER, RX_PLUS, RX_QUERY_START, RX_REGEXP_REPLACE, RX_SPACES, RX_SPACE_SPLIT, RX_START_SPACE_WORD, RX_STRIP_LOCALE_MODS, RX_TRIM_LEFT, RX_TRIM_RIGHT, RX_UNDERSCORE };

package/dist/vendor/bootstrap-vue/src/constants/safe-types.js

@@ -0,0 +1,15 @@
+import { HAS_WINDOW_SUPPORT, WINDOW } from './env';
+
+/* istanbul ignore next */
+const Element = HAS_WINDOW_SUPPORT ? WINDOW.Element : class Element extends Object {};
+
+/* istanbul ignore next */
+const HTMLElement = HAS_WINDOW_SUPPORT ? WINDOW.HTMLElement : class HTMLElement extends Element {};
+
+/* istanbul ignore next */
+const SVGElement = HAS_WINDOW_SUPPORT ? WINDOW.SVGElement : class SVGElement extends Element {};
+
+/* istanbul ignore next */
+const File = HAS_WINDOW_SUPPORT ? WINDOW.File : class File extends Object {};
+
+export { Element, File, HTMLElement, SVGElement };

package/dist/vendor/bootstrap-vue/src/constants/slots.js

@@ -0,0 +1,36 @@
+const SLOT_NAME_APPEND = 'append';
+const SLOT_NAME_BOTTOM_ROW = 'bottom-row';
+const SLOT_NAME_BUTTON_CONTENT = 'button-content';
+const SLOT_NAME_CUSTOM_FOOT = 'custom-foot';
+const SLOT_NAME_DEFAULT = 'default';
+const SLOT_NAME_DESCRIPTION = 'description';
+const SLOT_NAME_EMPTY = 'empty';
+const SLOT_NAME_EMPTYFILTERED = 'emptyfiltered';
+const SLOT_NAME_FIRST = 'first';
+const SLOT_NAME_HEADER = 'header';
+const SLOT_NAME_INVALID_FEEDBACK = 'invalid-feedback';
+const SLOT_NAME_LABEL = 'label';
+const SLOT_NAME_MODAL_BACKDROP = 'modal-backdrop';
+const SLOT_NAME_MODAL_CANCEL = 'modal-cancel';
+const SLOT_NAME_MODAL_FOOTER = 'modal-footer';
+const SLOT_NAME_MODAL_HEADER = 'modal-header';
+const SLOT_NAME_MODAL_HEADER_CLOSE = 'modal-header-close';
+const SLOT_NAME_MODAL_OK = 'modal-ok';
+const SLOT_NAME_MODAL_TITLE = 'modal-title';
+const SLOT_NAME_PREPEND = 'prepend';
+const SLOT_NAME_ROW_DETAILS = 'row-details';
+const SLOT_NAME_TABLE_BUSY = 'table-busy';
+const SLOT_NAME_TABLE_CAPTION = 'table-caption';
+const SLOT_NAME_TABLE_COLGROUP = 'table-colgroup';
+const SLOT_NAME_TABS_END = 'tabs-end';
+const SLOT_NAME_TABS_START = 'tabs-start';
+const SLOT_NAME_TOOLBAR_END = 'toolbar-end';
+const SLOT_NAME_TOOLBAR_START = 'toolbar-start';
+const SLOT_NAME_TEXT = 'text';
+const SLOT_NAME_THEAD_TOP = 'thead-top';
+const SLOT_NAME_TITLE = 'title';
+const SLOT_NAME_TOAST_TITLE = 'toast-title';
+const SLOT_NAME_TOP_ROW = 'top-row';
+const SLOT_NAME_VALID_FEEDBACK = 'valid-feedback';
+
+export { SLOT_NAME_APPEND, SLOT_NAME_BOTTOM_ROW, SLOT_NAME_BUTTON_CONTENT, SLOT_NAME_CUSTOM_FOOT, SLOT_NAME_DEFAULT, SLOT_NAME_DESCRIPTION, SLOT_NAME_EMPTY, SLOT_NAME_EMPTYFILTERED, SLOT_NAME_FIRST, SLOT_NAME_HEADER, SLOT_NAME_INVALID_FEEDBACK, SLOT_NAME_LABEL, SLOT_NAME_MODAL_BACKDROP, SLOT_NAME_MODAL_CANCEL, SLOT_NAME_MODAL_FOOTER, SLOT_NAME_MODAL_HEADER, SLOT_NAME_MODAL_HEADER_CLOSE, SLOT_NAME_MODAL_OK, SLOT_NAME_MODAL_TITLE, SLOT_NAME_PREPEND, SLOT_NAME_ROW_DETAILS, SLOT_NAME_TABLE_BUSY, SLOT_NAME_TABLE_CAPTION, SLOT_NAME_TABLE_COLGROUP, SLOT_NAME_TABS_END, SLOT_NAME_TABS_START, SLOT_NAME_TEXT, SLOT_NAME_THEAD_TOP, SLOT_NAME_TITLE, SLOT_NAME_TOAST_TITLE, SLOT_NAME_TOOLBAR_END, SLOT_NAME_TOOLBAR_START, SLOT_NAME_TOP_ROW, SLOT_NAME_VALID_FEEDBACK };

package/dist/vendor/bootstrap-vue/src/directives/modal/index.js

@@ -0,0 +1 @@
+export { VBModal } from './modal';

package/dist/vendor/bootstrap-vue/src/directives/modal/modal.js

@@ -0,0 +1,112 @@
+import { NAME_MODAL } from '../../constants/components';
+import { EVENT_NAME_SHOW, EVENT_OPTIONS_PASSIVE } from '../../constants/events';
+import { CODE_ENTER, CODE_SPACE } from '../../constants/key-codes';
+import { matches, select, hasAttr, setAttr, getAttr, isDisabled } from '../../utils/dom';
+import { getRootActionEventName, eventOff, eventOn } from '../../utils/events';
+import { isString } from '../../utils/inspect';
+import { keys } from '../../utils/object';
+import { getEventRoot } from '../../utils/get-event-root';
+import { getInstanceFromDirective } from '../../utils/get-instance-from-directive';
+
+// Emitted show event for modal
+const ROOT_ACTION_EVENT_NAME_SHOW = getRootActionEventName(NAME_MODAL, EVENT_NAME_SHOW);
+
+// Prop name we use to store info on root element
+const PROPERTY = '__bv_modal_directive__';
+const getTarget = _ref => {
+  let {
+    modifiers = {},
+    arg,
+    value
+  } = _ref;
+  // Try value, then arg, otherwise pick last modifier
+  return isString(value) ? value : isString(arg) ? arg : keys(modifiers).reverse()[0];
+};
+const getTriggerElement = el => {
+  // If root element is a dropdown-item or nav-item, we
+  // need to target the inner link or button instead
+  return el && matches(el, '.dropdown-menu > li, li.nav-item') ? select('a, button', el) || el : el;
+};
+const setRole = trigger => {
+  // Ensure accessibility on non button elements
+  if (trigger && trigger.tagName !== 'BUTTON') {
+    // Only set a role if the trigger element doesn't have one
+    if (!hasAttr(trigger, 'role')) {
+      setAttr(trigger, 'role', 'button');
+    }
+    // Add a tabindex is not a button or link, and tabindex is not provided
+    if (trigger.tagName !== 'A' && !hasAttr(trigger, 'tabindex')) {
+      setAttr(trigger, 'tabindex', '0');
+    }
+  }
+};
+const bind = (el, binding, vnode) => {
+  const target = getTarget(binding);
+  const trigger = getTriggerElement(el);
+  if (target && trigger) {
+    const handler = event => {
+      // `currentTarget` is the element with the listener on it
+      const currentTarget = event.currentTarget;
+      if (!isDisabled(currentTarget)) {
+        const type = event.type;
+        const key = event.keyCode;
+        // Open modal only if trigger is not disabled
+        if (type === 'click' || type === 'keydown' && (key === CODE_ENTER || key === CODE_SPACE)) {
+          getEventRoot(getInstanceFromDirective(vnode, binding)).$emit(ROOT_ACTION_EVENT_NAME_SHOW, target, currentTarget);
+        }
+      }
+    };
+    el[PROPERTY] = {
+      handler,
+      target,
+      trigger
+    };
+    // If element is not a button, we add `role="button"` for accessibility
+    setRole(trigger);
+    // Listen for click events
+    eventOn(trigger, 'click', handler, EVENT_OPTIONS_PASSIVE);
+    if (trigger.tagName !== 'BUTTON' && getAttr(trigger, 'role') === 'button') {
+      // If trigger isn't a button but has role button,
+      // we also listen for `keydown.space` && `keydown.enter`
+      eventOn(trigger, 'keydown', handler, EVENT_OPTIONS_PASSIVE);
+    }
+  }
+};
+const unbind = el => {
+  const oldProp = el[PROPERTY] || {};
+  const trigger = oldProp.trigger;
+  const handler = oldProp.handler;
+  if (trigger && handler) {
+    eventOff(trigger, 'click', handler, EVENT_OPTIONS_PASSIVE);
+    eventOff(trigger, 'keydown', handler, EVENT_OPTIONS_PASSIVE);
+    eventOff(el, 'click', handler, EVENT_OPTIONS_PASSIVE);
+    eventOff(el, 'keydown', handler, EVENT_OPTIONS_PASSIVE);
+  }
+  delete el[PROPERTY];
+};
+const componentUpdated = (el, binding, vnode) => {
+  const oldProp = el[PROPERTY] || {};
+  const target = getTarget(binding);
+  const trigger = getTriggerElement(el);
+  if (target !== oldProp.target || trigger !== oldProp.trigger) {
+    // We bind and rebind if the target or trigger changes
+    unbind(el);
+    bind(el, binding, vnode);
+  }
+  // If trigger element is not a button, ensure `role="button"`
+  // is still set for accessibility
+  setRole(trigger);
+};
+const updated = () => {};
+
+/*
+ * Export our directive
+ */
+const VBModal = {
+  inserted: componentUpdated,
+  updated,
+  componentUpdated,
+  unbind
+};
+
+export { VBModal };

package/dist/vendor/bootstrap-vue/src/directives/tooltip/index.js

@@ -0,0 +1 @@
+export { VBTooltip } from './tooltip';

package/dist/vendor/bootstrap-vue/src/directives/tooltip/tooltip.js

@@ -0,0 +1,267 @@
+import { IS_BROWSER } from '../../constants/env';
+import { EVENT_NAME_SHOW } from '../../constants/events';
+import { concat } from '../../utils/array';
+import { isVue3 } from '../../vue';
+import { getScopeId } from '../../utils/get-scope-id';
+import { TOOLTIP_DELAY } from '../../constants/config';
+import { identity } from '../../utils/identity';
+import { getInstanceFromDirective } from '../../utils/get-instance-from-directive';
+import { isFunction, isString, isNumber, isPlainObject, isUndefined, isUndefinedOrNull } from '../../utils/inspect';
+import { looseEqual } from '../../utils/loose-equal';
+import { toInteger } from '../../utils/number';
+import { keys } from '../../utils/object';
+import { createNewChildComponent, eventProp } from '../../utils/create-new-child-component';
+import { BVTooltip } from '../../components/tooltip/helpers/bv-tooltip';
+
+// Key which we use to store tooltip object on element
+const BV_TOOLTIP = '__BV_Tooltip__';
+
+// Default trigger
+const DefaultTrigger = 'hover focus';
+
+// Valid event triggers
+const validTriggers = {
+  focus: true,
+  hover: true,
+  click: true,
+  blur: true,
+  manual: true
+};
+
+// Directive modifier test regular expressions. Pre-compile for performance
+const htmlRE = /^html$/i;
+const noninteractiveRE = /^noninteractive$/i;
+const noFadeRE = /^nofade$/i;
+const placementRE = /^(auto|top(left|right)?|bottom(left|right)?|left(top|bottom)?|right(top|bottom)?)$/i;
+const boundaryRE = /^(window|viewport|scrollParent)$/i;
+const delayRE = /^d\d+$/i;
+const delayShowRE = /^ds\d+$/i;
+const delayHideRE = /^dh\d+$/i;
+const offsetRE = /^o-?\d+$/i;
+const variantRE = /^v-.+$/i;
+const spacesRE = /\s+/;
+
+// Build a Tooltip config based on bindings (if any)
+// Arguments and modifiers take precedence over passed value config object
+const parseBindings = (bindings, vnode) => /* istanbul ignore next: not easy to test */{
+  // We start out with a basic config
+  let config = {
+    title: undefined,
+    trigger: '',
+    // Default set below if needed
+    placement: 'top',
+    fallbackPlacement: 'flip',
+    container: false,
+    // Default of body
+    animation: true,
+    offset: 0,
+    id: null,
+    html: false,
+    interactive: true,
+    disabled: false,
+    delay: {
+      ...TOOLTIP_DELAY
+    },
+    boundary: 'scrollParent',
+    boundaryPadding: 5,
+    variant: undefined,
+    customClass: 'gl-tooltip'
+  };
+  // Process `bindings.value`
+  if (isString(bindings.value) || isNumber(bindings.value)) {
+    // Value is tooltip content (HTML optionally supported)
+    config.title = bindings.value;
+  } else if (isFunction(bindings.value)) {
+    // Title generator function
+    config.title = bindings.value;
+  } else if (isPlainObject(bindings.value)) {
+    // Value is config object, so merge
+    config = {
+      ...config,
+      ...bindings.value
+    };
+  }
+
+  // If title is not provided, try title attribute
+  if (isUndefined(config.title)) {
+    // Try attribute
+    const attrs = isVue3(getInstanceFromDirective(vnode, bindings)) ? vnode.props : (vnode.data || {}).attrs;
+    config.title = attrs && !isUndefinedOrNull(attrs.title) ? attrs.title : undefined;
+  }
+
+  // Normalize delay
+  if (!isPlainObject(config.delay)) {
+    config.delay = {
+      show: toInteger(config.delay, 0),
+      hide: toInteger(config.delay, 0)
+    };
+  }
+
+  // If argument, assume element ID of container element
+  if (bindings.arg) {
+    // Element ID specified as arg
+    // We must prepend '#' to become a CSS selector
+    config.container = `#${bindings.arg}`;
+  }
+
+  // Process modifiers
+  keys(bindings.modifiers).forEach(mod => {
+    if (htmlRE.test(mod)) {
+      // Title allows HTML
+      config.html = true;
+    } else if (noninteractiveRE.test(mod)) {
+      // Noninteractive
+      config.interactive = false;
+    } else if (noFadeRE.test(mod)) {
+      // No animation
+      config.animation = false;
+    } else if (placementRE.test(mod)) {
+      // Placement of tooltip
+      config.placement = mod;
+    } else if (boundaryRE.test(mod)) {
+      // Boundary of tooltip
+      mod = mod === 'scrollparent' ? 'scrollParent' : mod;
+      config.boundary = mod;
+    } else if (delayRE.test(mod)) {
+      // Delay value
+      const delay = toInteger(mod.slice(1), 0);
+      config.delay.show = delay;
+      config.delay.hide = delay;
+    } else if (delayShowRE.test(mod)) {
+      // Delay show value
+      config.delay.show = toInteger(mod.slice(2), 0);
+    } else if (delayHideRE.test(mod)) {
+      // Delay hide value
+      config.delay.hide = toInteger(mod.slice(2), 0);
+    } else if (offsetRE.test(mod)) {
+      // Offset value, negative allowed
+      config.offset = toInteger(mod.slice(1), 0);
+    } else if (variantRE.test(mod)) {
+      // Variant
+      config.variant = mod.slice(2) || null;
+    }
+  });
+
+  // Special handling of event trigger modifiers trigger is
+  // a space separated list
+  const selectedTriggers = {};
+
+  // Parse current config object trigger
+  concat(config.trigger || '').filter(identity).join(' ').trim().toLowerCase().split(spacesRE).forEach(trigger => {
+    if (validTriggers[trigger]) {
+      selectedTriggers[trigger] = true;
+    }
+  });
+
+  // Parse modifiers for triggers
+  keys(bindings.modifiers).forEach(mod => {
+    mod = mod.toLowerCase();
+    if (validTriggers[mod]) {
+      // If modifier is a valid trigger
+      selectedTriggers[mod] = true;
+    }
+  });
+
+  // Sanitize triggers
+  config.trigger = keys(selectedTriggers).join(' ');
+  if (config.trigger === 'blur') {
+    // Blur by itself is useless, so convert it to 'focus'
+    config.trigger = 'focus';
+  }
+  if (!config.trigger) {
+    // Use default trigger
+    config.trigger = DefaultTrigger;
+  }
+
+  // Return the config
+  return config;
+};
+
+// Add/update Tooltip on our element
+const applyTooltip = (el, bindings, vnode) => {
+  if (!IS_BROWSER) {
+    /* istanbul ignore next */
+    return;
+  }
+  const config = parseBindings(bindings, vnode);
+  if (!el[BV_TOOLTIP]) {
+    const parent = getInstanceFromDirective(vnode, bindings);
+    el[BV_TOOLTIP] = createNewChildComponent(parent, BVTooltip, {
+      // Add the parent's scoped style attribute data
+      _scopeId: getScopeId(parent, undefined),
+      propsData: {
+        [eventProp(EVENT_NAME_SHOW)]: () => /* istanbul ignore next: for now */{
+          // Before showing the tooltip, we update the title if it is a function
+          if (isFunction(config.title)) {
+            el[BV_TOOLTIP].updateData({
+              title: config.title(el)
+            });
+          }
+        }
+      }
+    });
+    el[BV_TOOLTIP].__bv_prev_data__ = {};
+  }
+  const data = {
+    title: config.title,
+    triggers: config.trigger,
+    placement: config.placement,
+    fallbackPlacement: config.fallbackPlacement,
+    variant: config.variant,
+    customClass: config.customClass,
+    container: config.container,
+    boundary: config.boundary,
+    delay: config.delay,
+    offset: config.offset,
+    noFade: !config.animation,
+    id: config.id,
+    interactive: config.interactive,
+    disabled: config.disabled,
+    html: config.html
+  };
+  const oldData = el[BV_TOOLTIP].__bv_prev_data__;
+  el[BV_TOOLTIP].__bv_prev_data__ = data;
+  if (!looseEqual(data, oldData)) {
+    // We only update the instance if data has changed
+    const newData = {
+      target: el
+    };
+    keys(data).forEach(prop => {
+      // We only pass data properties that have changed
+      if (data[prop] !== oldData[prop]) {
+        // if title is a function, we execute it here
+        newData[prop] = prop === 'title' && isFunction(data[prop]) ? data[prop](el) : data[prop];
+      }
+    });
+    el[BV_TOOLTIP].updateData(newData);
+  }
+};
+
+// Remove Tooltip on our element
+const removeTooltip = el => {
+  if (el[BV_TOOLTIP]) {
+    el[BV_TOOLTIP].$destroy();
+    el[BV_TOOLTIP] = null;
+  }
+  delete el[BV_TOOLTIP];
+};
+
+// Export our directive
+const VBTooltip = {
+  bind(el, bindings, vnode) {
+    applyTooltip(el, bindings, vnode);
+  },
+  // We use `componentUpdated` here instead of `update`, as the former
+  // waits until the containing component and children have finished updating
+  componentUpdated(el, bindings, vnode) {
+    // Performed in a `$nextTick()` to prevent render update loops
+    getInstanceFromDirective(vnode, bindings).$nextTick(() => {
+      applyTooltip(el, bindings, vnode);
+    });
+  },
+  unbind(el) {
+    removeTooltip(el);
+  }
+};
+
+export { VBTooltip };

package/dist/vendor/bootstrap-vue/src/directives/visible/index.js

@@ -0,0 +1 @@
+export { VBVisible } from './visible';