@evance/evance-ui 1.0.0

package/dist/composables/lists/list-items.d.ts

@@ -0,0 +1,159 @@
+import { ListItemProps } from '../../components/EvList';
+import { PropType } from 'vue';
+import { GetterPropertyKey, isDeepEqual } from '../../util';
+
+/**
+ * # List Item
+ */
+export interface ListItem<T = any> {
+    key: number;
+    title: string;
+    value: any;
+    props: {
+        [key: string]: any;
+        title: string;
+        value: any;
+    };
+    children?: ListItem<T>[];
+    raw: T;
+}
+/**
+ * # List Item Key
+ *
+ * Defines where to look for item information.
+ *
+ * For example: each Item might have a `title` property.
+ * So an Item key may represent either an array index, or an object property.
+ *
+ * - `boolean` - Ignored
+ * - `string` - Property name, or use Object path notation.
+ * - `array` of strings or numbers represent nested lookup - each array element represents a key in the hierarchy
+ */
+export type ListItemKey = GetterPropertyKey;
+/**
+ * # List Items Props
+ *
+ * - `items` - the array of items to render within a list.
+ * - `item-title` - the title property/key to use as the title in each list item.
+ * - `item-value` - the value property/key to use for selection per list item.
+ * - `item-props` - the props to assign to each list item.
+ * - `return-object` - return the full item object on selection if `true`, or the `item-value` if `false`.
+ */
+export interface ListItemsProps {
+    items: any[];
+    itemTitle: ListItemKey;
+    itemValue: ListItemKey;
+    itemChildren: ListItemKey;
+    itemProps: ListItemKey;
+    returnObject: boolean;
+    valueComparator: typeof isDeepEqual;
+}
+/**
+ * # Make List Items Props
+ *
+ * Applies `ListItemProps` with the following defaults:
+ *
+ * - `items` - a blank array.
+ * - `item-title` - 'title'
+ * - `item-value` - 'value'
+ * - `item-children` - 'children'
+ * - `item-props` - 'props'
+ * - `return-object` - `false`
+ *
+ * @see ListItemsProps
+ */
+export declare const makeListItemsProps: <Defaults extends {
+    items?: unknown;
+    itemTitle?: unknown;
+    itemValue?: unknown;
+    itemChildren?: unknown;
+    itemProps?: unknown;
+    returnObject?: unknown;
+    valueComparator?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    items: unknown extends Defaults["items"] ? {
+        type: PropType<any[]>;
+        default: () => never[];
+    } : Omit<{
+        type: PropType<any[]>;
+        default: () => never[];
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["items"] ? any[] : any[] | Defaults["items"]>;
+        default: unknown extends Defaults["items"] ? any[] : any[] | Defaults["items"];
+    };
+    itemTitle: unknown extends Defaults["itemTitle"] ? {
+        type: PropType<GetterPropertyKey>;
+        default: string;
+    } : Omit<{
+        type: PropType<GetterPropertyKey>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["itemTitle"] ? GetterPropertyKey : NonNullable<GetterPropertyKey> | Defaults["itemTitle"]>;
+        default: unknown extends Defaults["itemTitle"] ? GetterPropertyKey : NonNullable<GetterPropertyKey> | Defaults["itemTitle"];
+    };
+    itemValue: unknown extends Defaults["itemValue"] ? {
+        type: PropType<GetterPropertyKey>;
+        default: string;
+    } : Omit<{
+        type: PropType<GetterPropertyKey>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["itemValue"] ? GetterPropertyKey : NonNullable<GetterPropertyKey> | Defaults["itemValue"]>;
+        default: unknown extends Defaults["itemValue"] ? GetterPropertyKey : NonNullable<GetterPropertyKey> | Defaults["itemValue"];
+    };
+    itemChildren: unknown extends Defaults["itemChildren"] ? {
+        type: PropType<GetterPropertyKey>;
+        default: string;
+    } : Omit<{
+        type: PropType<GetterPropertyKey>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["itemChildren"] ? GetterPropertyKey : NonNullable<GetterPropertyKey> | Defaults["itemChildren"]>;
+        default: unknown extends Defaults["itemChildren"] ? GetterPropertyKey : NonNullable<GetterPropertyKey> | Defaults["itemChildren"];
+    };
+    itemProps: unknown extends Defaults["itemProps"] ? {
+        type: PropType<GetterPropertyKey>;
+        default: string;
+    } : Omit<{
+        type: PropType<GetterPropertyKey>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["itemProps"] ? GetterPropertyKey : NonNullable<GetterPropertyKey> | Defaults["itemProps"]>;
+        default: unknown extends Defaults["itemProps"] ? GetterPropertyKey : NonNullable<GetterPropertyKey> | Defaults["itemProps"];
+    };
+    returnObject: unknown extends Defaults["returnObject"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["returnObject"] ? boolean : boolean | Defaults["returnObject"]>;
+        default: unknown extends Defaults["returnObject"] ? boolean : boolean | Defaults["returnObject"];
+    };
+    valueComparator: unknown extends Defaults["valueComparator"] ? {
+        type: PropType<typeof isDeepEqual>;
+        default: typeof isDeepEqual;
+    } : Omit<{
+        type: PropType<typeof isDeepEqual>;
+        default: typeof isDeepEqual;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["valueComparator"] ? typeof isDeepEqual : typeof isDeepEqual | Defaults["valueComparator"]>;
+        default: unknown extends Defaults["valueComparator"] ? typeof isDeepEqual : typeof isDeepEqual | Defaults["valueComparator"];
+    };
+};
+/**
+ * # Transform Item
+ *
+ * @param props
+ * @param item
+ */
+export declare function transformItem(props: Omit<ListItemProps, 'items'>, item: any): ListItem;
+/**
+ * # Transform Items
+ */
+export declare function transformItems(props: Omit<ListItemProps, 'items'>, items: ListItemProps['items']): ListItem<any>[];
+/**
+ * # Use Items
+ *
+ * @param props
+ */
+export declare function useItems(props: any): {
+    items: import('vue').ComputedRef<ListItem<any>[]>;
+    transformIn: (value: any[]) => ListItem[];
+    transformOut: (value: ListItem[]) => any[];
+};

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

