@evance/evance-ui 1.0.0

package/dist/composables/display.d.ts

@@ -0,0 +1,157 @@
+import { InjectionKey, Ref } from 'vue';
+
+/**
+ * # Breakpoints
+ * Excludes `xs` as this is the smallest size - not really a breakpoint.
+ */
+export declare const breakpoints: readonly ["sm", "md", "lg", "xl", "xxl"];
+export type Breakpoint = typeof breakpoints[number];
+export type DisplayBreakpoint = 'xs' | Breakpoint;
+export type DisplayThresholds = {
+    [key in DisplayBreakpoint]: number;
+};
+export interface DisplayOptions {
+    mobileBreakpoint?: number | DisplayBreakpoint;
+    thresholds?: Partial<DisplayThresholds>;
+}
+export interface InternalDisplayOptions {
+    mobileBreakpoint: number | DisplayBreakpoint;
+    thresholds: DisplayThresholds;
+}
+export type SSROptions = boolean | {
+    clientWidth: number;
+    clientHeight?: number;
+};
+export interface DisplayPlatform {
+    android: boolean;
+    ios: boolean;
+    cordova: boolean;
+    electron: boolean;
+    chrome: boolean;
+    edge: boolean;
+    firefox: boolean;
+    opera: boolean;
+    win: boolean;
+    mac: boolean;
+    linux: boolean;
+    touch: boolean;
+    ssr: boolean;
+}
+export interface DisplayInstance {
+    xs: Ref<boolean>;
+    sm: Ref<boolean>;
+    md: Ref<boolean>;
+    lg: Ref<boolean>;
+    xl: Ref<boolean>;
+    xxl: Ref<boolean>;
+    xsUp: Ref<boolean>;
+    smUp: Ref<boolean>;
+    mdUp: Ref<boolean>;
+    lgUp: Ref<boolean>;
+    xlUp: Ref<boolean>;
+    xxlUp: Ref<boolean>;
+    smDown: Ref<boolean>;
+    mdDown: Ref<boolean>;
+    lgDown: Ref<boolean>;
+    xlDown: Ref<boolean>;
+    name: Ref<DisplayBreakpoint>;
+    height: Ref<number>;
+    width: Ref<number>;
+    mobile: Ref<boolean>;
+    mobileBreakpoint: Ref<number | DisplayBreakpoint>;
+    platform: Ref<DisplayPlatform>;
+    thresholds: Ref<DisplayThresholds>;
+    /** @internal */
+    ssr: boolean;
+    update(): void;
+}
+export declare const DisplaySymbol: InjectionKey<DisplayInstance>;
+export declare const defaultDisplayOptions: DisplayOptions;
+/**
+ * # Create Display
+ * @param options
+ * @param ssr
+ */
+export declare function createDisplay(options?: DisplayOptions, ssr?: SSROptions): DisplayInstance;
+/**
+ * # Use Display (from Symbol);
+ */
+export declare function useDisplay(): DisplayInstance;
+/**
+ * # Display Point Options
+ *
+ * These are listed in order of calculation priority.
+ */
+export declare const displayRules: readonly ["xxl", "xl", "lg", "md", "sm", "xs", "xxlOnly", "xlOnly", "lgOnly", "mdOnly", "smOnly", "xsOnly", "xxlUp", "xlUp", "lgUp", "mdUp", "smUp", "xsUp", "smDown", "mdDown", "lgDown", "xlDown"];
+export declare const displayRulesKebab: readonly ["xxl-only", "xl-only", "lg-only", "md-only", "sm-only", "xs-only", "xxl-up", "xl-up", "lg-up", "md-up", "sm-up", "xs-up", "sm-down", "md-down", "lg-down", "xl-down"];
+export type DisplayRuleSuffix = 'only' | 'up' | 'down';
+export type DisplayRuleKey = typeof displayRules[number];
+export type DisplayRuleKebab = typeof displayRulesKebab[number];
+export type DisplayRuleValue = number | string;
+export type DisplayRuleObject = {
+    [key in DisplayRuleKey]?: DisplayRuleValue;
+};
+export type DisplayRuleProp = DisplayRuleValue | DisplayRuleObject;
+export type DisplayRuleListProp = DisplayRuleKey | DisplayRuleKey[] | DisplayRuleKebab | DisplayRuleKebab[];
+/** Visibility props */
+export type VisibilityRuleProp = DisplayRuleListProp | boolean;
+/**
+ * # calculateDisplayRuleValue
+ *
+ * @param rules
+ */
+export declare function calculateDisplayRuleValue(rules?: DisplayRuleObject | DisplayRuleValue): string | undefined;
+/**
+ * # To Display Key
+ *
+ * @param displayRule
+ */
+export declare function toDisplayStateKey(displayRule: string): string;
+export declare namespace toDisplayStateKey {
+    var cache: Map<string, string>;
+}
+/**
+ * # To Display Rule Kebab
+ *
+ * @param displayRule
+ */
+export declare function toDisplayRuleKebab(displayRule: string): string;
+export declare namespace toDisplayRuleKebab {
+    var cache: Map<string, string>;
+}
+/**
+ * # isDisplayRule
+ *
+ * @param value
+ * @param acceptKebabs
+ */
+export declare function isDisplayRule(value: unknown, acceptKebabs?: boolean): value is DisplayRuleKey | DisplayRuleKebab;
+/**
+ * # isDisplayBreakpoint
+ *
+ * @param value
+ */
+export declare function isDisplayBreakpoint(value: unknown): value is DisplayBreakpoint;
+/**
+ * # createBreakpointClasses
+ *
+ * @param props
+ * @param propName
+ * @param prefix
+ * @param useXs
+ */
+export declare function useBreakpointClasses<PropsObject extends object, PropName extends Extract<keyof PropsObject, string>, Prefix extends string | undefined, UseXs extends boolean>(props: PropsObject, propName: PropName, prefix?: Prefix, useXs?: UseXs): import('vue').ComputedRef<string[]>;
+/**
+ * # useDisplayRuleClasses
+ *
+ * @param props
+ * @param propName
+ * @param prefix
+ */
+export declare function useDisplayRuleClasses<PropsObject extends object, PropName extends Extract<keyof PropsObject, string>, Prefix extends string | undefined>(props: PropsObject, propName: PropName, prefix?: Prefix): import('vue').ComputedRef<string[]>;
+/**
+ * # toDisplayRuleArray
+ *
+ * @param prop
+ */
+export declare function toDisplayRuleArray(prop: unknown): string[];

