@evance/evance-ui 1.0.0

package/dist/modules/Locale/Localized.d.ts

@@ -0,0 +1,40 @@
+import { Ref } from 'vue/dist/vue';
+
+/**
+ * # Localized
+ */
+export declare class Localized {
+    readonly defaultLocale: Ref<string>;
+    readonly currentLocale: Ref<string>;
+    /**
+     * @param defaultLocale
+     * @param currentLocale
+     */
+    constructor(defaultLocale: Ref<string>, currentLocale: Ref<string>);
+    /**
+     * ## Get Translation Codes
+     *
+     * Returns all the translation codes for the Locale we should use when getting a translatable.
+     * This includes a fallback to our default TranslationCode.
+     *
+     * @param locale
+     */
+    getTranslationCodes(locale: string): string[];
+    /**
+     * ## Set Current Locale
+     *
+     * Set the current locale so that we don't have to use it in each translate call,
+     * unless we want to.
+     *
+     * @param locale
+     */
+    setCurrentLocale(locale: string): void;
+    /**
+     * ## Set Default Locale
+     *
+     * The default locale to use if translations are unavailable for the current locale.
+     *
+     * @param locale
+     */
+    setDefaultLocale(locale: string): void;
+}

package/dist/modules/NumberFormatter.d.ts

@@ -0,0 +1,9 @@
+import { Localized } from './Locale/Localized.ts';
+
+/**
+ * # Number Formatter
+ */
+export declare class NumberFormatter extends Localized {
+    format(value: number, options?: Intl.NumberFormatOptions, locale?: string): string;
+    formatter(options?: Intl.NumberFormatOptions, locale?: string): Intl.NumberFormat;
+}

package/dist/modules/Translation/LanguagePack.d.ts

@@ -0,0 +1,26 @@
+import { PluralizationRules } from './Pluralization.ts';
+import { Translatable } from './Translatable.ts';
+
+/**
+ * # Language Pack
+ */
+export declare class LanguagePack {
+    translationCode: string;
+    data: LanguagePackData;
+    /**
+     * @param translationCode
+     * @param data
+     */
+    constructor(translationCode: string, data?: LanguagePackData);
+    /**
+     * ## Get Translatable
+     * @param reference
+     */
+    getTranslatable(reference: string): Translatable | null;
+}
+/**
+ * # Language Pack Data
+ */
+export interface LanguagePackData {
+    [key: string]: LanguagePackData | PluralizationRules | string;
+}

package/dist/modules/Translation/Pluralization.d.ts

@@ -0,0 +1,30 @@
+/**
+ * # Pluralization
+ *
+ * Pluralization supports cardinal and ordinal values.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules
+ */
+export declare const pluralizationRuleKeys: readonly ["zero", "one", "two", "few", "many", "other"];
+export type PluralizationRuleKey = typeof pluralizationRuleKeys[number];
+export type PluralizationRules = {
+    [K in PluralizationRuleKey]?: string;
+} & {
+    ordinal?: boolean;
+};
+/**
+ * ## Is Pluralization Key
+ *
+ * Determines whether the value supplied represents a valid pluralization rule key.
+ *
+ * @param key
+ */
+export declare function isPluralizationKey(key: any): key is PluralizationRuleKey;
+/**
+ * # Is Pluralization Rules
+ *
+ * Determines whether a value contains an object with pluralization rules within it.
+ *
+ * @param value
+ */
+export declare function isPluralizationRules(value: any): value is PluralizationRules;

package/dist/modules/Translation/Translatable.d.ts

@@ -0,0 +1,21 @@
+import { TranslationVariables } from './Translator.ts';
+import { PluralizationRuleKey, PluralizationRules } from './Pluralization.ts';
+
+/**
+ * # Translatable
+ */
+export declare class Translatable {
+    translationCode: string;
+    reference: string;
+    data: string | PluralizationRules;
+    constructor(translationCode: string, reference: string, data: string | PluralizationRules);
+    get defaultText(): string;
+    get isString(): boolean;
+    get isPluralization(): boolean;
+    getText(rule: PluralizationRuleKey): string | null;
+    /**
+     * ## Translate
+     * @param variables
+     */
+    translate(variables?: TranslationVariables): string | undefined;
+}

