@gradient-ui/core 0.8.0 → 2.0.0

package/dist/types-cjs/use/overlay.d.cts

@@ -0,0 +1,111 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+export type OverlayPlacement = 'center' | 'left' | 'right' | 'top' | 'bottom' | 'fullscreen';
+export type OverlayPosition = 'fixed' | 'absolute';
+export declare const makeOverlayProps: <Defaults extends {
+    modelValue?: unknown;
+    defaultOpen?: unknown;
+    appendTo?: unknown;
+    zIndexBase?: unknown;
+    position?: unknown;
+    placement?: unknown;
+    persistent?: unknown;
+    closeOnEsc?: unknown;
+    closeOnOutside?: unknown;
+    lockScroll?: unknown;
+    scrim?: unknown;
+    disabled?: unknown;
+    transition?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    modelValue: Omit<{
+        type: BooleanConstructor;
+        default: undefined;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["modelValue"] extends infer T ? T extends Defaults["modelValue"] ? T extends unknown ? boolean : boolean | T : never : never>;
+        default: Defaults["modelValue"] extends infer T_1 ? T_1 extends Defaults["modelValue"] ? T_1 extends unknown ? boolean : boolean | T_1 : never : never;
+    };
+    defaultOpen: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["defaultOpen"] extends infer T_2 ? T_2 extends Defaults["defaultOpen"] ? T_2 extends unknown ? boolean : boolean | T_2 : never : never>;
+        default: Defaults["defaultOpen"] extends infer T_3 ? T_3 extends Defaults["defaultOpen"] ? T_3 extends unknown ? boolean : boolean | T_3 : never : never;
+    };
+    appendTo: Omit<{
+        type: StringConstructor;
+        default: string;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["appendTo"] extends infer T_4 ? T_4 extends Defaults["appendTo"] ? T_4 extends unknown ? string : string | T_4 : never : never>;
+        default: Defaults["appendTo"] extends infer T_5 ? T_5 extends Defaults["appendTo"] ? T_5 extends unknown ? string : string | T_5 : never : never;
+    };
+    zIndexBase: Omit<{
+        type: NumberConstructor;
+        default: number;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["zIndexBase"] extends infer T_6 ? T_6 extends Defaults["zIndexBase"] ? T_6 extends unknown ? number : number | T_6 : never : never>;
+        default: Defaults["zIndexBase"] extends infer T_7 ? T_7 extends Defaults["zIndexBase"] ? T_7 extends unknown ? number : number | T_7 : never : never;
+    };
+    position: Omit<{
+        type: PropType<OverlayPosition>;
+        default: string;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["position"] extends infer T_8 ? T_8 extends Defaults["position"] ? T_8 extends unknown ? OverlayPosition : OverlayPosition | T_8 : never : never>;
+        default: Defaults["position"] extends infer T_9 ? T_9 extends Defaults["position"] ? T_9 extends unknown ? OverlayPosition : T_9 | NonNullable<OverlayPosition> : never : never;
+    };
+    placement: Omit<{
+        type: PropType<OverlayPlacement>;
+        default: string;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["placement"] extends infer T_10 ? T_10 extends Defaults["placement"] ? T_10 extends unknown ? OverlayPlacement : OverlayPlacement | T_10 : never : never>;
+        default: Defaults["placement"] extends infer T_11 ? T_11 extends Defaults["placement"] ? T_11 extends unknown ? OverlayPlacement : T_11 | NonNullable<OverlayPlacement> : never : never;
+    };
+    persistent: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["persistent"] extends infer T_12 ? T_12 extends Defaults["persistent"] ? T_12 extends unknown ? boolean : boolean | T_12 : never : never>;
+        default: Defaults["persistent"] extends infer T_13 ? T_13 extends Defaults["persistent"] ? T_13 extends unknown ? boolean : boolean | T_13 : never : never;
+    };
+    closeOnEsc: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["closeOnEsc"] extends infer T_14 ? T_14 extends Defaults["closeOnEsc"] ? T_14 extends unknown ? boolean : boolean | T_14 : never : never>;
+        default: Defaults["closeOnEsc"] extends infer T_15 ? T_15 extends Defaults["closeOnEsc"] ? T_15 extends unknown ? boolean : boolean | T_15 : never : never;
+    };
+    closeOnOutside: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["closeOnOutside"] extends infer T_16 ? T_16 extends Defaults["closeOnOutside"] ? T_16 extends unknown ? boolean : boolean | T_16 : never : never>;
+        default: Defaults["closeOnOutside"] extends infer T_17 ? T_17 extends Defaults["closeOnOutside"] ? T_17 extends unknown ? boolean : boolean | T_17 : never : never;
+    };
+    lockScroll: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["lockScroll"] extends infer T_18 ? T_18 extends Defaults["lockScroll"] ? T_18 extends unknown ? boolean : boolean | T_18 : never : never>;
+        default: Defaults["lockScroll"] extends infer T_19 ? T_19 extends Defaults["lockScroll"] ? T_19 extends unknown ? boolean : boolean | T_19 : never : never;
+    };
+    scrim: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["scrim"] extends infer T_20 ? T_20 extends Defaults["scrim"] ? T_20 extends unknown ? boolean : boolean | T_20 : never : never>;
+        default: Defaults["scrim"] extends infer T_21 ? T_21 extends Defaults["scrim"] ? T_21 extends unknown ? boolean : boolean | T_21 : never : never;
+    };
+    disabled: {
+        type: PropType<Defaults["disabled"] extends infer T_22 ? T_22 extends Defaults["disabled"] ? T_22 extends unknown ? boolean : boolean | T_22 : never : never>;
+        default: Defaults["disabled"] extends infer T_23 ? T_23 extends Defaults["disabled"] ? T_23 extends unknown ? boolean : boolean | T_23 : never : never;
+    };
+    transition: Omit<Omit<{
+        type: PropType<import("./transition.cjs").GTransitionValue>;
+        default: undefined;
+    }, "default" | "type"> & {
+        type: PropType<import("./transition.cjs").GTransitionValue>;
+        default: import("./transition.cjs").GTransitionValue;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["transition"] extends infer T_24 ? T_24 extends Defaults["transition"] ? T_24 extends unknown ? import("./transition.cjs").GTransitionValue : import("./transition.cjs").GTransitionValue | T_24 : never : never>;
+        default: Defaults["transition"] extends infer T_25 ? T_25 extends Defaults["transition"] ? T_25 extends unknown ? import("./transition.cjs").GTransitionValue : NonNullable<import("./transition.cjs").GTransitionValue> | T_25 : never : never;
+    };
+};
+export type GOverlayProps = ExtractPropTypes<ReturnType<typeof makeOverlayProps>>;

