@gitlab/ui 132.0.1 → 132.0.3

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

@@ -0,0 +1,120 @@
+import { extend } from '../vue';
+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 (!this[PROP][event].includes(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

@@ -0,0 +1,62 @@
+import { extend } from '../vue';
+import { IS_BROWSER } from '../constants/env';
+import { EVENT_OPTIONS_NO_CAPTURE } from '../constants/events';
+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 (!this[PROP][event].includes(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

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { isFunction } from './inspect';
+
+// --- Static ---
+
+const from = function () {
+  return Array.from(...arguments);
+};
+
+// --- Instance ---
+
+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 { concat, createArray, from };

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

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

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

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

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

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