@flux-ui/components 3.1.2 → 3.1.3

package/dist/component/FluxAvatarGroup.vue.d.ts

@@ -0,0 +1,17 @@
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly max?: number;
+    readonly overlap?: number;
+    readonly size?: number;
+};
+type __VLS_Slots = {
+    default(): VNode[];
+};
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/FluxContextMenu.vue.d.ts

@@ -0,0 +1,26 @@
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly debugCone?: boolean;
+    readonly disabled?: boolean;
+    readonly position?: 'top' | 'top-left' | 'top-right' | 'left' | 'left-top' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom' | 'bottom' | 'bottom-left' | 'bottom-right';
+};
+type __VLS_Slots = {
+    default(): VNode[];
+    menu(props: {
+        close(): void;
+    }): VNode[];
+};
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+    open: (args_0: MouseEvent) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: () => any;
+    onOpen?: (args_0: MouseEvent) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/FluxDataTable.vue.d.ts

@@ -1,6 +1,7 @@
 import { VNode, PublicProps } from 'vue';
 declare const _default: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: PublicProps & __VLS_PrettifyLocal<({
+        readonly expandMode?: "single" | "multiple";
         readonly fillColumns?: number;
         readonly isBordered?: boolean;
         readonly isHoverable?: boolean;
@@ -16,25 +17,18 @@ declare const _default: <T extends Record<string, any>>(__VLS_props: NonNullable
         readonly uniqueKey?: string;
     } & {
         selected?: (string | number) | (string | number)[];
+        expanded?: (string | number)[];
     }) & {
         onNavigate?: (args_0: number) => any;
         onLimit?: (args_0: number) => any;
         "onUpdate:selected"?: (value: (string | number) | (string | number)[]) => any;
+        "onUpdate:expanded"?: (value: (string | number)[]) => any;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: {}) => void;
     attrs: any;
     slots: {
-        [key: string]: (props: {
-            readonly index: number;
-            readonly page: number;
-            readonly perPage: number;
-            readonly item: T;
-            readonly items: T[];
-            readonly total: number;
-            readonly isSelected: boolean;
-        }) => VNode;
         filter(props: {
             readonly page: number;
             readonly perPage: number;
@@ -60,8 +54,24 @@ declare const _default: <T extends Record<string, any>>(__VLS_props: NonNullable
             readonly total: number;
         }): VNode;
         colgroups(): VNode;
+        expandable(props: {
+            readonly index: number;
+            readonly item: T;
+            readonly isExpanded: boolean;
+            toggle(): void;
+        }): VNode;
+    } & {
+        [key: string]: (props: {
+            readonly index: number;
+            readonly page: number;
+            readonly perPage: number;
+            readonly item: T;
+            readonly items: T[];
+            readonly total: number;
+            readonly isSelected: boolean;
+        }) => VNode;
     };
-    emit: (((evt: "navigate", args_0: number) => void) & ((evt: "limit", args_0: number) => void)) & ((event: "update:selected", value: (string | number) | (string | number)[]) => void);
+    emit: (((evt: "navigate", args_0: number) => void) & ((evt: "limit", args_0: number) => void)) & (((event: "update:selected", value: (string | number) | (string | number)[]) => void) & ((event: "update:expanded", value: (string | number)[]) => void));
 }>) => VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/component/FluxDescriptionItem.vue.d.ts

@@ -0,0 +1,19 @@
+import { FluxIconName } from '@flux-ui/types';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly icon?: FluxIconName;
+    readonly isStacked?: boolean;
+    readonly label?: string;
+};
+type __VLS_Slots = {
+    default(): VNode[];
+    label(): VNode[];
+};
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/FluxDescriptionList.vue.d.ts

@@ -0,0 +1,17 @@
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly direction?: 'horizontal' | 'vertical';
+    readonly title?: string;
+};
+type __VLS_Slots = {
+    default(): VNode[];
+    header(): VNode[];
+};
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/FluxFormCombobox.vue.d.ts