package/dist/modules/Translation/TranslationCode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * # Translation Code
+ *
+ * Language Code: ISO 639-1 codes (required)
+ * Country Code: ISO 3166-1 Alpha-2 country code (optional)
+ */
+export declare class TranslationCode {
+    languageCode: string;
+    countryCode: string | null;
+    /**
+     * @param languageCode
+     * @param countryCode
+     */
+    constructor(languageCode: string, countryCode?: string | null);
+    get isRegional(): boolean;
+    /**
+     * ## From String
+     *
+     * Accepts an Evance Locale Code string e.g. 'en-gb'.
+     * But will also accept 'en_GB'.
+     * @param code
+     */
+    static fromString(code: string): TranslationCode;
+    /**
+     * ## To String
+     */
+    toString(): string;
+}

package/dist/modules/Translation/Translator.d.ts

@@ -0,0 +1,77 @@
+import { Localized } from '../Locale/Localized.ts';
+import { LanguagePack, LanguagePackData } from './LanguagePack.ts';
+
+/**
+ * # Translation Options
+ *
+ * When requesting a translation you may supply an object with keys matching
+ * the variable names of the string template within a Language Pack.
+ *
+ * The only reserved key term is `ordinal`, which is reserved for telling the
+ * translator that we should expect an ordinal, not a cardinal translation
+ * from a pluralization rule set.
+ *
+ */
+export type TranslationVariables = {
+    [key: string]: string | number | boolean;
+};
+/**
+ * # Translator
+ */
+export declare class Translator extends Localized {
+    private languagePacks;
+    private translatables;
+    /**
+     * ## Add Language Pack
+     *
+     * The new language pack is added to the beginning of the array of available language packs.
+     * This makes it possible for subsequent language packs to override references.
+     *
+     * @param locale
+     * @param messages
+     */
+    addLanguagePack(locale: string, messages: LanguagePackData): void;
+    /**
+     * ## Get Closest Translatable
+     *
+     * Returns the closest available translatable object matching the reference supplied across all
+     * language packs matching translation codes from the locale, or the default.
+     *
+     * For example if a locale was supplied of "de-de", and our default translations were in "en",
+     * then we would search for language packs "de-de", "de" and "en" in sequence.
+     *
+     * @param locale
+     * @param reference
+     */
+    private getClosestTranslatable;
+    /**
+     * ## Get Language Packs
+     */
+    getLanguagePacks(): LanguagePack[];
+    /**
+     * # Get Language Packs for TranslationCode
+     *
+     * Returns the all available language pack matching the translation code.
+     *
+     * @param translationCode
+     */
+    private getLanguagePacksForTranslationCode;
+    /**
+     * ## Get Translatable
+     *
+     * Returns a translatable item from a language pack matching the supplied translation code.
+     * Returns `null` if either the language pack is unavailable, or if the
+     *
+     * @param translationCode
+     * @param reference
+     */
+    private getTranslatable;
+    /**
+     * ## Translate
+     *
+     * @param locale
+     * @param reference
+     * @param variables
+     */
+    translate(reference: string, variables?: TranslationVariables, locale?: string | undefined): string | undefined;
+}

package/dist/services/dialog.d.ts

@@ -0,0 +1,9 @@
+import { App } from 'vue';
+
+/**
+ * # EvDialogService
+ */
+declare const _default: {
+    install: (app: App) => void;
+};
+export default _default;

package/dist/services/drawer.d.ts

@@ -0,0 +1,9 @@
+import { App } from 'vue';
+
+/**
+ * # EvDialogService
+ */
+declare const _default: {
+    install: (app: App) => void;
+};
+export default _default;

package/dist/services/index.d.ts

@@ -0,0 +1,3 @@
+export { default as EvDialogService } from './dialog.ts';
+export { default as EvDrawerService } from './drawer.ts';
+export { default as EvNotificationService } from './notification.ts';

package/dist/services/notification.d.ts

@@ -0,0 +1,9 @@
+import { App } from 'vue';
+
+/**
+ * # EvNotificationService
+ */
+declare const _default: {
+    install: (app: App) => void;
+};
+export default _default;

