@gitlab/duo-ui 0.1.0

package/src/components/base/new_dropdowns/disclosure/disclosure_dropdown.scss

@@ -0,0 +1,17 @@
+.gl-disclosure-dropdown {
+  &.gl-new-dropdown {
+    .gl-new-dropdown-inner {
+      max-height: none;
+    }
+
+    .gl-new-dropdown-item-content {
+      &:disabled,
+      &[disabled] {
+        color: var(--gl-dropdown-option-text-color-disabled);
+        cursor: not-allowed;
+        background: none;
+        text-decoration: none;
+      }
+    }
+  }
+}

package/src/components/base/new_dropdowns/disclosure/disclosure_dropdown.vue

@@ -0,0 +1,458 @@
+<!-- eslint-disable vue/multi-word-component-names -->
+<script>
+import clamp from 'lodash/clamp';
+import uniqueId from 'lodash/uniqueId';
+import { stopEvent, filterVisible } from '../../../../utils/utils';
+import {
+  GL_DROPDOWN_SHOWN,
+  GL_DROPDOWN_HIDDEN,
+  GL_DROPDOWN_BEFORE_CLOSE,
+  GL_DROPDOWN_FOCUS_CONTENT,
+  ENTER,
+  SPACE,
+  HOME,
+  END,
+  ARROW_DOWN,
+  ARROW_UP,
+  GL_DROPDOWN_CONTENTS_CLASS,
+  POSITION_ABSOLUTE,
+  POSITION_FIXED,
+} from '../constants';
+import {
+  buttonCategoryOptions,
+  buttonSizeOptions,
+  dropdownPlacements,
+  dropdownVariantOptions,
+} from '../../../../utils/constants';
+import GlBaseDropdown, { BASE_DROPDOWN_CLASS } from '../base_dropdown/base_dropdown.vue';
+import GlDisclosureDropdownItem, { ITEM_CLASS } from './disclosure_dropdown_item.vue';
+import GlDisclosureDropdownGroup from './disclosure_dropdown_group.vue';
+import { itemsValidator, isItem, hasOnlyListItems } from './utils';
+
+export const DROPDOWN_SELECTOR = `.${BASE_DROPDOWN_CLASS}`;
+export const ITEM_SELECTOR = `.${ITEM_CLASS}`;
+
+export default {
+  name: 'GlDisclosureDropdown',
+  events: {
+    GL_DROPDOWN_SHOWN,
+    GL_DROPDOWN_HIDDEN,
+    GL_DROPDOWN_BEFORE_CLOSE,
+    GL_DROPDOWN_FOCUS_CONTENT,
+  },
+  components: {
+    GlBaseDropdown,
+    GlDisclosureDropdownItem,
+    GlDisclosureDropdownGroup,
+  },
+  props: {
+    /**
+     * Items to display in the dropdown
+     */
+    items: {
+      type: Array,
+      required: false,
+      default: () => [],
+      validator: itemsValidator,
+    },
+    /**
+     * Toggle button text
+     */
+    toggleText: {
+      type: String,
+      required: false,
+      default: '',
+    },
+    /**
+     * Toggle text to be read by screen readers only
+     */
+    textSrOnly: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+    /**
+     * Styling option - dropdown's toggle category
+     */
+    category: {
+      type: String,
+      required: false,
+      default: buttonCategoryOptions.primary,
+      validator: (value) => value in buttonCategoryOptions,
+    },
+    /**
+     * Styling option - dropdown's toggle variant
+     */
+    variant: {
+      type: String,
+      required: false,
+      default: dropdownVariantOptions.default,
+      validator: (value) => value in dropdownVariantOptions,
+    },
+    /**
+     * The size of the dropdown toggle
+     */
+    size: {
+      type: String,
+      required: false,
+      default: 'medium',
+      validator: (value) => value in buttonSizeOptions,
+    },
+    /**
+     * Icon name that will be rendered in the toggle button
+     */
+    icon: {
+      type: String,
+      required: false,
+      default: '',
+    },
+    /**
+     * Set to "true" to disable the dropdown
+     */
+    disabled: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+    /**
+     * Set to "true" when dropdown content (items) is loading
+     * It will render a small loader in the dropdown toggle and make it disabled
+     */
+    loading: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+    /**
+     * Custom toggle id.
+     * For instance, it can be referenced by tooltip or popover
+     */
+    toggleId: {
+      type: String,
+      required: false,
+      default: () => uniqueId('dropdown-toggle-btn-'),
+    },
+    /**
+     * Additional CSS classes to customize toggle appearance
+     */
+    toggleClass: {
+      type: [String, Array, Object],
+      required: false,
+      default: null,
+    },
+    /**
+     * Set to "true" to hide the caret
+     */
+    noCaret: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+    /**
+     * Align disclosure dropdown with respect to the toggle button
+     */
+    placement: {
+      type: String,
+      required: false,
+      default: 'bottom-start',
+      validator: (value) => Object.keys(dropdownPlacements).includes(value),
+    },
+    /**
+     * The `aria-labelledby` attribute value for the toggle button
+     * Provide the string of ids seperated by space
+     */
+    toggleAriaLabelledBy: {
+      type: String,
+      required: false,
+      default: null,
+    },
+    /**
+     * The `aria-labelledby` attribute value for the list of options
+     * Provide the string of ids seperated by space
+     */
+    listAriaLabelledBy: {
+      type: String,
+      required: false,
+      default: null,
+    },
+    /**
+     * Render the toggle button as a block element
+     */
+    block: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+    /**
+     * Custom offset to be applied to Floating UI's offset middleware.
+     * https://floating-ui.com/docs/offset
+     */
+    dropdownOffset: {
+      type: [Number, Object],
+      required: false,
+      default: undefined,
+    },
+    /**
+     * Lets the dropdown extend to match its content's width, up to a maximum width
+     * defined by the `$gl-new-dropdown-max-width` variable.
+     */
+    fluidWidth: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+    /**
+     * Close the dropdown on item click (action)
+     */
+    autoClose: {
+      type: Boolean,
+      required: false,
+      default: true,
+    },
+    /**
+     * Strategy to be applied by computePosition. If the dropdown's container is too short for it to
+     * fit in, setting this to fixed will let it position itself above its container.
+     * https://floating-ui.com/docs/computePosition#strategy
+     */
+    positioningStrategy: {
+      type: String,
+      required: false,
+      default: POSITION_ABSOLUTE,
+      validator: (strategy) => [POSITION_ABSOLUTE, POSITION_FIXED].includes(strategy),
+    },
+    /**
+     * Opens dropdown on render
+     */
+    startOpened: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+  },
+  data() {
+    return {
+      disclosureId: uniqueId('disclosure-'),
+      nextFocusedItemIndex: null,
+    };
+  },
+  computed: {
+    disclosureTag() {
+      if (
+        this.items?.length ||
+        // eslint-disable-next-line @gitlab/vue-prefer-dollar-scopedslots
+        hasOnlyListItems(this.$scopedSlots.default || this.$slots.default)
+      ) {
+        return 'ul';
+      }
+      return 'div';
+    },
+    hasCustomToggle() {
+      return Boolean(this.$scopedSlots.toggle);
+    },
+  },
+  mounted() {
+    if (this.startOpened) {
+      this.open();
+    }
+  },
+  methods: {
+    open() {
+      this.$refs.baseDropdown.open();
+    },
+    close() {
+      this.$refs.baseDropdown.close();
+    },
+    onShow() {
+      /**
+       * Emitted when dropdown is shown
+       *
+       * @event shown
+       */
+      this.$emit(GL_DROPDOWN_SHOWN);
+    },
+    onBeforeClose(event) {
+      /**
+       * Emitted when dropdown is about to be closed
+       *
+       * @event beforeClose
+       */
+      this.$emit(GL_DROPDOWN_BEFORE_CLOSE, event);
+    },
+    onHide() {
+      /**
+       * Emitted when dropdown is hidden
+       *
+       * @event hidden
+       */
+      this.$emit(GL_DROPDOWN_HIDDEN);
+      this.nextFocusedItemIndex = null;
+    },
+    onKeydown(event) {
+      const { code } = event;
+      const elements = this.getFocusableListItemElements();
+
+      if (elements.length < 1) return;
+
+      let stop = true;
+
+      if (code === HOME) {
+        this.focusItem(0, elements);
+      } else if (code === END) {
+        this.focusItem(elements.length - 1, elements);
+      } else if (code === ARROW_UP) {
+        this.focusNextItem(event, elements, -1);
+      } else if (code === ARROW_DOWN) {
+        this.focusNextItem(event, elements, 1);
+      } else if (code === ENTER || code === SPACE) {
+        this.handleAutoClose(event);
+      } else {
+        stop = false;
+      }
+
+      if (stop) {
+        stopEvent(event);
+      }
+    },
+    getFocusableListItemElements() {
+      const items = this.$refs.content?.querySelectorAll(ITEM_SELECTOR);
+      return filterVisible(Array.from(items || []));
+    },
+    focusNextItem(event, elements, offset) {
+      const { target } = event;
+      const currentIndex = elements.indexOf(target);
+      const nextIndex = clamp(currentIndex + offset, 0, elements.length - 1);
+
+      this.focusItem(nextIndex, elements);
+    },
+    focusItem(index, elements) {
+      this.nextFocusedItemIndex = index;
+
+      elements[index]?.focus();
+    },
+    closeAndFocus() {
+      this.$refs.baseDropdown.closeAndFocus();
+    },
+    handleAction(action) {
+      // See https://gitlab.com/gitlab-org/gitlab-ui/-/merge_requests/4376 for
+      // detailed explanation why we need requestAnimationFrame
+      window.requestAnimationFrame(() => {
+        /**
+         * Emitted when one of disclosure dropdown items is clicked
+         *
+         * @event action
+         */
+        this.$emit('action', action);
+      });
+    },
+    handleAutoClose(e) {
+      if (
+        this.autoClose &&
+        e.target.closest(ITEM_SELECTOR) &&
+        e.target.closest(DROPDOWN_SELECTOR) === this.$refs.baseDropdown.$el
+      ) {
+        this.closeAndFocus();
+      }
+    },
+    uniqueItemId() {
+      return uniqueId(`disclosure-item-`);
+    },
+    isItem,
+  },
+  GL_DROPDOWN_CONTENTS_CLASS,
+};
+</script>
+
+<template>
+  <gl-base-dropdown
+    ref="baseDropdown"
+    :aria-labelledby="toggleAriaLabelledBy"
+    :toggle-id="toggleId"
+    :toggle-text="toggleText"
+    :toggle-class="toggleClass"
+    :text-sr-only="textSrOnly"
+    :category="category"
+    :variant="variant"
+    :size="size"
+    :icon="icon"
+    :disabled="disabled"
+    :loading="loading"
+    :no-caret="noCaret"
+    :placement="placement"
+    :block="block"
+    :offset="dropdownOffset"
+    :fluid-width="fluidWidth"
+    :positioning-strategy="positioningStrategy"
+    class="gl-disclosure-dropdown"
+    @[$options.events.GL_DROPDOWN_SHOWN]="onShow"
+    @[$options.events.GL_DROPDOWN_HIDDEN]="onHide"
+    @[$options.events.GL_DROPDOWN_BEFORE_CLOSE]="onBeforeClose"
+    @[$options.events.GL_DROPDOWN_FOCUS_CONTENT]="onKeydown"
+  >
+    <template v-if="hasCustomToggle" #toggle>
+      <!-- @slot Custom toggle content -->
+      <slot name="toggle"></slot>
+    </template>
+
+    <!-- @slot Content to display in dropdown header -->
+    <slot name="header"></slot>
+
+    <component
+      :is="disclosureTag"
+      :id="disclosureId"
+      ref="content"
+      :aria-labelledby="listAriaLabelledBy || toggleId"
+      data-testid="disclosure-content"
+      :class="$options.GL_DROPDOWN_CONTENTS_CLASS"
+      tabindex="-1"
+      @keydown="onKeydown"
+      @click="handleAutoClose"
+    >
+      <slot>
+        <template v-for="(item, index) in items">
+          <template v-if="isItem(item)">
+            <!-- eslint-disable-next-line vue/valid-v-for -->
+            <gl-disclosure-dropdown-item :key="uniqueItemId()" :item="item" @action="handleAction">
+              <template v-if="'list-item' in $scopedSlots" #list-item>
+                <!-- @slot Custom template of the disclosure dropdown item -->
+                <slot name="list-item" :item="item"></slot>
+              </template>
+            </gl-disclosure-dropdown-item>
+          </template>
+
+          <template v-else>
+            <gl-disclosure-dropdown-group
+              :key="item.name"
+              :bordered="index !== 0"
+              :group="item"
+              @action="handleAction"
+            >
+              <template v-if="$scopedSlots['group-label']" #group-label>
+                <!-- @slot Custom template for group names -->
+                <slot name="group-label" :group="item"></slot>
+              </template>
+
+              <template v-if="$scopedSlots['list-item']">
+                <!-- eslint-disable vue/valid-v-for -->
+                <gl-disclosure-dropdown-item
+                  v-for="groupItem in item.items"
+                  :key="uniqueItemId()"
+                  :item="groupItem"
+                  @action="handleAction"
+                >
+                  <template #list-item>
+                    <!-- @slot Custom template of the disclosure dropdown item -->
+                    <slot name="list-item" :item="groupItem"></slot>
+                  </template>
+                </gl-disclosure-dropdown-item>
+                <!-- eslint-enable vue/valid-v-for -->
+              </template>
+            </gl-disclosure-dropdown-group>
+          </template>
+        </template>
+      </slot>
+    </component>
+
+    <!-- @slot Content to display in dropdown footer -->
+    <slot name="footer"></slot>
+  </gl-base-dropdown>
+</template>

