@gitlab/ui 132.1.0 → 132.2.0

package/dist/components/dashboards/dashboard_layout/grid_layout/grid_layout.js

@@ -4,6 +4,29 @@ import { pickBy } from 'lodash-es';
 import { breakpoints } from '../../../../utils/breakpoints';
 import __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';
 
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+
+const _excluded = ["gridAttributes"],
+  _excluded2 = ["grid"];
 const CURSOR_GRABBING_CLASS = '!gl-cursor-grabbing';
 var script = {
   name: 'GlGridLayout',
@@ -70,10 +93,8 @@ var script = {
   computed: {
     gridConfig() {
       return this.value.panels.map(panel => {
-        const {
-          gridAttributes,
-          ...otherProps
-        } = panel;
+        panel.gridAttributes;
+          const otherProps = _objectWithoutProperties(panel, _excluded);
         return {
           ...this.getPanelGridItemConfig(panel),
           props: otherProps
@@ -207,19 +228,16 @@ var script = {
       });
     },
     getPanelGridItemConfig(_ref) {
-      let {
-        gridAttributes: {
-          xPos,
-          yPos,
-          width,
-          height,
-          minHeight,
-          minWidth,
-          maxHeight,
-          maxWidth
-        },
-        id
-      } = _ref;
+      let _ref$gridAttributes = _ref.gridAttributes,
+        xPos = _ref$gridAttributes.xPos,
+        yPos = _ref$gridAttributes.yPos,
+        width = _ref$gridAttributes.width,
+        height = _ref$gridAttributes.height,
+        minHeight = _ref$gridAttributes.minHeight,
+        minWidth = _ref$gridAttributes.minWidth,
+        maxHeight = _ref$gridAttributes.maxHeight,
+        maxWidth = _ref$gridAttributes.maxWidth,
+        id = _ref.id;
       const filterUndefinedValues = obj => pickBy(obj, value => value !== undefined);
 
       // GridStack renders undefined layout values so we need to filter them out.
@@ -253,10 +271,8 @@ var script = {
     },
     addGridPanels(items) {
       const newPanels = items.map(_ref2 => {
-        let {
-          grid,
-          ...rest
-        } = _ref2;
+        _ref2.grid;
+          let rest = _objectWithoutProperties(_ref2, _excluded2);
         return {
           ...rest
         };

package/dist/components/utilities/friendly_wrap/friendly_wrap.js

@@ -23,13 +23,9 @@ var script = {
     }
   },
   render(createElement, _ref) {
-    let {
-      props
-    } = _ref;
-    const {
-      symbols,
-      text
-    } = props;
+    let props = _ref.props;
+    const symbols = props.symbols,
+      text = props.text;
     const textParts = splitAfterSymbols(symbols, text !== null && text !== void 0 ? text : '');
     const content = intersperse(() => createElement('wbr'), textParts);
     return createElement('span', {

package/dist/components/utilities/intersperse/intersperse.js

@@ -4,9 +4,7 @@ import { isVnodeEmpty } from '../../../utils/is_slot_empty';
 import __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';
 
 const filterEmptyNodesVue2 = vNodes => vNodes.filter(vNode => typeof vNode.tag === 'string' || vNode.text.trim() !== '');
-const {
-  Fragment
-} = Vue;
+const Fragment = Vue.Fragment;
 const filterEmptyNodesVue3 = vNode => {
   return vNode.reduce((acc, node) => {
     if (Fragment && node.type === Fragment && Array.isArray(node.children)) {
@@ -51,14 +49,11 @@ var script = {
     }
   },
   render(createElement, context) {
-    const {
-      props: {
-        separator,
-        lastSeparator
-      },
-      slots,
-      data
-    } = context;
+    const _context$props = context.props,
+      separator = _context$props.separator,
+      lastSeparator = _context$props.lastSeparator,
+      slots = context.slots,
+      data = context.data;
     const slotContent = slots().default || [];
     const filtered = filterEmptyNodes(slotContent);
     const separated = intersperse(separator, filtered);

package/dist/components/utilities/sprintf/sprintf.js

@@ -1,7 +1,55 @@
 import { isString, has } from 'lodash-es';
 import __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';
 
-/* eslint-disable no-continue */
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
 const PREFIX = '%{';
 const SUFFIX = '}';
 const START_SUFFIX = 'Start';
@@ -10,7 +58,11 @@ const PLACE_HOLDER_REGEX = new RegExp(`(${PREFIX}[a-z]+[\\w-]*[a-z0-9]+${SUFFIX}
 function groupPlaceholdersByStartTag() {
   let placeholders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   return Object.entries(placeholders).reduce((acc, _ref) => {
-    let [slotName, [startTag, endTag]] = _ref;
+    let _ref2 = _slicedToArray(_ref, 2),
+      slotName = _ref2[0],
+      _ref2$ = _slicedToArray(_ref2[1], 2),
+      startTag = _ref2$[0],
+      endTag = _ref2$[1];
     acc[startTag] = {
       slotName,
       endTag
@@ -99,11 +151,10 @@ var script = {
         vnodes.push(chunk);
         continue;
       }
-      const {
-        slotName,
-        endTag,
-        tagName
-      } = getPlaceholderDefinition(chunk, placeholdersByStartTag);
+      const _getPlaceholderDefini = getPlaceholderDefinition(chunk, placeholdersByStartTag),
+        slotName = _getPlaceholderDefini.slotName,
+        endTag = _getPlaceholderDefini.endTag,
+        tagName = _getPlaceholderDefini.tagName;
       if (endTag) {
         // Peek ahead to find end placeholder, if any
         const indexOfEnd = chunks.indexOf(`${PREFIX}${endTag}${SUFFIX}`, i);

package/dist/components/utilities/truncate/truncate.js

@@ -51,10 +51,8 @@ var script = {
       // See https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
       // and https://infra.spec.whatwg.org/#ascii-whitespace.
       const collapsibleWhitespaceChar = /^[ \n\t\r\f]$/;
-      const {
-        text,
-        middleIndex
-      } = this;
+      const text = this.text,
+        middleIndex = this.middleIndex;
       const lastCharOfFirstIsCollapsibleWhitespace = collapsibleWhitespaceChar.test(text.charAt(middleIndex - 1));
       const firstCharOfLastIsCollapsibleWhitespace = collapsibleWhitespaceChar.test(text.charAt(middleIndex));
       return lastCharOfFirstIsCollapsibleWhitespace && !firstCharOfLastIsCollapsibleWhitespace;

package/dist/components/utilities/truncate_text/truncate_text.js

@@ -88,9 +88,7 @@ var script = {
   },
   methods: {
     onResize(_ref) {
-      let {
-        target
-      } = _ref;
+      let target = _ref.target;
       if (target.scrollHeight > target.offsetHeight) {
         this.state = STATES.TRUNCATED;
       } else if (this.isTruncated) {

package/dist/config.js

@@ -17,10 +17,9 @@ let configured = false;
  *
  */
 const setConfigs = function () {
-  let {
-    translations,
-    firstDayOfWeek
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    translations = _ref.translations,
+    firstDayOfWeek = _ref.firstDayOfWeek;
   if (configured) {
     if (process.env.NODE_ENV === 'development') {
       throw new Error('GitLab UI can only be configured once!');

package/dist/directives/hover_load/hover_load.js

@@ -4,9 +4,7 @@ const DELAY_ON_HOVER = 100;
 let mouseOverTimer;
 let mouseOverHandler;
 const bind = (el, _ref) => {
-  let {
-    value: loadHandler
-  } = _ref;
+  let loadHandler = _ref.value;
   if (!isFunction(loadHandler)) {
     throw TypeError('Directive value must be a function');
   }

package/dist/directives/outside/outside.js

@@ -17,10 +17,8 @@ const activeEventTypes = new Set();
 let lastMousedown = null;
 const globalListener = event => {
   callbacks.forEach((_ref, element) => {
-    let {
-      callback,
-      eventTypes
-    } = _ref;
+    let callback = _ref.callback,
+      eventTypes = _ref.eventTypes;
     const originalEvent = event.type === click ? lastMousedown || event : event;
     if (
     // Ignore events that aren't targeted outside the element
@@ -73,9 +71,7 @@ const stopListening = eventTypesToUnbind => {
   eventTypesToUnbind.forEach(eventType => {
     if (activeEventTypes.has(eventType)) {
       if ([...callbacks.values()].every(_ref2 => {
-        let {
-          eventTypes
-        } = _ref2;
+        let eventTypes = _ref2.eventTypes;
         return !eventTypes.includes(eventType);
       })) {
         document.removeEventListener(eventType, globalListener);
@@ -88,11 +84,9 @@ const stopListening = eventTypesToUnbind => {
   }
 };
 function parseBinding(_ref3) {
-  let {
-    arg,
-    value,
-    modifiers
-  } = _ref3;
+  let arg = _ref3.arg,
+    value = _ref3.value,
+    modifiers = _ref3.modifiers;
   const modifiersList = Object.keys(modifiers);
   if (process.env.NODE_ENV !== 'production') {
     if (typeof value !== 'function') {
@@ -112,10 +106,9 @@ function parseBinding(_ref3) {
   };
 }
 const bind = (el, bindings) => {
-  const {
-    callback,
-    eventTypes
-  } = parseBinding(bindings);
+  const _parseBinding = parseBinding(bindings),
+    callback = _parseBinding.callback,
+    eventTypes = _parseBinding.eventTypes;
   if (callbacks.has(el)) {
     // This element is already bound. This is possible if two components, which
     // share the same root node, (i.e., one is a higher-order component

package/dist/directives/resize_observer/resize_observer.js

@@ -33,19 +33,17 @@ const detachObserver = el => {
 };
 const GlResizeObserverDirective = {
   bind(el, _ref) {
-    let {
-      value: resizeHandler,
-      arg: enabled = true
-    } = _ref;
+    let resizeHandler = _ref.value,
+      _ref$arg = _ref.arg,
+      enabled = _ref$arg === void 0 ? true : _ref$arg;
     if (enabled) {
       attachObserver(el, resizeHandler);
     }
   },
   update(el, _ref2) {
-    let {
-      value: resizeHandler,
-      arg: enabled = true
-    } = _ref2;
+    let resizeHandler = _ref2.value,
+      _ref2$arg = _ref2.arg,
+      enabled = _ref2$arg === void 0 ? true : _ref2$arg;
     if (enabled) {
       attachObserver(el, resizeHandler);
     } else {

package/dist/directives/safe_html/safe_html.js

@@ -1,9 +1,7 @@
 import DOMPurify from 'dompurify';
 import { forbiddenDataAttrs, forbiddenTags } from './constants';
 
-const {
-  sanitize
-} = DOMPurify;
+const sanitize = DOMPurify.sanitize;
 
 // Mitigate against future dompurify mXSS bypasses by
 // avoiding additional serialize/parse round trip.

package/dist/directives/safe_link/safe_link.js

@@ -1,10 +1,9 @@
 import Vue from 'vue';
 
 const getBaseURL = () => {
-  const {
-    protocol,
-    host
-  } = window.location;
+  const _window$location = window.location,
+    protocol = _window$location.protocol,
+    host = _window$location.host;
   return `${protocol}//${host}`;
 };
 const isTargetBlank = target => {
@@ -32,19 +31,17 @@ const isSafeURL = url => {
   }
 };
 const transform = function (el) {
-  let {
-    arg: {
-      skipSanitization = false
-    } = {}
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$arg = _ref.arg,
+    _ref$arg2 = _ref$arg === void 0 ? {} : _ref$arg,
+    _ref$arg2$skipSanitiz = _ref$arg2.skipSanitization,
+    skipSanitization = _ref$arg2$skipSanitiz === void 0 ? false : _ref$arg2$skipSanitiz;
   if (skipSanitization) {
     return;
   }
-  const {
-    href,
-    target,
-    rel
-  } = el;
+  const href = el.href,
+    target = el.target,
+    rel = el.rel;
   if (!isSafeURL(href)) {
     el.href = 'about:blank';
   }