@@ -0,0 +1,26 @@
+import { InjectionKey, Ref } from 'vue';
+
+/**
+ * # List Key
+ */
+export declare const ListKey: InjectionKey<{
+    hasPrepend: Ref<boolean>;
+    updateHasPrepend: (value: boolean) => void;
+}>;
+/**
+ * # Create List
+ * @see useList
+ */
+export declare function createList(): {
+    hasPrepend: Ref<boolean>;
+    updateHasPrepend: (value: boolean) => void;
+};
+/**
+ * # Use List
+ *
+ * @see createList
+ */
+export declare function useList(): {
+    hasPrepend: Ref<boolean>;
+    updateHasPrepend: (value: boolean) => void;
+} | null;

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

@@ -0,0 +1,134 @@
+import { OpenStrategyProps } from './open-strategies.ts';
+import { InjectionKey, Ref } from 'vue';
+import { Selected, SelectStrategyProps } from './select-strategies.ts';
+import { SequencedPosition } from './sequenced.ts';
+
+/**
+ * # Nested Position
+ *
+ * Typically applies to requests to move a node within the nested data set.
+ *
+ * 'inside' - Position a node as a child of another node
+ */
+export type NestedPosition = SequencedPosition & 'inside';
+export interface NestedProps extends SelectStrategyProps, OpenStrategyProps {
+}
+type NestedProvide = {
+    id: Ref<unknown>;
+    isGroupActivator?: boolean;
+    root: {
+        children: Ref<Map<unknown, unknown[]>>;
+        parents: Ref<Map<unknown, unknown>>;
+        opened: Ref<Set<unknown>>;
+        select: (id: unknown, value: boolean, event?: Event) => void;
+        selected: Ref<Map<unknown, Selected>>;
+        selectedValues: Ref<unknown[]>;
+        register: (id: unknown, parentId: unknown, isGroup?: boolean) => void;
+        unregister: (id: unknown) => void;
+        open: (id: unknown, value: boolean, event?: Event) => void;
+        openOnSelect: (id: unknown, value: boolean, event?: Event) => void;
+    };
+};
+export declare const EvNestedSymbol: InjectionKey<NestedProvide>;
+/**
+ * # Empty Nested List
+ */
+export declare const emptyNestedList: NestedProvide;
+/**
+ * # Make Nested Props
+ */
+export declare const makeNestedProps: <Defaults extends {
+    openStrategy?: unknown;
+    opened?: unknown;
+    selectStrategy?: unknown;
+    selected?: unknown;
+    required?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    openStrategy: unknown extends Defaults["openStrategy"] ? import('vue').PropType<import("@/composables/lists/open-strategies.ts").OpenStrategy | import("@/composables/lists/open-strategies.ts").OpenStrategyRef> : {
+        /**
+         * # Use Nested List
+         * @param props
+         */
+        type: import('vue').PropType<unknown extends Defaults["openStrategy"] ? import("@/composables/lists/open-strategies.ts").OpenStrategy | import("@/composables/lists/open-strategies.ts").OpenStrategyRef : NonNullable<import("@/composables/lists/open-strategies.ts").OpenStrategy | import("@/composables/lists/open-strategies.ts").OpenStrategyRef> | Defaults["openStrategy"]>;
+        default: unknown extends Defaults["openStrategy"] ? import('./open-strategies.ts').OpenStrategy | import('./open-strategies.ts').OpenStrategyRef : NonNullable<import('./open-strategies.ts').OpenStrategy | import('./open-strategies.ts').OpenStrategyRef> | Defaults["openStrategy"];
+    };
+    opened: unknown extends Defaults["opened"] ? import('vue').PropType<readonly unknown[]> : {
+        /**
+         * # Use Nested List
+         * @param props
+         */
+        type: import('vue').PropType<unknown extends Defaults["opened"] ? readonly unknown[] : readonly unknown[] | Defaults["opened"]>;
+        default: unknown extends Defaults["opened"] ? readonly unknown[] : readonly unknown[] | Defaults["opened"];
+    };
+    selectStrategy: unknown extends Defaults["selectStrategy"] ? import('vue').PropType<import("./select-strategies.ts").SelectStrategyFn | import("./select-strategies.ts").SelectStrategyRef> : {
+        /**
+         * # Use Nested List
+         * @param props
+         */
+        type: import('vue').PropType<unknown extends Defaults["selectStrategy"] ? import("./select-strategies.ts").SelectStrategyFn | import("./select-strategies.ts").SelectStrategyRef : NonNullable<import("./select-strategies.ts").SelectStrategyFn | import("./select-strategies.ts").SelectStrategyRef> | Defaults["selectStrategy"]>;
+        default: unknown extends Defaults["selectStrategy"] ? import('./select-strategies.ts').SelectStrategyFn | import('./select-strategies.ts').SelectStrategyRef : NonNullable<import('./select-strategies.ts').SelectStrategyFn | import('./select-strategies.ts').SelectStrategyRef> | Defaults["selectStrategy"];
+    };
+    selected: unknown extends Defaults["selected"] ? import('vue').PropType<readonly unknown[]> : {
+        /**
+         * # Use Nested List
+         * @param props
+         */
+        type: import('vue').PropType<unknown extends Defaults["selected"] ? readonly unknown[] : readonly unknown[] | Defaults["selected"]>;
+        default: unknown extends Defaults["selected"] ? readonly unknown[] : readonly unknown[] | Defaults["selected"];
+    };
+    required: unknown extends Defaults["required"] ? BooleanConstructor : {
+        /**
+         * # Use Nested List
+         * @param props
+         */
+        type: import('vue').PropType<unknown extends Defaults["required"] ? boolean : boolean | Defaults["required"]>;
+        default: unknown extends Defaults["required"] ? boolean : boolean | Defaults["required"];
+    };
+};
+/**
+ * # Use Nested List
+ * @param props
+ */
+export declare const useNestedList: (props: NestedProps) => {
+    children: Ref<Map<unknown, unknown[]>>;
+    parents: Ref<Map<unknown, unknown>>;
+    opened: Ref<Set<unknown>>;
+    select: (id: unknown, value: boolean, event?: Event) => void;
+    selected: Ref<Map<unknown, Selected>>;
+    selectedValues: Ref<unknown[]>;
+    register: (id: unknown, parentId: unknown, isGroup?: boolean) => void;
+    unregister: (id: unknown) => void;
+    open: (id: unknown, value: boolean, event?: Event) => void;
+    openOnSelect: (id: unknown, value: boolean, event?: Event) => void;
+};
+/**
+ * # Use Nested List Item
+ * @param id
+ * @param isGroup
+ */
+export declare const useNestedListItem: (id: Ref<unknown>, isGroup: boolean) => {
+    id: import('vue').ComputedRef<{} | null>;
+    parent: import('vue').ComputedRef<unknown>;
+    select: (selected: boolean, e?: Event) => void;
+    isSelected: import('vue').ComputedRef<boolean>;
+    isIndeterminate: import('vue').ComputedRef<boolean>;
+    isLeaf: import('vue').ComputedRef<boolean>;
+    isGroupActivator: boolean | undefined;
+    root: {
+        children: Ref<Map<unknown, unknown[]>>;
+        parents: Ref<Map<unknown, unknown>>;
+        opened: Ref<Set<unknown>>;
+        select: (id: unknown, value: boolean, event?: Event) => void;
+        selected: Ref<Map<unknown, Selected>>;
+        selectedValues: Ref<unknown[]>;
+        register: (id: unknown, parentId: unknown, isGroup?: boolean) => void;
+        unregister: (id: unknown) => void;
+        open: (id: unknown, value: boolean, event?: Event) => void;
+        openOnSelect: (id: unknown, value: boolean, event?: Event) => void;
+    };
+};
+/**
+ *
+ */
+export declare const useNestedGroupActivator: () => void;
+export {};

