@gitlab/ui 84.2.0 → 85.0.1

package/dist/vendor/bootstrap-vue/src/utils/math.js

@@ -0,0 +1,11 @@
+// Math utilty functions
+
+const mathMin = Math.min;
+const mathMax = Math.max;
+const mathAbs = Math.abs;
+const mathCeil = Math.ceil;
+const mathFloor = Math.floor;
+const mathPow = Math.pow;
+const mathRound = Math.round;
+
+export { mathAbs, mathCeil, mathFloor, mathMax, mathMin, mathPow, mathRound };

package/dist/vendor/bootstrap-vue/src/utils/memoize.js

@@ -0,0 +1,14 @@
+import { create } from './object';
+
+const memoize = fn => {
+  const cache = create(null);
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    const argsKey = JSON.stringify(args);
+    return cache[argsKey] = cache[argsKey] || fn.apply(null, args);
+  };
+};
+
+export { memoize };

package/dist/vendor/bootstrap-vue/src/utils/model.js

@@ -0,0 +1,33 @@
+import { extend } from '../vue';
+import { EVENT_NAME_INPUT } from '../constants/events';
+import { PROP_TYPE_ANY } from '../constants/props';
+import { makeProp } from './props';
+
+const makeModelMixin = function (prop) {
+  let {
+    type = PROP_TYPE_ANY,
+    defaultValue = undefined,
+    validator = undefined,
+    event = EVENT_NAME_INPUT
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const props = {
+    [prop]: makeProp(type, defaultValue, validator)
+  };
+
+  // @vue/component
+  const mixin = extend({
+    model: {
+      prop,
+      event
+    },
+    props
+  });
+  return {
+    mixin,
+    props,
+    prop,
+    event
+  };
+};
+
+export { makeModelMixin };

package/dist/vendor/bootstrap-vue/src/utils/noop.js

@@ -0,0 +1,3 @@
+const noop = () => {};
+
+export { noop };

package/dist/vendor/bootstrap-vue/src/utils/normalize-slot.js

@@ -0,0 +1,51 @@
+import { concat } from './array';
+import { identity } from './identity';
+import { isFunction } from './inspect';
+
+// Note for functional components:
+// In functional components, `slots` is a function so it must be called
+// first before passing to the below methods. `scopedSlots` is always an
+// object and may be undefined (for Vue < 2.6.x)
+
+/**
+ * Returns true if either scoped or unscoped named slot exists
+ *
+ * @param {String, Array} name or name[]
+ * @param {Object} scopedSlots
+ * @param {Object} slots
+ * @returns {Array|undefined} VNodes
+ */
+const hasNormalizedSlot = function (names) {
+  let $scopedSlots = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let $slots = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  // Ensure names is an array
+  names = concat(names).filter(identity);
+  // Returns true if the either a $scopedSlot or $slot exists with the specified name
+  return names.some(name => $scopedSlots[name] || $slots[name]);
+};
+
+/**
+ * Returns VNodes for named slot either scoped or unscoped
+ *
+ * @param {String, Array} name or name[]
+ * @param {String} scope
+ * @param {Object} scopedSlots
+ * @param {Object} slots
+ * @returns {Array|undefined} VNodes
+ */
+const normalizeSlot = function (names) {
+  let scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let $scopedSlots = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let $slots = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  // Ensure names is an array
+  names = concat(names).filter(identity);
+  let slot;
+  for (let i = 0; i < names.length && !slot; i++) {
+    const name = names[i];
+    slot = $scopedSlots[name] || $slots[name];
+  }
+  // Note: in Vue 2.6.x, all named slots are also scoped slots
+  return isFunction(slot) ? slot(scope) : slot;
+};
+
+export { hasNormalizedSlot, normalizeSlot };

package/dist/vendor/bootstrap-vue/src/utils/number.js

@@ -0,0 +1,23 @@
+// Number utilities
+
+// Converts a value (string, number, etc.) to an integer number
+// Assumes radix base 10
+const toInteger = function (value) {
+  let defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : NaN;
+  const integer = parseInt(value, 10);
+  return isNaN(integer) ? defaultValue : integer;
+};
+
+// Converts a value (string, number, etc.) to a number
+const toFloat = function (value) {
+  let defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : NaN;
+  const float = parseFloat(value);
+  return isNaN(float) ? defaultValue : float;
+};
+
+// Converts a value (string, number, etc.) to a string
+// representation with `precision` digits after the decimal
+// Returns the string 'NaN' if the value cannot be converted
+const toFixed = (val, precision) => toFloat(val).toFixed(toInteger(precision, 0));
+
+export { toFixed, toFloat, toInteger };

package/dist/vendor/bootstrap-vue/src/utils/object.js

@@ -0,0 +1,79 @@
+import { isObject } from './inspect';
+
+// --- Static ---
+
+const assign = function () {
+  return Object.assign(...arguments);
+};
+const create = (proto, optionalProps) => Object.create(proto, optionalProps);
+const defineProperties = (obj, props) => Object.defineProperties(obj, props);
+const defineProperty = (obj, prop, descriptor) => Object.defineProperty(obj, prop, descriptor);
+const freeze = obj => Object.freeze(obj);
+const getOwnPropertyNames = obj => Object.getOwnPropertyNames(obj);
+const getOwnPropertyDescriptor = (obj, prop) => Object.getOwnPropertyDescriptor(obj, prop);
+const getOwnPropertySymbols = obj => Object.getOwnPropertySymbols(obj);
+const getPrototypeOf = obj => Object.getPrototypeOf(obj);
+const is = (value1, value2) => Object.is(value1, value2);
+const isFrozen = obj => Object.isFrozen(obj);
+const keys = obj => Object.keys(obj);
+
+// --- "Instance" ---
+
+const hasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+const toString = obj => Object.prototype.toString.call(obj);
+
+// --- Utilities ---
+
+// Shallow copy an object
+const clone = obj => ({
+  ...obj
+});
+
+// Return a shallow copy of object with the specified properties only
+// See: https://gist.github.com/bisubus/2da8af7e801ffd813fab7ac221aa7afc
+const pick = (obj, props) => keys(obj).filter(key => props.indexOf(key) !== -1).reduce((result, key) => ({
+  ...result,
+  [key]: obj[key]
+}), {});
+
+// Return a shallow copy of object with the specified properties omitted
+// See: https://gist.github.com/bisubus/2da8af7e801ffd813fab7ac221aa7afc
+const omit = (obj, props) => keys(obj).filter(key => props.indexOf(key) === -1).reduce((result, key) => ({
+  ...result,
+  [key]: obj[key]
+}), {});
+
+// Merges two object deeply together
+// See: https://gist.github.com/Salakar/1d7137de9cb8b704e48a
+const mergeDeep = (target, source) => {
+  if (isObject(target) && isObject(source)) {
+    keys(source).forEach(key => {
+      if (isObject(source[key])) {
+        if (!target[key] || !isObject(target[key])) {
+          target[key] = source[key];
+        }
+        mergeDeep(target[key], source[key]);
+      } else {
+        assign(target, {
+          [key]: source[key]
+        });
+      }
+    });
+  }
+  return target;
+};
+
+// Returns a shallow copy of the object with keys in sorted order
+const sortKeys = obj => keys(obj).sort().reduce((result, key) => ({
+  ...result,
+  [key]: obj[key]
+}), {});
+
+// Convenience method to create a read-only descriptor
+const readonlyDescriptor = () => ({
+  enumerable: true,
+  configurable: false,
+  writable: false
+});
+
+export { assign, clone, create, defineProperties, defineProperty, freeze, getOwnPropertyDescriptor, getOwnPropertyNames, getOwnPropertySymbols, getPrototypeOf, hasOwnProperty, is, isFrozen, keys, mergeDeep, omit, pick, readonlyDescriptor, sortKeys, toString };

package/dist/vendor/bootstrap-vue/src/utils/observe-dom.js

@@ -0,0 +1,76 @@
+import { isElement, MutationObs } from './dom';
+import { warnNoMutationObserverSupport } from './warn';
+
+/**
+ * Observe a DOM element changes, falls back to eventListener mode
+ * @param {Element} el The DOM element to observe
+ * @param {Function} callback callback to be called on change
+ * @param {object} [options={childList: true, subtree: true}] observe options
+ * @see https://stackoverflow.com/questions/3219758
+ */
+const observeDom = (el, callback, options) => /* istanbul ignore next: difficult to test in JSDOM */{
+  // Handle cases where we might be passed a Vue instance
+  el = el ? el.$el || el : null;
+
+  // Early exit when we have no element
+  /* istanbul ignore next: difficult to test in JSDOM */
+  if (!isElement(el)) {
+    return null;
+  }
+
+  // Exit and throw a warning when `MutationObserver` isn't available
+  if (warnNoMutationObserverSupport('observeDom')) {
+    return null;
+  }
+
+  // Define a new observer
+  const obs = new MutationObs(mutations => {
+    let changed = false;
+
+    // A mutation can contain several change records, so we loop
+    // through them to see what has changed
+    // We break out of the loop early if any "significant" change
+    // has been detected
+    for (let i = 0; i < mutations.length && !changed; i++) {
+      // The mutation record
+      const mutation = mutations[i];
+      // Mutation type
+      const type = mutation.type;
+      // DOM node (could be any DOM node type - HTMLElement, Text, comment, etc.)
+      const target = mutation.target;
+
+      // Detect whether a change happened based on type and target
+      if (type === 'characterData' && target.nodeType === Node.TEXT_NODE) {
+        // We ignore nodes that are not TEXT (i.e. comments, etc.)
+        // as they don't change layout
+        changed = true;
+      } else if (type === 'attributes') {
+        changed = true;
+      } else if (type === 'childList' && (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0)) {
+        // This includes HTMLElement and text nodes being
+        // added/removed/re-arranged
+        changed = true;
+      }
+    }
+
+    // We only call the callback if a change that could affect
+    // layout/size truly happened
+    if (changed) {
+      callback();
+    }
+  });
+
+  // Have the observer observe foo for changes in children, etc
+  obs.observe(el, {
+    childList: true,
+    subtree: true,
+    ...options
+  });
+
+  // We return a reference to the observer so that `obs.disconnect()`
+  // can be called if necessary
+  // To reduce overhead when the root element is hidden
+  return obs;
+};
+
+export { observeDom };

package/dist/vendor/bootstrap-vue/src/utils/plugins.js

@@ -0,0 +1,183 @@
+import { Vue } from '../vue';
+import { IS_JSDOM, HAS_WINDOW_SUPPORT } from '../constants/env';
+import { setConfig } from './config-set';
+import { warn } from './warn';
+
+/**
+ * Checks if there are multiple instances of Vue, and warns (once) about possible issues.
+ * @param {object} Vue
+ */
+const checkMultipleVue = (() => {
+  let checkMultipleVueWarned = false;
+  const MULTIPLE_VUE_WARNING = ['Multiple instances of Vue detected!', 'You may need to set up an alias for Vue in your bundler config.', 'See: https://bootstrap-vue.org/docs#using-module-bundlers'].join('\n');
+  return Vue$1 => {
+    /* istanbul ignore next */
+    if (!checkMultipleVueWarned && Vue !== Vue$1 && !IS_JSDOM) {
+      warn(MULTIPLE_VUE_WARNING);
+    }
+    checkMultipleVueWarned = true;
+  };
+})();
+
+/**
+ * Plugin install factory function.
+ * @param {object} { components, directives }
+ * @returns {function} plugin install function
+ */
+const installFactory = function () {
+  let {
+    components,
+    directives,
+    plugins
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const install = function (Vue) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (install.installed) {
+      /* istanbul ignore next */
+      return;
+    }
+    install.installed = true;
+    checkMultipleVue(Vue);
+    setConfig(config, Vue);
+    registerComponents(Vue, components);
+    registerDirectives(Vue, directives);
+    registerPlugins(Vue, plugins);
+  };
+  install.installed = false;
+  return install;
+};
+
+/**
+ * Plugin install factory function (no plugin config option).
+ * @param {object} { components, directives }
+ * @returns {function} plugin install function
+ */
+const installFactoryNoConfig = function () {
+  let {
+    components,
+    directives,
+    plugins
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const install = Vue => {
+    if (install.installed) {
+      /* istanbul ignore next */
+      return;
+    }
+    install.installed = true;
+    checkMultipleVue(Vue);
+    registerComponents(Vue, components);
+    registerDirectives(Vue, directives);
+    registerPlugins(Vue, plugins);
+  };
+  install.installed = false;
+  return install;
+};
+
+/**
+ * Plugin object factory function.
+ * @param {object} { components, directives, plugins }
+ * @returns {object} plugin install object
+ */
+const pluginFactory = function () {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let extend = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return {
+    ...extend,
+    install: installFactory(options)
+  };
+};
+
+/**
+ * Plugin object factory function (no config option).
+ * @param {object} { components, directives, plugins }
+ * @returns {object} plugin install object
+ */
+const pluginFactoryNoConfig = function () {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let extend = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return {
+    ...extend,
+    install: installFactoryNoConfig(options)
+  };
+};
+
+/**
+ * Load a group of plugins.
+ * @param {object} Vue
+ * @param {object} Plugin definitions
+ */
+const registerPlugins = function (Vue) {
+  let plugins = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  for (const plugin in plugins) {
+    if (plugin && plugins[plugin]) {
+      Vue.use(plugins[plugin]);
+    }
+  }
+};
+
+/**
+ * Load a component.
+ * @param {object} Vue
+ * @param {string} Component name
+ * @param {object} Component definition
+ */
+const registerComponent = (Vue, name, def) => {
+  if (Vue && name && def) {
+    Vue.component(name, def);
+  }
+};
+
+/**
+ * Load a group of components.
+ * @param {object} Vue
+ * @param {object} Object of component definitions
+ */
+const registerComponents = function (Vue) {
+  let components = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  for (const component in components) {
+    registerComponent(Vue, component, components[component]);
+  }
+};
+
+/**
+ * Load a directive.
+ * @param {object} Vue
+ * @param {string} Directive name
+ * @param {object} Directive definition
+ */
+const registerDirective = (Vue, name, def) => {
+  if (Vue && name && def) {
+    // Ensure that any leading V is removed from the
+    // name, as Vue adds it automatically
+    Vue.directive(name.replace(/^VB/, 'B'), def);
+  }
+};
+
+/**
+ * Load a group of directives.
+ * @param {object} Vue
+ * @param {object} Object of directive definitions
+ */
+const registerDirectives = function (Vue) {
+  let directives = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  for (const directive in directives) {
+    registerDirective(Vue, directive, directives[directive]);
+  }
+};
+
+/**
+ * Install plugin if window.Vue available
+ * @param {object} Plugin definition
+ */
+const vueUse = VuePlugin => {
+  /* istanbul ignore next */
+  if (HAS_WINDOW_SUPPORT && window.Vue) {
+    window.Vue.use(VuePlugin);
+  }
+  /* istanbul ignore next */
+  if (HAS_WINDOW_SUPPORT && VuePlugin.NAME) {
+    window[VuePlugin.NAME] = VuePlugin;
+  }
+};
+
+export { checkMultipleVue, installFactory, installFactoryNoConfig, pluginFactory, pluginFactoryNoConfig, registerComponent, registerComponents, registerDirective, registerDirectives, registerPlugins, vueUse };

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

@@ -0,0 +1,103 @@
+import { PROP_TYPE_ANY } from '../constants/props';
+import { cloneDeep } from './clone-deep';
+import { getComponentConfig } from './config';
+import { identity } from './identity';
+import { isFunction, isUndefined, isObject, isArray } from './inspect';
+import { hasOwnProperty, clone, keys } from './object';
+import { upperFirst, lowerFirst } from './string';
+
+// Prefix a property
+const prefixPropName = (prefix, value) => prefix + upperFirst(value);
+
+// Remove a prefix from a property
+const unprefixPropName = (prefix, value) => lowerFirst(value.replace(prefix, ''));
+
+// Suffix can be a falsey value so nothing is appended to string
+// (helps when looping over props & some shouldn't change)
+// Use data last parameters to allow for currying
+const suffixPropName = (suffix, value) => value + (suffix ? upperFirst(suffix) : '');
+
+// Generates a prop object
+const makeProp = function () {
+  let type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : PROP_TYPE_ANY;
+  let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  let requiredOrValidator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  let validator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+  const required = requiredOrValidator === true;
+  validator = required ? validator : requiredOrValidator;
+  return {
+    ...(type ? {
+      type
+    } : {}),
+    ...(required ? {
+      required
+    } : isUndefined(value) ? {} : {
+      default: isObject(value) ? () => value : value
+    }),
+    ...(isUndefined(validator) ? {} : {
+      validator
+    })
+  };
+};
+
+// Copies props from one array/object to a new array/object
+// Prop values are also cloned as new references to prevent possible
+// mutation of original prop object values
+// Optionally accepts a function to transform the prop name
+const copyProps = function (props) {
+  let transformFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
+  if (isArray(props)) {
+    return props.map(transformFn);
+  }
+  const copied = {};
+  for (const prop in props) {
+    /* istanbul ignore else */
+    if (hasOwnProperty(props, prop)) {
+      // If the prop value is an object, do a shallow clone
+      // to prevent potential mutations to the original object
+      copied[transformFn(prop)] = isObject(props[prop]) ? clone(props[prop]) : props[prop];
+    }
+  }
+  return copied;
+};
+
+// Given an array of properties or an object of property keys,
+// plucks all the values off the target object, returning a new object
+// that has props that reference the original prop values
+const pluckProps = function (keysToPluck, objToPluck) {
+  let transformFn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : identity;
+  return (isArray(keysToPluck) ? keysToPluck.slice() : keys(keysToPluck)).reduce((memo, prop) => {
+    memo[transformFn(prop)] = objToPluck[prop];
+    return memo;
+  }, {});
+};
+
+// Make a prop object configurable by global configuration
+// Replaces the current `default` key of each prop with a `getComponentConfig()`
+// call that falls back to the current default value of the prop
+const makePropConfigurable = (prop, key, componentKey) => ({
+  ...cloneDeep(prop),
+  default: function bvConfigurablePropDefault() {
+    const value = getComponentConfig(componentKey, key, prop.default);
+    return isFunction(value) ? value() : value;
+  }
+});
+
+// Make a props object configurable by global configuration
+// Replaces the current `default` key of each prop with a `getComponentConfig()`
+// call that falls back to the current default value of the prop
+const makePropsConfigurable = (props, componentKey) => keys(props).reduce((result, key) => ({
+  ...result,
+  [key]: makePropConfigurable(props[key], key, componentKey)
+}), {});
+
+// Get function name we use in `makePropConfigurable()`
+// for the prop default value override to compare
+// against in `hasPropFunction()`
+const configurablePropDefaultFnName = makePropConfigurable({}, '', '').default.name;
+
+// Detect wether the given value is currently a function
+// and isn't the props default function
+const hasPropFunction = fn => isFunction(fn) && fn.name && fn.name !== configurablePropDefaultFnName;
+
+export { copyProps, hasPropFunction, makeProp, makePropConfigurable, makePropsConfigurable, pluckProps, prefixPropName, suffixPropName, unprefixPropName };