@quoreadmin/ui 1.4.0 → 1.4.2

package/dist/src/components/list/list.vue.d.ts

@@ -0,0 +1,2 @@
+export * from './list.js';
+export { default } from './list.js';

package/dist/src/components/menu/menu.d.ts

@@ -0,0 +1,120 @@
+export interface MenuItem {
+    text: string;
+    classes: string;
+}
+declare const QMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** is menu visible */
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Menu actions */
+    actions: {
+        type: {
+            (arrayLength: number): MenuItem[];
+            (...items: MenuItem[]): MenuItem[];
+            new (arrayLength: number): MenuItem[];
+            new (...items: MenuItem[]): MenuItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+    };
+    dismissibleOverlay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Menu links */
+    links: {
+        type: {
+            (arrayLength: number): MenuItem[];
+            (...items: MenuItem[]): MenuItem[];
+            new (arrayLength: number): MenuItem[];
+            new (...items: MenuItem[]): MenuItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+    linksBackground: {
+        type: StringConstructor;
+        default: string;
+    };
+    overlay: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click:link" | "click:action")[], "click:link" | "click:action", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** is menu visible */
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Menu actions */
+    actions: {
+        type: {
+            (arrayLength: number): MenuItem[];
+            (...items: MenuItem[]): MenuItem[];
+            new (arrayLength: number): MenuItem[];
+            new (...items: MenuItem[]): MenuItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+    };
+    dismissibleOverlay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Menu links */
+    links: {
+        type: {
+            (arrayLength: number): MenuItem[];
+            (...items: MenuItem[]): MenuItem[];
+            new (arrayLength: number): MenuItem[];
+            new (...items: MenuItem[]): MenuItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+    linksBackground: {
+        type: StringConstructor;
+        default: string;
+    };
+    overlay: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onClick:link"?: ((...args: any[]) => any) | undefined;
+    "onClick:action"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: boolean;
+    overlay: string;
+    dismissibleOverlay: boolean;
+    linksBackground: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default QMenu;

package/dist/src/components/menu/menu.stories.d.ts

@@ -0,0 +1,239 @@
+import { Args, Meta } from '@storybook/vue3';
+declare const meta: Meta<any>;
+export default meta;
+export declare const Primary: {
+    name: string;
+    render: (args: Args) => {
+        components: {
+            QButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                size: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                status: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                hasOutline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                useLoadingSpinner: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isFab: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                shape: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                noMinWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                propsClasses: import('vue').ComputedRef<(string | {
+                    [x: string]: string;
+                    'min-w-min'?: undefined;
+                } | {
+                    'min-w-min': boolean;
+                } | {
+                    [x: string]: boolean;
+                    'min-w-min'?: undefined;
+                })[]>;
+                disabledAttributes: import('vue').ComputedRef<object>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                size: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                status: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                hasOutline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                useLoadingSpinner: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isFab: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                shape: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                noMinWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                size: string;
+                shape: string;
+                disabled: boolean;
+                isWide: boolean;
+                status: string;
+                hasOutline: boolean;
+                loading: boolean;
+                useLoadingSpinner: boolean;
+                isFab: boolean;
+                noMinWidth: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            QMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                modelValue: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                actions: {
+                    type: {
+                        (arrayLength: number): import('./menu').MenuItem[];
+                        (...items: import('./menu').MenuItem[]): import('./menu').MenuItem[];
+                        new (arrayLength: number): import('./menu').MenuItem[];
+                        new (...items: import('./menu').MenuItem[]): import('./menu').MenuItem[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                };
+                dismissibleOverlay: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                links: {
+                    type: {
+                        (arrayLength: number): import('./menu').MenuItem[];
+                        (...items: import('./menu').MenuItem[]): import('./menu').MenuItem[];
+                        new (arrayLength: number): import('./menu').MenuItem[];
+                        new (...items: import('./menu').MenuItem[]): import('./menu').MenuItem[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    required: true;
+                };
+                linksBackground: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                overlay: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click:link" | "click:action")[], "click:link" | "click:action", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                modelValue: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                actions: {
+                    type: {
+                        (arrayLength: number): import('./menu').MenuItem[];
+                        (...items: import('./menu').MenuItem[]): import('./menu').MenuItem[];
+                        new (arrayLength: number): import('./menu').MenuItem[];
+                        new (...items: import('./menu').MenuItem[]): import('./menu').MenuItem[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                };
+                dismissibleOverlay: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                links: {
+                    type: {
+                        (arrayLength: number): import('./menu').MenuItem[];
+                        (...items: import('./menu').MenuItem[]): import('./menu').MenuItem[];
+                        new (arrayLength: number): import('./menu').MenuItem[];
+                        new (...items: import('./menu').MenuItem[]): import('./menu').MenuItem[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    required: true;
+                };
+                linksBackground: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                overlay: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                "onClick:link"?: ((...args: any[]) => any) | undefined;
+                "onClick:action"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                modelValue: boolean;
+                overlay: string;
+                dismissibleOverlay: boolean;
+                linksBackground: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        };
+        setup(this: void): {
+            show: import('vue').Ref<boolean, boolean>;
+            args: Args;
+        };
+        template: string;
+    };
+    args: {
+        links: {
+            text: string;
+            classes: string;
+        }[];
+        linksBackground: string;
+        actions: {
+            text: string;
+        }[];
+    };
+};

package/dist/src/components/menu/menu.vue.d.ts

@@ -0,0 +1,2 @@
+export * from './menu.js';
+export { default } from './menu.js';

package/dist/src/components/modal/modal.d.ts

@@ -0,0 +1,192 @@
+declare const QModal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    closeButtonClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    containerClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    dismissible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dismissibleOverlay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dismissText: {
+        type: StringConstructor;
+        default: string;
+    };
+    overlay: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    showCancelLink: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasBuildingBg: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    onCloseModal: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "close"[], "close", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    closeButtonClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    containerClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    dismissible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dismissibleOverlay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dismissText: {
+        type: StringConstructor;
+        default: string;
+    };
+    overlay: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    showCancelLink: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasBuildingBg: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: string;
+    overlay: string;
+    id: string;
+    dismissibleOverlay: boolean;
+    closeButtonClass: string;
+    containerClass: string;
+    dismissible: boolean;
+    dismissText: string;
+    showCancelLink: boolean;
+    hasBuildingBg: boolean;
+}, {}, {
+    QIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        icon: {
+            type: StringConstructor;
+            required: true;
+        };
+        type: {
+            type: StringConstructor;
+            default: string;
+        };
+        width: {
+            type: NumberConstructor;
+            default: number;
+            required: false;
+        };
+        height: {
+            type: NumberConstructor;
+            default: number;
+            required: false;
+        };
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        color: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        customClass: {
+            type: StringConstructor;
+            default: string;
+        };
+        customSize: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        iconPath: import('vue').ComputedRef<string>;
+        customizedSize: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        icon: {
+            type: StringConstructor;
+            required: true;
+        };
+        type: {
+            type: StringConstructor;
+            default: string;
+        };
+        width: {
+            type: NumberConstructor;
+            default: number;
+            required: false;
+        };
+        height: {
+            type: NumberConstructor;
+            default: number;
+            required: false;
+        };
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        color: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        customClass: {
+            type: StringConstructor;
+            default: string;
+        };
+        customSize: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        type: string;
+        color: string;
+        size: string;
+        height: number;
+        width: number;
+        inline: boolean;
+        customClass: string;
+        customSize: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export type QModalType = typeof QModal;
+export default QModal;