package/dist/composables/lists/open-strategies.d.ts

@@ -0,0 +1,72 @@
+import { ComputedRef, PropType } from 'vue';
+import { EventProp } from '../../util';
+import { Selected } from './select-strategies.ts';
+
+/**
+ * # Open Strategy
+ */
+export type OpenStrategy = {
+    open: OpenStrategyFn;
+    select: OpenSelectStrategyFn;
+};
+/**
+ * # Open Strategy Data
+ */
+export interface OpenStrategyData {
+    id: unknown;
+    value: boolean;
+    opened: Set<unknown>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}
+/**
+ * # Open Strategy Function
+ */
+export type OpenStrategyFn = (data: OpenStrategyData) => Set<unknown>;
+/**
+ * # Open Select Strategy Data
+ */
+export interface OpenSelectStrategyData extends OpenStrategyData {
+    selected: Map<unknown, Selected>;
+}
+/**
+ * # Open Select Strategy Function
+ */
+export type OpenSelectStrategyFn = (data: OpenSelectStrategyData) => Set<unknown> | null;
+/**
+ * # Open Strategy Reference
+ * Recognised open strategy strings.
+ */
+export type OpenStrategyRef = 'single' | 'multiple' | 'list';
+export type OpenStrategyProp = OpenStrategyRef | OpenStrategy;
+/**
+ * # Open Strategy Props
+ * Defines the `props` required by components to be able to use `OpenStrategy`.
+ */
+export interface OpenStrategyProps {
+    openStrategy?: OpenStrategyProp;
+    opened?: readonly unknown[];
+    'onUpdate:opened'?: EventProp<[unknown[]]>;
+}
+/**
+ * # Make Open Strategy Props
+ */
+export declare const makeOpenStrategyProps: <Defaults extends {
+    openStrategy?: unknown;
+    opened?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    openStrategy: unknown extends Defaults["openStrategy"] ? PropType<OpenStrategy | OpenStrategyRef> : {
+        type: PropType<unknown extends Defaults["openStrategy"] ? OpenStrategy | OpenStrategyRef : Defaults["openStrategy"] | NonNullable<OpenStrategy | OpenStrategyRef>>;
+        default: unknown extends Defaults["openStrategy"] ? OpenStrategy | OpenStrategyRef : Defaults["openStrategy"] | NonNullable<OpenStrategy | OpenStrategyRef>;
+    };
+    opened: unknown extends Defaults["opened"] ? PropType<readonly unknown[]> : {
+        type: PropType<unknown extends Defaults["opened"] ? readonly unknown[] : readonly unknown[] | Defaults["opened"]>;
+        default: unknown extends Defaults["opened"] ? readonly unknown[] : readonly unknown[] | Defaults["opened"];
+    };
+};
+/**
+ * # Use Open Strategy
+ * @param props
+ */
+export declare function useOpenStrategy(props: OpenStrategyProps): ComputedRef<OpenStrategy>;