package/dist/types-cjs/use/placement.d.cts

@@ -0,0 +1,16 @@
+import { type PropType } from 'vue';
+import { type Placement } from '../types/CommonTypes.cjs';
+export declare const makePlacementProps: <Defaults extends {
+    placement?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    placement: Omit<{
+        type: PropType<Placement>;
+        default: string;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["placement"] extends infer T ? T extends Defaults["placement"] ? T extends unknown ? Placement : Placement | T : never : never>;
+        default: Defaults["placement"] extends infer T_1 ? T_1 extends Defaults["placement"] ? T_1 extends unknown ? Placement : T_1 | NonNullable<Placement> : never : never;
+    };
+};
+export declare function usePlacement(props: {
+    placement: Placement;
+}, base: string): import("vue").ComputedRef<string>;

package/dist/types-cjs/use/px.d.cts

@@ -0,0 +1,4 @@
+import type { PXtype } from '../types/CommonTypes.cjs';
+import { type ComputedRef, type MaybeRef } from 'vue';
+declare const _default: (value: MaybeRef<PXtype>) => ComputedRef<string>;
+export default _default;

package/dist/types-cjs/use/rounded.d.cts

@@ -0,0 +1,12 @@
+import { type PropType } from 'vue';
+export declare const makeRoundedProps: <Defaults extends {
+    rounded?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    rounded: {
+        type: PropType<Defaults["rounded"] extends infer T ? T extends Defaults["rounded"] ? T extends unknown ? boolean : boolean | T : never : never>;
+        default: Defaults["rounded"] extends infer T_1 ? T_1 extends Defaults["rounded"] ? T_1 extends unknown ? boolean : boolean | T_1 : never : never;
+    };
+};
+export declare function useRounded(props: {
+    rounded?: boolean;
+}, base: string): import("vue").ComputedRef<string>;

package/dist/types-cjs/use/routerLink.d.cts

@@ -0,0 +1,10 @@
+import { type Component } from 'vue';
+export type RouterTo = string | {
+    path?: string;
+    name?: string | symbol;
+    params?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    hash?: string;
+};
+export declare const useOptionalRouterLink: () => Component | string | undefined;
+export declare const getRouterFallbackHref: (to: RouterTo | undefined) => string | undefined;

package/dist/types-cjs/use/select/comboboxController.d.cts