package/dist/composables/drawer.d.ts

@@ -0,0 +1,21 @@
+import { EvDrawerServiceOpener } from '../components/EvDrawer/EvDrawerServiceOpener.ts';
+import { EvDrawerInstance } from '../components/EvDrawer/EvDrawerInstance.ts';
+import { InjectionKey } from 'vue';
+
+export declare const EvDrawerServiceSymbol: InjectionKey<EvDrawerServiceOpener>;
+export declare const EvDrawerInstanceSymbol: InjectionKey<EvDrawerInstance | undefined>;
+/**
+ * # useDrawer
+ *
+ * Requires that the App has provided `EvDrawerService`.
+ */
+export declare function useDrawer(): EvDrawerServiceOpener;
+/**
+ * # injectDrawer
+ */
+export declare function injectDrawer(): EvDrawerInstance | undefined;
+/**
+ * # provideDrawer
+ * @param instance
+ */
+export declare function provideDrawer(instance: EvDrawerInstance | undefined): void;

package/dist/composables/filter.d.ts

@@ -0,0 +1,105 @@
+import { MaybeRef, PropType, Ref } from 'vue';
+
+/**
+ * - match without highlight
+ * - single match (index), length already known
+ * - single match (start, end)
+ * - multiple matches (start, end), probably shouldn't overlap
+ */
+export type FilterMatch = boolean | number | [number, number] | [number, number][];
+export type FilterFunction = (value: string, query: string, item?: InternalItem) => FilterMatch;
+export type FilterKeyFunctions = Record<string, FilterFunction>;
+export type FilterKeys = string | string[];
+export type FilterMode = 'some' | 'every' | 'union' | 'intersection';
+/**
+ * # FilterProps
+ */
+export interface FilterProps {
+    filterFunction?: FilterFunction;
+    filterKeyFunctions?: FilterKeyFunctions;
+    filterKeys?: FilterKeys;
+    filterMode?: FilterMode;
+    noFilter?: boolean;
+}
+/**
+ * # InternalItem
+ */
+export interface InternalItem<T = any> {
+    value: any;
+    raw: T;
+}
+/**
+ * # defaultFilter
+ * @param value
+ * @param query
+ * @param item
+ */
+export declare const defaultFilter: FilterFunction;
+/**
+ * # makeFilterProps
+ */
+export declare const makeFilterProps: <Defaults extends {
+    filterFunction?: unknown;
+    filterKeyFunctions?: unknown;
+    filterKeys?: unknown;
+    filterMode?: unknown;
+    noFilter?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    filterFunction: unknown extends Defaults["filterFunction"] ? PropType<FilterFunction> : {
+        type: PropType<unknown extends Defaults["filterFunction"] ? FilterFunction : FilterFunction | Defaults["filterFunction"]>;
+        default: unknown extends Defaults["filterFunction"] ? FilterFunction : FilterFunction | Defaults["filterFunction"];
+    };
+    filterKeyFunctions: unknown extends Defaults["filterKeyFunctions"] ? PropType<FilterKeyFunctions> : {
+        type: PropType<unknown extends Defaults["filterKeyFunctions"] ? FilterKeyFunctions : FilterKeyFunctions | Defaults["filterKeyFunctions"]>;
+        default: unknown extends Defaults["filterKeyFunctions"] ? FilterKeyFunctions : FilterKeyFunctions | Defaults["filterKeyFunctions"];
+    };
+    filterKeys: unknown extends Defaults["filterKeys"] ? PropType<FilterKeys> : {
+        type: PropType<unknown extends Defaults["filterKeys"] ? FilterKeys : NonNullable<FilterKeys> | Defaults["filterKeys"]>;
+        default: unknown extends Defaults["filterKeys"] ? FilterKeys : NonNullable<FilterKeys> | Defaults["filterKeys"];
+    };
+    filterMode: unknown extends Defaults["filterMode"] ? {
+        type: PropType<FilterMode>;
+        default: string;
+    } : Omit<{
+        type: PropType<FilterMode>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["filterMode"] ? FilterMode : Defaults["filterMode"] | NonNullable<FilterMode>>;
+        default: unknown extends Defaults["filterMode"] ? FilterMode : Defaults["filterMode"] | NonNullable<FilterMode>;
+    };
+    noFilter: unknown extends Defaults["noFilter"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["noFilter"] ? boolean : boolean | Defaults["noFilter"]>;
+        default: unknown extends Defaults["noFilter"] ? boolean : boolean | Defaults["noFilter"];
+    };
+};
+/**
+ * # filterItems
+ * @param items
+ * @param query
+ * @param options
+ */
+export declare function filterItems(items: readonly (readonly [item: InternalItem, transformed: {}])[] | readonly InternalItem[], query: string, options?: {
+    filterKeyFunctions?: FilterKeyFunctions;
+    default?: FilterFunction;
+    filterKeys?: FilterKeys;
+    filterMode?: FilterMode;
+    noFilter?: boolean;
+}): {
+    index: number;
+    matches: Record<string, FilterMatch>;
+}[];
+/**
+ * # useFilter
+ * @param props
+ * @param items
+ * @param query
+ * @param options
+ */
+export declare function useFilter<T extends InternalItem>(props: FilterProps, items: MaybeRef<T[]>, query: Ref<string | undefined> | (() => string | undefined), options?: {
+    transform?: (item: T) => {};
+    filterKeyFunctions?: MaybeRef<FilterKeyFunctions | undefined>;
+}): {
+    filteredItems: Ref<T[]>;
+    filteredMatches: Ref<Map<unknown, Record<string, FilterMatch>>>;
+    getMatches: (item: T) => Record<string, FilterMatch> | undefined;
+};

