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

package/src/component/FluxFilterDate.vue

@@ -13,9 +13,9 @@
     import type { FluxIconName } from '@flux-ui/types';
     import { DateTime } from 'luxon';
     import { computed, unref } from 'vue';
-    import { useFilterInjection } from '$flux/composable';
+    import { useFilterInjection } from '~flux/components/composable';
     import FluxDatePicker from './FluxDatePicker.vue';
-    import $style from '$flux/css/component/Filter.module.scss';
+    import $style from '~flux/components/css/component/Filter.module.scss';
 
     const {
         name

package/src/component/FluxFilterDateRange.vue

@@ -14,9 +14,9 @@
     import type { FluxIconName } from '@flux-ui/types';
     import { DateTime } from 'luxon';
     import { computed, unref } from 'vue';
-    import { useFilterInjection } from '$flux/composable';
+    import { useFilterInjection } from '~flux/components/composable';
     import FluxDatePicker from './FluxDatePicker.vue';
-    import $style from '$flux/css/component/Filter.module.scss';
+    import $style from '~flux/components/css/component/Filter.module.scss';
 
     const {
         name,

package/src/component/FluxFilterOption.vue

@@ -11,10 +11,10 @@
 <script
     lang="ts"
     setup>
-    import type { FluxFilterOptionRow, FluxFilterValue, FluxFilterValueSingle, FluxIconName } from '@flux-ui/types';
+    import type { FluxFilterOptionRow, FluxIconName } from '@flux-ui/types';
     import { computed, unref } from 'vue';
-    import { useFilterInjection } from '$flux/composable';
-    import { isFluxFilterOptionHeader } from '$flux/data';
+    import { useFilterOptionSingle } from '~flux/components/composable/private';
+    import { isFluxFilterOptionHeader } from '~flux/components/data';
     import { FilterOptionBase } from './primitive';
 
     const modelSearch = defineModel<string>('searchQuery', {default: ''});
@@ -31,19 +31,8 @@
         readonly searchPlaceholder?: string;
     }>();
 
-    const {back, state, setValue} = useFilterInjection();
+    const {currentValue, onSelect} = useFilterOptionSingle(name);
 
-    const currentValue = computed(() => unref(state)[name] as FluxFilterValueSingle);
     const filteredOptions = computed(() => options
         .filter(o => isFluxFilterOptionHeader(o) || unref(modelSearch).length === 0 || o.label.toLowerCase().includes(unref(modelSearch).toLowerCase())));
-
-    function onSelect(value: FluxFilterValue): void {
-        if (unref(currentValue) === value) {
-            setValue(name, null);
-        } else {
-            setValue(name, value);
-        }
-
-        back();
-    }
 </script>

package/src/component/FluxFilterOptionAsync.vue

@@ -12,12 +12,9 @@
 <script
     lang="ts"
     setup>
-    import { useDebouncedRef } from '@flux-ui/internals';
-    import type { FluxFilterOptionRow, FluxFilterValue, FluxFilterValueSingle, FluxIconName } from '@flux-ui/types';
-    import { computed, ref, unref, watch } from 'vue';
-    import { useFilterInjection } from '$flux/composable';
-    import { useLoaded } from '$flux/composable/private';
-    import { isFluxFilterOptionItem } from '$flux/data';
+    import type { FluxFilterOptionRow, FluxFilterValue, FluxIconName } from '@flux-ui/types';
+    import { computed, unref } from 'vue';
+    import { useAsyncFilterOptions, useFilterOptionSingle } from '~flux/components/composable/private';
     import { FilterOptionBase } from './primitive';
 
     const modelSearch = defineModel<string>('searchQuery', {
@@ -40,64 +37,23 @@
         readonly searchPlaceholder?: string;
     }>();
 
-    const {back, state, setValue} = useFilterInjection();
-    const {isLoading, loaded} = useLoaded();
-    const debouncedModelSearch = useDebouncedRef(modelSearch, 150);
-    const fetchOptions = computed(() => loaded(fetchOptionsProp));
-    const fetchRelevant = computed(() => loaded(fetchRelevantProp));
-    const fetchSearch = computed(() => loaded(fetchSearchProp));
+    const {currentValue, onSelect} = useFilterOptionSingle(name);
 
-    const selectedOptions = ref<FluxFilterOptionRow[]>([]);
-    const visibleOptions = ref<FluxFilterOptionRow[]>([]);
+    const currentValueIds = computed<FluxFilterValue[]>(() => {
+        const value = unref(currentValue);
 
-    const currentValue = computed(() => unref(state)[name] as FluxFilterValueSingle);
-
-    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;
-    });
-
-    function onSelect(value: FluxFilterValue): void {
-        if (unref(currentValue) === value) {
-            setValue(name, null);
-        } else {
-            setValue(name, value);
-        }
-
-        back();
-    }
-
-    watch(currentValue, async value => {
-        if (!value && value !== 0) {
-            return;
+        if (value === null || value === undefined) {
+            return [];
         }
 
-        selectedOptions.value = await unref(fetchOptions)([value]);
-    }, {immediate: true});
+        return [value];
+    });
 
-    watch(debouncedModelSearch, async searchQuery => {
-        if (searchQuery.length > 0) {
-            visibleOptions.value = await unref(fetchSearch)(searchQuery);
-        } else {
-            visibleOptions.value = await unref(fetchRelevant)();
-        }
-    }, {immediate: true});
+    const {isLoading, options} = useAsyncFilterOptions({
+        currentValueIds,
+        modelSearch,
+        fetchOptions: (ids: FluxFilterValue[]) => fetchOptionsProp(ids),
+        fetchRelevant: () => fetchRelevantProp(),
+        fetchSearch: (searchQuery: string) => fetchSearchProp(searchQuery)
+    });
 </script>

package/src/component/FluxFilterOptions.vue

@@ -11,10 +11,10 @@
 <script
     lang="ts"
     setup>
-    import type { FluxFilterOptionRow, FluxFilterValueSingle, FluxIconName } from '@flux-ui/types';
+    import type { FluxFilterOptionRow, FluxIconName } from '@flux-ui/types';
     import { computed, unref } from 'vue';
-    import { useFilterInjection } from '$flux/composable';
-    import { isFluxFilterOptionHeader } from '$flux/data';
+    import { useFilterOptionMulti } from '~flux/components/composable/private';
+    import { isFluxFilterOptionHeader } from '~flux/components/data';
     import { FilterOptionBase } from './primitive';
 
     const modelSearch = defineModel<string>('searchQuery', {
@@ -33,30 +33,8 @@
         readonly searchPlaceholder?: string;
     }>();
 
-    const {state, setValue} = useFilterInjection();
-
-    const currentValue = computed(() => {
-        const value = unref(state)[name];
-
-        if (Array.isArray(value)) {
-            return value;
-        }
-
-        return [];
-    });
+    const {currentValue, onSelect} = useFilterOptionMulti(name);
 
     const filteredOptions = computed(() => options
         .filter(o => isFluxFilterOptionHeader(o) || unref(modelSearch).length === 0 || o.label.toLowerCase().includes(unref(modelSearch).toLowerCase())));
-
-    function onSelect(value: FluxFilterValueSingle): void {
-        let values = Array.from(unref(currentValue));
-
-        if (values.includes(value)) {
-            values = values.filter(v => v !== value);
-        } else {
-            values.push(value);
-        }
-
-        setValue(name, values);
-    }
 </script>

package/src/component/FluxFilterOptionsAsync.vue

@@ -12,12 +12,8 @@
 <script
     lang="ts"
     setup>
-    import { useDebouncedRef } from '@flux-ui/internals';
-    import type { FluxFilterOptionRow, FluxFilterValue, FluxFilterValueSingle, FluxIconName } from '@flux-ui/types';
-    import { computed, ref, unref, watch } from 'vue';
-    import { useFilterInjection } from '$flux/composable';
-    import { useLoaded } from '$flux/composable/private';
-    import { isFluxFilterOptionItem } from '$flux/data';
+    import type { FluxFilterOptionRow, FluxFilterValue, FluxIconName } from '@flux-ui/types';
+    import { useAsyncFilterOptions, useFilterOptionMulti } from '~flux/components/composable/private';
     import { FilterOptionBase } from './primitive';
 
     const modelSearch = defineModel<string>('searchQuery', {
@@ -40,74 +36,13 @@
         readonly searchPlaceholder?: string;
     }>();
 
-    const {state, setValue} = useFilterInjection();
-    const {isLoading, loaded} = useLoaded();
-    const debouncedModelSearch = useDebouncedRef(modelSearch, 150);
-    const fetchOptions = computed(() => loaded(fetchOptionsProp));
-    const fetchRelevant = computed(() => loaded(fetchRelevantProp));
-    const fetchSearch = computed(() => loaded(fetchSearchProp));
+    const {currentValue, onSelect} = useFilterOptionMulti(name);
 
-    const selectedOptions = ref<FluxFilterOptionRow[]>([]);
-    const visibleOptions = ref<FluxFilterOptionRow[]>([]);
-
-    const currentValue = computed(() => {
-        const value = unref(state)[name];
-
-        if (Array.isArray(value)) {
-            return value;
-        }
-
-        return [];
-    });
-
-    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;
+    const {isLoading, options} = useAsyncFilterOptions({
+        currentValueIds: currentValue,
+        modelSearch,
+        fetchOptions: (ids: FluxFilterValue[]) => fetchOptionsProp(ids),
+        fetchRelevant: () => fetchRelevantProp(),
+        fetchSearch: (searchQuery: string) => fetchSearchProp(searchQuery)
     });
-
-    function onSelect(value: FluxFilterValueSingle): void {
-        let values = Array.from(unref(currentValue));
-
-        if (values.includes(value)) {
-            values = values.filter(v => v !== value);
-        } else {
-            values.push(value);
-        }
-
-        setValue(name, values);
-    }
-
-    watch(currentValue, async value => {
-        if (value.length === 0) {
-            return;
-        }
-
-        selectedOptions.value = await unref(fetchOptions)(value);
-    }, {immediate: true});
-
-    watch(debouncedModelSearch, async searchQuery => {
-        if (searchQuery.length > 0) {
-            visibleOptions.value = await unref(fetchSearch)(searchQuery);
-        } else {
-            visibleOptions.value = await unref(fetchRelevant)();
-        }
-    }, {immediate: true});
 </script>

package/src/component/FluxFilterRange.vue

@@ -40,8 +40,8 @@
     import { formatNumber } from '@basmilius/utils';
     import type { FluxIconName } from '@flux-ui/types';
     import { computed, unref } from 'vue';
-    import { useFilterInjection } from '$flux/composable';
-    import { useTranslate } from '$flux/composable/private';
+    import { useFilterInjection } from '~flux/components/composable';
+    import { useTranslate } from '~flux/components/composable/private';
     import FluxFormColumn from './FluxFormColumn.vue';
     import FluxFormField from './FluxFormField.vue';
     import FluxFormSlider from './FluxFormSlider.vue';

package/src/component/FluxFilterWindow.vue

@@ -0,0 +1,83 @@
+<template>
+    <div
+        v-height-transition
+        :class="$style.filter">
+        <FluxWindow ref="window">
+            <template #default="{navigate}">
+                <FluxMenu>
+                    <FilterMenuRenderer
+                        :menu-items="menuItems"
+                        :navigate="navigate"/>
+                </FluxMenu>
+            </template>
+
+            <template
+                v-for="(filter, name) of filters"
+                #[name]>
+                <FluxMenu>
+                    <FluxMenuGroup
+                        :class="$style.filterHeader"
+                        is-horizontal>
+                        <FluxMenuItem
+                            :class="$style.filterBack"
+                            :label="translate('flux.back')"
+                            icon-leading="angle-left"
+                            @click="back()"/>
+
+                        <FluxMenuItem
+                            v-if="resettable?.includes(name)"
+                            :class="$style.filterReset"
+                            icon-leading="trash"
+                            is-destructive
+                            @click="reset(name)"
+                            style="flex-grow: 0"/>
+                    </FluxMenuGroup>
+
+                    <VNodeRenderer :vnode="filter"/>
+                </FluxMenu>
+            </template>
+        </FluxWindow>
+    </div>
+</template>
+
+<script
+    lang="ts"
+    setup>
+    import { vHeightTransition } from '@flux-ui/internals';
+    import type { FluxFilterItem } from '@flux-ui/types';
+    import { unref, useTemplateRef, type VNode } from 'vue';
+    import { useTranslate } from '~flux/components/composable/private';
+    import FluxMenu from './FluxMenu.vue';
+    import FluxMenuGroup from './FluxMenuGroup.vue';
+    import FluxMenuItem from './FluxMenuItem.vue';
+    import FluxWindow from './FluxWindow.vue';
+    import { FilterMenuRenderer, VNodeRenderer } from './primitive';
+    import $style from '~flux/components/css/component/Filter.module.scss';
+
+    const emit = defineEmits<{
+        reset: [string]
+    }>();
+
+    defineProps<{
+        readonly filters: Record<string, VNode>;
+        readonly menuItems: (FluxFilterItem | VNode)[][];
+        readonly resettable?: string[];
+    }>();
+
+    defineSlots<{
+        default(): VNode[];
+    }>();
+
+    const translate = useTranslate();
+
+    const windowRef = useTemplateRef<{ back(to: string): void; }>('window');
+
+    function back(): void {
+        unref(windowRef)?.back('default');
+    }
+
+    function reset(name: string): void {
+        back();
+        emit('reset', name);
+    }
+</script>

package/src/component/FluxFlickeringGrid.vue

@@ -10,7 +10,7 @@
     import { mulberry32 } from '@basmilius/utils';
     import { useInView } from '@flux-ui/internals';
     import { computed, unref, useTemplateRef, watch } from 'vue';
-    import $style from '$flux/css/component/Visual.module.scss';
+    import $style from '~flux/components/css/component/Visual.module.scss';
 
     const {
         color = '#1d4ed8',

package/src/component/FluxFlyout.vue

@@ -6,12 +6,12 @@
             '--opener-width': `${openerWidth}px`,
             '--pane-mx': `${paneMarginX}px`,
             '--pane-my': `${paneMarginY}px`,
-            '--pane-x': `${paneX - 12}px`,
-            '--pane-y': `${paneY - 12}px`
+            '--pane-x': `${paneX - 30}px`,
+            '--pane-y': `${paneY - 30}px`
         }">
         <slot
             name="opener"
-            v-bind="{close, open, toggle}"/>
+            v-bind="{close, open, toggle, isOpen: isOpen || isOpening || isClosing}"/>
 
         <dialog
             ref="dialog"
@@ -39,13 +39,13 @@
 <script
     lang="ts"
     setup>
-    import { unrefTemplateElement, useFocusTrap } from '@flux-ui/internals';
+    import { isSSR, unrefTemplateElement, useEventListener, useFocusTrap } from '@flux-ui/internals';
     import type { FluxDirection } from '@flux-ui/types';
     import { clsx } from 'clsx';
-    import { provide, ref, unref, useTemplateRef, watch } from 'vue';
-    import { FluxFlyoutInjectionKey } from '$flux/data';
+    import { provide, ref, unref, useTemplateRef, type VNode, watch } from 'vue';
+    import { FluxFlyoutInjectionKey } from '~flux/components/data';
     import FluxPane from './FluxPane.vue';
-    import $style from '$flux/css/component/Flyout.module.scss';
+    import $style from '~flux/components/css/component/Flyout.module.scss';
 
     const {
         direction = 'vertical',
@@ -65,13 +65,15 @@
             readonly paneY: number;
             readonly openerWidth: number;
             readonly openerHeight: number;
-        }): any;
+        }): VNode[];
 
         opener(props: {
             close(): void;
             open(): void;
             toggle(): void;
-        }): any;
+
+            readonly isOpen: boolean;
+        }): VNode[];
     }>();
 
     const dialogRef = useTemplateRef('dialog');