package/dist/composables/lists/open-strategy/index.d.ts

@@ -0,0 +1,3 @@
+export * from './single';
+export * from './multiple';
+export * from './list';

package/dist/composables/lists/open-strategy/list.d.ts

@@ -0,0 +1,6 @@
+import { OpenStrategy } from '../open-strategies';
+
+/**
+ * # List Open Strategy
+ */
+export declare const listOpenStrategy: OpenStrategy;

package/dist/composables/lists/open-strategy/multiple.d.ts

@@ -0,0 +1,6 @@
+import { OpenStrategy } from '../open-strategies';
+
+/**
+ * # Multiple Open Strategy
+ */
+export declare const multipleOpenStrategy: OpenStrategy;

package/dist/composables/lists/open-strategy/single.d.ts

@@ -0,0 +1,6 @@
+import { OpenStrategy } from '../open-strategies';
+
+/**
+ * # Single Open Strategy
+ */
+export declare const singleOpenStrategy: OpenStrategy;

package/dist/composables/lists/select-strategies.d.ts

@@ -0,0 +1,83 @@
+import { ComputedRef, PropType, Ref } from 'vue';
+
+/**
+ * # Select Strategy
+ */
+export type SelectStrategy = {
+    select: SelectStrategyFn;
+    in: SelectTransformInFn;
+    out: SelectTransformOutFn;
+};
+/**
+ * # Selected
+ */
+export type Selected = 'on' | 'off' | 'indeterminate';
+/**
+ * # Select Strategy Data
+ */
+export interface SelectStrategyData {
+    id: unknown;
+    value: boolean;
+    selected: Map<unknown, Selected>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}
+/**
+ * # Select Strategy Function
+ */
+export type SelectStrategyFn = (data: SelectStrategyData) => Map<unknown, Selected>;
+/**
+ * # Select Strategy Reference
+ * Recognised selection strategy strings.
+ */
+export type SelectStrategyRef = 'cascade-leaf' | 'multi-any' | 'multi-leaf' | 'single-any' | 'single-leaf';
+/**
+ * # Select Strategy Props
+ * Defines the `props` required by components to be able to use `SelectStrategy`.
+ */
+export interface SelectStrategyProps {
+    selectStrategy?: SelectStrategyRef | SelectStrategyFn;
+    selected?: readonly unknown[];
+    required?: boolean;
+    'onUpdate:selected'?: ((values: unknown[]) => void) | undefined;
+}
+/**
+ * # Select Transform In
+ */
+export type SelectTransformInFn = (values: readonly unknown[] | unknown, children: Map<unknown, unknown[]>, parents: Map<unknown, unknown>) => Map<unknown, Selected>;
+/**
+ * # Select Transform Out
+ */
+export type SelectTransformOutFn = (values: Map<unknown, Selected>, children: Map<unknown, unknown[]>, parents: Map<unknown, unknown>) => unknown[];
+/**
+ * # Make Selected Props
+ */
+export declare const makeSelectedProps: <Defaults extends {
+    selectStrategy?: unknown;
+    selected?: unknown;
+    required?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    selectStrategy: unknown extends Defaults["selectStrategy"] ? PropType<SelectStrategyFn | SelectStrategyRef> : {
+        type: PropType<unknown extends Defaults["selectStrategy"] ? SelectStrategyFn | SelectStrategyRef : NonNullable<SelectStrategyFn | SelectStrategyRef> | Defaults["selectStrategy"]>;
+        default: unknown extends Defaults["selectStrategy"] ? SelectStrategyFn | SelectStrategyRef : NonNullable<SelectStrategyFn | SelectStrategyRef> | Defaults["selectStrategy"];
+    };
+    selected: unknown extends Defaults["selected"] ? PropType<readonly unknown[]> : {
+        type: PropType<unknown extends Defaults["selected"] ? readonly unknown[] : readonly unknown[] | Defaults["selected"]>;
+        default: unknown extends Defaults["selected"] ? readonly unknown[] : readonly unknown[] | Defaults["selected"];
+    };
+    required: unknown extends Defaults["required"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["required"] ? boolean : boolean | Defaults["required"]>;
+        default: unknown extends Defaults["required"] ? boolean : boolean | Defaults["required"];
+    };
+};
+/**
+ * # Use Select Strategy
+ * @param props
+ */
+export declare function useSelectStrategy(props: SelectStrategyProps): ComputedRef<SelectStrategy>;
+/**
+ * # Use Selected Values
+ * @param selected
+ */
+export declare function useSelectedValues(selected: Ref<Map<unknown, Selected>>): ComputedRef<unknown[]>;

