@flux-ui/components 3.0.0-next.34 → 3.0.0-next.38

package/src/component/primitive/SelectBase.vue

@@ -9,7 +9,10 @@
             isSearchable && $style.isSearchable
         )"
         :id="id"
+        role="combobox"
         :aria-disabled="disabled ? true : undefined"
+        :aria-expanded="isPopupOpen"
+        aria-haspopup="listbox"
         tabindex="0"
         tag-name="div"
         @click="toggle()"
@@ -133,13 +136,12 @@
 <script
     lang="ts"
     setup>
-    import { useClickOutside } from '@basmilius/common';
     import { unrefTemplateElement } from '@flux-ui/internals';
     import type { FluxFormSelectOption, FluxFormSelectOptions } from '@flux-ui/types';
     import { clsx } from 'clsx';
     import { type ComponentPublicInstance, computed, nextTick, ref, toRef, unref, useTemplateRef, watch } from 'vue';
     import { useDisabled, useFormFieldInjection } from '$flux/composable';
-    import { useTranslate } from '$flux/composable/private';
+    import { useDropdownPopup, useTranslate } from '$flux/composable/private';
     import { isFluxFormSelectGroup, isFluxFormSelectOption } from '$flux/data';
     import { FluxFadeTransition } from '$flux/transition';
     import FluxFormInput from '$flux/component/FluxFormInput.vue';
@@ -193,20 +195,27 @@
     const translate = useTranslate();
 
     const anchorRef = useTemplateRef<ComponentPublicInstance>('anchor');
-    const anchorPopupRef = useTemplateRef('anchorPopup');
+    const anchorPopupRef = useTemplateRef<ComponentPublicInstance>('anchorPopup');
     const optionElementRefs = useTemplateRef<typeof FluxMenuItem[]>('optionElements');
     const searchInputElementRef = useTemplateRef<ComponentPublicInstance<typeof FluxFormInput>>('searchInputElement');
 
     const highlightedIndex = ref(INITIAL_HIGHLIGHTED_INDEX);
     const isKeyboardAction = ref(false);
-    const isPopupOpen = ref(false);
 
     const focusElement = computed(() => unrefTemplateElement(searchInputElementRef) ?? unrefTemplateElement(anchorRef));
     const highlightedId = computed(() => unref(rawOptions)[unref(highlightedIndex)]?.value);
     const rawOptions = computed(() => options.map(group => group[1]).flat());
 
