@gitlab/ui 131.2.0 → 131.3.1

package/dist/vendor/bootstrap-vue/src/mixins/listen-on-root.js

@@ -1,121 +0,0 @@
-import { extend } from '../vue';
-import { arrayIncludes } from '../utils/array';
-import { keys } from '../utils/object';
-import { getEventRoot } from '../utils/get-event-root';
-
-// --- Constants ---
-
-const PROP = '$_rootListeners';
-
-// --- Mixin ---
-
-// @vue/component
-const listenOnRootMixin = extend({
-  computed: {
-    bvEventRoot() {
-      return getEventRoot(this);
-    }
-  },
-  created() {
-    // Define non-reactive property
-    // Object of arrays, keyed by event name,
-    // where value is an array of callbacks
-    this[PROP] = {};
-  },
-  beforeDestroy() {
-    // Unregister all registered listeners
-    keys(this[PROP] || {}).forEach(event => {
-      this[PROP][event].forEach(callback => {
-        this.listenOffRoot(event, callback);
-      });
-    });
-    this[PROP] = null;
-  },
-  methods: {
-    registerRootListener(event, callback) {
-      if (this[PROP]) {
-        this[PROP][event] = this[PROP][event] || [];
-        if (!arrayIncludes(this[PROP][event], callback)) {
-          this[PROP][event].push(callback);
-        }
-      }
-    },
-    unregisterRootListener(event, callback) {
-      if (this[PROP] && this[PROP][event]) {
-        this[PROP][event] = this[PROP][event].filter(cb => cb !== callback);
-      }
-    },
-    /**
-     * Safely register event listeners on the root Vue node
-     * While Vue automatically removes listeners for individual components,
-     * when a component registers a listener on `$root` and is destroyed,
-     * this orphans a callback because the node is gone, but the `$root`
-     * does not clear the callback
-     *
-     * When registering a `$root` listener, it also registers the listener
-     * to be removed in the component's `beforeDestroy()` hook
-     *
-     * @param {string} event
-     * @param {function} callback
-     */
-    listenOnRoot(event, callback) {
-      if (this.bvEventRoot) {
-        this.bvEventRoot.$on(event, callback);
-        this.registerRootListener(event, callback);
-      }
-    },
-    /**
-     * Safely register a `$once()` event listener on the root Vue node
-     * While Vue automatically removes listeners for individual components,
-     * when a component registers a listener on `$root` and is destroyed,
-     * this orphans a callback because the node is gone, but the `$root`
-     * does not clear the callback
-     *
-     * When registering a `$root` listener, it also registers the listener
-     * to be removed in the component's `beforeDestroy()` hook
-     *
-     * @param {string} event
-     * @param {function} callback
-     */
-    listenOnRootOnce(event, callback) {
-      var _this = this;
-      if (this.bvEventRoot) {
-        const _callback = function () {
-          _this.unregisterRootListener(_callback);
-          // eslint-disable-next-line node/no-callback-literal
-          callback(...arguments);
-        };
-        this.bvEventRoot.$once(event, _callback);
-        this.registerRootListener(event, _callback);
-      }
-    },
-    /**
-     * Safely unregister event listeners from the root Vue node
-     *
-     * @param {string} event
-     * @param {function} callback
-     */
-    listenOffRoot(event, callback) {
-      this.unregisterRootListener(event, callback);
-      if (this.bvEventRoot) {
-        this.bvEventRoot.$off(event, callback);
-      }
-    },
-    /**
-     * Convenience method for calling `vm.$emit()` on `$root`
-     *
-     * @param {string} event
-     * @param {*} args
-     */
-    emitOnRoot(event) {
-      if (this.bvEventRoot) {
-        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-        this.bvEventRoot.$emit(event, ...args);
-      }
-    }
-  }
-});
-
-export { listenOnRootMixin };

package/dist/vendor/bootstrap-vue/src/mixins/listen-on-window.js