@@ -0,0 +1,36 @@
+import { type ComboboxItemFromQuery } from './creatable.cjs';
+import { type SelectMenuFilter } from './filter.cjs';
+import type { GMenuItemBase } from '../menu.cjs';
+import type { InternalItem, SelectBaseProps, SelectionValue } from './types.cjs';
+import type { MaybeRef, MaybeRefOrGetter } from 'vue';
+export type { ComboboxItemFromQuery } from './creatable.cjs';
+export type ComboboxFilter<T, V> = SelectMenuFilter<T, V>;
+type MaybeRefSelectProps<T, V, Multiple extends boolean, ReturnObject extends boolean> = {
+    [K in keyof SelectBaseProps<T, V, Multiple, ReturnObject>]: MaybeRef<SelectBaseProps<T, V, Multiple, ReturnObject>[K]>;
+};
+export interface UseComboboxControllerOptions<T, V, Multiple extends boolean, ReturnObject extends boolean> extends MaybeRefSelectProps<T, V, Multiple, ReturnObject> {
+    search?: MaybeRefOrGetter<string | undefined>;
+    allowCustom?: MaybeRefOrGetter<boolean | undefined>;
+    itemFromQuery?: MaybeRefOrGetter<ComboboxItemFromQuery<T> | undefined>;
+    filter?: MaybeRefOrGetter<ComboboxFilter<T, V> | undefined>;
+    onSearch: (value: string) => void;
+}
+export declare function useComboboxController<T, V, Multiple extends boolean = false, ReturnObject extends boolean = false>(props: UseComboboxControllerOptions<T, V, Multiple, ReturnObject>, emit: (e: 'update:modelValue', value: SelectionValue<T, V, Multiple, ReturnObject>) => void): {
+    isMultiple: import("vue").ComputedRef<boolean>;
+    shouldCloseOnSelect: import("vue").ComputedRef<boolean>;
+    searchValue: import("vue").ComputedRef<string>;
+    setSearch: (value: string) => void;
+    filteredMenuItems: import("vue").ComputedRef<import("./menuItems.cjs").SelectMenuItem<T, V>[]>;
+    getSlotItem: (item: GMenuItemBase) => import("./menuItems.cjs").SelectMenuItem<T, V>;
+    resolveMenuItem: (item: GMenuItemBase) => import("./menuItems.cjs").SelectMenuItem<T, V> | undefined;
+    isItemSelected: (item: InternalItem<T, V>) => boolean;
+    isMenuItemSelected: (item: GMenuItemBase) => boolean;
+    isCustomItem: (item: InternalItem<T, V>) => boolean;
+    isCustomMenuItem: (item: GMenuItemBase) => boolean;
+    customSelectionItem: import("vue").ComputedRef<InternalItem<T, V> | undefined>;
+    firstVisibleItem: () => import("./menuItems.cjs").SelectMenuItem<T, V> | undefined;
+    selectItem: (item: InternalItem<T, V>) => void;
+    selectedItems: import("vue").ComputedRef<InternalItem<T, V>[]>;
+    hasSelection: import("vue").ComputedRef<boolean>;
+    selectionText: import("vue").ComputedRef<string>;
+};

package/dist/types-cjs/use/select/commit.d.cts

@@ -0,0 +1,23 @@
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+import type { GMenuItemBase } from '../menu.cjs';
+import type { InternalItem } from './types.cjs';
+export interface UseSelectCommitOptions<T, V> {
+    open: Ref<boolean>;
+    isMultiple: MaybeRefOrGetter<boolean>;
+    shouldCloseOnSelect: MaybeRefOrGetter<boolean>;
+    searchValue: MaybeRefOrGetter<string>;
+    resolveMenuItem: (item: GMenuItemBase) => InternalItem<T, V> | undefined;
+    firstVisibleItem: () => InternalItem<T, V> | undefined;
+    selectItem: (item: InternalItem<T, V>) => void;
+    setSearch: (value: string) => void;
+    onInputValidation: () => void;
+    isCustomItem?: (item: InternalItem<T, V>) => boolean;
+    onAdd?: (item: T, query: string) => void;
+    onSelect?: (item: InternalItem<T, V>) => void;
+}
+export declare function useSelectCommit<T, V>(options: UseSelectCommitOptions<T, V>): {
+    commitItem: (item: InternalItem<T, V>) => void;
+    onSelect: (item: GMenuItemBase) => void;
+    selectFirstVisibleItem: () => void;
+    removeItem: (item: InternalItem<T, V>) => void;
+};

package/dist/types-cjs/use/select/controller.d.cts