@@ -0,0 +1,20 @@
+import { FluxFormInputBaseProps, FluxFormSelectEntry, FluxFormSelectValue } from '@flux-ui/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = Pick<FluxFormInputBaseProps, 'autoFocus' | 'disabled' | 'error' | 'isCondensed' | 'isLoading' | 'isReadonly' | 'isSecondary' | 'name' | 'placeholder'> & {
+    readonly isCreatable?: boolean;
+    readonly isMultiple?: boolean;
+    readonly options: FluxFormSelectEntry[];
+};
+type __VLS_ModelProps = {
+    'searchQuery'?: string;
+    modelValue: FluxFormSelectValue;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: FluxFormSelectValue) => any;
+    "update:searchQuery": (value: string) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: FluxFormSelectValue) => any;
+    "onUpdate:searchQuery"?: (value: string) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/component/FluxFormRating.vue.d.ts

@@ -0,0 +1,21 @@
+import { FluxFormInputBaseProps, FluxIconName } from '@flux-ui/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = Pick<FluxFormInputBaseProps, 'disabled' | 'error' | 'isReadonly' | 'name'> & {
+    readonly allowHalf?: boolean;
+    readonly clearable?: boolean;
+    readonly count?: number;
+    readonly icon?: FluxIconName;
+    readonly size?: number;
+};
+type __VLS_ModelProps = {
+    modelValue?: number | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    change: (args_0: number) => any;
+    "update:modelValue": (value: number) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: (args_0: number) => any;
+    "onUpdate:modelValue"?: (value: number) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/component/FluxFormTagsInput.vue.d.ts

@@ -0,0 +1,27 @@
+import { FluxColor, FluxFormInputBaseProps, FluxFormSelectOption } from '@flux-ui/types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = Pick<FluxFormInputBaseProps, 'disabled' | 'error' | 'isCondensed' | 'isReadonly' | 'isSecondary' | 'name' | 'placeholder'> & {
+    readonly allowDuplicates?: boolean;
+    readonly delimiters?: string[];
+    readonly max?: number;
+    readonly suggestions?: FluxFormSelectOption[];
+    readonly tagColor?: FluxColor;
+    readonly validate?: (value: string) => boolean;
+};
+type __VLS_ModelProps = {
+    modelValue?: string[];
+    'searchQuery'?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    add: (args_0: string) => any;
+    remove: (args_0: string) => any;
+    "update:modelValue": (value: string[]) => any;
+    "update:searchQuery": (value: string) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onAdd?: (args_0: string) => any;
+    onRemove?: (args_0: string) => any;
+    "onUpdate:modelValue"?: (value: string[]) => any;
+    "onUpdate:searchQuery"?: (value: string) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/component/FluxFormTextArea.vue.d.ts

@@ -5,11 +5,16 @@ type __VLS_Props = FluxFormInputBaseProps & {
     readonly maxLength?: number;
     readonly rows?: number;
 };
+declare function blur(): void;
+declare function focus(): void;
 type __VLS_ModelProps = {
     modelValue?: string;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+declare const _default: DefineComponent<__VLS_PublicProps, {
+    blur: typeof blur;
+    focus: typeof focus;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     blur: () => any;
     focus: () => any;
     "update:modelValue": (value: string) => any;

package/dist/component/FluxInlineEdit.vue.d.ts

@@ -0,0 +1,41 @@
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly disabled?: boolean;
+    readonly error?: string | null;
+    readonly isReadonly?: boolean;
+    readonly multiline?: boolean;
+    readonly placeholder?: string;
+    readonly saveOnBlur?: boolean;
+};
+type __VLS_Slots = {
+    actions?(props: {
+        save(): void;
+        cancel(): void;
+    }): VNode[];
+    default?(props: {
+        value: string;
+        edit(): void;
+    }): VNode[];
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    cancel: () => any;
+    edit: () => any;
+    save: (args_0: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onCancel?: () => any;
+    onEdit?: () => any;
+    onSave?: (args_0: string) => any;
+    "onUpdate:modelValue"?: (value: string) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/FluxMenu.vue.d.ts

@@ -1,5 +1,6 @@
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
+    readonly debugCone?: boolean;
     readonly isLarge?: boolean;
 };
 type __VLS_Slots = {

package/dist/component/FluxMenuFlyout.vue.d.ts

@@ -0,0 +1,22 @@
+import { FluxIconName } from '@flux-ui/types';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly disabled?: boolean;
+    readonly icon?: FluxIconName;
+    readonly isActive?: boolean;
+    readonly isDestructive?: boolean;
+    readonly label?: string;
+    readonly position?: 'top' | 'top-left' | 'top-right' | 'left' | 'left-top' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom' | 'bottom' | 'bottom-left' | 'bottom-right';
+};
+type __VLS_Slots = {
+    default(): VNode[];
+    trigger(): VNode[];
+};
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/FluxTableCell.vue.d.ts

@@ -1,5 +1,6 @@
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
+    readonly colspan?: number;
     readonly contentDirection?: 'column' | 'row';
     readonly contentGap?: number;
 };

package/dist/component/FluxTour.vue.d.ts

@@ -0,0 +1,35 @@
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly maskPadding?: number;
+    readonly root?: string | HTMLElement | (() => HTMLElement | null);
+};
+type __VLS_Slots = {
+    default(): VNode[];
+};
+type __VLS_ModelProps = {
+    'active': boolean;
+    'step'?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    next: (args_0: number) => any;
+    finish: () => any;
+    skip: () => any;
+    prev: (args_0: number) => any;
+    "update:active": (value: boolean) => any;
+    "update:step": (value: number) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onNext?: (args_0: number) => any;
+    onFinish?: () => any;
+    onSkip?: () => any;
+    onPrev?: (args_0: number) => any;
+    "onUpdate:active"?: (value: boolean) => any;
+    "onUpdate:step"?: (value: number) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/FluxTourItem.vue.d.ts

@@ -0,0 +1,18 @@
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type FluxTourPosition = 'top' | 'top-left' | 'top-right' | 'left' | 'left-top' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom' | 'bottom' | 'bottom-left' | 'bottom-right';
+type __VLS_Props = {
+    readonly target: string | (() => HTMLElement | null);
+    readonly title?: string;
+    readonly position?: FluxTourPosition;
+};
+type __VLS_Slots = {
+    default(): VNode[];
+};
+declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/component/FluxVirtualScroller.vue.d.ts

@@ -0,0 +1,27 @@
+import { VNode, PublicProps } from 'vue';
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: PublicProps & __VLS_PrettifyLocal<{
+        readonly estimatedItemHeight?: number;
+        readonly items: T[];
+        readonly overscan?: number;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default(props: {
+            readonly index: number;
+            readonly item: T;
+        }): VNode[];
+    };
+    emit: {};
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/component/index.d.ts

@@ -7,6 +7,7 @@ export { default as FluxAdaptiveSlot } from './FluxAdaptiveSlot.vue';
 export { default as FluxAnimatedColors } from './FluxAnimatedColors.vue';
 export { default as FluxAspectRatio } from './FluxAspectRatio.vue';
 export { default as FluxAvatar } from './FluxAvatar.vue';
+export { default as FluxAvatarGroup } from './FluxAvatarGroup.vue';
 export { default as FluxBadge } from './FluxBadge.vue';
 export { default as FluxBadgeStack } from './FluxBadgeStack.vue';
 export { default as FluxBorderBeam } from './FluxBorderBeam.vue';
@@ -28,8 +29,11 @@ export { default as FluxComment } from './FluxComment.vue';
 export { default as FluxColorPicker } from './FluxColorPicker.vue';
 export { default as FluxColorSelect } from './FluxColorSelect.vue';
 export { default as FluxContainer } from './FluxContainer.vue';
+export { default as FluxContextMenu } from './FluxContextMenu.vue';
 export { default as FluxDataTable } from './FluxDataTable.vue';
 export { default as FluxDatePicker } from './FluxDatePicker.vue';
+export { default as FluxDescriptionItem } from './FluxDescriptionItem.vue';
+export { default as FluxDescriptionList } from './FluxDescriptionList.vue';
 export { default as FluxDestructiveButton } from './FluxDestructiveButton.vue';
 export { default as FluxDisabled } from './FluxDisabled.vue';
 export { default as FluxDivider } from './FluxDivider.vue';
@@ -59,6 +63,7 @@ export { default as FluxForm } from './FluxForm.vue';
 export { default as FluxFormCheckbox } from './FluxFormCheckbox.vue';
 export { default as FluxFormCheckboxGroup } from './FluxFormCheckboxGroup.vue';
 export { default as FluxFormColumn } from './FluxFormColumn.vue';
+export { default as FluxFormCombobox } from './FluxFormCombobox.vue';
 export { default as FluxFormDateInput } from './FluxFormDateInput.vue';
 export { default as FluxFormDateRangeInput } from './FluxFormDateRangeInput.vue';
 export { default as FluxFormDateTimeInput } from './FluxFormDateTimeInput.vue';
@@ -73,11 +78,13 @@ export { default as FluxFormPinInput } from './FluxFormPinInput.vue';
 export { default as FluxFormRadio } from './FluxFormRadio.vue';
 export { default as FluxFormRadioGroup } from './FluxFormRadioGroup.vue';
 export { default as FluxFormRangeSlider } from './FluxFormRangeSlider.vue';
+export { default as FluxFormRating } from './FluxFormRating.vue';
 export { default as FluxFormRow } from './FluxFormRow.vue';
 export { default as FluxFormSection } from './FluxFormSection.vue';
 export { default as FluxFormSelect } from './FluxFormSelect.vue';
 export { default as FluxFormSelectAsync } from './FluxFormSelectAsync.vue';
 export { default as FluxFormSlider } from './FluxFormSlider.vue';
+export { default as FluxFormTagsInput } from './FluxFormTagsInput.vue';
 export { default as FluxFormTextArea } from './FluxFormTextArea.vue';
 export { default as FluxFormTimeZonePicker } from './FluxFormTimeZonePicker.vue';
 export { default as FluxFormTreeViewSelect } from './FluxFormTreeViewSelect.vue';
@@ -88,6 +95,7 @@ export { default as FluxGridColumn } from './FluxGridColumn.vue';
 export { default as FluxGridPattern } from './FluxGridPattern.vue';
 export { default as FluxIcon } from './FluxIcon.vue';
 export { default as FluxInfo } from './FluxInfo.vue';
+export { default as FluxInlineEdit } from './FluxInlineEdit.vue';
 export { default as FluxKanban } from './FluxKanban.vue';
 export { default as FluxKanbanColumn } from './FluxKanbanColumn.vue';
 export { default as FluxKanbanItem } from './FluxKanbanItem.vue';
@@ -102,6 +110,7 @@ export { default as FluxLayerPaneSecondary } from './FluxLayerPaneSecondary.vue'
 export { default as FluxLink } from './FluxLink.vue';
 export { default as FluxMenu } from './FluxMenu.vue';
 export { default as FluxMenuCollapsible } from './FluxMenuCollapsible.vue';
+export { default as FluxMenuFlyout } from './FluxMenuFlyout.vue';
 export { default as FluxMenuGroup } from './FluxMenuGroup.vue';
 export { default as FluxMenuItem } from './FluxMenuItem.vue';
 export { default as FluxMenuOptions } from './FluxMenuOptions.vue';
@@ -171,5 +180,8 @@ export { default as FluxToolbar } from './FluxToolbar.vue';
 export { default as FluxToolbarGroup } from './FluxToolbarGroup.vue';
 export { default as FluxTooltip } from './FluxTooltip.vue';
 export { default as FluxTooltipProvider } from './FluxTooltipProvider.vue';
+export { default as FluxTour } from './FluxTour.vue';
+export { default as FluxTourItem } from './FluxTourItem.vue';
 export { default as FluxTreeView } from './FluxTreeView.vue';
+export { default as FluxVirtualScroller } from './FluxVirtualScroller.vue';
 export { default as FluxWindow } from './FluxWindow.vue';

package/dist/component/primitive/AnchorPopup.vue.d.ts

@@ -2,6 +2,7 @@ import { FluxDirection } from '@flux-ui/types';
 import { ComponentPublicInstance, VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly anchor?: ComponentPublicInstance | HTMLElement | null;
+    readonly clampToViewport?: boolean;
     readonly direction?: FluxDirection;
     readonly margin?: number;
     readonly position?: 'top' | 'top-left' | 'top-right' | 'left' | 'left-top' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom' | 'bottom' | 'bottom-left' | 'bottom-right';
@@ -10,7 +11,12 @@ type __VLS_Props = {
 type __VLS_Slots = {
     default(): VNode[];
 };
-declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare function reposition(): void;
+declare function resize(): void;
+declare const __VLS_base: DefineComponent<__VLS_Props, {
+    reposition: typeof reposition;
+    resize: typeof resize;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/component/primitive/SelectBase.vue.d.ts

@@ -2,6 +2,7 @@ import { FluxFormSelectOption, FluxFormSelectOptions } from '@flux-ui/types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly disabled?: boolean;
+    readonly isCreatable?: boolean;
     readonly isLoading?: boolean;
     readonly isMultiple?: boolean;
     readonly isSearchable?: boolean;
@@ -21,6 +22,7 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
     "update:searchQuery": (value: string) => any;
     keyDown: (args_0: KeyboardEvent) => any;
     deselect: (args_0: string | number) => any;
+    create: (args_0: string) => any;
 }, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     onClose?: () => any;
     onSearch?: (args_0: string) => any;
@@ -29,5 +31,6 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
     "onUpdate:searchQuery"?: (value: string) => any;
     onKeyDown?: (args_0: KeyboardEvent) => any;
     onDeselect?: (args_0: string | number) => any;
+    onCreate?: (args_0: string) => any;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/composable/private/index.d.ts

@@ -4,6 +4,7 @@ export { default as useDateFlyout } from './useDateFlyout';
 export { default as useDropdownPopup, type UseDropdownPopupOptions, type UseDropdownPopupReturn } from './useDropdownPopup';
 export { default as useFormSelect } from './useFormSelect';
 export { useKanban } from './useKanban';
+export { default as useMenuFlyout, useMenuFlyoutContext, useMenuFlyoutProvider, type UseMenuFlyoutOptions, type UseMenuFlyoutProviderOptions, type UseMenuFlyoutReturn } from './useMenuFlyout';
 export { useSplitView, type SplitViewPane, type UseSplitViewOptions, type UseSplitViewReturn } from './useSplitView';
 export { default as useTranslate } from './useTranslate';
 export { useCommandPalette, type CommandPaletteGroup, type CommandPaletteResultItem } from './useCommandPalette';

package/dist/composable/private/useMenuFlyout.d.ts

@@ -0,0 +1,42 @@
+import { ComponentPublicInstance, Ref } from 'vue';
+import { FluxMenuFlyoutCone, FluxMenuFlyoutInjection } from '../../data';
+export type UseMenuFlyoutProviderOptions = {
+    readonly debugCone: Ref<boolean>;
+    readonly onCloseAll?: () => void;
+};
+export type UseMenuFlyoutOptions = {
+    readonly triggerRef: Ref<ComponentPublicInstance | HTMLElement | null>;
+    readonly popupRef: Ref<ComponentPublicInstance | HTMLElement | null>;
+    readonly disabled?: Ref<boolean>;
+};
+export type UseMenuFlyoutReturn = {
+    readonly context: FluxMenuFlyoutInjection | null;
+    readonly cone: Ref<FluxMenuFlyoutCone | null>;
+    readonly isOpen: Ref<boolean>;
+    closeAll(): void;
+    focusTrigger(): void;
+    onPopupKeydown(evt: KeyboardEvent): void;
+    onTriggerClick(evt: MouseEvent): void;
+    onTriggerKeydown(evt: KeyboardEvent): void;
+};
+/**
+ * Creates and provides the shared menu-flyout context for an entire open menu tree. Used by the
+ * outermost menu surface (FluxContextMenu, or a standalone root FluxMenu). Tracks the pointer, the
+ * active prediction cone, the keyboard-trap stack and the set of teleported flyout popups so that
+ * click-outside and close-all can reason about the whole tree.
+ */
+export declare function useMenuFlyoutProvider(options: UseMenuFlyoutProviderOptions): FluxMenuFlyoutInjection;
+/**
+ * Returns the shared menu-flyout context, creating (and providing) a new root context when none
+ * exists higher up the tree. Used by FluxMenu so that a standalone menu becomes the root while a
+ * menu nested inside a FluxContextMenu or another flyout inherits the existing context.
+ */
+export declare function useMenuFlyoutContext(options: UseMenuFlyoutProviderOptions): FluxMenuFlyoutInjection;
+/**
+ * Per-flyout open/close and prediction-cone behaviour for FluxMenuFlyout. Submenus open instantly
+ * on hover and close instantly once the pointer is neither over the trigger/popup (or an open
+ * descendant) nor aiming at the submenu through the prediction cone (the safe triangle). There are
+ * no open/close delays — the cone is the only thing that keeps a submenu open during a diagonal
+ * move, which is also why the debug cone only shows while it actually applies.
+ */
+export default function useMenuFlyout(options: UseMenuFlyoutOptions): UseMenuFlyoutReturn;

package/dist/data/di.d.ts

@@ -11,6 +11,7 @@ export declare const FluxFilterInjectionKey: InjectionKey<FluxFilterInjection>;
 export declare const FluxFormCheckboxGroupInjectionKey: InjectionKey<FluxFormCheckboxGroupInjection>;
 export declare const FluxFormFieldInjectionKey: InjectionKey<FluxFormFieldInjection>;
 export declare const FluxFormRadioGroupInjectionKey: InjectionKey<FluxFormRadioGroupInjection>;
+export declare const FluxMenuFlyoutInjectionKey: InjectionKey<FluxMenuFlyoutInjection>;
 export declare const FluxSegmentedControlInjectionKey: InjectionKey<FluxSegmentedControlInjection>;
 export declare const FluxSplitViewInjectionKey: InjectionKey<FluxSplitViewInjection>;
 export declare const FluxTabBarInjectionKey: InjectionKey<FluxTabBarInjection>;
@@ -128,6 +129,40 @@ export type FluxFlyoutInjection = {
     readonly isOpen: Ref<boolean>;
     readonly isOpening: Ref<boolean>;
 };
+export type FluxMenuFlyoutPointer = {
+    readonly x: number;
+    readonly y: number;
+    readonly px: number;
+    readonly py: number;
+};
+export type FluxMenuFlyoutCone = {
+    readonly id: number;
+    readonly ax: number;
+    readonly ay: number;
+    readonly bx: number;
+    readonly by: number;
+    readonly cx: number;
+    readonly cy: number;
+};
+export type FluxMenuFlyoutEntry = {
+    getTrigger(): HTMLElement | null;
+    getPopup(): HTMLElement | null;
+    readonly isOpen: Ref<boolean>;
+    close(): void;
+};
+export type FluxMenuFlyoutInjection = {
+    readonly debugCone: Ref<boolean>;
+    readonly pointer: Readonly<Ref<FluxMenuFlyoutPointer>>;
+    readonly activeCone: Ref<FluxMenuFlyoutCone | null>;
+    readonly keyboardStack: Ref<number[]>;
+    register(entry: FluxMenuFlyoutEntry): void;
+    unregister(entry: FluxMenuFlyoutEntry): void;
+    closeOthers(self: FluxMenuFlyoutEntry): void;
+    hasOpenDescendant(self: FluxMenuFlyoutEntry): boolean;
+    isAimingAtOpenSubmenu(): boolean;
+    isInsidePopups(target: Node | null): boolean;
+    closeAll(): void;
+};
 export type FluxFormFieldInjection = {
     readonly id?: string;
     readonly labelId?: string;