@@ -1,63 +0,0 @@
-import { extend } from '../vue';
-import { IS_BROWSER } from '../constants/env';
-import { EVENT_OPTIONS_NO_CAPTURE } from '../constants/events';
-import { arrayIncludes } from '../utils/array';
-import { eventOn, eventOff } from '../utils/events';
-import { keys } from '../utils/object';
-
-// --- Constants ---
-
-const PROP = '$_windowListeners';
-
-// --- Mixin ---
-
-// @vue/component
-const listenOnWindowMixin = extend({
-  created() {
-    // Define non-reactive property
-    // Object of arrays, keyed by event name,
-    // where value is an array of callbacks
-    this[PROP] = {};
-  },
-  beforeDestroy() {
-    // Unregister all registered listeners
-    keys(this[PROP] || {}).forEach(event => {
-      this[PROP][event].forEach(callback => {
-        this.listenOffWindow(event, callback);
-      });
-    });
-    this[PROP] = null;
-  },
-  methods: {
-    registerWindowListener(event, callback) {
-      if (this[PROP]) {
-        this[PROP][event] = this[PROP][event] || [];
-        if (!arrayIncludes(this[PROP][event], callback)) {
-          this[PROP][event].push(callback);
-        }
-      }
-    },
-    unregisterWindowListener(event, callback) {
-      if (this[PROP] && this[PROP][event]) {
-        this[PROP][event] = this[PROP][event].filter(cb => cb !== callback);
-      }
-    },
-    listenWindow(on, event, callback) {
-      on ? this.listenOnWindow(event, callback) : this.listenOffWindow(event, callback);
-    },
-    listenOnWindow(event, callback) {
-      if (IS_BROWSER) {
-        eventOn(window, event, callback, EVENT_OPTIONS_NO_CAPTURE);
-        this.registerWindowListener(event, callback);
-      }
-    },
-    listenOffWindow(event, callback) {
-      if (IS_BROWSER) {
-        eventOff(window, event, callback, EVENT_OPTIONS_NO_CAPTURE);
-      }
-      this.unregisterWindowListener(event, callback);
-    }
-  }
-});
-
-export { listenOnWindowMixin };

package/dist/vendor/bootstrap-vue/src/mixins/listeners.js

@@ -1,25 +0,0 @@
-import { isVue3 } from '../vue';
-import { getInternalPropName, makePropCacheMixin } from '../utils/cache';
-
-const internalPropName = getInternalPropName('bvListeners');
-const listenersMixin = makePropCacheMixin('$listeners', 'bvListeners').extend({
-  created() {
-    if (!isVue3(this)) {
-      return;
-    }
-    this[internalPropName] = {
-      // bug: this.$listeners is non-reactive in Vue.js 3 compat
-      ...this.$listeners
-    };
-  },
-  beforeUpdate() {
-    if (!isVue3(this)) {
-      return;
-    }
-    this[internalPropName] = {
-      ...this.$listeners
-    };
-  }
-});
-
-export { listenersMixin };

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

@@ -1,10 +0,0 @@
-import { makeModelMixin } from '../utils/model';
-
-const {
-  mixin,
-  props,
-  prop,
-  event
-} = makeModelMixin('value');
-
-export { event as MODEL_EVENT_NAME, prop as MODEL_PROP_NAME, mixin as modelMixin, props };

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

@@ -1,30 +0,0 @@
-import { extend } from '../vue';
-import { SLOT_NAME_DEFAULT } from '../constants/slots';
-import { hasNormalizedSlot, normalizeSlot } from '../utils/normalize-slot';
-import { concat } from '../utils/array';
-
-// @vue/component
-const normalizeSlotMixin = extend({
-  methods: {
-    // Returns `true` if the either a `$scopedSlot` or `$slot` exists with the specified name
-    // `name` can be a string name or an array of names
-    hasNormalizedSlot() {
-      let name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SLOT_NAME_DEFAULT;
-      let scopedSlots = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.$scopedSlots;
-      let slots = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.$slots;
-      return hasNormalizedSlot(name, scopedSlots, slots);
-    },
-    // Returns an array of rendered VNodes if slot found, otherwise `undefined`
-    // `name` can be a string name or an array of names
-    normalizeSlot() {
-      let name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SLOT_NAME_DEFAULT;
-      let scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      let scopedSlots = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.$scopedSlots;
-      let slots = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.$slots;
-      const vNodes = normalizeSlot(name, scope, scopedSlots, slots);
-      return vNodes ? concat(vNodes) : vNodes;
-    }
-  }
-});
-
-export { normalizeSlotMixin };