package/dist/composables/lists/select-strategy/cascade-leaf.d.ts

@@ -0,0 +1,14 @@
+import { SelectStrategy } from '..';
+
+/**
+ * # Cascade Leaf Select Strategy
+ *
+ * This is the equivalent of Vuetify's classic select strategy.
+ *
+ * Selecting a parent node will cause all children to be selected,
+ * parent nodes will be displayed as selected if all their descendants
+ * are selected. Only leaf nodes will be added to the model.
+ *
+ * @param isRequired
+ */
+export declare const cascadeLeaf: (isRequired?: boolean) => SelectStrategy;

package/dist/composables/lists/select-strategy/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cascade-leaf';
+export * from './multi-any';
+export * from './multi-leaf';
+export * from './single-any';
+export * from './single-leaf';

package/dist/composables/lists/select-strategy/multi-any.d.ts

@@ -0,0 +1,10 @@
+import { SelectStrategy } from '..';
+
+/**
+ * # Multi Any
+ *
+ * Any node may be selected regardless of whether it has children.
+ *
+ * @param isRequired
+ */
+export declare const multiAny: (isRequired?: boolean) => SelectStrategy;

package/dist/composables/lists/select-strategy/multi-leaf.d.ts

@@ -0,0 +1,10 @@
+import { SelectStrategy } from '..';
+
+/**
+ * # Multi-Leaf Select Strategy
+ *
+ * Only leaf nodes (items without children) can be selected.
+ *
+ * @param isRequired
+ */
+export declare const multiLeaf: (isRequired?: boolean) => SelectStrategy;

