@flux-ui/components 3.0.0-next.6 → 3.0.0-next.60

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()"
@@ -21,6 +24,8 @@
                 :command="selected[0].command"
                 :command-icon="selected[0].commandIcon"
                 :icon-leading="selected[0].icon"
+                :image-alt="selected[0].imageAlt"
+                :image-src="selected[0].imageSrc"
                 :label="selected[0].label"
                 tabindex="-1"/>
         </template>
@@ -97,6 +102,8 @@
                                     :command="subItem.command"
                                     :command-icon="subItem.commandIcon"
                                     :icon-leading="subItem.icon"
+                                    :image-alt="subItem.imageAlt"
+                                    :image-src="subItem.imageSrc"
                                     :is-active="!!selected.find(so => so.value === subItem.value)"
                                     :is-highlighted="highlightedId === subItem.value"
                                     :label="subItem.label"
@@ -112,6 +119,8 @@
                             :command="item.command"
                             :command-icon="item.commandIcon"
                             :icon-leading="item.icon"
+                            :image-alt="item.imageAlt"
+                            :image-src="item.imageSrc"
                             :is-active="!!selected.find(so => so.value === item.value)"
                             :is-highlighted="highlightedId === item.value"
                             :label="item.label"
@@ -127,25 +136,25 @@
 <script
     lang="ts"
     setup>
-    import { unrefTemplateElement, useClickOutside } from '@flux-ui/internals';
+    import { unrefTemplateElement } from '@flux-ui/internals';
     import type { FluxFormSelectOption, FluxFormSelectOptions } from '@flux-ui/types';
     import { clsx } from 'clsx';
-    import { ComponentPublicInstance, computed, nextTick, ref, toRef, unref, useTemplateRef, watch } from 'vue';
-    import { useDisabled, useFormFieldInjection } from '$flux/composable';
-    import { useTranslate } from '$flux/composable/private';
-    import { isFluxFormSelectGroup, isFluxFormSelectOption } from '$flux/data';
-    import { FluxFadeTransition } from '$flux/transition';
-    import FluxFormInput from '$flux/component/FluxFormInput.vue';
-    import FluxIcon from '$flux/component/FluxIcon.vue';
-    import FluxMenu from '$flux/component/FluxMenu.vue';
-    import FluxMenuGroup from '$flux/component/FluxMenuGroup.vue';
-    import FluxMenuItem from '$flux/component/FluxMenuItem.vue';
-    import FluxMenuSubHeader from '$flux/component/FluxMenuSubHeader.vue';
-    import FluxSpinner from '$flux/component/FluxSpinner.vue';
-    import FluxTag from '$flux/component/FluxTag.vue';
+    import { type ComponentPublicInstance, computed, nextTick, ref, toRef, unref, useTemplateRef, watch } from 'vue';
+    import { useDisabled, useFormFieldInjection } from '~flux/components/composable';
+    import { useDropdownPopup, useTranslate } from '~flux/components/composable/private';
+    import { isFluxFormSelectGroup, isFluxFormSelectOption } from '~flux/components/data';
+    import { FluxFadeTransition } from '~flux/components/transition';
+    import FluxFormInput from '../FluxFormInput.vue';
+    import FluxIcon from '../FluxIcon.vue';
+    import FluxMenu from '../FluxMenu.vue';
+    import FluxMenuGroup from '../FluxMenuGroup.vue';
+    import FluxMenuItem from '../FluxMenuItem.vue';
+    import FluxMenuSubHeader from '../FluxMenuSubHeader.vue';
+    import FluxSpinner from '../FluxSpinner.vue';
+    import FluxTag from '../FluxTag.vue';
     import Anchor from './Anchor.vue';
     import AnchorPopup from './AnchorPopup.vue';
-    import $style from '$flux/css/component/Form.module.scss';
+    import $style from '~flux/components/css/component/Form.module.scss';
 
     const INITIAL_HIGHLIGHTED_INDEX = -1;
 
@@ -186,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);
@@ -210,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 = '';
@@ -218,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);
 
@@ -239,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);
@@ -270,17 +284,9 @@
                 id && select(id);
                 break;
 
-            case 'Escape':
-                isPopupOpen.value = false;
-                break;
-
-            case 'Tab':
-                isPopupOpen.value = false;
-                return;
-
             default:
-                if (evt.key.match(/[a-z]/)) {
-                    highlightedIndex.value = unref(rawOptions).findIndex(o => o.label.toLowerCase().startsWith(evt.key));
+                if (evt.key.length === 1) {
+                    highlightedIndex.value = unref(rawOptions).findIndex(o => o.label.toLowerCase().startsWith(evt.key.toLowerCase()));
                 } else {
                     highlightedIndex.value = -1;
                 }
@@ -307,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
@@ -22,10 +21,10 @@
     setup>
     import { unrefTemplateElement } from '@flux-ui/internals';
     import { clsx } from 'clsx';
-    import { onMounted, onUnmounted, toRef, unref, useTemplateRef, watch } from 'vue';
-    import { useDisabled } from '$flux/composable';
-    import FluxTicks from '$flux/component/FluxTicks.vue';
-    import $style from '$flux/css/component/primitive/Slider.module.scss';
+    import { onUnmounted, toRef, unref, useTemplateRef } from 'vue';
+    import { useDisabled } from '~flux/components/composable';
+    import FluxTicks from '../FluxTicks.vue';
+    import $style from '~flux/components/css/component/primitive/Slider.module.scss';
 
     const emit = defineEmits<{
         dragging: [boolean];
@@ -47,22 +46,14 @@
     const disabled = useDisabled(toRef(() => componentDisabled));
     const rootRef = useTemplateRef('root');
 
-    onMounted(() => {
-        document.addEventListener('pointermove', onPointerMove);
-        document.addEventListener('pointerup', onPointerUp, {passive: true});
-    });
-
-    onUnmounted(() => {
-        document.removeEventListener('pointermove', onPointerMove);
-        document.removeEventListener('pointerup', onPointerUp);
-    });
-
     function onPointerDown(evt: PointerEvent): void {
         if (unref(disabled)) {
             return;
         }
 
         emit('dragging', true);
+        document.addEventListener('pointermove', onPointerMove);
+        document.addEventListener('pointerup', onPointerUp, {passive: true});
         requestAnimationFrame(() => onPointerMove(evt));
     }
 
@@ -77,13 +68,18 @@
         left += 6; // margin.
         width -= 12; // margin times two.
 
-        emit('update', Math.max(0, Math.min(1, (evt.pageX - left) / width)));
+        emit('update', Math.max(0, Math.min(1, (evt.clientX - left) / width)));
         evt.preventDefault();
     }
 
     function onPointerUp(): void {
         emit('dragging', false);
+        document.removeEventListener('pointermove', onPointerMove);
+        document.removeEventListener('pointerup', onPointerUp);
     }
 
-    watch(() => isDragging, () => emit('dragging', isDragging));
+    onUnmounted(() => {
+        document.removeEventListener('pointermove', onPointerMove);
+        document.removeEventListener('pointerup', onPointerUp);
+    });
 </script>

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"
@@ -20,8 +25,8 @@
     setup>
     import { clsx } from 'clsx';
     import { toRef, unref } from 'vue';
-    import { useDisabled } from '$flux/composable';
-    import $style from '$flux/css/component/primitive/Slider.module.scss';
+    import { useDisabled } from '~flux/components/composable';
+    import $style from '~flux/components/css/component/primitive/Slider.module.scss';
 
     const emit = defineEmits<{
         decrement: [];
@@ -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/SliderTrack.vue

@@ -13,7 +13,7 @@
 <script
     lang="ts"
     setup>
-    import $style from '$flux/css/component/primitive/Slider.module.scss';
+    import $style from '~flux/components/css/component/primitive/Slider.module.scss';
 
     defineProps<{
         readonly percentageLower: number;

package/src/component/primitive/TreeNodeRenderer.vue

@@ -0,0 +1,76 @@
+<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 { getLevelColor, type TreeBaseOption, type TreeFlatNode } from '~flux/components/composable/private';
+    import FluxIcon from '../FluxIcon.vue';
+    import $style from '~flux/components/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/VNodeRenderer.ts

@@ -1,5 +1,4 @@
-import type { PropType, VNode } from 'vue';
-import { defineComponent } from 'vue';
+import { defineComponent, type PropType, type VNode } from 'vue';
 
 export const VNodeRenderer = defineComponent({
     props: {

package/src/component/primitive/index.ts

@@ -1,10 +1,14 @@
 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';
 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,9 +1,14 @@
 export { default as useBreakpoints } from './useBreakpoints';
 export { default as useDisabled } from './useDisabled';
 
+export { default as useAdaptiveGroupInjection } from './useAdaptiveGroupInjection';
+export { default as useCalendarInjection } from './useCalendarInjection';
 export { default as useDisabledInjection } from './useDisabledInjection';
 export { default as useExpandableGroupInjection } from './useExpandableGroupInjection';
 export { default as useFilterInjection } from './useFilterInjection';
 export { default as useFlyoutInjection } from './useFlyoutInjection';
 export { default as useFormFieldInjection } from './useFormFieldInjection';
+export { default as useKanbanInjection } from './useKanbanInjection';
+export { default as useTabBarInjection } from './useTabBarInjection';
 export { default as useTableInjection } from './useTableInjection';
+export { default as useTooltipInjection } from './useTooltipInjection';

package/src/composable/private/index.ts

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

package/src/composable/private/useAsyncFilterOptions.ts

@@ -0,0 +1,64 @@
+import { useDebouncedRef, useLoaded } from '@basmilius/common';
+import type { FluxFilterOptionRow, FluxFilterValue } from '@flux-ui/types';
+import { computed, ref, unref, watch, type ComputedRef, type ModelRef, type Ref } from 'vue';
+import { isFluxFilterOptionItem } from '~flux/components/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 (params: UseAsyncFilterOptionsParams) {
+    const {isLoading, loaded} = useLoaded();
+    const debouncedModelSearch = useDebouncedRef(params.modelSearch, 150) as unknown as Ref<string>;
+    const fetchOptions = computed(() => loaded(params.fetchOptions));
+    const fetchRelevant = computed(() => loaded(params.fetchRelevant));
+    const fetchSearch = computed(() => loaded(params.fetchSearch));
+
+    const selectedOptions = ref<FluxFilterOptionRow[]>([]);
+    const visibleOptions = ref<FluxFilterOptionRow[]>([]);
+
+    const options = computed(() => {
+        const options: FluxFilterOptionRow[] = [];
+        const search = unref(params.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(params.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};
+}