package/dist/util/anchor.d.ts

@@ -0,0 +1,62 @@
+import { Axis } from './dimensions.ts';
+
+/**
+ * # Anchors
+ *
+ */
+type VerticalSide = "top" | "bottom";
+type EdgeAlignment = "start" | "end" | "center";
+type HorizontalSide = "left" | "right";
+type SelectorSeparator = " " | "-";
+export type AnchorSelector = VerticalSide | HorizontalSide | `${VerticalSide}${SelectorSeparator}${EdgeAlignment}` | `${HorizontalSide}${SelectorSeparator}${EdgeAlignment}` | 'auto' | `auto${SelectorSeparator}${EdgeAlignment | 'auto'}` | 'center' | `center${SelectorSeparator}center`;
+export type AnchorSide = VerticalSide | HorizontalSide | 'auto' | 'center';
+export type AnchorAlignment = EdgeAlignment | 'auto';
+export type PhysicalAlignment = 'left' | 'right' | 'center';
+export type PhysicalSide = HorizontalSide | VerticalSide;
+/**
+ * # Anchor
+ *
+ * - `alignment`: 'start', 'end', 'center', 'auto'
+ * - `side`: 'top', 'bottom', 'left', 'right', 'center', 'auto'
+ *
+ */
+export declare class Anchor {
+    side: AnchorSide;
+    alignment: AnchorAlignment;
+    constructor(side: AnchorSide, alignment: AnchorAlignment);
+    /**
+     * ## Get Axis
+     * Returns either x or y axis.
+     */
+    get axis(): Axis;
+    /**
+     * ## Physical Alignment
+     */
+    get physicalAlignment(): PhysicalAlignment;
+    /**
+     * ## Center Align
+     */
+    centerAlign(): Anchor;
+    /**
+     * ## Flip Alignment
+     */
+    flipAlignment(): Anchor;
+    /**
+     * ## Flip Corner
+     */
+    flipCorner(): Anchor;
+    /**
+     * ## Flip Side
+     */
+    flipSide(): Anchor;
+    /**
+     * ## Parse Selector
+     * @param selector
+     * @param isRtl
+     * @private
+     */
+    static fromSelector(selector: AnchorSelector, isRtl?: boolean): Anchor;
+    toCssValue(): string;
+    toString(): string;
+}
+export {};

package/dist/util/animate.d.ts

@@ -0,0 +1,38 @@
+/**
+ * # Animate
+ *
+ * We take advantage of the Element interface's animate() method.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/animate
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API/Keyframe_Formats
+ *
+ * @param el The element we wish to animate
+ * @param keyframes The keyframes to use during animation (see the Keyframes format)
+ * @param options An integer duration (in milliseconds), OR an Object containing timing properties
+ */
+export declare function animate(el: Element, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): {
+    readonly finished: Promise<void>;
+} | Animation;
+/**
+ * ## Animate Finished
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/finished
+ */
+export declare const animateFinished: {
+    readonly finished: Promise<void>;
+};
+/**
+ * # Click Blocked Animation
+ * @param el
+ */
+export declare function clickBlockedAnimation(el: HTMLElement | null | undefined): {
+    readonly finished: Promise<void>;
+} | Animation | null;
+/**
+ * Schedule a task to run in an animation frame on its own
+ * This is useful for heavy tasks that may cause jank if all ran together
+ */
+export declare function requestNewFrame(callback: () => void): void;
+export declare const easingStandard = "cubic-bezier(0.4, 0, 0.2, 1)";
+export declare const easingDecelerate = "cubic-bezier(0.0, 0, 0.2, 1)";
+export declare const easingAccelerate = "cubic-bezier(0.4, 0, 1, 1)";

package/dist/util/appearance.d.ts