package/src/components/base/new_dropdowns/disclosure/disclosure_dropdown_group.vue

@@ -0,0 +1,104 @@
+<script>
+import uniqueId from 'lodash/uniqueId';
+import GlDisclosureDropdownItem from './disclosure_dropdown_item.vue';
+import { isGroup } from './utils';
+import {
+  DISCLOSURE_DROPDOWN_GROUP_NAME,
+  DISCLOSURE_DROPDOWN_GROUP_BORDER_POSITIONS as borderPositions,
+} from './constants';
+
+export const BORDER_CLASSES = {
+  [borderPositions.top]: 'gl-border-t gl-border-t-dropdown gl-pt-2 gl-mt-2',
+  [borderPositions.bottom]: 'gl-border-b gl-border-b-dropdown gl-pb-2 gl-mb-2',
+};
+
+export default {
+  name: DISCLOSURE_DROPDOWN_GROUP_NAME,
+  components: {
+    GlDisclosureDropdownItem,
+  },
+  props: {
+    /**
+     * Group of items
+     */
+    group: {
+      type: Object,
+      required: false,
+      default: null,
+      validator: isGroup,
+    },
+    /**
+     * If 'true', will set top border for the group
+     * to separate from other groups. You can control
+     * the border position using the `borderPosition`
+     * property.
+     */
+    bordered: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+
+    /**
+     * Controls the position of the group's border. Valid
+     * values are 'top' and 'bottom'.
+     */
+    borderPosition: {
+      type: String,
+      required: false,
+      default: borderPositions.top,
+      validator: (value) => Object.keys(borderPositions).includes(value),
+    },
+  },
+  computed: {
+    borderClass() {
+      return this.bordered ? BORDER_CLASSES[this.borderPosition] : null;
+    },
+    showHeader() {
+      return this.$scopedSlots['group-label'] || this.group?.name;
+    },
+    groupLabeledBy() {
+      return this.showHeader ? this.nameId : null;
+    },
+  },
+  created() {
+    this.nameId = uniqueId('gl-disclosure-dropdown-group-');
+  },
+  methods: {
+    handleAction(action) {
+      this.$emit('action', action);
+    },
+    uniqueItemId() {
+      return uniqueId(`disclosure-item-`);
+    },
+  },
+};
+</script>
+
+<template>
+  <li :class="borderClass">
+    <div
+      v-if="showHeader"
+      :id="nameId"
+      aria-hidden="true"
+      class="gl-py-2 gl-pl-4 gl-text-sm gl-font-bold gl-text-strong"
+    >
+      <slot name="group-label">{{ group.name }}</slot>
+    </div>
+    <ul :aria-labelledby="groupLabeledBy" class="gl-mb-0 gl-list-none gl-pl-0">
+      <slot>
+        <!-- eslint-disable vue/valid-v-for -->
+        <gl-disclosure-dropdown-item
+          v-for="item in group.items"
+          :key="uniqueItemId()"
+          :item="item"
+          @action="handleAction"
+        >
+          <template #list-item>
+            <slot name="list-item" :item="item"></slot>
+          </template>
+        </gl-disclosure-dropdown-item>
+      </slot>
+    </ul>
+  </li>
+</template>