package/dist/composables/focus.d.ts

@@ -0,0 +1,46 @@
+/**
+ * # Focus Props Type
+ */
+export interface FocusProps {
+    focused: boolean;
+    'onUpdate:focused': ((focused: boolean) => any) | undefined;
+}
+/**
+ * # Make Focus Props
+ */
+export declare const makeFocusProps: <Defaults extends {
+    focused?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    focused: unknown extends Defaults["focused"] ? BooleanConstructor : {
+        type: import('vue').PropType<unknown extends Defaults["focused"] ? boolean : boolean | Defaults["focused"]>;
+        default: unknown extends Defaults["focused"] ? boolean : boolean | Defaults["focused"];
+    };
+};
+/**
+ * # Use Focus Composable
+ */
+export declare function useFocus(props: FocusProps): {
+    isFocused: import('vue').Ref<any> & {
+        readonly externalValue: boolean;
+    };
+    isFocusedVisible: import('vue').Ref<boolean>;
+    focusClasses: import('vue').ComputedRef<{
+        'is-focused': any;
+        'is-focused-visible': boolean;
+    }>;
+    focus: (e?: Event) => void;
+    blur: () => void;
+};
+/**
+ * ## Auto Focus
+ */
+export interface AutofocusProps {
+    autofocus: boolean;
+}
+/**
+ * # Use Auto Focus
+ * @param props
+ */
+export declare function useAutofocus(props: AutofocusProps): {
+    mounted: (el: HTMLElement) => void;
+};