@@ -0,0 +1,23 @@
+import { type MaybeRef } from 'vue';
+import type { GMenuItemBase } from '../menu.cjs';
+import type { SelectBaseProps, SelectionValue } from './types.cjs';
+type MaybeRefSelectProps<T, V, Multiple extends boolean, ReturnObject extends boolean> = {
+    [K in keyof SelectBaseProps<T, V, Multiple, ReturnObject>]: MaybeRef<SelectBaseProps<T, V, Multiple, ReturnObject>[K]>;
+};
+export declare function useSelectController<T, V, Multiple extends boolean = false, ReturnObject extends boolean = false>(props: MaybeRefSelectProps<T, V, Multiple, ReturnObject>, emit: (e: 'update:modelValue', value: SelectionValue<T, V, Multiple, ReturnObject>) => void): {
+    isMultiple: import("vue").ComputedRef<boolean>;
+    isReturnObject: import("vue").ComputedRef<boolean>;
+    shouldCloseOnSelect: import("vue").ComputedRef<boolean>;
+    normalizedItems: import("vue").ComputedRef<import("./types.cjs").InternalItem<T, V>[]>;
+    menuItems: import("vue").ComputedRef<import("./menuItems.cjs").SelectMenuItem<T, V>[]>;
+    resolveMenuItem: (item: GMenuItemBase) => import("./menuItems.cjs").SelectMenuItem<T, V> | undefined;
+    getSlotItem: (item: GMenuItemBase) => import("./menuItems.cjs").SelectMenuItem<T, V>;
+    isItemSelected: (item: import("./types.cjs").InternalItem<T, V>) => boolean;
+    isMenuItemSelected: (item: GMenuItemBase) => boolean;
+    handleSelect: (item: GMenuItemBase, onClose?: () => void) => void;
+    selectItem: (item: import("./types.cjs").InternalItem<T, V>) => void;
+    selectedItems: import("vue").ComputedRef<import("./types.cjs").InternalItem<T, V>[]>;
+    hasSelection: import("vue").ComputedRef<boolean>;
+    selectionText: import("vue").ComputedRef<string>;
+};
+export {};

package/dist/types-cjs/use/select/creatable.d.cts

@@ -0,0 +1,18 @@
+import type { InternalItem, SelectBaseProps } from './types.cjs';
+import type { MaybeRef, MaybeRefOrGetter } from 'vue';
+export type ComboboxItemFromQuery<T> = (query: string) => T;
+type MaybeRefItemKeyProps<T, V> = Pick<{
+    [K in keyof SelectBaseProps<T, V>]: MaybeRef<SelectBaseProps<T, V>[K]>;
+}, 'labelKey' | 'valueKey'>;
+export interface UseComboboxCreatableOptions<T, V> extends MaybeRefItemKeyProps<T, V> {
+    searchValue: MaybeRefOrGetter<string>;
+    normalizedQuery: MaybeRefOrGetter<string>;
+    normalizedSourceItems: MaybeRefOrGetter<readonly InternalItem<T, V>[]>;
+    allowCustom?: MaybeRefOrGetter<boolean | undefined>;
+    itemFromQuery?: MaybeRefOrGetter<ComboboxItemFromQuery<T> | undefined>;
+    createRawRecord: (label: string, value: unknown) => T;
+}
+export declare function useComboboxCreatable<T, V>(options: UseComboboxCreatableOptions<T, V>): {
+    customItem: import("vue").ComputedRef<T | undefined>;
+};
+export {};

package/dist/types-cjs/use/select/fieldControl.d.cts

@@ -0,0 +1,59 @@
+import type { MdiIcon, Sizes } from '../../types/CommonTypes.cjs';
+import type { GGradienStates } from '../../components/ui/GGradient/types.cjs';
+import type { GColor } from '../color.cjs';
+import type { GlassProps } from '../glass.cjs';
+import type { ValidationRule } from 'gib-validate';
+import type { MaybeRefOrGetter } from 'vue';
+import type { GFieldVariant } from '../form/props.cjs';
+import type { StringeredNumber } from '../../types/CommonTypes.cjs';
+export interface UseSelectFieldControlOptions<TModel> {
+    id: MaybeRefOrGetter<string>;
+    modelValue: MaybeRefOrGetter<TModel>;
+    rules: MaybeRefOrGetter<ValidationRule<TModel>[] | undefined>;
+    message: MaybeRefOrGetter<string | undefined>;
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    label?: MaybeRefOrGetter<string | undefined>;
+    color?: MaybeRefOrGetter<GColor | undefined>;
+    variant?: MaybeRefOrGetter<GFieldVariant | undefined>;
+    backdropBlur?: MaybeRefOrGetter<GlassProps['backdropBlur']>;
+    borderWidth?: MaybeRefOrGetter<StringeredNumber | undefined>;
+    state?: MaybeRefOrGetter<GGradienStates | undefined>;
+    clearable?: MaybeRefOrGetter<boolean | undefined>;
+    size?: MaybeRefOrGetter<Sizes | undefined>;
+    focused?: MaybeRefOrGetter<boolean | undefined>;
+    hasValue: MaybeRefOrGetter<boolean>;
+    prependIcon?: MaybeRefOrGetter<MdiIcon | undefined>;
+    appendIcon?: MaybeRefOrGetter<MdiIcon | undefined>;
+    multiline?: MaybeRefOrGetter<boolean | undefined>;
+}
+export declare function useSelectFieldControl<TModel>(options: UseSelectFieldControlOptions<TModel>): {
+    fieldProps: import("vue").ComputedRef<{
+        id: string;
+        label: string | undefined;
+        color: GColor | undefined;
+        variant: GFieldVariant | undefined;
+        backdropBlur: StringeredNumber | undefined;
+        borderWidth: StringeredNumber | undefined;
+        state: GGradienStates | undefined;
+        disabled: boolean;
+        clearable: boolean | undefined;
+        size: Sizes | undefined;
+        focused: boolean;
+        message: string;
+        prependIcon: MdiIcon | undefined;
+        appendIcon: MdiIcon | undefined;
+        hasValue: boolean;
+        multiline: boolean;
+    }>;
+    focused: import("vue").Ref<boolean, boolean>;
+    $v: import("gib-validate").ValidationResult<{
+        modelValue: import("gib-validate").Validatable;
+    }>;
+    disabled: import("vue").ComputedRef<boolean>;
+    validateOn: import("vue").ComputedRef<import("../form/context.cjs").GFormValidateOn>;
+    computedMessage: import("vue").ComputedRef<string>;
+    hasValidationError: import("vue").ComputedRef<boolean>;
+    onFocus: () => void;
+    onBlur: () => void;
+    onInputValidation: () => void;
+};