@@ -0,0 +1,148 @@
+import { GroupItemProvide } from '../composables/groupItem.ts';
+import { MaybeRef, PropType, Ref } from 'vue';
+
+/**
+ * # Appearance
+ *
+ * Default appearance keys for
+ *
+ */
+export declare enum Appearance {
+    default = "default",
+    danger = "danger",
+    information = "information",
+    notice = "notice",
+    primary = "primary",
+    success = "success",
+    warning = "warning"
+}
+export type AppearanceProp = keyof typeof Appearance;
+export declare enum Variant {
+    default = "default",
+    bold = "bold",
+    outlined = "outlined",
+    subtle = "subtle",
+    tonal = "tonal"
+}
+export type VariantProp = keyof typeof Variant;
+export interface AppearanceProps {
+    appearance: AppearanceProp;
+    variant: VariantProp;
+}
+export declare const makeAppearanceProps: <Defaults extends {
+    appearance?: unknown;
+    variant?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    appearance: unknown extends Defaults["appearance"] ? {
+        type: PropType<"default" | "danger" | "information" | "notice" | "primary" | "success" | "warning">;
+        default: Appearance;
+    } : Omit<{
+        type: PropType<"default" | "danger" | "information" | "notice" | "primary" | "success" | "warning">;
+        default: Appearance;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["appearance"] ? "default" | "danger" | "information" | "notice" | "primary" | "success" | "warning" : Defaults["appearance"] | NonNullable<"default" | "danger" | "information" | "notice" | "primary" | "success" | "warning">>;
+        default: unknown extends Defaults["appearance"] ? "default" | "danger" | "information" | "notice" | "primary" | "success" | "warning" : Defaults["appearance"] | NonNullable<"default" | "danger" | "information" | "notice" | "primary" | "success" | "warning">;
+    };
+    variant: unknown extends Defaults["variant"] ? {
+        type: PropType<"default" | "bold" | "outlined" | "subtle" | "tonal">;
+        default: Variant;
+    } : Omit<{
+        type: PropType<"default" | "bold" | "outlined" | "subtle" | "tonal">;
+        default: Variant;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["variant"] ? "default" | "bold" | "outlined" | "subtle" | "tonal" : NonNullable<"default" | "bold" | "outlined" | "subtle" | "tonal"> | Defaults["variant"]>;
+        default: unknown extends Defaults["variant"] ? "default" | "bold" | "outlined" | "subtle" | "tonal" : NonNullable<"default" | "bold" | "outlined" | "subtle" | "tonal"> | Defaults["variant"];
+    };
+};
+/**
+ * # useAppearance
+ *
+ * @param props
+ * @param group
+ * @param isActive
+ * @param defaultVariant
+ */
+export declare function useAppearance(props: MaybeRef<Partial<AppearanceProps>>, group?: GroupItemProvide | null, isActive?: Ref<boolean | undefined> | null, defaultVariant?: string): {
+    appearance: import('vue').ComputedRef<string>;
+    appearanceClass: import('vue').ComputedRef<string | undefined>;
+    variant: import('vue').ComputedRef<string>;
+    variantClass: import('vue').ComputedRef<string | undefined>;
+};
+/**
+ * # Input Appearance
+ */
+export declare enum InputAppearance {
+    default = "default",
+    button = "button",
+    none = "none",
+    subtle = "subtle"
+}
+export type InputAppearanceKey = keyof typeof InputAppearance;
+export type InputAppearanceProp = typeof InputAppearance[InputAppearanceKey];
+export declare const makeInputAppearanceProps: <Defaults extends {
+    appearance?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    appearance: unknown extends Defaults["appearance"] ? {
+        type: PropType<InputAppearanceProp>;
+        default: InputAppearance;
+    } : Omit<{
+        type: PropType<InputAppearanceProp>;
+        default: InputAppearance;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["appearance"] ? InputAppearanceProp : Defaults["appearance"] | NonNullable<InputAppearanceProp>>;
+        default: unknown extends Defaults["appearance"] ? InputAppearanceProp : Defaults["appearance"] | NonNullable<InputAppearanceProp>;
+    };
+};
+/**
+ * # Input Sizes
+ */
+export declare enum InputSize {
+    default = "medium",
+    xSmall = "x-small",
+    small = "small",
+    medium = "medium",
+    large = "large",
+    xLarge = "x-large"
+}
+export type InputSizeCamel = keyof typeof InputSize;
+export type InputSizeKebab = 'x-small' | 'x-large';
+export type InputSizeProp = InputSizeCamel | InputSizeKebab;
+export declare const makeInputSizeProps: <Defaults extends {
+    size?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    size: unknown extends Defaults["size"] ? {
+        type: PropType<InputSizeProp>;
+        default: InputSize;
+    } : Omit<{
+        type: PropType<InputSizeProp>;
+        default: InputSize;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["size"] ? InputSizeProp : Defaults["size"] | NonNullable<InputSizeProp>>;
+        default: unknown extends Defaults["size"] ? InputSizeProp : Defaults["size"] | NonNullable<InputSizeProp>;
+    };
+};
+/**
+ * # Text Align
+ */
+export declare enum TextAlign {
+    default = "left",
+    left = "left",
+    center = "center",
+    right = "right"
+}
+export type TextAlignKey = keyof typeof TextAlign;
+export type TextAlignProp = typeof TextAlign[TextAlignKey];
+export declare const makeTextAlignProps: <Defaults extends {
+    align?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    align: unknown extends Defaults["align"] ? {
+        type: PropType<TextAlignProp>;
+        default: TextAlign;
+    } : Omit<{
+        type: PropType<TextAlignProp>;
+        default: TextAlign;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["align"] ? TextAlignProp : Defaults["align"] | NonNullable<TextAlignProp>>;
+        default: unknown extends Defaults["align"] ? TextAlignProp : Defaults["align"] | NonNullable<TextAlignProp>;
+    };
+};