package/dist/vendor/bootstrap-vue/src/mixins/scoped-style.js

@@ -1,18 +0,0 @@
-import { extend } from '../vue';
-import { useParentMixin } from './use-parent';
-import { getScopeId } from '../utils/get-scope-id';
-
-// @vue/component
-const scopedStyleMixin = extend({
-  mixins: [useParentMixin],
-  computed: {
-    scopedStyleAttrs() {
-      const scopeId = getScopeId(this.bvParent);
-      return scopeId ? {
-        [scopeId]: ''
-      } : {};
-    }
-  }
-});
-
-export { scopedStyleMixin };

package/dist/vendor/bootstrap-vue/src/mixins/use-parent.js

@@ -1,14 +0,0 @@
-import { extend } from '../vue';
-
-// --- Mixin ---
-
-// @vue/component
-const useParentMixin = extend({
-  computed: {
-    bvParent() {
-      return this.$parent || this.$root === this && this.$options.bvParent;
-    }
-  }
-});
-
-export { useParentMixin };

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

@@ -1,28 +0,0 @@
-import { isFunction } from './inspect';
-
-// --- Static ---
-
-const from = function () {
-  return Array.from(...arguments);
-};
-
-// --- Instance ---
-
-const arrayIncludes = (array, value) => array.indexOf(value) !== -1;
-const concat = function () {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-  return Array.prototype.concat.apply([], args);
-};
-
-// --- Utilities ---
-
-const createArray = (length, fillFn) => {
-  const mapFn = isFunction(fillFn) ? fillFn : () => fillFn;
-  return Array.apply(null, {
-    length
-  }).map(mapFn);
-};
-
-export { arrayIncludes, concat, createArray, from };

package/dist/vendor/bootstrap-vue/src/utils/bv-event.class.js

@@ -1,60 +0,0 @@
-import { assign, defineProperties, readonlyDescriptor, defineProperty } from './object';
-
-class BvEvent {
-  constructor(type) {
-    let eventInit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    // Start by emulating native Event constructor
-    if (!type) {
-      /* istanbul ignore next */
-      throw new TypeError(`Failed to construct '${this.constructor.name}'. 1 argument required, ${arguments.length} given.`);
-    }
-
-    // Merge defaults first, the eventInit, and the type last
-    // so it can't be overwritten
-    assign(this, BvEvent.Defaults, this.constructor.Defaults, eventInit, {
-      type
-    });
-
-    // Freeze some props as readonly, but leave them enumerable
-    defineProperties(this, {
-      type: readonlyDescriptor(),
-      cancelable: readonlyDescriptor(),
-      nativeEvent: readonlyDescriptor(),
-      target: readonlyDescriptor(),
-      relatedTarget: readonlyDescriptor(),
-      vueTarget: readonlyDescriptor(),
-      componentId: readonlyDescriptor()
-    });
-
-    // Create a private variable using closure scoping
-    let defaultPrevented = false;
-    // Recreate preventDefault method. One way setter
-    this.preventDefault = function preventDefault() {
-      if (this.cancelable) {
-        defaultPrevented = true;
-      }
-    };
-
-    // Create `defaultPrevented` publicly accessible prop that
-    // can only be altered by the preventDefault method
-    defineProperty(this, 'defaultPrevented', {
-      enumerable: true,
-      get() {
-        return defaultPrevented;
-      }
-    });
-  }
-  static get Defaults() {
-    return {
-      type: '',
-      cancelable: true,
-      nativeEvent: null,
-      target: null,
-      relatedTarget: null,
-      vueTarget: null,
-      componentId: null
-    };
-  }
-}
-
-export { BvEvent };

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