-    useClickOutside([anchorRef, anchorPopupRef], isPopupOpen, () => isPopupOpen.value = false);
-    useClickOutside(anchorRef, isPopupOpen, () => unref(focusElement)?.focus());
+    const {
+        isOpen: isPopupOpen,
+        toggle,
+        onKeyDownBase
+    } = useDropdownPopup({
+        anchorRef,
+        popupRef: anchorPopupRef,
+        focusElement,
+        disabled
+    });
 
     function deselect(id: string | number | null): void {
         emit('deselect', id);
@@ -217,7 +226,9 @@
     function select(id: string | number | null): void {
         emit('select', id);
 
-        !isMultiple && (isPopupOpen.value = false);
+        if (!isMultiple) {
+            isPopupOpen.value = false;
+        }
 
         highlightedIndex.value = INITIAL_HIGHLIGHTED_INDEX;
         modelSearch.value = '';
@@ -225,14 +236,6 @@
         nextTick(() => unref(focusElement)?.focus());
     }
 
-    function toggle(): void {
-        if (unref(disabled)) {
-            return;
-        }
-
-        isPopupOpen.value = !unref(isPopupOpen);
-    }
-
     function onKeyDown(evt: KeyboardEvent): void {
         emit('keyDown', evt);
 
@@ -246,6 +249,10 @@
 
         isKeyboardAction.value = true;
 
+        if (onKeyDownBase(evt)) {
+            return;
+        }
+
         if (unref(highlightedIndex) === INITIAL_HIGHLIGHTED_INDEX && ['ArrowDown', 'ArrowUp'].includes(evt.key)) {
             const options = unref(optionElementRefs);
             const selectedIndex = options?.findIndex(o => 'isActive' in o.$props && o.$props.isActive);
@@ -277,14 +284,6 @@
                 id && select(id);
                 break;
 
-            case 'Escape':
-                isPopupOpen.value = false;
-                break;
-
-            case 'Tab':
-                isPopupOpen.value = false;
-                return;
-
             default:
                 if (evt.key.length === 1) {
                     highlightedIndex.value = unref(rawOptions).findIndex(o => o.label.toLowerCase().startsWith(evt.key.toLowerCase()));
@@ -314,11 +313,6 @@
             return;
         }
 
-        nextTick(() => {
-            const searchInput = unref(searchInputElementRef);
-            searchInput?.focus();
-        });
-
         nextTick(() => {
             const options = unref(optionElementRefs);
 

package/src/component/primitive/SliderBase.vue

@@ -6,7 +6,6 @@
             disabled && $style.isDisabled,
             isDragging && $style.isDragging
         )"
-        role="slider"
         :aria-disabled="disabled ? true : undefined"
         @pointerdown="onPointerDown">
         <FluxTicks

package/src/component/primitive/SliderThumb.vue

@@ -8,7 +8,12 @@
         :style="{
             left: `${position * 100}%`
         }"
+        role="slider"
         :aria-disabled="disabled ? true : undefined"
+        :aria-label="ariaLabel"
+        :aria-valuemax="ariaValuemax"
+        :aria-valuemin="ariaValuemin"
+        :aria-valuenow="ariaValuenow"
         :tabindex="disabled ? -1 : 0"
         type="button"
         @keydown="onKeyDown"
@@ -32,6 +37,10 @@
     const {
         disabled: componentDisabled
     } = defineProps<{
+        readonly ariaLabel?: string;
+        readonly ariaValuemax?: number;
+        readonly ariaValuemin?: number;
+        readonly ariaValuenow?: number;
         readonly disabled?: boolean;
         readonly isDragging?: boolean;
         readonly position: number;

package/src/component/primitive/TreeNodeRenderer.vue

@@ -0,0 +1,77 @@
+<template>
+    <div :class="$style.treeNodeLineArea">
+        <span
+            v-for="(showLine, guideIndex) in node.lineGuides"
+            :key="`g-${guideIndex}`"
+            :class="[$style.treeIndent, showLine && $style.hasLine]"/>
+
+        <span
+            v-if="node.depth > 0"
+            :class="[$style.treeConnector, node.isLast && $style.isLast]"/>
+
+        <span
+            :class="$style.treeNodeExpand"
+            @click="onExpandClick($event)">
+            <FluxIcon
+                v-if="node.children?.length"
+                :name="expanded ? 'angle-down' : 'angle-right'"
+                :size="12"/>
+        </span>
+    </div>
+
+    <span
+        v-if="dotColor"
+        :class="$style.treeNodeColorDot"
+        :style="{ background: dotColor }"/>
+
+    <FluxIcon
+        v-if="node.icon"
+        :class="$style.treeNodeIcon"
+        :name="node.icon"
+        :size="16"/>
+
+    <span :class="$style.treeNodeLabel">{{ node.label }}</span>
+
+    <slot
+        name="trailing"
+        :node="node"/>
+</template>
+
+<script
+    lang="ts"
+    setup
+    generic="TOption extends TreeBaseOption">
+    import type { FluxColor } from '@flux-ui/types';
+    import { computed } from 'vue';
+    import type { TreeBaseOption, TreeFlatNode } from '$flux/composable/private';
+    import { getLevelColor } from '$flux/composable/private';
+    import FluxIcon from '$flux/component/FluxIcon.vue';
+    import $style from '$flux/css/component/primitive/TreeNode.module.scss';
+
+    const emit = defineEmits<{
+        expandClick: [MouseEvent];
+    }>();
+
+    const {
+        levelColors,
+        node
+    } = defineProps<{
+        readonly node: TreeFlatNode<TOption>;
+        readonly expanded: boolean;
+        readonly levelColors?: (FluxColor | string)[];
+    }>();
+
+    defineSlots<{
+        trailing?(props: { node: TreeFlatNode<TOption> }): any;
+    }>();
+
+    defineOptions({
+        inheritAttrs: false
+    });
+
+    const dotColor = computed(() => getLevelColor(node.depth, levelColors));
+
+    function onExpandClick(evt: MouseEvent): void {
+        emit('expandClick', evt);
+    }
+</script>

package/src/component/primitive/index.ts

@@ -1,5 +1,6 @@
 export { default as Anchor } from './Anchor.vue';
 export { default as AnchorPopup } from './AnchorPopup.vue';
+export { default as DialogLayout } from './DialogLayout.vue';
 export { default as FilterBadge } from './FilterBadge.vue';
 export { default as FilterItem } from './FilterItem.vue';
 export { default as FilterOptionBase } from './FilterOptionBase.vue';
@@ -7,6 +8,7 @@ export { default as SelectBase } from './SelectBase.vue';
 export { default as SliderBase } from './SliderBase.vue';
 export { default as SliderThumb } from './SliderThumb.vue';
 export { default as SliderTrack } from './SliderTrack.vue';
+export { default as TreeNodeRenderer } from './TreeNodeRenderer.vue';
 
 export { FilterMenuRenderer } from './FilterMenuRenderer';
 export { VNodeRenderer } from './VNodeRenderer';

package/src/composable/index.ts

@@ -1,6 +1,7 @@
 export { default as useBreakpoints } from './useBreakpoints';
 export { default as useDisabled } from './useDisabled';
 
+export { default as useAdaptiveGroupInjection } from './useAdaptiveGroupInjection';
 export { default as useDisabledInjection } from './useDisabledInjection';
 export { default as useExpandableGroupInjection } from './useExpandableGroupInjection';
 export { default as useFilterInjection } from './useFilterInjection';

package/src/composable/private/index.ts

@@ -1,4 +1,12 @@
+export { default as useAsyncFilterOptions } from './useAsyncFilterOptions';
+export { default as useDateFlyout } from './useDateFlyout';
+export { default as useDropdownPopup } from './useDropdownPopup';
+export type { UseDropdownPopupOptions, UseDropdownPopupReturn } from './useDropdownPopup';
 export { default as useFormSelect } from './useFormSelect';
 export { default as useTranslate } from './useTranslate';
+export { useCommandPalette } from './useCommandPalette';
+export type { CommandPaletteGroup, CommandPaletteResultItem } from './useCommandPalette';
+export { useFilterOptionMulti, useFilterOptionSingle } from './useFilterOption';
+export type { FilterOptionMulti, FilterOptionSingle } from './useFilterOption';
 export { flattenAll, flattenVisible, getLevelColor, INITIAL_HIGHLIGHTED_INDEX, useTreeView } from './useTreeView';
 export type { TreeBaseOption, TreeFlatNode } from './useTreeView';

package/src/composable/private/useAsyncFilterOptions.ts

@@ -0,0 +1,70 @@
+import { useDebouncedRef, useLoaded } from '@basmilius/common';
+import type { FluxFilterOptionRow, FluxFilterValue } from '@flux-ui/types';
+import { type ComputedRef, type ModelRef, computed, type Ref, ref, unref, watch } from 'vue';
+import { isFluxFilterOptionItem } from '$flux/data';
+
+type UseAsyncFilterOptionsParams = {
+    readonly currentValueIds: ComputedRef<FluxFilterValue[]>;
+    readonly modelSearch: ModelRef<string, string, string, string>;
+    fetchOptions(ids: FluxFilterValue[]): Promise<FluxFilterOptionRow[]>;
+    fetchRelevant(): Promise<FluxFilterOptionRow[]>;
+    fetchSearch(searchQuery: string): Promise<FluxFilterOptionRow[]>;
+};
+
+export default function ({
+    currentValueIds,
+    modelSearch,
+    fetchOptions: fetchOptionsProp,
+    fetchRelevant: fetchRelevantProp,
+    fetchSearch: fetchSearchProp
+}: UseAsyncFilterOptionsParams) {
+    const {isLoading, loaded} = useLoaded();
+    const debouncedModelSearch = useDebouncedRef(modelSearch, 150) as unknown as Ref<string>;
+    const fetchOptions = computed(() => loaded(fetchOptionsProp));
+    const fetchRelevant = computed(() => loaded(fetchRelevantProp));
+    const fetchSearch = computed(() => loaded(fetchSearchProp));
+
+    const selectedOptions = ref<FluxFilterOptionRow[]>([]);
+    const visibleOptions = ref<FluxFilterOptionRow[]>([]);
+
+    const options = computed(() => {
+        const options: FluxFilterOptionRow[] = [];
+        const search = unref(modelSearch);
+        const selected = unref(selectedOptions);
+        const visible = unref(visibleOptions);
+
+        visible.forEach(vo => options.push(vo));
+
+        selected.forEach(so => {
+            if (isFluxFilterOptionItem(so) && visible.find(vo => isFluxFilterOptionItem(vo) && vo.value === so.value)) {
+                return;
+            }
+
+            if (isFluxFilterOptionItem(so) && !so.label.toLowerCase().includes(search.toLowerCase())) {
+                return;
+            }
+
+            options.push(so);
+        });
+
+        return options;
+    });
+
+    watch(currentValueIds, async ids => {
+        if (ids.length === 0) {
+            return;
+        }
+
+        selectedOptions.value = await unref(fetchOptions)(ids);
+    }, {immediate: true});
+
+    watch(debouncedModelSearch, async searchQuery => {
+        if (searchQuery.length > 0) {
+            visibleOptions.value = await unref(fetchSearch)(searchQuery);
+        } else {
+            visibleOptions.value = await unref(fetchRelevant)();
+        }
+    }, {immediate: true});
+
+    return {isLoading, options};
+}