@xosen/vuetify-grid 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,625 @@
+import { Component } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { DefineComponent } from 'vue';
+import { MaybeRefOrGetter } from 'vue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+
+declare const __VLS_component: DefineComponent<Props, {
+    reload: () => void;
+    refresh: () => void;
+    loadData: () => Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    changed: (args_0: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+    "update:page": (page: number) => any;
+    "update:itemsPerPage": (limit: number) => any;
+    "update:items": (items: any[]) => any;
+    "update:sortBy": (sortBy: any[]) => any;
+}, string, PublicProps, Readonly<Props> & Readonly<{
+    onChanged?: (args_0: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+    "onUpdate:page"?: (page: number) => any;
+    "onUpdate:itemsPerPage"?: (limit: number) => any;
+    "onUpdate:items"?: (items: any[]) => any;
+    "onUpdate:sortBy"?: (sortBy: any[]) => any;
+}>, {
+    itemsPerPageOptions: number[];
+    density: "default" | "comfortable" | "compact";
+    searchable: boolean;
+    refreshable: boolean;
+    filterPersistent: boolean;
+    itemsPerPage: number;
+    sortable: boolean;
+    hover: boolean;
+    mobileBreakpoint: number;
+    actionsOnHover: boolean;
+    paginationTotalVisible: number;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    gridContentRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_2: DefineComponent<Props_2, {
+    reload: () => void;
+    refresh: () => void;
+    loadData: () => Promise<void>;
+    items: Ref<any[], any[]>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    changed: (args_0: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+    "update:search": (search: string) => any;
+    "update:page": (page: number) => any;
+    "update:itemsPerPage": (limit: number) => any;
+    "update:items": (items: any[]) => any;
+}, string, PublicProps, Readonly<Props_2> & Readonly<{
+    onChanged?: (args_0: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+    "onUpdate:search"?: (search: string) => any;
+    "onUpdate:page"?: (page: number) => any;
+    "onUpdate:itemsPerPage"?: (limit: number) => any;
+    "onUpdate:items"?: (items: any[]) => any;
+}>, {
+    itemsPerPageOptions: number[];
+    searchable: boolean;
+    refreshable: boolean;
+    filterPersistent: boolean;
+    itemsPerPage: number;
+    actionsOnHover: boolean;
+    paginationTotalVisible: number;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    listContentRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_3: DefineComponent<XTreeProps, {
+    reload: typeof reload;
+    selectedItem: Ref<any, any>;
+    activeItems: Ref<any[], any[]>;
+    openedItems: Ref<any[], any[]>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    changed: (event: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+    "update:selected": (value: any) => any;
+    "update:opened": (value: any[]) => any;
+}, string, PublicProps, Readonly<XTreeProps> & Readonly<{
+    onChanged?: (event: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+    "onUpdate:selected"?: (value: any) => any;
+    "onUpdate:opened"?: (value: any[]) => any;
+}>, {
+    searchable: boolean;
+    refreshable: boolean;
+    filterPersistent: boolean;
+    itemValue: string;
+    itemTitle: string;
+    itemChildren: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_4: DefineComponent<Props_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:search": (value: string) => any;
+    refresh: () => any;
+}, string, PublicProps, Readonly<Props_5> & Readonly<{
+    "onUpdate:search"?: (value: string) => any;
+    onRefresh?: () => any;
+}>, {
+    loading: boolean;
+    searchable: boolean;
+    refreshable: boolean;
+    filterPersistent: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    searchField: unknown;
+}, HTMLDivElement>;
+
+declare const __VLS_component_5: DefineComponent<Props_7, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props_7> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: any;
+    refs: {
+        gridContentRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_2(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        'toolbar-actions'?(_: {}): any;
+        filter?(_: {}): any;
+        'header-bottom'?(_: {}): any;
+        item?(_: {
+            item: any;
+        }): any;
+        item?(_: {
+            item: any;
+        }): any;
+        'no-data'?(_: {}): any;
+    };
+    refs: {
+        listContentRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_3(): {
+    attrs: Partial<{}>;
+    slots: any;
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_4(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        actions?(_: {}): any;
+        filter?(_: {}): any;
+    };
+    refs: {
+        searchField: unknown;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_5(): {
+    attrs: Partial<{}>;
+    slots: {
+        'header-bottom'?(_: {}): any;
+        item?(_: {
+            item: any;
+        }): any;
+        'no-data'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
+
+declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
+
+declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;
+
+declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_4<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_5<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare interface ActionConfig {
+    text?: string | ((item?: any) => string);
+    icon?: string;
+    type?: 'icon' | 'button';
+    color?: string;
+    disabled?: boolean | ((item?: any) => boolean);
+    visible?: boolean | ((item?: any) => boolean);
+    loading?: boolean;
+    handler?: (item?: any, action?: ActionConfig) => Promise<any> | any;
+    children?: ActionsConfig;
+    top?: boolean;
+    divider?: boolean;
+    fab?: boolean;
+    [key: string]: any;
+}
+
+export declare type ActionsConfig = Record<string, ActionConfig>;
+
+export declare interface CrudGridOptions {
+    onLoad?: (params: LoadParams) => Promise<CrudGridResponse> | CrudGridResponse;
+    onError?: (error: Error) => void;
+    useRouter?: boolean;
+    filterPersistent?: boolean;
+    requiredFilters?: string[];
+    itemsPerPageOptions?: number[];
+    initialItemsPerPage?: number;
+    initialFilter?: Record<string, any>;
+}
+
+export declare interface CrudGridResponse {
+    data: any[];
+    meta: {
+        total: number;
+        [key: string]: any;
+    };
+}
+
+/**
+ * Get all default translations
+ * Useful for integrating with vue-i18n
+ */
+export declare function getDefaultTranslations(): Record<string, string>;
+
+/**
+ * Grid column definition
+ */
+export declare interface GridColumn {
+    key: string;
+    label: string;
+    sortable?: boolean;
+    filterable?: boolean;
+    width?: string | number;
+    align?: 'start' | 'center' | 'end';
+    formatter?: (value: any, row: any) => string;
+}
+
+/**
+ * List schema for creating simple list views without full Vue components
+ *
+ * @example
+ * ```ts
+ * export function useProductsList(): ListSchema {
+ *   const api = useProductsApi();
+ *   const dialog = useDialog();
+ *
+ *   return {
+ *     title: 'Products',
+ *     searchable: true,
+ *     refreshable: true,
+ *     itemsPerPage: 25,
+ *     onLoad: async (params) => {
+ *       const response = await api.getProducts(params);
+ *       return { data: response.data, total: response.total };
+ *     },
+ *     rowActions: {
+ *       edit: { icon: 'mdi-pencil', handler: (item) => dialog.show(productDialog, { id: item.id }) },
+ *       delete: { icon: 'mdi-delete', color: 'error', handler: deleteProduct },
+ *     },
+ *     toolbarActions: {
+ *       create: { text: 'New Product', icon: 'mdi-plus', handler: () => dialog.show(productDialog) },
+ *     },
+ *     itemComponent: ProductListItem,
+ *     noDataText: 'No products found',
+ *   };
+ * }
+ * ```
+ */
+export declare interface ListSchema<TItem = any> {
+    /** List title */
+    title: string;
+    /** Enable search functionality */
+    searchable?: boolean;
+    /** Enable refresh button */
+    refreshable?: boolean;
+    /** Items per page */
+    itemsPerPage?: number;
+    /** Hide pagination controls */
+    hidePagination?: boolean;
+    /** Function to load data */
+    onLoad: (params: {
+        page: number;
+        limit: number;
+        search?: string;
+    }) => Promise<{
+        data: TItem[];
+        meta: {
+            total: number;
+        };
+    }>;
+    /** Row actions configuration */
+    rowActions?: ActionsConfig;
+    /** Toolbar actions configuration */
+    toolbarActions?: ActionsConfig;
+    /** Component to render each item */
+    itemComponent?: Component;
+    /** Props to pass to item component (default: { [itemKey]: item }) */
+    itemProps?: string | ((item: TItem) => Record<string, any>);
+    /** CSS class(es) to apply to item component */
+    itemClass?: string | string[] | Record<string, boolean>;
+    /** Render function for each item (alternative to itemComponent) */
+    itemRender?: (item: TItem) => any;
+    /** No data message */
+    noDataText?: string;
+    /** Error handler */
+    onError?: (error: Error) => void;
+    /** Filter object for reactive filtering */
+    filter?: Record<string, any>;
+    /** Additional XList props */
+    listOptions?: Record<string, any>;
+}
+
+export declare interface LoadParams {
+    page: number;
+    limit: number;
+    sortBy?: string;
+    sortDesc?: boolean;
+    search?: string;
+    [key: string]: any;
+}
+
+declare interface Props {
+    title?: string;
+    hideToolbar?: boolean;
+    searchable?: boolean;
+    refreshable?: boolean;
+    filterPersistent?: boolean;
+    headers?: GridColumn[];
+    items?: any[];
+    sortable?: boolean;
+    hover?: boolean;
+    density?: 'default' | 'comfortable' | 'compact';
+    mobileBreakpoint?: number;
+    rowActions?: Record<string, ActionConfig>;
+    toolbarActions?: Record<string, ActionConfig>;
+    actionsOnHover?: boolean;
+    onLoad?: (params: any) => Promise<{
+        data: any[];
+        meta: {
+            total: number;
+        };
+    }>;
+    onError?: (error: Error) => void;
+    filter?: Record<string, any>;
+    requiredFilters?: string[];
+    itemsPerPage?: number;
+    itemsPerPageOptions?: number[];
+    paginationTotalVisible?: number;
+    hidePagination?: boolean;
+    total?: number;
+}
+
+declare interface Props_2 {
+    title?: string;
+    hideToolbar?: boolean;
+    searchable?: boolean;
+    refreshable?: boolean;
+    filterPersistent?: boolean;
+    items?: any[];
+    rowActions?: Record<string, ActionConfig>;
+    toolbarActions?: Record<string, ActionConfig>;
+    actionsOnHover?: boolean;
+    onLoad?: (params: any) => Promise<{
+        data: any[];
+        meta: {
+            total: number;
+        };
+    }>;
+    onError?: (error: Error) => void;
+    filter?: Record<string, any>;
+    requiredFilters?: string[];
+    itemsPerPage?: number;
+    itemsPerPageOptions?: number[];
+    paginationTotalVisible?: number;
+    hidePagination?: boolean;
+    total?: number;
+    page?: number;
+    search?: string;
+}
+
+declare interface Props_3 {
+    actions?: Record<string, ActionConfig>;
+    item?: any;
+    icon?: boolean;
+    text?: boolean;
+    onError?: (error: Error) => void;
+}
+
+declare interface Props_4 {
+    actions?: Record<string, ActionConfig>;
+    item?: any;
+    icon?: string;
+    text?: string;
+    onError?: (error: Error) => void;
+}
+
+declare interface Props_5 {
+    title?: string;
+    loading?: boolean;
+    searchable?: boolean;
+    refreshable?: boolean;
+    filterPersistent?: boolean;
+    search?: string;
+    searchLabel?: string;
+}
+
+declare interface Props_6 {
+    page: number;
+    pageCount: number;
+    totalVisible?: number;
+    itemsPerPage?: number;
+    itemsPerPageOptions?: number[];
+    total?: number;
+    itemsPerPageText?: string;
+    itemsRangeTextTemplate?: string;
+}
+
+declare interface Props_7 {
+    schema: MaybeRefOrGetter<ListSchema>;
+}
+
+/**
+ * Register custom translations
+ * Useful for adding translations without vue-i18n
+ *
+ * @param translations - Object with translation key-value pairs
+ */
+export declare function registerTranslations(translations: Record<string, string>): void;
+
+declare function reload(): Promise<void>;
+
+export declare const SchemaList: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;
+
+export declare function useActions(options?: UseActionsOptions): {
+    loadingState: Ref<Record<string, boolean>, Record<string, boolean>>;
+    getParam: <T>(param: T | ((item?: any) => T) | undefined, item: any, defaultValue: T) => T;
+    handleActionClick: (action: ActionConfig, item: any | undefined, key: string) => Promise<void>;
+    isActionVisible: (action: ActionConfig, item: any) => boolean;
+    isActionDisabled: (action: ActionConfig, item: any) => boolean;
+    getActionText: (action: ActionConfig, item: any) => string;
+};
+
+export declare interface UseActionsOptions {
+    onError?: (error: Error) => void;
+    defaultHandler?: (item?: any, action?: ActionConfig) => Promise<any> | any;
+}
+
+export declare function useCrudGrid(options?: CrudGridOptions): {
+    loading: Ref<boolean, boolean>;
+    page: Ref<number, number>;
+    limit: Ref<number, number>;
+    sortBy: Ref<any[], any[]>;
+    sortDesc: Ref<boolean, boolean>;
+    searchValue: Ref<string, string>;
+    filterValue: Ref<Record<string, any>, Record<string, any>>;
+    items: Ref<any[], any[]>;
+    total: Ref<number, number>;
+    pageCount: ComputedRef<number>;
+    loadParams: ComputedRef<LoadParams>;
+    itemsPerPageOptions: number[];
+    loadData: () => Promise<void>;
+    reload: () => void;
+    goToFirstPageAndLoad: () => void;
+};
+
+export declare function useSearch(props: {
+    search?: string;
+}, emit: (event: 'update:search', value: string) => void): {
+    searchModel: Ref<string, string>;
+    searchMode: Ref<boolean, boolean>;
+    searchField: Ref<any, any>;
+    clearSearch: () => void;
+    hideSearch: () => void;
+    showSearch: () => Promise<void>;
+};
+
+/**
+ * Lightweight i18n composable for vuetify-shared
+ *
+ * This composable:
+ * 1. Checks if vue-i18n is available in the app
+ * 2. Falls back to default English translations if not
+ * 3. Allows overriding via props
+ *
+ * Usage:
+ * ```ts
+ * const { t } = useTranslation();
+ * const text = t('vuetify-shared.no-items');
+ * ```
+ */
+export declare function useTranslation(): {
+    t: (key: string, params?: Record<string, any> | string, fallback?: string) => string;
+    getLocale: () => string;
+};
+
+export declare const version = "0.0.1";
+
+export declare const XActions: DefineComponent<Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    changed: (args_0: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+}, string, PublicProps, Readonly<Props_3> & Readonly<{
+    onChanged?: (args_0: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+}>, {
+    text: boolean;
+    icon: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+export declare const XGrid: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+export declare const XGridToolbar: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;
+
+export declare const XList: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
+
+export declare const XMenuActions: DefineComponent<Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    changed: (args_0: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+}, string, PublicProps, Readonly<Props_4> & Readonly<{
+    onChanged?: (args_0: {
+        item: any;
+        action: ActionConfig;
+        response: any;
+    }) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const XPagination: DefineComponent<Props_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:page": (page: number) => any;
+    "update:itemsPerPage": (limit: number) => any;
+}, string, PublicProps, Readonly<Props_6> & Readonly<{
+    "onUpdate:page"?: (page: number) => any;
+    "onUpdate:itemsPerPage"?: (limit: number) => any;
+}>, {
+    totalVisible: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const XTree: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
+
+declare interface XTreeProps {
+    title?: string;
+    items?: any[];
+    selected?: any;
+    opened?: any[];
+    itemTitle?: string;
+    itemValue?: string;
+    itemChildren?: string;
+    toolbarActions?: Record<string, ActionConfig>;
+    rowActions?: Record<string, ActionConfig>;
+    searchable?: boolean;
+    refreshable?: boolean;
+    filterPersistent?: boolean;
+    onLoad?: (params: any) => Promise<{
+        data: any[];
+        meta: {
+            total: number;
+        };
+    }>;
+    treeProps?: Record<string, any>;
+    noDataText?: string;
+}
+
+export { }