@propelinc/citrus-ui 1.0.4 → 1.3.0

package/dist/components/CFixedPageFooter.vue.d.ts

@@ -0,0 +1,153 @@
+import { VNode, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentPublicInstance, ComponentOptionsBase, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, DefineComponent, PublicProps } from 'vue';
+import { OnCleanup } from '@vue/reactivity';
+type __VLS_Props = {
+    /** The HTML tag to render as. Avoid changing this if possible. */
+    tag?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => VNode[];
+    }> & {
+        default?: () => VNode[];
+    };
+    refs: {
+        footer: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly tag?: string | undefined;
+                readonly large?: boolean | null | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<{
+                tag?: string;
+                large?: boolean | null;
+            }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+                large: boolean | null;
+                tag: string;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            large: boolean | null;
+            tag: string;
+        }> & Omit<Readonly<{
+            tag?: string;
+            large?: boolean | null;
+        }> & Readonly<{}>, "large" | "tag"> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
+            $slots: Readonly<{
+                default?: () => VNode[];
+            }> & {
+                default?: () => VNode[];
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "change:height": (height: number) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onChange:height"?: ((height: number) => any) | undefined;
+}>, {
+    tag: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    footer: ({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly tag?: string | undefined;
+            readonly large?: boolean | null | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<{
+            tag?: string;
+            large?: boolean | null;
+        }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+            large: boolean | null;
+            tag: string;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        large: boolean | null;
+        tag: string;
+    }> & Omit<Readonly<{
+        tag?: string;
+        large?: boolean | null;
+    }> & Readonly<{}>, "large" | "tag"> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            default?: () => VNode[];
+        }> & {
+            default?: () => VNode[];
+        };
+    }) | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/CForm.vue.d.ts