package/dist/composables/lists/select-strategy/single-any.d.ts

@@ -0,0 +1,10 @@
+import { SelectStrategy } from '..';
+
+/**
+ * # Single Any
+ *
+ * One node may be selected, regardless of whether the node has children.
+ *
+ * @param isRequired
+ */
+export declare const singleAny: (isRequired?: boolean) => SelectStrategy;

package/dist/composables/lists/select-strategy/single-leaf.d.ts

@@ -0,0 +1,10 @@
+import { SelectStrategy } from '..';
+
+/**
+ * # Single Leaf Select Strategy
+ *
+ * Only one leaf node (items without children) can be selected.
+ *
+ * @param isRequired
+ */
+export declare const singleLeaf: (isRequired?: boolean) => SelectStrategy;

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

@@ -0,0 +1,11 @@
+/**
+ * # Sequenced Position
+ *
+ * Typically applies to requests to move a node within a sequence.
+ *
+ * - 'after' - Position a node after another node as its sibling
+ * - 'before' - Position a node before another node as its sibling
+ * - 'first' - Position a node as the first child in the sequence
+ * - 'last' - Position a node as the last child in the sequence
+ */
+export type SequencedPosition = 'after' | 'before' | 'first' | 'last';

package/dist/composables/locale.d.ts