package/dist/composables/form.d.ts

@@ -0,0 +1,78 @@
+import { Form } from '../modules/Form/Form.ts';
+import { ValidationError, FormFieldProps } from './validation.ts';
+import { InjectionKey, PropType } from 'vue';
+
+/**
+ * # Form Key
+ * Used for provide/inject functions.
+ */
+export declare const FormKey: InjectionKey<any>;
+/**
+ * # Submit Event Promise
+ */
+export interface SubmitEventPromise extends SubmitEvent, Promise<FormValidationResult> {
+}
+/**
+ * # Form Props
+ */
+export interface FormProps {
+    disabled: boolean;
+    readonly: boolean;
+    modelValue: boolean | null;
+    'onUpdate:modelValue'?: ((val: boolean | null) => void) | undefined;
+    validateOn: FormFieldProps['validateOn'];
+}
+/**
+ * # Form Validation Result
+ */
+export interface FormValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+/**
+ * # Make Form Props
+ */
+export declare const makeFormProps: <Defaults extends {
+    disabled?: unknown;
+    readonly?: unknown;
+    modelValue?: unknown;
+    validateOn?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    disabled: unknown extends Defaults["disabled"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["disabled"] ? boolean : boolean | Defaults["disabled"]>;
+        default: unknown extends Defaults["disabled"] ? boolean : boolean | Defaults["disabled"];
+    };
+    readonly: unknown extends Defaults["readonly"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["readonly"] ? boolean : boolean | Defaults["readonly"]>;
+        default: unknown extends Defaults["readonly"] ? boolean : boolean | Defaults["readonly"];
+    };
+    modelValue: unknown extends Defaults["modelValue"] ? {
+        type: PropType<boolean | null>;
+        default: null;
+    } : Omit<{
+        type: PropType<boolean | null>;
+        default: null;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["modelValue"] ? boolean | null : Defaults["modelValue"] | NonNullable<boolean | null>>;
+        default: unknown extends Defaults["modelValue"] ? boolean | null : Defaults["modelValue"] | NonNullable<boolean | null>;
+    };
+    validateOn: unknown extends Defaults["validateOn"] ? {
+        type: PropType<import('./validation.ts').ValidateOnEvent | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | "lazy" | undefined>;
+        default: string;
+    } : Omit<{
+        type: PropType<import('./validation.ts').ValidateOnEvent | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | "lazy" | undefined>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["validateOn"] ? import('./validation.ts').ValidateOnEvent | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | "lazy" | undefined : Defaults["validateOn"] | NonNullable<import('./validation.ts').ValidateOnEvent | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | "lazy" | undefined>>;
+        default: unknown extends Defaults["validateOn"] ? import('./validation.ts').ValidateOnEvent | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | "lazy" | undefined : Defaults["validateOn"] | NonNullable<import('./validation.ts').ValidateOnEvent | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | "lazy" | undefined>;
+    };
+};
+/**
+ * # Create Form
+ * @param props
+ */
+export declare function createForm(props: FormProps): Form;
+/**
+ * # Use Form
+ */
+export declare function useForm(): any;