package/dist/types-cjs/use/select/filter.d.cts

@@ -0,0 +1,14 @@
+import type { SelectMenuItem } from './menuItems.cjs';
+import type { MaybeRefOrGetter } from 'vue';
+export type SelectMenuFilter<T, V> = (item: SelectMenuItem<T, V>, query: string) => boolean;
+export interface UseFilteredSelectMenuOptions<T, V> {
+    items: MaybeRefOrGetter<readonly SelectMenuItem<T, V>[]>;
+    searchValue: MaybeRefOrGetter<string>;
+    normalizedQuery: MaybeRefOrGetter<string>;
+    filter?: MaybeRefOrGetter<SelectMenuFilter<T, V> | undefined>;
+    isAlwaysVisible?: (item: SelectMenuItem<T, V>) => boolean;
+}
+export declare function useFilteredSelectMenu<T, V>(options: UseFilteredSelectMenuOptions<T, V>): {
+    filteredMenuItems: import("vue").ComputedRef<SelectMenuItem<T, V>[]>;
+    firstVisibleItem: import("vue").ComputedRef<SelectMenuItem<T, V> | undefined>;
+};

package/dist/types-cjs/use/select/items.d.cts

@@ -0,0 +1,14 @@
+import { type MaybeRef } from 'vue';
+import type { InternalItem, SelectItemChildren, SelectLabelKey, SelectValueKey } from './types.cjs';
+interface UseItemsOptions<T, V> {
+    items: MaybeRef<readonly T[]>;
+    labelKey?: MaybeRef<SelectLabelKey<T> | undefined>;
+    valueKey?: MaybeRef<SelectValueKey<T, V> | undefined>;
+    itemChildren?: MaybeRef<SelectItemChildren<T> | undefined>;
+}
+export declare function useItems<T, V = unknown>(options: UseItemsOptions<T, V>): {
+    items: import("vue").ComputedRef<InternalItem<T, V>[]>;
+    resolveLabel: (item: T) => string;
+    resolveValue: (item: T) => V;
+};
+export {};

package/dist/types-cjs/use/select/listboxKeyboard.d.cts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue';
+import type { FieldKeyboardHandler } from '../form/fieldKeyboard.cjs';
+export interface UseSelectListboxKeyboardOptions {
+    open: Ref<boolean>;
+    selectFirstVisibleItem: () => void;
+}
+export declare function useSelectListboxKeyboard(options: UseSelectListboxKeyboardOptions): {
+    handlers: readonly FieldKeyboardHandler[];
+};

package/dist/types-cjs/use/select/menuItems.d.cts

@@ -0,0 +1,11 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { GMenuItemBase } from '../menu.cjs';
+import type { InternalItem } from './types.cjs';
+export interface SelectMenuItem<T, V> extends InternalItem<T, V> {
+    id: string;
+    children?: SelectMenuItem<T, V>[];
+}
+export declare function useSelectMenuItems<T, V>(items: Ref<InternalItem<T, V>[]>): {
+    menuItems: ComputedRef<SelectMenuItem<T, V>[]>;
+    resolveMenuItem: (item: GMenuItemBase) => SelectMenuItem<T, V> | undefined;
+};

package/dist/types-cjs/use/select/menuSlot.d.cts

@@ -0,0 +1,5 @@
+import type { GMenuItemBase } from '../menu.cjs';
+import type { SelectMenuItem } from './menuItems.cjs';
+export declare function useSelectMenuSlot<T, V>(resolveMenuItem: (item: GMenuItemBase) => SelectMenuItem<T, V> | undefined): {
+    getSlotItem: (item: GMenuItemBase) => SelectMenuItem<T, V>;
+};