@@ -0,0 +1,31 @@
+import { TranslationVariables } from '../modules/Translation/Translator.ts';
+import { LocaleManager, LocaleOptions } from '../modules/Locale/LocaleManager.ts';
+import { InjectionKey } from 'vue';
+
+/**
+ * # Locale Symbol
+ */
+export declare const LocaleSymbol: InjectionKey<LocaleManager>;
+/**
+ * # Create Locale Manager
+ * @todo: we need a lot more settings and options.
+ */
+export declare function createLocaleManager(localeOptions: LocaleOptions): LocaleManager;
+/**
+ * # Use Locale Manager
+ */
+export declare function useLocaleManager(): LocaleManager;
+/**
+ * # Use Locale Functions
+ */
+export declare function useLocaleFunctions(): {
+    t: (reference: string, variables?: TranslationVariables, locale?: string) => string | undefined;
+    n: (value: number, options?: Intl.NumberFormatOptions, locale?: string) => string;
+};
+/**
+ *
+ */
+export declare function useRtl(): {
+    isRtl: import('vue').ShallowRef<boolean>;
+    rtlClasses: import('vue').ShallowRef<never[]>;
+};

package/dist/composables/modelProxy.d.ts

@@ -0,0 +1,11 @@
+import { EventProp } from '../util';
+import { Ref } from 'vue';
+
+/**
+ * # Model Proxy
+ */
+export declare function useModelProxy<PropsObject extends object & Partial<{
+    [key in ModelName as `onUpdate:${ModelName}`]: EventProp | undefined;
+}>, ModelName extends Extract<keyof PropsObject, string>, Inner = PropsObject[ModelName]>(props: PropsObject, modelName: ModelName, defaultValue?: PropsObject[ModelName], transformIn?: (modelValue?: PropsObject[ModelName]) => Inner, transformOut?: (modelValue: Inner) => PropsObject[ModelName]): Ref<any> & {
+    readonly externalValue: PropsObject[ModelName];
+};

package/dist/composables/notification.d.ts

@@ -0,0 +1,19 @@
+import { EvNotificationProps, EvNotificationSlots } from '../components';
+import { EvNotificationsManager } from '../components/EvNotifications';
+import { InjectionKey } from 'vue';
+
+export declare const EvNotificationServiceSymbol: InjectionKey<EvNotificationsManager>;
+/**
+ * # injectNotifications
+ */
+export declare function injectNotifications(): EvNotificationsManager;
+/**
+ * # useNotification
+ */
+export declare function useNotification(): {
+    add: (props: EvNotificationProps, slots?: EvNotificationSlots) => {
+        id: number;
+        dismiss: () => void;
+    };
+    dismiss: (id: number) => void;
+};