@@ -1,60 +0,0 @@
-import { extend, isVue3 } from '../vue';
-import { cloneDeep } from './clone-deep';
-import { looseEqual } from './loose-equal';
-import { hasOwnProperty, keys } from './object';
-
-const isEmpty = value => !value || keys(value).length === 0;
-const makePropWatcher = propName => ({
-  handler(newValue, oldValue) {
-    if (looseEqual(newValue, oldValue)) {
-      return;
-    }
-    if (isEmpty(newValue) || isEmpty(oldValue)) {
-      this[propName] = cloneDeep(newValue);
-      return;
-    }
-    for (const key in oldValue) {
-      if (!hasOwnProperty(newValue, key)) {
-        this.$delete(this.$data[propName], key);
-      }
-    }
-    for (const key in newValue) {
-      this.$set(this.$data[propName], key, newValue[key]);
-    }
-  }
-});
-const getInternalPropName = proxyPropName => `bv_internal__${proxyPropName}`;
-const makePropCacheMixin = (propName, proxyPropName) => {
-  const internalPropName = getInternalPropName(proxyPropName);
-  return extend({
-    data() {
-      return {
-        [internalPropName]: isVue3(this) ? null : cloneDeep(this[propName] || {})
-      };
-    },
-    computed: {
-      [proxyPropName]() {
-        if (internalPropName in this && this[internalPropName]) {
-          return this[internalPropName];
-        }
-        const result = {
-          ...this[propName]
-        };
-        Object.keys(result).forEach(key => {
-          if (result[key] === undefined) {
-            delete result[key];
-          }
-        });
-        return result;
-      }
-    },
-    created() {
-      if (!isVue3(this)) {
-        // Work around unwanted re-renders: https://github.com/vuejs/vue/issues/10115
-        this.$watch(propName, makePropWatcher(internalPropName).handler);
-      }
-    }
-  });
-};
-
-export { getInternalPropName, makePropCacheMixin, makePropWatcher };

package/dist/vendor/bootstrap-vue/src/utils/clone-deep.js

@@ -1,18 +0,0 @@
-import { isArray, isPlainObject } from './inspect';
-import { keys } from './object';
-
-const cloneDeep = function (obj) {
-  let defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : obj;
-  if (isArray(obj)) {
-    return obj.reduce((result, val) => [...result, cloneDeep(val, val)], []);
-  }
-  if (isPlainObject(obj)) {
-    return keys(obj).reduce((result, key) => ({
-      ...result,
-      [key]: cloneDeep(obj[key], obj[key])
-    }), {});
-  }
-  return defaultValue;
-};
-
-export { cloneDeep };

package/dist/vendor/bootstrap-vue/src/utils/config-set.js

@@ -1,86 +0,0 @@
-import { NAME } from '../constants/config';
-import { cloneDeep } from './clone-deep';
-import { getRaw } from './get';
-import { isPlainObject, isArray, isString, isUndefined } from './inspect';
-import { getOwnPropertyNames } from './object';
-import { warn } from './warn';
-
-// Config manager class
-class BvConfig {
-  constructor() {
-    this.$_config = {};
-  }
-
-  // Method to merge in user config parameters
-  setConfig() {
-    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    /* istanbul ignore next */
-    if (!isPlainObject(config)) {
-      return;
-    }
-    const configKeys = getOwnPropertyNames(config);
-    configKeys.forEach(key => {
-      /* istanbul ignore next */
-      const subConfig = config[key];
-      if (key === 'breakpoints') {
-        /* istanbul ignore if */
-        if (!isArray(subConfig) || subConfig.length < 2 || subConfig.some(b => !isString(b) || b.length === 0)) {
-          warn('"breakpoints" must be an array of at least 2 breakpoint names', NAME);
-        } else {
-          this.$_config[key] = cloneDeep(subConfig);
-        }
-      } else if (isPlainObject(subConfig)) {
-        // Component prop defaults
-        this.$_config[key] = getOwnPropertyNames(subConfig).reduce((config, prop) => {
-          if (!isUndefined(subConfig[prop])) {
-            config[prop] = cloneDeep(subConfig[prop]);
-          }
-          return config;
-        }, this.$_config[key] || {});
-      }
-    });
-  }
-
-  // Clear the config
-  resetConfig() {
-    this.$_config = {};
-  }
-
-  // Returns a deep copy of the user config
-  getConfig() {
-    return cloneDeep(this.$_config);
-  }
-
-  // Returns a deep copy of the config value
-  getConfigValue(key) {
-    let defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
-    return cloneDeep(getRaw(this.$_config, key, defaultValue));
-  }
-}
-
-// Module-level singleton instance
-let bvConfig = null;
-
-// Get or create the config instance
-const getConfigInstance = () => {
-  if (!bvConfig) {
-    bvConfig = new BvConfig();
-  }
-  return bvConfig;
-};
-
-// Method for applying a global config
-const setConfig = function () {
-  let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  getConfigInstance().setConfig(config);
-};
-
-// Method for resetting the user config
-// Exported for testing purposes only
-const resetConfig = () => {
-  if (bvConfig) {
-    bvConfig.resetConfig();
-  }
-};
-
-export { getConfigInstance, resetConfig, setConfig };

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