package/dist/types-cjs/use/select/modelFallbackItems.d.cts

@@ -0,0 +1,12 @@
+import type { SelectBaseProps } from './types.cjs';
+import type { MaybeRef } from 'vue';
+type MaybeRefSelectProps<T, V, Multiple extends boolean, ReturnObject extends boolean> = Pick<{
+    [K in keyof SelectBaseProps<T, V, Multiple, ReturnObject>]: MaybeRef<SelectBaseProps<T, V, Multiple, ReturnObject>[K]>;
+}, 'items' | 'modelValue' | 'labelKey' | 'valueKey' | 'itemChildren' | 'returnObject'>;
+export type UseModelFallbackItemsOptions<T, V, Multiple extends boolean, ReturnObject extends boolean> = MaybeRefSelectProps<T, V, Multiple, ReturnObject>;
+export declare function useModelFallbackItems<T, V, Multiple extends boolean, ReturnObject extends boolean>(options: UseModelFallbackItemsOptions<T, V, Multiple, ReturnObject>): {
+    sourceItems: import("vue").ComputedRef<readonly T[]>;
+    normalizedSourceItems: import("vue").ComputedRef<import("./types.cjs").InternalItem<T, V>[]>;
+    createRawRecord: (label: string, value: unknown) => T;
+};
+export {};

package/dist/types-cjs/use/select/search.d.cts

@@ -0,0 +1,14 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+export interface UseSelectSearchOptions {
+    search?: MaybeRefOrGetter<string | undefined>;
+    selectionText?: ComputedRef<string>;
+    isMultiple?: MaybeRefOrGetter<boolean>;
+    onSearch: (value: string) => void;
+}
+export declare const normalizeSelectSearch: (value: string) => string;
+export declare function useSelectSearch(options: UseSelectSearchOptions): {
+    searchValue: ComputedRef<string>;
+    normalizedQuery: ComputedRef<string>;
+    setSearch: (value: string) => void;
+    syncSelectionText: (selectionText: ComputedRef<string>, isMultiple: MaybeRefOrGetter<boolean>) => void;
+};

package/dist/types-cjs/use/select/searchFieldControl.d.cts

@@ -0,0 +1,24 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+export interface UseSearchFieldControlOptions {
+    open: Ref<boolean>;
+    inputRef: Ref<HTMLInputElement | undefined>;
+    disabled: MaybeRefOrGetter<boolean | undefined>;
+    setSearch: (value: string) => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    onInputValidation: () => void;
+    emitFocus: (event: FocusEvent) => void;
+    emitBlur: (event: FocusEvent) => void;
+    emitClear: () => void;
+    clearValue: () => void;
+    afterBlur?: () => void;
+    activatorIgnoreSelector?: string;
+}
+export declare function useSearchFieldControl(options: UseSearchFieldControlOptions): {
+    handleInput: (event: Event) => void;
+    handleFocus: (event: FocusEvent) => void;
+    handleBlur: (event: FocusEvent) => void;
+    handleClear: () => void;
+    focusControl: () => void;
+    handleActivatorMousedown: (event: MouseEvent) => void;
+};

package/dist/types-cjs/use/select/selection.d.cts

@@ -0,0 +1,12 @@
+import { type MaybeRef } from 'vue';
+import type { InternalItem, SelectionValue, SelectionValueComparator } from './types.cjs';
+export declare function useSelection<T, V, Multiple extends boolean, ReturnObject extends boolean>(props: {
+    modelValue: MaybeRef<SelectionValue<T, V, Multiple, ReturnObject>>;
+    multiple?: MaybeRef<unknown>;
+    returnObject?: MaybeRef<unknown>;
+    comparator?: SelectionValueComparator<SelectionValue<T, V, Multiple, ReturnObject>>;
+}, emit: (e: 'update:modelValue', value: SelectionValue<T, V, Multiple, ReturnObject>) => void): {
+    isSelected: (item: InternalItem<T, V>) => boolean;
+    getNextValue: (item: InternalItem<T, V>) => SelectionValue<T, V, Multiple, ReturnObject> | undefined;
+    select: (item: InternalItem<T, V>) => void;
+};

package/dist/types-cjs/use/select/selectionController.d.cts

