@caipira/tamandua 0.0.115 → 0.0.117

package/dist/types/components/InputSelect/index.d.ts

@@ -0,0 +1,4 @@
+import { default as InputSelect } from './InputSelect.vue';
+import { default as InputSelectPlugin } from './plugin.js';
+export { InputSelect, InputSelectPlugin };
+export type { InputSelectValue, InputSelectProps, InputSelectOption, InputSelectEvents, } from './types.js';

package/dist/types/components/InputSelect/plugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vue';
+declare const _default: Plugin;
+export default _default;

package/dist/types/components/InputSelect/types.d.ts

@@ -0,0 +1,85 @@
+import { Component } from 'vue';
+import { Pagination } from '../../types/ui.js';
+import { APISearchFilters } from '../../types/api.js';
+import { Icon, FormControlSize, ElementPosition } from '../../enums/ui.js';
+export type SelectValuePrimitives = string | number;
+export type InputSelectValue = SelectValuePrimitives | Array<SelectValuePrimitives>;
+export type InputSelectOption = {
+    /** Optional icon, to be appended to the label */
+    icon?: `${Icon}`;
+    /** Option label, either a string or an object containing the props
+     * necessary to render the option
+     */
+    label: string | object;
+    /** Optional type, used to diferentiate options from one another */
+    type?: string;
+    /**
+     * Optional renderer component
+     */
+    renderer?: Component;
+    /**
+     * Optional props to be passed to the renderer component.
+     */
+    rendererProps?: {
+        [props: string]: any;
+    };
+    /**
+     * Optional events to be passed to the renderer component.
+     */
+    rendererEvents?: {
+        [event: string]: (payload: any) => void;
+    };
+} & ({
+    /** If true, the option is a group label and can't be selected */
+    isGroupLabel: boolean;
+    value?: never;
+    action?: never;
+} | {
+    /** Option value */
+    value: InputSelectValue;
+    action?: never;
+    isGroupLabel?: never;
+} | {
+    /** Action to be executed once the option is selected */
+    action: (filters?: APISearchFilters) => Promise<{
+        items: unknown[];
+        pagination: Pagination;
+    }> | Promise<void> | void;
+    /** If false, the action will not be executed immediately after
+        selection. Default false. */
+    manual?: boolean;
+    value?: never;
+    isGroupLabel?: never;
+});
+export type InputSelectProps = {
+    size?: FormControlSize;
+    options?: InputSelectOption[];
+    /** Mapper to convert search results to InputSelectOption  */
+    mapper?: (i: any) => InputSelectOption;
+    /** Disable component */
+    disabled?: boolean;
+    /** Async function used to fetch options from */
+    resource?: (filters?: APISearchFilters | undefined) => Promise<{
+        items: unknown[];
+        pagination: Pagination;
+    }>;
+    /** Filter function, used to filter the options on search */
+    filter?: (input: string, option: InputSelectOption) => boolean;
+    /** Collection of default params to pass alongside @resource request */
+    defaultParams?: {
+        [props: string]: string;
+    };
+    multiple?: boolean;
+    placeholder?: string;
+    initialValue?: any;
+    /** Indicates whether the user can search the options */
+    isSearchable?: boolean;
+    dropdownPlacement?: `${ElementPosition}`;
+    widthClass?: string;
+    borderClass?: string;
+    roundnessClass?: string;
+};
+export type InputSelectEvents = {
+    (e: "update:model-value", val: any): void;
+    (e: "initial-hydration", val: any): void;
+};

package/dist/types/components/InputSwitch/InputSwitch.story.d.ts

@@ -0,0 +1,27 @@
+import { FormControlSize } from '../../enums/ui.js';
+declare const _default: {
+    title: string;
+    args: {
+        label: string;
+        disabled: boolean;
+        size: FormControlSize;
+    };
+    argTypes: {
+        size: {
+            options: FormControlSize[];
+            control: string;
+        };
+        disabled: {
+            options: boolean[];
+            control: string;
+            description: string;
+        };
+    };
+};
+export default _default;
+export declare const Switch: (args: any) => {
+    setup(): {
+        args: any;
+    };
+    template: string;
+};

package/dist/types/components/InputSwitch/InputSwitch.vue.d.ts