@@ -1,71 +0,0 @@
-import { DEFAULT_BREAKPOINT } from '../constants/config';
-import { cloneDeep } from './clone-deep';
-import { getConfigInstance } from './config-set';
-import { memoize } from './memoize';
-
-// --- Getter methods ---
-// All methods return a deep clone (immutable) copy of the config value,
-// to prevent mutation of the user config object
-
-// Get the current config
-const getConfig = () => {
-  return getConfigInstance().getConfig();
-};
-
-// Method to grab a config value based on a dotted/array notation key
-const getConfigValue = function (key) {
-  let defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
-  return getConfigInstance().getConfigValue(key, defaultValue);
-};
-
-// Method to grab a config value for a particular component
-const getComponentConfig = function (key) {
-  let propKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  let defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
-  // Return the particular config value for key if specified,
-  // otherwise we return the full config (or an empty object if not found)
-  return propKey ? getConfigValue(`${key}.${propKey}`, defaultValue) : getConfigValue(key, {});
-};
-
-// Get all breakpoint names
-const getBreakpoints = () => getConfigValue('breakpoints', DEFAULT_BREAKPOINT);
-
-// Private method for caching breakpoint names
-const _getBreakpointsCached = memoize(() => getBreakpoints());
-
-// Get all breakpoint names (cached)
-const getBreakpointsCached = () => cloneDeep(_getBreakpointsCached());
-
-// Get breakpoints with the smallest breakpoint set as ''
-// Useful for components that create breakpoint specific props
-const getBreakpointsUp = () => {
-  const breakpoints = getBreakpoints();
-  breakpoints[0] = '';
-  return breakpoints;
-};
-
-// Get breakpoints with the smallest breakpoint set as '' (cached)
-// Useful for components that create breakpoint specific props
-const getBreakpointsUpCached = memoize(() => {
-  const breakpoints = getBreakpointsCached();
-  breakpoints[0] = '';
-  return breakpoints;
-});
-
-// Get breakpoints with the largest breakpoint set as ''
-const getBreakpointsDown = () => {
-  const breakpoints = getBreakpoints();
-  breakpoints[breakpoints.length - 1] = '';
-  return breakpoints;
-};
-
-// Get breakpoints with the largest breakpoint set as '' (cached)
-// Useful for components that create breakpoint specific props
-/* istanbul ignore next: we don't use this method anywhere, yet */
-const getBreakpointsDownCached = () => {
-  const breakpoints = getBreakpointsCached();
-  breakpoints[breakpoints.length - 1] = '';
-  return breakpoints;
-};
-
-export { getBreakpoints, getBreakpointsCached, getBreakpointsDown, getBreakpointsDownCached, getBreakpointsUp, getBreakpointsUpCached, getComponentConfig, getConfig, getConfigValue };