package/dist/util/array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * # randomArrayItem
+ *
+ * Returns a random element from any array, or `undefined` if the array is empty.
+ *
+ * You can change the value returned if the array is empty by supplying the `emptyValue`.
+ *
+ * @param array
+ * @param emptyValue
+ */
+export declare function randomArrayItem(array: any[], emptyValue?: any): any;

package/dist/util/bindProps.d.ts

@@ -0,0 +1,12 @@
+/**
+ * # Bind Props
+ * @param el
+ * @param props
+ */
+export declare function bindProps(el: HTMLElement, props: Record<string, any>): void;
+/**
+ * # Unbind Props
+ * @param el
+ * @param props
+ */
+export declare function unbindProps(el: HTMLElement, props: Record<string, any>): void;

package/dist/util/browser.d.ts

@@ -0,0 +1,13 @@
+/**
+ * # Browser
+ */
+export declare class Browser {
+    static readonly hasWindow: boolean;
+    static readonly supportsIntersection: boolean;
+    /**
+     * ## Supports Touch
+     * Added into a static getter method to avoid issues during development when switching between emulators.
+     */
+    static get supportsTouch(): boolean;
+    static readonly supportsFocusVisible: boolean;
+}

package/dist/util/children.d.ts

@@ -0,0 +1,24 @@
+import { ComponentInternalInstance, InjectionKey, VNodeChild } from 'vue';
+
+/**
+ * # findChildren
+ *
+ * @param vnode
+ */
+export declare function findChildren(vnode?: VNodeChild): ComponentInternalInstance[];
+/**
+ * # findChildrenWithProvide
+ *
+ * @param key
+ * @param vnode
+ */
+export declare function findChildrenWithProvide(key: InjectionKey<any> | symbol, vnode?: VNodeChild): ComponentInternalInstance[];
+/**
+ * # focusableChildren
+ *
+ * Find children within the supplied `el` we focus to.
+ *
+ * @param el
+ * @param filterByTabIndex
+ */
+export declare function focusableChildren(el: Element, filterByTabIndex?: boolean): HTMLElement[];

package/dist/util/components.d.ts

@@ -0,0 +1,10 @@
+import { ComponentInternalInstance } from 'vue';
+
+/**
+ * # Get Current Component
+ *
+ * Gets the current instance of component from vue.
+ *
+ * @param callee
+ */
+export declare function getCurrentComponent(callee: string): ComponentInternalInstance;

package/dist/util/console.d.ts

@@ -0,0 +1,10 @@
+/**
+ * # Console Warn
+ * @param message
+ */
+export declare function consoleWarn(message: string): void;
+/**
+ * # Console Error
+ * @param message
+ */
+export declare function consoleError(message: string): void;