@@ -88,6 +90,7 @@
     const paneMarginX = ref(0);
     const paneMarginY = ref(0);
 
+    !isSSR && useEventListener(ref(window), 'resize', () => unref(isOpen) && reposition());
     useFocusTrap(paneRef);
 
     function close(): void {
@@ -132,14 +135,14 @@
         const {top, left, width, height} = mount.children[0].getBoundingClientRect();
         const {width: paneWidth, height: paneHeight} = pane.getBoundingClientRect();
 
-        let x, y, mx = 0, my = 0;
+        let x: number, y: number, mx = 0, my = 0;
 
         if (direction === 'horizontal') {
             x = left + width;
             y = top + height / 2 - paneHeight / 2;
             mx = margin;
 
-            if (x + paneWidth > innerWidth - 30) {
+            if (x + paneWidth > innerWidth - 12) {
                 x = left - paneWidth;
                 mx = -mx;
             }
@@ -148,14 +151,14 @@
             y = top + height;
             my = margin;
 
-            if (y + paneHeight > innerHeight - 30) {
+            if (y + paneHeight > innerHeight - 12) {
                 y = top - paneHeight;
                 my = -my;
             }
         }
 
-        paneX.value = Math.max(30, Math.min(innerWidth - paneWidth - 30, x));
-        paneY.value = Math.max(30, Math.min(innerHeight - paneHeight - 30, y));
+        paneX.value = Math.max(12, Math.min(innerWidth - paneWidth - 12, x));
+        paneY.value = Math.max(12, Math.min(innerHeight - paneHeight - 12, y));
         paneMarginX.value = mx;
         paneMarginY.value = my;
     }

package/src/component/FluxFocalPointEditor.vue

@@ -56,14 +56,14 @@
     lang="ts"
     setup>
     import { computed, onMounted, onUnmounted, ref, unref, useTemplateRef, watch } from 'vue';
-    import { useTranslate } from '$flux/composable/private';
-    import { FluxFadeTransition } from '$flux/transition';
+    import { useTranslate } from '~flux/components/composable/private';
+    import { FluxFadeTransition } from '~flux/components/transition';
     import FluxPane from './FluxPane.vue';
     import FluxPaneBody from './FluxPaneBody.vue';
     import FluxPaneFooter from './FluxPaneFooter.vue';
     import FluxSecondaryButton from './FluxSecondaryButton.vue';
     import FluxSpacer from './FluxSpacer.vue';
-    import $style from '$flux/css/component/FocalPoint.module.scss';
+    import $style from '~flux/components/css/component/FocalPoint.module.scss';
 
     const modelValue = defineModel<[number, number]>({
         required: true
@@ -112,11 +112,11 @@
         }
 
         const {top, left, width, height} = image.getBoundingClientRect();
-        const {pageX, pageY} = evt;
+        const {clientX, clientY} = evt;
 
         dragging.value = [
-            Math.max(0, Math.min(1, (pageX - left) / width)) * 100,
-            Math.max(0, Math.min(1, (pageY - top) / height)) * 100
+            Math.max(0, Math.min(1, (clientX - left) / width)) * 100,
+            Math.max(0, Math.min(1, (clientY - top) / height)) * 100
         ];
     }
 

package/src/component/FluxFocalPointImage.vue

@@ -13,7 +13,7 @@
     setup>
     import type { FluxFocalPointObject } from '@flux-ui/types';
     import { computed } from 'vue';
-    import $style from '$flux/css/component/FocalPoint.module.scss';
+    import $style from '~flux/components/css/component/FocalPoint.module.scss';
 
     const {
         alt = '',

package/src/component/FluxForm.vue

@@ -1,19 +1,20 @@
 <template>
-    <FluxDisabled :disabled="disabled">
-        <form
-            :class="$style.form"
-            :aria-disabled="disabled ? true : undefined"
-            @submit.prevent="onSubmit()">
+    <form
+        :class="$style.form"
+        :aria-disabled="disabled ? true : undefined"
+        @submit.prevent="onSubmit()">
+        <FluxDisabled :disabled="disabled">
             <slot/>
-        </form>
-    </FluxDisabled>
+        </FluxDisabled>
+    </form>
 </template>
 
 <script
     lang="ts"
     setup>
+    import type { VNode } from 'vue';
     import FluxDisabled from './FluxDisabled.vue';
-    import $style from '$flux/css/component/Form.module.scss';
+    import $style from '~flux/components/css/component/Form.module.scss';
 
     const emit = defineEmits<{
         submit: [];
@@ -26,7 +27,7 @@
     }>();
 
     defineSlots<{
-        default(): any;
+        default(): VNode[];
     }>();
 
     function onSubmit(): void {

package/src/component/FluxFormColumn.vue

@@ -7,9 +7,10 @@
 <script
     lang="ts"
     setup>
-    import $style from '$flux/css/component/Form.module.scss';
+    import type { VNode } from 'vue';
+    import $style from '~flux/components/css/component/Form.module.scss';
 
     defineSlots<{
-        default(): any;
+        default(): VNode[];
     }>();
 </script>