@gitlab/ui 131.2.0 → 131.3.1

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

@@ -1,63 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

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

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

@@ -1,35 +0,0 @@
-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

@@ -1,19 +0,0 @@
-import { RX_STRIP_LOCALE_MODS } from '../constants/regex';
-import { arrayIncludes } from './array';
-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 arrayIncludes(RTL_LANGS, locale1) || arrayIncludes(RTL_LANGS, locale2);
-};
-
-export { isLocaleRTL };

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

@@ -1,59 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,9 +0,0 @@
-// 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

@@ -1,14 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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

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

@@ -1,51 +0,0 @@
-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

@@ -1,23 +0,0 @@
-// 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

@@ -1,72 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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 };