@@ -0,0 +1,44 @@
+import { VNode, DefineComponent, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface FormValidation {
+    id: string;
+    validate: () => boolean;
+    valid: boolean;
+    field?: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null;
+}
+type __VLS_Props = {
+    dataTest?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => VNode[];
+    }> & {
+        default?: () => VNode[];
+    };
+    refs: {
+        form: HTMLFormElement;
+    };
+    rootEl: HTMLFormElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {
+    validate: () => boolean;
+    inputs: ComputedRef<FormValidation[]>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    input: (value: boolean) => any;
+    submit: (event: Event) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onInput?: ((value: boolean) => any) | undefined;
+    onSubmit?: ((event: Event) => any) | undefined;
+}>, {
+    dataTest: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    form: HTMLFormElement;
+}, HTMLFormElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/CFormFieldCounter.vue.d.ts

@@ -0,0 +1,15 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    /** Sets the denominator of the counter. */
+    counter?: number | null;
+    /** Function or number that determines the numerator of the counter. */
+    counterValue?: number | (() => number | null) | null;
+    /** Input value of the parent form field */
+    value?: string;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    value: string;
+    counter: number | null;
+    counterValue: number | (() => number | null) | null;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/CIconButton.vue.d.ts

@@ -0,0 +1,97 @@
+import { IconDefinition } from '@fortawesome/pro-light-svg-icons';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { RouteLocationRaw } from 'vue-router';
+import { ButtonLevel, ButtonSize, ButtonVariant } from './CButton/types';
+type __VLS_Props = {
+    /** ARIA label for the button. You must use either this or ariaLabelledby. */
+    ariaLabel?: string;
+    /** ARIA labelledby for the button. You must use either this or ariaLabel. */
+    ariaLabelledby?: string;
+    /** Controls whether button is disabled */
+    disabled?: boolean;
+    /** Designates the button as an anchor and applies the href attribute */
+    href?: string;
+    /** Specifies a Font Awesome icon */
+    icon?: string | string[] | IconDefinition;
+    /**
+     * Controls whether button uses the large variant
+     * @deprecated Use `size="large"` instead
+     */
+    large?: boolean;
+    /**
+     * Controls the level of the button
+     * @default 'normal'
+     */
+    level?: ButtonLevel;
+    /** Controls whether button is loading */
+    loading?: boolean;
+    /**
+     * Controls whether button uses the secondary variant
+     * @deprecated Use `variant="secondary"` instead
+     */
+    secondary?: boolean;
+    /**
+     * Controls the size of the button
+     * @default 'medium'
+     */
+    size?: ButtonSize;
+    /** Spins the icon for loading states */
+    spinIcon?: boolean;
+    /** Designates the target attribute. Only use with the href prop. */
+    target?: string;
+    /**
+     * Controls whether button uses the tertiary variant
+     * @deprecated Use `variant="tertiary"` instead
+     */
+    tertiary?: boolean;
+    /** Controls whether button functions as a router-link */
+    to?: RouteLocationRaw;
+    /**
+     * Controls the variant of the button
+     * @default 'primary'
+     */
+    variant?: ButtonVariant;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => VNode[];
+    }> & {
+        default?: () => VNode[];
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    blur: (event: Event) => any;
+    click: (event: MouseEvent) => any;
+    focus: (event: Event) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onBlur?: ((event: Event) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onFocus?: ((event: Event) => any) | undefined;
+}>, {
+    to: RouteLocationRaw;
+    size: ButtonSize;
+    icon: string | string[] | IconDefinition;
+    target: string;
+    tertiary: boolean;
+    loading: boolean;
+    large: boolean;
+    disabled: boolean;
+    ariaLabel: string;
+    secondary: boolean;
+    href: string;
+    level: ButtonLevel;
+    variant: ButtonVariant;
+    ariaLabelledby: string;
+    spinIcon: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/CLabel.vue.d.ts

@@ -0,0 +1,36 @@
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    /** Specifies the label's icon, overwritten if icon slot is used */
+    icon?: string | string[] | IconDefinition | null;
+    /** A custom data test string */
+    dataTest?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Icon slot, overrides icon prop */
+        icon?: () => VNode[];
+        /** Default content */
+        default?: () => VNode[];
+    }> & {
+        /** Icon slot, overrides icon prop */
+        icon?: () => VNode[];
+        /** Default content */
+        default?: () => VNode[];
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    icon: string | string[] | IconDefinition | null;
+    dataTest: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/CListItem.vue.d.ts

@@ -0,0 +1,56 @@
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
+import { RouteLocationRaw } from 'vue-router';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    /** The Font Awesome icon to display */
+    icon?: string | string[] | IconDefinition | null;
+    /** The icon to display on the right side for clickable items, defaulting to right arrow */
+    actionIcon?: string | string[] | IconDefinition | null;
+    /** Color of the icon background */
+    iconColor?: string;
+    /** Emphasized text above body text. Overridden by the default slot. */
+    title?: string;
+    /** Plain body copy. Overridden by the default slot. */
+    label?: string;
+    /** Router location for links within the app */
+    to?: RouteLocationRaw;
+    /** HTML target attribute for links to outside the app */
+    target?: string;
+    /** Location for links to outside the app */
+    href?: string;
+    /** Changes alignment of icon and action icon */
+    align?: 'top' | 'center';
+    /** Overrides default behavior to display a chevron in the action slot */
+    hideAction?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: {}) => any>> & {
+        prepend?(_: {}): any;
+        icon?(_: {}): any;
+        append?(_: {}): any;
+        action?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    label: string;
+    title: string;
+    align: "top" | "center";
+    to: RouteLocationRaw;
+    icon: string | string[] | IconDefinition | null;
+    target: string;
+    href: string;
+    iconColor: string;
+    actionIcon: string | string[] | IconDefinition | null;
+    hideAction: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/CListItemContent.vue.d.ts

@@ -0,0 +1,27 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    title?: string;
+    label?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        title?(_: {}): any;
+        label?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    label: string;
+    title: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/CListItemIcon.vue.d.ts

@@ -0,0 +1,28 @@
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    icon?: string | string[] | IconDefinition | null;
+    iconColor?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        icon?: () => VNode[];
+    }> & {
+        icon?: () => VNode[];
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    icon: string | string[] | IconDefinition | null;
+    iconColor: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/CLoader.vue.d.ts

@@ -0,0 +1,23 @@
+import { HexColor, default as Colors } from '../colors/colors';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type Size = 'sm' | 'md' | 'lg';
+type __VLS_Props = {
+    /** Customizes screen reader only text alternative, should be translated */
+    accessibleText?: string;
+    /** Sets the color of the indicator of the loader */
+    color?: HexColor | keyof typeof Colors;
+    /** @deprecated Shows a smaller version of the loading icon */
+    small?: boolean;
+    /** Sets the size of the loader */
+    size?: Size;
+    /** Sets the color of the track of the loader */
+    trackColor?: HexColor | keyof typeof Colors;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    small: boolean;
+    size: Size;
+    accessibleText: string;
+    color: HexColor | keyof typeof Colors;
+    trackColor: HexColor | keyof typeof Colors;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

package/dist/components/CLogo.vue.d.ts

@@ -0,0 +1,9 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    /** Show just the orange icon */
+    icon?: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    icon: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLImageElement>;
+export default _default;