@gitlab/ui 132.0.1 → 132.0.2

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

@@ -0,0 +1,63 @@
+import { RX_ARRAY_NOTATION } from '../constants/regex';
+import { identity } from './identity';
+import { isArray, isObject, isUndefinedOrNull, isNull } from './inspect';
+
+/**
+ * Get property defined by dot/array notation in string, returns undefined if not found
+ *
+ * @link https://gist.github.com/jeneg/9767afdcca45601ea44930ea03e0febf#gistcomment-1935901
+ *
+ * @param {Object} obj
+ * @param {string|Array} path
+ * @return {*}
+ */
+const getRaw = function (obj, path) {
+  let defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  // Handle array of path values
+  path = isArray(path) ? path.join('.') : path;
+
+  // If no path or no object passed
+  if (!path || !isObject(obj)) {
+    return defaultValue;
+  }
+
+  // Handle edge case where user has dot(s) in top-level item field key
+  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2762
+  // Switched to `in` operator vs `hasOwnProperty` to handle obj.prototype getters
+  // https://github.com/bootstrap-vue/bootstrap-vue/issues/3463
+  if (path in obj) {
+    return obj[path];
+  }
+
+  // Handle string array notation (numeric indices only)
+  path = String(path).replace(RX_ARRAY_NOTATION, '.$1');
+  const steps = path.split('.').filter(identity);
+
+  // Handle case where someone passes a string of only dots
+  if (steps.length === 0) {
+    return defaultValue;
+  }
+
+  // Traverse path in object to find result
+  // Switched to `in` operator vs `hasOwnProperty` to handle obj.prototype getters
+  // https://github.com/bootstrap-vue/bootstrap-vue/issues/3463
+  return steps.every(step => isObject(obj) && step in obj && !isUndefinedOrNull(obj = obj[step])) ? obj : isNull(obj) ? null : defaultValue;
+};
+
+/**
+ * Get property defined by dot/array notation in string.
+ *
+ * @link https://gist.github.com/jeneg/9767afdcca45601ea44930ea03e0febf#gistcomment-1935901
+ *
+ * @param {Object} obj
+ * @param {string|Array} path
+ * @param {*} defaultValue (optional)
+ * @return {*}
+ */
+const get = function (obj, path) {
+  let defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  const value = getRaw(obj, path);
+  return isUndefinedOrNull(value) ? defaultValue : value;
+};
+
+export { get, getRaw };

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

@@ -0,0 +1,16 @@
+import { RX_HTML_TAGS } from '../constants/regex';
+
+// Removes anything that looks like an HTML tag from the supplied string
+const stripTags = function () {
+  let text = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return String(text).replace(RX_HTML_TAGS, '');
+};
+
+// Generate a `domProps` object for either `innerHTML`, `textContent` or an empty object
+const htmlOrText = (innerHTML, textContent) => innerHTML ? {
+  innerHTML
+} : textContent ? {
+  textContent
+} : {};
+
+export { htmlOrText, stripTags };

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

@@ -0,0 +1,3 @@
+const identity = x => x;
+
+export { identity };

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

@@ -0,0 +1,35 @@
+import { RX_NUMBER } from '../constants/regex';
+import { File } from '../constants/safe-types';
+
+// --- Convenience inspection utilities ---
+
+const toType = value => typeof value;
+const toRawType = value => Object.prototype.toString.call(value).slice(8, -1);
+const toRawTypeLC = value => toRawType(value).toLowerCase();
+const isUndefined = value => value === undefined;
+const isNull = value => value === null;
+const isUndefinedOrNull = value => isUndefined(value) || isNull(value);
+const isFunction = value => toType(value) === 'function';
+const isBoolean = value => toType(value) === 'boolean';
+const isString = value => toType(value) === 'string';
+const isNumber = value => toType(value) === 'number';
+const isNumeric = value => RX_NUMBER.test(String(value));
+const isPrimitive = value => isBoolean(value) || isString(value) || isNumber(value);
+const isArray = value => Array.isArray(value);
+
+// Quick object check
+// This is primarily used to tell Objects from primitive values
+// when we know the value is a JSON-compliant type
+// Note object could be a complex type like array, Date, etc.
+const isObject = obj => obj !== null && typeof obj === 'object';
+
+// Strict object type check
+// Only returns true for plain JavaScript objects
+const isPlainObject = obj => Object.prototype.toString.call(obj) === '[object Object]';
+const isDate = value => value instanceof Date;
+const isEvent = value => value instanceof Event;
+const isFile = value => value instanceof File;
+const isRegExp = value => toRawType(value) === 'RegExp';
+const isPromise = value => !isUndefinedOrNull(value) && isFunction(value.then) && isFunction(value.catch);
+
+export { isArray, isBoolean, isDate, isEvent, isFile, isFunction, isNull, isNumber, isNumeric, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isString, isUndefined, isUndefinedOrNull, toRawType, toRawTypeLC, toType };

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