@@ -0,0 +1,39 @@
+import { InputSwitchProps } from './types.js';
+import { FormControlSize } from '../../enums/ui.js';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue', { with: { "resolution-mode": "import" } }).DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<InputSwitchProps>, {
+    label: string;
+    disabled: boolean;
+    size: FormControlSize;
+}>, unknown, unknown, {}, {}, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {
+    "update:model-value": (val: boolean) => void;
+}, string, import('vue', { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import('vue', { with: { "resolution-mode": "import" } }).ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<InputSwitchProps>, {
+    label: string;
+    disabled: boolean;
+    size: FormControlSize;
+}>>> & {
+    "onUpdate:model-value"?: ((val: boolean) => any) | undefined;
+}, {
+    label: string;
+    size: `${FormControlSize}`;
+    disabled: boolean;
+}, {}>;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/InputSwitch/index.d.ts

@@ -0,0 +1,4 @@
+import { default as InputSwitch } from './InputSwitch.vue';
+import { default as InputSwitchPlugin } from './plugin.js';
+export { InputSwitch, InputSwitchPlugin };
+export type { InputSwitchProps, InputSwitchEvents } from './types.js';

package/dist/types/components/InputSwitch/plugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vue';
+declare const _default: Plugin;
+export default _default;

package/dist/types/components/InputSwitch/types.d.ts

@@ -0,0 +1,10 @@
+import { FormControlSize } from '../../enums/ui.js';
+export type InputSwitchProps = {
+    label?: string;
+    disabled?: boolean;
+    modelValue?: boolean;
+    size?: `${FormControlSize}`;
+};
+export type InputSwitchEvents = {
+    (e: "update:model-value", val: boolean): void;
+};

package/dist/types/components/InputText/InputText.story.d.ts

@@ -0,0 +1,21 @@
+import { FormControlSize } from '../../enums/ui.js';
+declare const _default: {
+    title: string;
+    args: {
+        size: FormControlSize;
+        model: string;
+    };
+    argTypes: {
+        size: {
+            options: FormControlSize[];
+            control: string;
+        };
+    };
+};
+export default _default;
+export declare const Text: (args: any) => {
+    setup(): {
+        args: any;
+    };
+    template: string;
+};

package/dist/types/components/InputText/InputText.vue.d.ts

@@ -0,0 +1,67 @@
+import { InputTextProps } from './types.js';
+import { FormControlSize } from '../../enums/ui.js';
+type __VLS_Props = InputTextProps;
+declare const __VLS_defaultModels: {
+    modelValue: string;
+};
+type __VLS_ModelProps = {
+    modelValue?: typeof __VLS_defaultModels['modelValue'];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import('vue', { with: { "resolution-mode": "import" } }).DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_PublicProps>, {
+    size: FormControlSize;
+    type: string;
+    disabled: boolean;
+    readonly: boolean;
+    placeholder: undefined;
+    autocomplete: undefined;
+    /**
+     * Classes
+     * */
+    rootClass: string;
+}>, unknown, unknown, {}, {}, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {
+    "keyup.enter": (val: any) => void;
+    "update:modelValue": (value: string) => void;
+}, string, import('vue', { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import('vue', { with: { "resolution-mode": "import" } }).ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_PublicProps>, {
+    size: FormControlSize;
+    type: string;
+    disabled: boolean;
+    readonly: boolean;
+    placeholder: undefined;
+    autocomplete: undefined;
+    /**
+     * Classes
+     * */
+    rootClass: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onKeyup.enter"?: ((val: any) => any) | undefined;
+}, {
+    type: string;
+    readonly: boolean;
+    size: `${FormControlSize}`;
+    disabled: boolean;
+    placeholder: string;
+    autocomplete: string;
+    rootClass: string;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/InputText/index.d.ts

@@ -0,0 +1,4 @@
+import { default as InputText } from './InputText.vue';
+import { default as InputTextPlugin } from './plugin.js';
+export { InputText, InputTextPlugin };
+export type { InputTextProps, InputTextEvents } from './types.js';

package/dist/types/components/InputText/plugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vue';
+declare const _default: Plugin;
+export default _default;

package/dist/types/components/InputText/types.d.ts

@@ -0,0 +1,16 @@
+import { FormControlSize } from '../../enums/ui.js';
+export type InputTextProps = {
+    size?: `${FormControlSize}`;
+    type?: string;
+    placeholder?: string;
+    autocomplete?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    /**
+     * Classes
+     */
+    rootClass?: string;
+};
+export type InputTextEvents = {
+    (e: "keyup.enter", val: any): void;
+};

package/dist/types/components/InputTextarea/InputTextarea.vue.d.ts

@@ -0,0 +1,41 @@
+import { InputTextareaProps } from './types.js';
+declare const __VLS_export: import('vue', { with: { "resolution-mode": "import" } }).DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<InputTextareaProps>, {
+    type: string;
+    disabled: boolean;
+    placeholder: undefined;
+    disableStyle: boolean;
+}>, unknown, unknown, {}, {}, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {
+    "update:model-value": (val: string) => void;
+}, string, import('vue', { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import('vue', { with: { "resolution-mode": "import" } }).ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<InputTextareaProps>, {
+    type: string;
+    disabled: boolean;
+    placeholder: undefined;
+    disableStyle: boolean;
+}>>> & {
+    "onUpdate:model-value"?: ((val: string) => any) | undefined;
+}, {
+    type: string;
+    disabled: boolean;
+    disableStyle: boolean;
+    placeholder: string;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/InputTextarea/index.d.ts

@@ -0,0 +1,4 @@
+import { default as InputTextarea } from './InputTextarea.vue';
+import { default as InputTextareaPlugin } from './plugin.js';
+export { InputTextarea, InputTextareaPlugin };
+export type { InputTextareaProps, InputTextareaEvents } from './types.js';

package/dist/types/components/InputTextarea/plugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vue';
+declare const _default: Plugin;
+export default _default;

package/dist/types/components/InputTextarea/types.d.ts

@@ -0,0 +1,10 @@
+export type InputTextareaProps = {
+    type?: string;
+    disabled?: boolean;
+    modelValue?: string;
+    placeholder?: string;
+    disableStyle?: boolean;
+};
+export type InputTextareaEvents = {
+    (e: "update:model-value", val: string): void;
+};

package/dist/types/components/Link/Link.story.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    title: string;
+    args: {
+        label: string;
+        href: string;
+    };
+    argTypes: {
+        target: {
+            options: string[];
+            control: string;
+        };
+    };
+};
+export default _default;
+export declare const Link: (args: any) => {
+    setup(): {
+        args: any;
+    };
+    template: string;
+};

package/dist/types/components/Link/Link.vue.d.ts

@@ -0,0 +1,50 @@
+import { LinkProps } from './types.js';
+import { LinkType } from '../../enums/ui.js';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import('vue', { with: { "resolution-mode": "import" } }).DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<LinkProps>, {
+    link: string;
+    type: LinkType;
+    label: string;
+    target: string;
+    disabled: boolean;
+}>, unknown, unknown, {}, {}, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {}, string, import('vue', { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import('vue', { with: { "resolution-mode": "import" } }).ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<LinkProps>, {
+    link: string;
+    type: LinkType;
+    label: string;
+    target: string;
+    disabled: boolean;
+}>>>, {
+    type: `${LinkType}`;
+    label: string;
+    disabled: boolean;
+    target: "_self" | "_blank" | "_parent" | "_top" | "_unfencedTop";
+}, {}>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/Link/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Link } from './Link.vue';
+import { default as LinkPlugin } from './plugin.js';
+export { Link, LinkPlugin };
+export type { LinkProps, LinkEvents } from './types.js';

package/dist/types/components/Link/plugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vue';
+declare const _default: Plugin;
+export default _default;

package/dist/types/components/Link/types.d.ts

@@ -0,0 +1,10 @@
+import { LinkType } from '../../enums/ui.js';
+export type LinkProps = {
+    to?: object;
+    href?: string;
+    type?: `${LinkType}`;
+    label?: string;
+    target?: "_self" | "_blank" | "_parent" | "_top" | "_unfencedTop";
+    disabled?: boolean;
+};
+export type LinkEvents = {};

package/dist/types/components/Modal/Modal.story.d.ts

@@ -0,0 +1,21 @@
+declare const _default: {
+    title: string;
+    args: {};
+};
+export default _default;
+export declare const Modal: (args: any) => {
+    setup(): {
+        args: any;
+        open: import('vue').Ref<boolean>;
+        title: import('vue').Ref<string>;
+        canClose: import('vue').Ref<boolean>;
+        modal: (options: import('./types.js').ModalProps & {
+            onClose?: () => void;
+        }) => void;
+        CustomModalBody: import('vue').Raw<import('vue').DefineComponent<{}, {
+            props: import('@vue/shared').LooseRequired<{} & {}>;
+            emit: (event: string, ...args: any[]) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>>;
+    };
+    template: string;
+};

package/dist/types/components/Modal/Modal.vue.d.ts

@@ -0,0 +1,78 @@
+import { ModalProps } from './types.js';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import('vue', { with: { "resolution-mode": "import" } }).DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ModalProps>, {
+    is: undefined;
+    on: () => {};
+    props: () => {};
+    title: string;
+    canClose: boolean;
+    showHeader: boolean;
+    showFooter: boolean;
+    injectStyle: () => {
+        wrapper: string;
+        body: string;
+        container: string;
+    };
+    hasBackdrop: boolean;
+    disableStyle: boolean;
+}>, unknown, unknown, {}, {}, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import('vue', { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {
+    closed: () => void;
+}, string, import('vue', { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import('vue', { with: { "resolution-mode": "import" } }).ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ModalProps>, {
+    is: undefined;
+    on: () => {};
+    props: () => {};
+    title: string;
+    canClose: boolean;
+    showHeader: boolean;
+    showFooter: boolean;
+    injectStyle: () => {
+        wrapper: string;
+        body: string;
+        container: string;
+    };
+    hasBackdrop: boolean;
+    disableStyle: boolean;
+}>>> & {
+    onClosed?: (() => any) | undefined;
+}, {
+    title: string;
+    props: Record<string, any>;
+    is: import('vue', { with: { "resolution-mode": "import" } }).Component;
+    on: Record<string, (...args: any[]) => void>;
+    canClose: boolean;
+    showHeader: boolean;
+    showFooter: boolean;
+    injectStyle: any;
+    hasBackdrop: boolean;
+    disableStyle: boolean;
+}, {}>, {
+    header?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+} & {
+    footer?: (props: {}) => any;
+}>;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/Modal/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Modal } from './Modal.vue';
+import { default as ModalPlugin } from './plugin.js';
+export { Modal, ModalPlugin };
+export type { ModalProps, ModalEvents } from './types.js';

package/dist/types/components/Modal/plugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vue';
+declare const _default: Plugin;
+export default _default;

package/dist/types/components/Modal/types.d.ts

@@ -0,0 +1,37 @@
+import { Component } from 'vue';
+export type ModalProps = {
+    /**
+     * Component to be rendered inside the modal body
+     */
+    is?: Component;
+    /**
+     * Events to be bound to the body component
+     */
+    on?: Record<string, (...args: any[]) => void>;
+    /**
+     * Body component props
+     */
+    props?: Record<string, any>;
+    /**
+     * Modal title
+     */
+    title?: string;
+    /**
+     * Whether the modal can be closed by the user
+     */
+    canClose?: boolean;
+    /**
+     * Whether to show the header section
+     */
+    showHeader?: boolean;
+    /**
+     * Whether to  show the footer section
+     */
+    showFooter?: boolean;
+    injectStyle?: any;
+    hasBackdrop?: boolean;
+    disableStyle?: boolean;
+};
+export type ModalEvents = {
+    (e: "closed"): void;
+};

package/dist/types/components/ModalForm/ModalForm.story.d.ts

@@ -0,0 +1,34 @@
+import { FormSchema } from '../../types/form.js';
+declare const _default: {
+    title: string;
+    args: {};
+    argTypes: {};
+};
+export default _default;
+export declare const ModalForm: (args: any) => {
+    components: {
+        Form: {
+            setup(): {
+                schema: FormSchema;
+            };
+            emits: string[];
+            name: string;
+            template: string;
+        };
+    };
+    setup(): {
+        args: any;
+        modalForm: import('vue').Ref<any>;
+        onChange: () => void;
+        openForm: () => any;
+        Form: {
+            setup(): {
+                schema: FormSchema;
+            };
+            emits: string[];
+            name: string;
+            template: string;
+        };
+    };
+    template: string;
+};