package/dist/composables/group.d.ts

@@ -0,0 +1,99 @@
+import { GroupItem } from './groupItem.ts';
+import { ComponentInternalInstance, ComputedRef, InjectionKey, PropType, Ref } from 'vue';
+import { EventProp } from '../util';
+
+/**
+ * # GroupProps
+ */
+export interface GroupProps {
+    disabled: boolean;
+    modelValue: unknown;
+    multiple?: boolean;
+    mandatory?: boolean | 'force' | undefined;
+    max?: number | undefined;
+    selectedClass: string | undefined;
+    selectedAppearance: string | undefined;
+    selectedVariant: string | undefined;
+    'onUpdate:modelValue': EventProp<[unknown]> | undefined;
+}
+/**
+ * # GroupProvide
+ */
+export interface GroupProvide {
+    register: (item: GroupItem, cmp: ComponentInternalInstance) => void;
+    unregister: (id: number) => void;
+    select: (id: number, value: boolean) => void;
+    selected: Ref<Readonly<number[]>>;
+    isSelected: (id: number) => boolean;
+    previous: () => void;
+    next: () => void;
+    selectedClass: Ref<string | undefined>;
+    selectedAppearance: Ref<string | undefined>;
+    selectedVariant: Ref<string | undefined>;
+    items: ComputedRef<{
+        id: number;
+        value: unknown;
+        disabled: boolean | undefined;
+    }[]>;
+    disabled: Ref<boolean | undefined>;
+    getItemIndex: (value: unknown) => number;
+}
+/**
+ * # makeGroupProps
+ */
+export declare const makeGroupProps: <Defaults extends {
+    modelValue?: unknown;
+    multiple?: unknown;
+    mandatory?: unknown;
+    max?: unknown;
+    selectedClass?: unknown;
+    selectedAppearance?: unknown;
+    selectedVariant?: unknown;
+    disabled?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    modelValue: unknown extends Defaults["modelValue"] ? {
+        type: null;
+        default: undefined;
+    } : Omit<{
+        type: null;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["modelValue"] ? any : any>;
+        default: unknown extends Defaults["modelValue"] ? any : any;
+    };
+    multiple: unknown extends Defaults["multiple"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["multiple"] ? boolean : boolean | Defaults["multiple"]>;
+        default: unknown extends Defaults["multiple"] ? boolean : boolean | Defaults["multiple"];
+    };
+    mandatory: unknown extends Defaults["mandatory"] ? PropType<boolean | "force"> : {
+        type: PropType<unknown extends Defaults["mandatory"] ? boolean | "force" : NonNullable<boolean | "force"> | Defaults["mandatory"]>;
+        default: unknown extends Defaults["mandatory"] ? boolean | "force" : NonNullable<boolean | "force"> | Defaults["mandatory"];
+    };
+    max: unknown extends Defaults["max"] ? NumberConstructor : {
+        type: PropType<unknown extends Defaults["max"] ? number : number | Defaults["max"]>;
+        default: unknown extends Defaults["max"] ? number : number | Defaults["max"];
+    };
+    selectedClass: unknown extends Defaults["selectedClass"] ? StringConstructor : {
+        type: PropType<unknown extends Defaults["selectedClass"] ? string : string | Defaults["selectedClass"]>;
+        default: unknown extends Defaults["selectedClass"] ? string : string | Defaults["selectedClass"];
+    };
+    selectedAppearance: unknown extends Defaults["selectedAppearance"] ? StringConstructor : {
+        type: PropType<unknown extends Defaults["selectedAppearance"] ? string : string | Defaults["selectedAppearance"]>;
+        default: unknown extends Defaults["selectedAppearance"] ? string : string | Defaults["selectedAppearance"];
+    };
+    selectedVariant: unknown extends Defaults["selectedVariant"] ? StringConstructor : {
+        type: PropType<unknown extends Defaults["selectedVariant"] ? string : string | Defaults["selectedVariant"]>;
+        default: unknown extends Defaults["selectedVariant"] ? string : string | Defaults["selectedVariant"];
+    };
+    disabled: unknown extends Defaults["disabled"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["disabled"] ? boolean : boolean | Defaults["disabled"]>;
+        default: unknown extends Defaults["disabled"] ? boolean : boolean | Defaults["disabled"];
+    };
+};
+/**
+ * # useGroup
+ *
+ * @param props
+ * @param injectKey
+ */
+export declare function useGroup(props: GroupProps, injectKey: InjectionKey<GroupProvide>): GroupProvide;

