@gitlab/duo-ui 0.1.0 → 0.2.0

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

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

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

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

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