@@ -0,0 +1,19 @@
+import { type MaybeRef } from 'vue';
+import type { InternalItem, SelectionValue, SelectionValueComparator, SelectItemChildren, SelectLabelKey, SelectValueKey } from './types.cjs';
+type MaybeRefSelectionControllerProps<T, V, Multiple extends boolean, ReturnObject extends boolean> = {
+    items: MaybeRef<readonly T[]>;
+    modelValue: MaybeRef<SelectionValue<T, V, Multiple, ReturnObject>>;
+    labelKey?: MaybeRef<SelectLabelKey<T> | undefined>;
+    valueKey?: MaybeRef<SelectValueKey<T, V> | undefined>;
+    itemChildren?: MaybeRef<SelectItemChildren<T> | undefined>;
+    returnObject?: MaybeRef<ReturnObject | undefined>;
+    multiple?: MaybeRef<Multiple | undefined>;
+    valueComparator?: MaybeRef<SelectionValueComparator<SelectionValue<T, V, Multiple, ReturnObject>> | undefined>;
+};
+export declare function useSelectionController<T, V, Multiple extends boolean, ReturnObject extends boolean>(props: MaybeRefSelectionControllerProps<T, V, Multiple, ReturnObject>, emit: (e: 'update:modelValue', value: SelectionValue<T, V, Multiple, ReturnObject>) => void): {
+    items: import("vue").ComputedRef<InternalItem<T, V>[]>;
+    isItemSelected: (item: InternalItem<T, V>) => boolean;
+    getNextItemValue: (item: InternalItem<T, V>) => SelectionValue<T, V, Multiple, ReturnObject> | undefined;
+    selectItem: (item: InternalItem<T, V>) => void;
+};
+export {};

package/dist/types-cjs/use/select/selectionSummary.d.cts

@@ -0,0 +1,8 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { InternalItem } from './types.cjs';
+export declare function flattenSelectItems<T, V>(items: readonly InternalItem<T, V>[]): InternalItem<T, V>[];
+export declare function useSelectionSummary<T, V>(items: Ref<InternalItem<T, V>[]>, isItemSelected: (item: InternalItem<T, V>) => boolean): {
+    selectedItems: ComputedRef<InternalItem<T, V>[]>;
+    hasSelection: ComputedRef<boolean>;
+    selectionText: ComputedRef<string>;
+};

package/dist/types-cjs/use/select/tokenInputKeyboard.d.cts

@@ -0,0 +1,11 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { FieldKeyboardHandler } from '../form/fieldKeyboard.cjs';
+export interface UseTokenInputKeyboardOptions<T> {
+    enabled?: MaybeRefOrGetter<boolean | undefined>;
+    searchValue: MaybeRefOrGetter<string>;
+    items: MaybeRefOrGetter<readonly T[]>;
+    removeItem: (item: T) => void;
+}
+export declare function useTokenInputKeyboard<T>(options: UseTokenInputKeyboardOptions<T>): {
+    handlers: readonly FieldKeyboardHandler[];
+};

package/dist/types-cjs/use/select/types.d.cts

@@ -0,0 +1,24 @@
+export interface InternalItem<T, V = unknown> {
+    label: string;
+    value: V;
+    raw: T;
+    disabled?: boolean;
+    children?: InternalItem<T, V>[];
+}
+export type SelectItemKey<T> = Extract<keyof T, string | number>;
+export type SelectLabelKey<T> = SelectItemKey<T> | ((item: T) => string);
+export type SelectValueKey<T, V> = SelectItemKey<T> | ((item: T) => V);
+export type SelectItemChildren<T> = SelectItemKey<T> | ((item: T) => readonly T[] | undefined);
+export type SelectionValue<T, V, Multiple extends boolean, ReturnObject extends boolean> = Multiple extends true ? ReturnObject extends true ? T[] : V[] : ReturnObject extends true ? T | null : V | null;
+export type SelectionComparatorValue<TModel> = TModel extends readonly (infer U)[] ? U : TModel;
+export type SelectionValueComparator<TModel> = (a: SelectionComparatorValue<TModel>, b: SelectionComparatorValue<TModel>) => boolean;
+export type SelectBaseProps<T, V, Multiple extends boolean = false, ReturnObject extends boolean = false> = {
+    items: readonly T[];
+    modelValue: SelectionValue<T, V, Multiple, ReturnObject>;
+    multiple?: Multiple;
+    returnObject?: ReturnObject;
+    closeOnSelect?: boolean;
+    labelKey?: SelectLabelKey<T>;
+    valueKey?: SelectValueKey<T, V>;
+    itemChildren?: SelectItemChildren<T>;
+};

package/dist/types-cjs/use/selected.d.cts

@@ -0,0 +1,17 @@
+import { type PropType } from 'vue';
+export type MaybeBoolean = boolean | (() => boolean);
+export declare function resolveMaybeBoolean(value: MaybeBoolean): boolean;
+export declare const makeSelectedProps: <Defaults extends {
+    selected?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    selected: Omit<{
+        type: PropType<MaybeBoolean>;
+        default: boolean;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["selected"] extends infer T ? T extends Defaults["selected"] ? T extends unknown ? MaybeBoolean : MaybeBoolean | T : never : never>;
+        default: Defaults["selected"] extends infer T_1 ? T_1 extends Defaults["selected"] ? T_1 extends unknown ? MaybeBoolean : T_1 | NonNullable<MaybeBoolean> : never : never;
+    };
+};
+export declare function useSelected(props: {
+    selected: MaybeBoolean;
+}, base: string): import("vue").ComputedRef<string>;