package/src/components/base/new_dropdowns/disclosure/disclosure_dropdown_item.vue

@@ -0,0 +1,131 @@
+<script>
+import { BLink } from '../../../../vendor/bootstrap-vue/src/components/link/link';
+import { ENTER, SPACE } from '../constants';
+import { stopEvent } from '../../../../utils/utils';
+import { isItem } from './utils';
+import { DISCLOSURE_DROPDOWN_ITEM_NAME } from './constants';
+
+export const ITEM_CLASS = 'gl-new-dropdown-item';
+
+export default {
+  name: DISCLOSURE_DROPDOWN_ITEM_NAME,
+  ITEM_CLASS,
+  components: { BLink },
+  props: {
+    item: {
+      type: Object,
+      required: false,
+      default: null,
+      validator: isItem,
+    },
+  },
+  computed: {
+    isLink() {
+      return typeof this.item?.href === 'string' || typeof this.item?.to === 'string';
+    },
+    isCustomContent() {
+      return Boolean(this.$scopedSlots.default);
+    },
+    itemComponent() {
+      const { item } = this;
+
+      if (this.isLink)
+        return {
+          is: BLink,
+          attrs: {
+            href: item.href,
+            to: item.to,
+            ...item.extraAttrs,
+          },
+          listeners: {
+            click: this.action,
+          },
+        };
+
+      return {
+        is: 'button',
+        attrs: {
+          ...item?.extraAttrs,
+          type: 'button',
+        },
+        listeners: {
+          click: () => {
+            item?.action?.call(undefined, item);
+            this.action();
+          },
+        },
+      };
+    },
+    listIndex() {
+      return this.item?.extraAttrs?.disabled ? null : 0;
+    },
+    componentIndex() {
+      return this.item?.extraAttrs?.disabled ? null : -1;
+    },
+    wrapperClass() {
+      return this.item?.wrapperClass ?? '';
+    },
+    wrapperListeners() {
+      const listeners = {
+        keydown: this.onKeydown,
+      };
+      if (this.isCustomContent) {
+        listeners.click = this.action;
+      }
+      return listeners;
+    },
+  },
+  methods: {
+    onKeydown(event) {
+      const { code } = event;
+
+      if (code === ENTER || code === SPACE) {
+        if (this.isCustomContent) {
+          this.action();
+        } else {
+          stopEvent(event);
+          /** Instead of simply navigating or calling the action, we want
+           * the `a/button` to be the target of the event as it might have additional attributes.
+           * E.g. `a` might have `target` attribute.
+           */
+          const e = new MouseEvent('click', { bubbles: true, cancelable: true });
+          if (this.isLink) {
+            this.$refs.item.$el.dispatchEvent(e);
+          } else {
+            this.$refs.item?.dispatchEvent(e);
+          }
+        }
+      }
+    },
+    action() {
+      this.$emit('action', this.item);
+    },
+  },
+};
+</script>
+
+<template>
+  <li
+    :tabindex="listIndex"
+    :class="[$options.ITEM_CLASS, wrapperClass]"
+    data-testid="disclosure-dropdown-item"
+    v-on="wrapperListeners"
+  >
+    <slot>
+      <component
+        :is="itemComponent.is"
+        v-bind="itemComponent.attrs"
+        ref="item"
+        class="gl-new-dropdown-item-content"
+        :tabindex="componentIndex"
+        v-on="itemComponent.listeners"
+      >
+        <span class="gl-new-dropdown-item-text-wrapper">
+          <slot name="list-item">
+            {{ item.text }}
+          </slot>
+        </span>
+      </component>
+    </slot>
+  </li>
+</template>