@@ -0,0 +1,18 @@
+import { RX_STRIP_LOCALE_MODS } from '../constants/regex';
+import { toString } from './string';
+
+// Localization utilities
+
+// Languages that are RTL
+const RTL_LANGS = ['ar', 'az', 'ckb', 'fa', 'he', 'ks', 'lrc', 'mzn', 'ps', 'sd', 'te', 'ug', 'ur', 'yi'].map(locale => locale.toLowerCase());
+
+// Returns true if the locale is RTL
+const isLocaleRTL = locale => {
+  // Determines if the locale is RTL (only single locale supported)
+  const parts = toString(locale).toLowerCase().replace(RX_STRIP_LOCALE_MODS, '').split('-');
+  const locale1 = parts.slice(0, 2).join('-');
+  const locale2 = parts[0];
+  return RTL_LANGS.includes(locale1) || RTL_LANGS.includes(locale2);
+};
+
+export { isLocaleRTL };

package/dist/vendor/bootstrap-vue/src/utils/loose-equal.js

@@ -0,0 +1,59 @@
+import { keys, hasOwnProperty } from './object';
+import { isDate, isArray, isObject } from './inspect';
+
+// Assumes both a and b are arrays!
+// Handles when arrays are "sparse" (array.every(...) doesn't handle sparse)
+const compareArrays = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let equal = true;
+  for (let i = 0; equal && i < a.length; i++) {
+    equal = looseEqual(a[i], b[i]);
+  }
+  return equal;
+};
+
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ * Returns boolean true or false
+ */
+const looseEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  let aValidType = isDate(a);
+  let bValidType = isDate(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+  }
+  aValidType = isArray(a);
+  bValidType = isArray(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? compareArrays(a, b) : false;
+  }
+  aValidType = isObject(a);
+  bValidType = isObject(b);
+  if (aValidType || bValidType) {
+    /* istanbul ignore if: this if will probably never be called */
+    if (!aValidType || !bValidType) {
+      return false;
+    }
+    const aKeysCount = keys(a).length;
+    const bKeysCount = keys(b).length;
+    if (aKeysCount !== bKeysCount) {
+      return false;
+    }
+    for (const key in a) {
+      const aHasKey = hasOwnProperty(a, key);
+      const bHasKey = hasOwnProperty(b, key);
+      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+  }
+  return String(a) === String(b);
+};
+
+export { looseEqual };

package/dist/vendor/bootstrap-vue/src/utils/loose-index-of.js

@@ -0,0 +1,13 @@
+import { looseEqual } from './loose-equal';
+
+// Assumes that the first argument is an array
+const looseIndexOf = (array, value) => {
+  for (let i = 0; i < array.length; i++) {
+    if (looseEqual(array[i], value)) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+export { looseIndexOf };

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

@@ -0,0 +1,9 @@
+// Math utilty functions
+
+const mathMin = Math.min;
+const mathMax = Math.max;
+const mathCeil = Math.ceil;
+const mathPow = Math.pow;
+const mathRound = Math.round;
+
+export { mathCeil, 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,72 @@
+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 getOwnPropertyNames = obj => Object.getOwnPropertyNames(obj);
+const keys = obj => Object.keys(obj);
+
+// --- "Instance" ---
+
+const hasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+
+// --- 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, getOwnPropertyNames, hasOwnProperty, keys, mergeDeep, omit, pick, readonlyDescriptor, sortKeys };

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/on-instance-destroy.js

@@ -0,0 +1,22 @@
+import { isVue3 } from '../vue';
+
+/**
+ * Register a callback to be called when a Vue instance is destroyed/unmounted.
+ *
+ * For Vue 2: Uses $once with 'hook:destroyed' event
+ * For Vue 3: Uses scope.cleanups for proper effect scope cleanup
+ *
+ * @param {Object} instance - The Vue instance to watch for destruction
+ * @param {Function} callback - The callback to run when the instance is destroyed
+ */
+const onInstanceDestroy = (instance, callback) => {
+  if (isVue3(instance)) {
+    // onScopeDispose is not available on instance and we do
+    // not want to import 'vue' in this file
+    instance.$.scope.cleanups.push(callback);
+    return;
+  }
+  instance.$once('hook:destroyed', callback);
+};
+
+export { onInstanceDestroy };

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

@@ -0,0 +1,124 @@
+import { HAS_WINDOW_SUPPORT } from '../constants/env';
+import { setConfig } from './config-set';
+
+/**
+ * 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;
+    setConfig(config, 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)
+  };
+};
+
+/**
+ * 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 { installFactory, pluginFactory, registerComponent, registerComponents, registerDirective, registerDirectives, registerPlugins, vueUse };