@gradient-ui/core 0.2.0 → 0.4.0

package/dist/types/components/ui/GTable/GTable.vue.d.ts

@@ -0,0 +1,143 @@
+import { type GTableCellContext, type GTableKey, type GTableRowEvent, type GTableRowContext, type GTableRowAttrs } from './types';
+declare const _default: <T extends Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{
+        loading: boolean;
+        caption: string;
+        rounded: boolean;
+        color: string;
+        variant: import("../../../use/variant").GVariant;
+        expanded: GTableKey[];
+        ariaLabel: string;
+        striped: boolean;
+        hover: boolean;
+        items: Record<string, unknown>[];
+        density: import("./types").GTableDensity;
+        headers: import("./types").GTableHeader<Record<string, unknown>>[];
+        itemKey: import("./types").GTableItemKey<Record<string, unknown>>;
+        stickyHeader: boolean;
+        fixedLayout: boolean;
+        clickableRows: boolean;
+        bordered: boolean;
+        hideHeader: boolean;
+        hideCaption: boolean;
+        ariaLabelledby: string;
+        loadingRows: number;
+        emptyText: string;
+        elevation: boolean;
+        showExpand: boolean;
+        singleExpand: boolean;
+        expandOnRowClick: boolean;
+        spans: import("./types").GTableCellSpan<Record<string, unknown>>[];
+        cellProps: ((context: GTableCellContext<Record<string, unknown>>) => import("./types").GTableCellAttrs | void) | undefined;
+        rowProps: ((context: GTableRowContext<Record<string, unknown>>) => GTableRowAttrs | void) | undefined;
+        headerProps: ((header: import("./types").GTableHeader<Record<string, unknown>>, index: number) => import("./types").GTableCellAttrs | void) | undefined;
+    }> & Omit<{
+        readonly loading: boolean;
+        readonly caption: string;
+        readonly rounded: boolean;
+        readonly color: string;
+        readonly variant: import("../../../use/variant").GVariant;
+        readonly expanded: GTableKey[];
+        readonly ariaLabel: string;
+        readonly striped: boolean;
+        readonly hover: boolean;
+        readonly items: Record<string, unknown>[];
+        readonly density: import("./types").GTableDensity;
+        readonly headers: import("./types").GTableHeader<Record<string, unknown>>[];
+        readonly itemKey: import("./types").GTableItemKey<Record<string, unknown>>;
+        readonly stickyHeader: boolean;
+        readonly fixedLayout: boolean;
+        readonly clickableRows: boolean;
+        readonly bordered: boolean;
+        readonly hideHeader: boolean;
+        readonly hideCaption: boolean;
+        readonly ariaLabelledby: string;
+        readonly loadingRows: number;
+        readonly emptyText: string;
+        readonly elevation: boolean;
+        readonly showExpand: boolean;
+        readonly singleExpand: boolean;
+        readonly expandOnRowClick: boolean;
+        readonly spans: import("./types").GTableCellSpan<Record<string, unknown>>[];
+        readonly cellProps: (context: GTableCellContext<Record<string, unknown>>) => import("./types").GTableCellAttrs | void;
+        readonly rowProps: (context: GTableRowContext<Record<string, unknown>>) => GTableRowAttrs | void;
+        readonly headerProps: (header: import("./types").GTableHeader<Record<string, unknown>>, index: number) => import("./types").GTableCellAttrs | void;
+        readonly onExpand?: ((item: T, expanded: boolean) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: GTableKey[]) => any) | undefined;
+        readonly "onRow-click"?: ((item: T, event: GTableRowEvent) => any) | undefined;
+        readonly "onCell-click"?: ((context: GTableCellContext<T>, event: MouseEvent) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "loading" | "caption" | "rounded" | "color" | "variant" | "expanded" | "ariaLabel" | "striped" | "hover" | "items" | "density" | "headers" | "itemKey" | "stickyHeader" | "fixedLayout" | "clickableRows" | "bordered" | "hideHeader" | "hideCaption" | "ariaLabelledby" | "loadingRows" | "emptyText" | "elevation" | "showExpand" | "singleExpand" | "expandOnRowClick" | "spans" | "cellProps" | "rowProps" | "headerProps">, "onExpand" | "onUpdate:expanded" | "onRow-click" | "onCell-click" | ("loading" | "caption" | "rounded" | "color" | "variant" | "expanded" | "ariaLabel" | "striped" | "hover" | "items" | "density" | "headers" | "itemKey" | "stickyHeader" | "fixedLayout" | "clickableRows" | "bordered" | "hideHeader" | "hideCaption" | "ariaLabelledby" | "loadingRows" | "emptyText" | "elevation" | "showExpand" | "singleExpand" | "expandOnRowClick" | "spans" | "cellProps" | "rowProps" | "headerProps")> & Partial<{}> & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        header: import("./types").GTableHeader<T>;
+        index: number;
+    }) => any>> & Partial<Record<string, (_: {
+        item: Record<string, unknown>;
+        header: import("./types").GTableHeader<Record<string, unknown>>;
+        value: unknown;
+        rowIndex: number;
+        columnIndex: number;
+        headers: import("./types").GTableHeader<Record<string, unknown>>[];
+    }) => any>> & {
+        top?(_: {}): any;
+        caption?(_: {}): any;
+        header?(_: {
+            header: import("./types").GTableHeader<T>;
+            index: number;
+        }): any;
+        header?(_: {
+            header: import("./types").GTableHeader<T>;
+            index: number;
+        }): any;
+        body?(_: {
+            columnCount: number;
+            classes: import("./types").GTableBodySlotClasses;
+            getCellContext: (item: Record<string, unknown>, header: import("./types").GTableHeader<Record<string, unknown>>, rowIndex: number, columnIndex: number) => GTableCellContext<Record<string, unknown>>;
+            getRowContext: (item: Record<string, unknown>, index: number) => GTableRowContext<Record<string, unknown>>;
+            headers: import("./types").GTableHeader<Record<string, unknown>>[];
+            items: Record<string, unknown>[];
+        }): any;
+        loading?(_: {}): any;
+        empty?(_: {}): any;
+        row?(_: {
+            headers: import("./types").GTableHeader<Record<string, unknown>>[];
+            item: Record<string, unknown>;
+            index: number;
+            key: GTableKey;
+            expanded: boolean;
+            toggleExpanded: () => void;
+        }): any;
+        expand?(_: {
+            item: Record<string, unknown>;
+            index: number;
+            key: GTableKey;
+            expanded: boolean;
+            toggleExpanded: () => void;
+        }): any;
+        item?(_: {
+            item: Record<string, unknown>;
+            header: import("./types").GTableHeader<Record<string, unknown>>;
+            value: unknown;
+            rowIndex: number;
+            columnIndex: number;
+            headers: import("./types").GTableHeader<Record<string, unknown>>[];
+        }): any;
+        "expanded-row"?(_: {
+            headers: import("./types").GTableHeader<Record<string, unknown>>[];
+            item: Record<string, unknown>;
+            index: number;
+            key: GTableKey;
+            expanded: boolean;
+            toggleExpanded: () => void;
+        }): any;
+        bottom?(_: {}): any;
+    };
+    emit: ((evt: "expand", item: T, expanded: boolean) => void) & ((evt: "update:expanded", value: GTableKey[]) => void) & ((evt: "row-click", item: T, event: GTableRowEvent) => void) & ((evt: "cell-click", context: GTableCellContext<T>, event: MouseEvent) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GTable/GTableBody.vue.d.ts

@@ -0,0 +1,69 @@
+declare const _default: <T extends Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Partial<{}> & {
+        hasRows: boolean;
+        loading?: boolean;
+        loadingRows?: number;
+        emptyText?: string;
+        showExpand?: boolean;
+        hasExpandedRowSlot?: boolean;
+    }> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        item: T;
+        header: import("./types.js").GTableHeader<T>;
+        value: unknown;
+        rowIndex: number;
+        columnIndex: number;
+        headers: import("./types.js").GTableHeader<T>[];
+    }) => any>> & {
+        body?(_: {
+            columnCount: number;
+            classes: import("./types.js").GTableBodySlotClasses;
+            getCellContext: (item: T, header: import("./types.js").GTableHeader<T>, rowIndex: number, columnIndex: number) => import("./types.js").GTableCellContext<T>;
+            getRowContext: (item: T, index: number) => import("./types.js").GTableRowContext<T>;
+            headers: import("./types.js").GTableHeader<T>[];
+            items: T[];
+        }): any;
+        loading?(_: {}): any;
+        empty?(_: {}): any;
+        row?(_: {
+            headers: import("./types.js").GTableHeader<T>[];
+            item: T;
+            index: number;
+            key: import("./types.js").GTableKey;
+            expanded: boolean;
+            toggleExpanded: () => void;
+        }): any;
+        expand?(_: {
+            item: T;
+            index: number;
+            key: import("./types.js").GTableKey;
+            expanded: boolean;
+            toggleExpanded: () => void;
+        }): any;
+        item?(_: {
+            item: T;
+            header: import("./types.js").GTableHeader<T>;
+            value: unknown;
+            rowIndex: number;
+            columnIndex: number;
+            headers: import("./types.js").GTableHeader<T>[];
+        }): any;
+        "expanded-row"?(_: {
+            headers: import("./types.js").GTableHeader<T>[];
+            item: T;
+            index: number;
+            key: import("./types.js").GTableKey;
+            expanded: boolean;
+            toggleExpanded: () => void;
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GTable/GTableCell.vue.d.ts

@@ -0,0 +1,35 @@
+import type { GTableHeader } from './types';
+declare const _default: <T extends Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Partial<{}> & {
+        item: T;
+        header: GTableHeader<T>;
+        rowIndex: number;
+        columnIndex: number;
+    }> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        item: T;
+        header: GTableHeader<T>;
+        value: unknown;
+        rowIndex: number;
+        columnIndex: number;
+        headers: GTableHeader<T>[];
+    }) => any>> & {
+        item?(_: {
+            item: T;
+            header: GTableHeader<T>;
+            value: unknown;
+            rowIndex: number;
+            columnIndex: number;
+            headers: GTableHeader<T>[];
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GTable/GTableExpandedRow.vue.d.ts

@@ -0,0 +1,25 @@
+declare const _default: <T extends Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Partial<{}> & {
+        item: T;
+        rowIndex: number;
+    }> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        "expanded-row"?(_: {
+            headers: import("./types").GTableHeader<T>[];
+            item: T;
+            index: number;
+            key: import("./types").GTableKey;
+            expanded: boolean;
+            toggleExpanded: () => void;
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GTable/GTableHead.vue.d.ts

@@ -0,0 +1,30 @@
+import type { GTableCellAttrs, GTableHeader } from './types';
+declare const _default: <T extends Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Partial<{}> & {
+        headers: GTableHeader<T>[];
+        showExpand?: boolean;
+        getHeaderStyle: (header: GTableHeader<T>) => Record<string, string | undefined>;
+        getHeaderAlign: (header: GTableHeader<T>) => string;
+        getHeaderAttrs: (header: GTableHeader<T>, index: number) => GTableCellAttrs;
+        getColumnFixedAttrs: (header: GTableHeader<T>, index: number) => GTableCellAttrs;
+        getHeaderSlotName: (header: GTableHeader<T>) => string;
+    }> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        header: GTableHeader<T>;
+        index: number;
+    }) => any>> & {
+        header?(_: {
+            header: GTableHeader<T>;
+            index: number;
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GTable/GTableRow.vue.d.ts

@@ -0,0 +1,40 @@
+declare const _default: <T extends Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Partial<{}> & {
+        item: T;
+        rowIndex: number;
+        showExpand?: boolean;
+    }> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        item: T;
+        header: import("./types.js").GTableHeader<T>;
+        value: unknown;
+        rowIndex: number;
+        columnIndex: number;
+        headers: import("./types.js").GTableHeader<T>[];
+    }) => any>> & {
+        expand?(_: {
+            item: T;
+            index: number;
+            key: import("./types.js").GTableKey;
+            expanded: boolean;
+            toggleExpanded: () => void;
+        }): any;
+        item?(_: {
+            item: T;
+            header: import("./types.js").GTableHeader<T>;
+            value: unknown;
+            rowIndex: number;
+            columnIndex: number;
+            headers: import("./types.js").GTableHeader<T>[];
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GTable/context.d.ts

@@ -0,0 +1,25 @@
+import { type ComputedRef } from 'vue';
+import type { GTableAlign, GTableBodySlotClasses, GTableCellAttrs, GTableCellContext, GTableHeader, GTableKey, GTableRowEvent, GTableRowAttrs, GTableRowContext } from './types';
+export interface GTableContext<T extends Record<string, unknown>> {
+    headers: ComputedRef<GTableHeader<T>[]>;
+    items: ComputedRef<T[]>;
+    columnCount: ComputedRef<number>;
+    rowInteractive: ComputedRef<boolean>;
+    bodySlotClasses: GTableBodySlotClasses;
+    getItemKey: (item: T, index: number) => GTableKey;
+    getRowContext: (item: T, index: number) => GTableRowContext<T>;
+    getRowAttrs: (item: T, index: number) => GTableRowAttrs;
+    getCellContext: (item: T, header: GTableHeader<T>, rowIndex: number, columnIndex: number) => GTableCellContext<T>;
+    getCellAttrs: (context: GTableCellContext<T>) => GTableCellAttrs;
+    getColumnFixedAttrs: (header: GTableHeader<T>, index: number) => GTableCellAttrs;
+    getAlign: (header: GTableHeader<T>) => GTableAlign;
+    getItemSlotName: (header: GTableHeader<T>) => string;
+    isRowExpanded: (item: T, index: number) => boolean;
+    shouldRenderExpandedRow: (item: T, index: number) => boolean;
+    onExpandedAfterLeave: (item: T, index: number) => void;
+    toggleExpanded: (item: T, index: number) => void;
+    onRowClick: (item: T, index: number, event: GTableRowEvent) => void;
+    onCellClick: (context: GTableCellContext<T>, event: MouseEvent) => void;
+}
+export declare const provideTableContext: <T extends Record<string, unknown>>(context: GTableContext<T>) => void;
+export declare const useTableContext: <T extends Record<string, unknown>>() => GTableContext<T>;

package/dist/types/components/ui/GTable/index.d.ts

@@ -0,0 +1,3 @@
+export { default as GTable } from './GTable.vue';
+export { default } from './GTable.vue';
+export type { GTableAlign, GTableBodySlotClasses, GTableBodySlotContext, GTableCellAttrs, GTableCellContext, GTableCellSpan, GTableDensity, GTableEmits, GTableHeader, GTableItemKey, GTableKey, GTableProps, GTableRowAttrs, GTableRowContext, GTableSlots } from './types';