package/dist/composables/groupItem.d.ts

@@ -0,0 +1,70 @@
+import { GroupProvide } from './group.ts';
+import { ExtractPropTypes, InjectionKey, Ref } from 'vue';
+import { EventProp } from '../util';
+
+/**
+ * # GroupItem
+ */
+export interface GroupItem {
+    id: number;
+    value: Ref<unknown>;
+    disabled: Ref<boolean | undefined>;
+}
+/**
+ * # GroupItemProvide
+ */
+export interface GroupItemProvide {
+    id: number;
+    isSelected: Ref<boolean>;
+    toggle: () => void;
+    select: (value: boolean) => void;
+    selectedClass: Ref<(string | undefined)[] | false>;
+    selectedAppearance: Ref<string | undefined>;
+    selectedVariant: Ref<string | undefined>;
+    value: Ref<unknown>;
+    disabled: Ref<boolean | undefined>;
+    group: GroupProvide;
+}
+/**
+ * # makeGroupItemProps
+ */
+export declare const makeGroupItemProps: <Defaults extends {
+    value?: unknown;
+    disabled?: unknown;
+    selectedClass?: unknown;
+    selectedAppearance?: unknown;
+    selectedVariant?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    value: unknown extends Defaults["value"] ? null : {
+        type: import('vue').PropType<unknown extends Defaults["value"] ? any : any>;
+        default: unknown extends Defaults["value"] ? any : any;
+    };
+    disabled: unknown extends Defaults["disabled"] ? BooleanConstructor : {
+        type: import('vue').PropType<unknown extends Defaults["disabled"] ? boolean : boolean | Defaults["disabled"]>;
+        default: unknown extends Defaults["disabled"] ? boolean : boolean | Defaults["disabled"];
+    };
+    selectedClass: unknown extends Defaults["selectedClass"] ? StringConstructor : {
+        type: import('vue').PropType<unknown extends Defaults["selectedClass"] ? string : string | Defaults["selectedClass"]>;
+        default: unknown extends Defaults["selectedClass"] ? string : string | Defaults["selectedClass"];
+    };
+    selectedAppearance: unknown extends Defaults["selectedAppearance"] ? StringConstructor : {
+        type: import('vue').PropType<unknown extends Defaults["selectedAppearance"] ? string : string | Defaults["selectedAppearance"]>;
+        default: unknown extends Defaults["selectedAppearance"] ? string : string | Defaults["selectedAppearance"];
+    };
+    selectedVariant: unknown extends Defaults["selectedVariant"] ? StringConstructor : {
+        type: import('vue').PropType<unknown extends Defaults["selectedVariant"] ? string : string | Defaults["selectedVariant"]>;
+        default: unknown extends Defaults["selectedVariant"] ? string : string | Defaults["selectedVariant"];
+    };
+};
+/**
+ * # GroupItemProps
+ */
+export interface GroupItemProps extends ExtractPropTypes<ReturnType<typeof makeGroupItemProps>> {
+    'onGroup:selected': EventProp<[{
+        value: boolean;
+    }]> | undefined;
+}
+/**
+ * # useGroupItem
+ */
+export declare function useGroupItem(props: GroupItemProps, injectKey: InjectionKey<GroupProvide>, required?: boolean): GroupItemProvide | null;