package/dist/types-cjs/use/selectionModel.d.cts

@@ -0,0 +1,19 @@
+import { type MaybeRef } from 'vue';
+export type SelectionComparator<T> = (a: T, b: T) => boolean;
+type UseSelectionModelProps<TModel, TValue> = {
+    modelValue: MaybeRef<TModel>;
+    multiple?: MaybeRef<unknown>;
+    mandatory?: MaybeRef<unknown>;
+    comparator?: SelectionComparator<TValue>;
+    emptyValue: TModel;
+};
+export declare function useSelectionModel<TModel, TValue = TModel>(props: UseSelectionModelProps<TModel, TValue>, onChange: (value: TModel) => void): {
+    isMultiple: import("vue").ComputedRef<boolean>;
+    isMandatory: import("vue").ComputedRef<boolean>;
+    isSelected: (value: TValue) => boolean;
+    getNextValue: (value: TValue) => TModel;
+    select: (value: TValue) => void;
+    unselect: (value: TValue) => void;
+    toggle: (value: TValue) => void;
+};
+export {};

package/dist/types-cjs/use/size.d.cts

@@ -0,0 +1,16 @@
+import { type PropType } from 'vue';
+import { type Sizes } from '../types/CommonTypes.cjs';
+export declare const makeSizeProps: <Defaults extends {
+    size?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    size: Omit<{
+        type: PropType<Sizes>;
+        default: string;
+    }, "default" | "type"> & {
+        type: PropType<Defaults["size"] extends infer T ? T extends Defaults["size"] ? T extends unknown ? Sizes : Sizes | T : never : never>;
+        default: Defaults["size"] extends infer T_1 ? T_1 extends Defaults["size"] ? T_1 extends unknown ? Sizes : T_1 | NonNullable<Sizes> : never : never;
+    };
+};
+export declare function useSize(props: {
+    size: Sizes;
+}, base: string): import("vue").ComputedRef<string>;

package/dist/types-cjs/use/slots.d.cts

@@ -0,0 +1,15 @@
+import { type VNodeChild } from 'vue';
+export type SlotDefinition<Props> = (props: Props) => VNodeChild;
+export type SlotsDefinition = Record<string, SlotDefinition<never>>;
+export type SlotProps<T> = T extends SlotDefinition<infer P> ? P : never;
+type WithDefaults<S extends SlotsDefinition, D extends Partial<S>> = {
+    [K in keyof S]: {
+        fn: K extends keyof D ? S[K] | D[K] : S[K];
+    };
+};
+export declare function slotsFactory<S extends SlotsDefinition>(slots: S): <D extends Partial<S> = object>(defaults?: D) => WithDefaults<S, D>;
+export declare function useTypedSlots<T extends SlotsDefinition>(_def: T): T;
+export type InferSlots<T extends SlotsDefinition> = {
+    [K in keyof T]: SlotProps<T[K]>;
+};
+export {};

package/dist/types-cjs/use/state.d.cts

@@ -0,0 +1,13 @@
+import { type PropType } from 'vue';
+import type { GGradienStates } from '../components/ui/GGradient/types.cjs';
+export declare const makeStateProps: <Defaults extends {
+    state?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    state: {
+        type: PropType<Defaults["state"] extends infer T ? T extends Defaults["state"] ? T extends unknown ? GGradienStates : GGradienStates | T : never : never>;
+        default: Defaults["state"] extends infer T_1 ? T_1 extends Defaults["state"] ? T_1 extends unknown ? GGradienStates : T_1 | NonNullable<GGradienStates> : never : never;
+    };
+};
+export declare function useState(props: {
+    state?: GGradienStates | undefined;
+}, base: string): import("vue").ComputedRef<string>;

package/dist/types-cjs/use/stateIcon.d.cts

@@ -0,0 +1,9 @@
+import type { MdiIcon } from '../types/CommonTypes.cjs';
+export type GStateIconMap<TState extends string> = Partial<Record<TState, MdiIcon>>;
+export interface ResolveStateIconOptions<TState extends string> {
+    state: TState;
+    icon?: MdiIcon;
+    icons?: GStateIconMap<TState>;
+    defaultIcons?: GStateIconMap<TState>;
+}
+export declare const resolveStateIcon: <TState extends string>({ state, icon, icons, defaultIcons }: ResolveStateIconOptions<TState>) => MdiIcon | undefined;