package/dist/composables/hasSlotWithContent.d.ts

@@ -0,0 +1,13 @@
+import { SetupContext } from '@vue/runtime-core';
+import { ComputedRef } from 'vue';
+
+/**
+ * # Has slot with content
+ *
+ * Determines whether the `slotName` is present within the supplied list of `slots`
+ * and whether it has content.
+ *
+ * @param slots
+ * @param slotName
+ */
+export declare function hasSlotWithContent(slots: SetupContext['slots'], slotName: string): ComputedRef;

package/dist/composables/icons.d.ts

@@ -0,0 +1,12 @@
+import { PropType } from 'vue';
+
+export type IconValue = string | (string | [path: string, opacity: number])[];
+export declare const IconProp: PropType<IconValue>;
+/**
+ * # appearanceIcon
+ *
+ * Returns the default icon associated with an appearance value.
+ *
+ * @param appearance
+ */
+export declare function appearanceIcon(appearance?: string): string;

package/dist/composables/index.d.ts

@@ -0,0 +1,7 @@
+export { useDate } from './date';
+export { useDefaults } from './defaults';
+export { useDisplay } from './display';
+export { useLocaleManager, useLocaleFunctions } from './locale';
+export type { DateAdapterInstance } from './date';
+export type { DefaultsInstance } from './defaults';
+export type { DisplayBreakpoint, DisplayInstance, DisplayThresholds } from './display';

package/dist/composables/lazy.d.ts

@@ -0,0 +1,23 @@
+import { Ref } from 'vue';
+
+export declare const makeLazyProps: <Defaults extends {
+    eager?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    eager: unknown extends Defaults["eager"] ? BooleanConstructor : {
+        type: import('vue').PropType<unknown extends Defaults["eager"] ? boolean : boolean | Defaults["eager"]>;
+        default: unknown extends Defaults["eager"] ? boolean : boolean | Defaults["eager"];
+    };
+};
+/**
+ * # useLazy
+ *
+ * @param props
+ * @param active
+ */
+export declare function useLazy(props: {
+    eager: boolean;
+}, active: Ref<boolean>): {
+    isBooted: import('vue').ShallowRef<boolean>;
+    hasContent: import('vue').ComputedRef<boolean>;
+    onAfterLeave: () => void;
+};

package/dist/composables/lists/index.d.ts

@@ -0,0 +1,6 @@
+export * from './list';
+export * from './list-items';
+export * from './sequenced';
+export * from './nested';
+export * from './select-strategies';
+export * from './open-strategies';