@zeedhi/teknisa-components-common 1.37.0 → 1.41.0

package/types/components/tek-grid/grid.d.ts

@@ -1,5 +1,5 @@
 import { GridEditable, IComponentRender } from '@zeedhi/common';
-import { IDictionary } from '@zeedhi/core';
+import { Datasource, IDictionary } from '@zeedhi/core';
 import { TekGridColumn } from './grid-column';
 import { ITekGrid, ITekGridColumn, ITekGridEvents, ITekGridExportConfig } from './interfaces';
 export declare class TekGrid extends GridEditable implements ITekGrid {
@@ -43,7 +43,6 @@ export declare class TekGrid extends GridEditable implements ITekGrid {
      * Export config
      */
     exportConfig: ITekGridExportConfig[];
-    private exportConfigButtons;
     /**
      * Actions to overwrite the default export config
      */
@@ -63,35 +62,21 @@ export declare class TekGrid extends GridEditable implements ITekGrid {
     private toolbarSlotProps;
     viewUpdateScrollData?: () => void;
     viewUpdateFixedColumns?: () => void;
+    private gridBase;
+    filterRelationsDatasource: Datasource;
+    filterOperationsDatasource: Datasource;
     /**
      * TekGrid class constructor
      * @param props TekGrid properties
      */
     constructor(props: ITekGrid);
-    private getExportConfigButtons;
     onCreated(): void;
     /**
      * Get Grid columns objects
      * @param columns Grid columns parameter
      */
     protected getColumns(columns: ITekGridColumn[]): TekGridColumn[];
-    private createToolbarProps;
-    private saveChanges;
-    private cancelChanges;
-    private addButtonClick;
-    private deleteButtonClick;
-    private reloadGrid;
-    private filterClick;
-    private filterModal?;
-    private createFilterFromColumns;
-    hideFilterModal(): void;
-    private getFilterModalComponents;
-    private loadFilterValues;
-    private applyFilter;
     columnHasFilterData(column: TekGridColumn): any;
-    filterRelationsDatasource: any;
-    filterOperationsDatasource: any;
-    private getFilterOptionsData;
     private buildReportGroups;
     private buildReportAggregations;
     getReport(type: string, portrait?: boolean, rowObj?: any): Promise<Window | null>;
@@ -140,4 +125,12 @@ export declare class TekGrid extends GridEditable implements ITekGrid {
      * @param element DOM Element
      */
     groupRowClick(row: IDictionary<any>, event: Event, element: HTMLElement): void;
+    /**
+     * Dispatches group select/unselect event
+     * @param row Group row
+     * @param isSelected Row is selected
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    selectGroupClick(row: IDictionary<any>, isSelected: boolean, event: Event, element: HTMLElement): void;
 }

package/types/components/tek-grid/interfaces.d.ts

@@ -18,6 +18,8 @@ export interface ITekGridEvents<T = IEventParam<any> | ITekGridLayoutEventParams
     loadLayouts?: ITekGridEvent<T>;
     saveLayouts?: IEvent<T>;
     groupRowClick?: IEvent<T>;
+    groupSelect?: IEvent<T>;
+    groupUnselect?: IEvent<T>;
     [key: string]: any;
 }
 export declare type ITekGridLayoutOptionsEvent<T> = (event: T) => Promise<any>;
@@ -67,7 +69,7 @@ export declare const columnAggregationValues: ["SUM", "MIN", "MAX", "AVG", "COUN
 export declare type ITekGridColumnAggregation = (typeof columnAggregationValues)[number];
 export interface ITekGridLayoutColumn {
     name: string;
-    width: string;
+    width?: string;
     minWidth?: string;
     maxWidth?: string;
     isVisible?: boolean;
@@ -77,6 +79,7 @@ export interface ITekGridLayoutColumn {
     label?: string;
     align?: 'left' | 'right' | 'center';
     groupOpened?: boolean;
+    filterHelperValue?: string | IDictionary<any>;
 }
 export interface ITekGridLayoutOptions extends IComponentRender {
     events?: ITekGridLayoutOptionsEvents;
@@ -86,6 +89,8 @@ export declare type IFilterOperation = 'CONTAINS' | 'NOT_CONTAINS' | 'EQUALS' |
 export interface IFilterPropsComponent extends IComponent {
     relation?: IFilterRelation;
     operation?: IFilterOperation;
+    helperOptions?: string[];
+    helperValue?: string;
 }
 export interface ITekGridColumn extends IGridColumnEditable {
     filterProps?: IFilterPropsComponent | IFilterPropsComponent[];
@@ -98,6 +103,7 @@ export interface ITekGridColumn extends IGridColumnEditable {
     storeData?: boolean;
 }
 export interface ITekGridColumnsButton extends IIterableColumnsButton {
+    hideGroups?: boolean;
 }
 export interface ITekGridGroup {
     column: ITekGridColumn;
@@ -118,6 +124,7 @@ export interface ITekGridGroupHeader {
     groupValue: any;
     groupOpened: boolean;
     groupHeaders: ITekGridGroupHeader[];
+    children: IDictionary<any>[];
 }
 export interface ITekGridFooter {
     [key: string]: ITekGridSummary;
@@ -128,3 +135,10 @@ export interface ITekGridSummary {
     min: any;
     max: any;
 }
+export interface ITekFilterHelperValue {
+    label: string;
+    fn: () => Date | [Date, Date];
+}
+export interface ITekFilterHelperValues {
+    [key: string]: ITekFilterHelperValue;
+}

package/types/components/tek-grid/layout-options.d.ts

@@ -1,6 +1,6 @@
 import { ComponentRender, Grid } from '@zeedhi/common';
 import { IDictionary } from '@zeedhi/core';
-import { IDynamicFilterItem } from '..';
+import { IDynamicFilterItem, ITekGridLayoutColumn } from '..';
 import { ITekGridLayoutOptions, ITekGridLayout, ITekGridLayoutOptionsEvents } from './interfaces';
 export declare class TekGridLayoutOptions extends ComponentRender implements ITekGridLayoutOptions {
     currentLayoutName: string;
@@ -8,7 +8,7 @@ export declare class TekGridLayoutOptions extends ComponentRender implements ITe
     layouts: IDictionary<ITekGridLayout>;
     layoutNames: string[];
     viewApplyLayout?: Function;
-    originalColumnProps: IDictionary<any>[];
+    originalColumnProps: ITekGridLayoutColumn[];
     originalDatasourceOrder: string[];
     originalDatasourceDynamicFilter: IDictionary<IDynamicFilterItem[]>;
     originalDatasourceFilter: IDictionary<any>;
@@ -16,6 +16,7 @@ export declare class TekGridLayoutOptions extends ComponentRender implements ITe
     grid: Grid;
     private getParentGrid;
     onMounted(element: HTMLElement): Promise<void>;
+    getHelperValue(column: any): string | (string | undefined)[] | undefined;
     newLayout(newLayout: ITekGridLayout): void;
     applyLayout(name: string, save?: boolean): void;
     private saveLayouts;

package/types/components/tek-loading/interfaces.d.ts

@@ -0,0 +1,6 @@
+import { IComponentRender } from '@zeedhi/common';
+export interface ILoading extends IComponentRender {
+    text?: string;
+    zIndex?: number | string;
+    image?: string;
+}

package/types/components/tek-loading/loading.d.ts

@@ -0,0 +1,24 @@
+import { ComponentRender } from '@zeedhi/common';
+import { ILoading } from './interfaces';
+/**
+ * Teknisa component
+ */
+export declare class Loading extends ComponentRender implements ILoading {
+    /**
+    * text to show in Loader Overlay
+    */
+    text: string;
+    /**
+    * zIndex value.
+    */
+    zIndex: number | string;
+    /**
+    * loading path.
+    */
+    image: string;
+    /**
+    * Creates a new instance of TekLoading
+    * @param props Image Link props
+    */
+    constructor(props: ILoading);
+}

package/types/components/tek-tree-grid/interfaces.d.ts

@@ -0,0 +1,19 @@
+import { IComponentRender, ITreeGridEditable } from '@zeedhi/common';
+import { ITekGridColumn, ITekGridEvents, ITekGridExportConfig } from '..';
+export interface ITekTreeGrid extends ITreeGridEditable {
+    actions?: IComponentRender[];
+    addButton?: boolean;
+    columnFilterButton?: boolean;
+    columns?: ITekGridColumn[];
+    columnsButton?: boolean;
+    columnsButtonIgnore?: string[];
+    deleteButton?: 'none' | 'currentRow' | 'selection';
+    events?: ITekGridEvents;
+    filterButton?: boolean;
+    showLayoutOptions?: boolean;
+    title?: string;
+    showExport?: boolean;
+    showReload?: boolean;
+    exportConfig?: ITekGridExportConfig[];
+    exportActions?: IComponentRender[];
+}

package/types/components/tek-tree-grid/tree-grid.d.ts

@@ -0,0 +1,76 @@
+import { IComponentRender, TreeGridEditable } from '@zeedhi/common';
+import { Datasource, IDictionary } from '@zeedhi/core';
+import { TekGridColumn } from '../tek-grid/grid-column';
+import { ITekGrid, ITekGridColumn, ITekGridEvents, ITekGridExportConfig } from '../tek-grid/interfaces';
+import { ITekTreeGrid } from './interfaces';
+export declare class TekTreeGrid extends TreeGridEditable implements ITekTreeGrid {
+    title: string;
+    addButton: boolean;
+    deleteButton: 'none' | 'currentRow' | 'selection';
+    actions: IComponentRender[];
+    filterButton: boolean;
+    columnFilterButton: boolean;
+    columnsButton: boolean;
+    columnsButtonIgnore: string[];
+    events: ITekGridEvents;
+    /**
+     * Enables column dragging
+     * @public
+     */
+    dragColumns: boolean;
+    /**
+     * Enables column resizing
+     * @public
+     */
+    resizeColumns: boolean;
+    /**
+     * Enables layout saving
+     * @public
+     */
+    showLayoutOptions: boolean;
+    /**
+     * Editable columns
+     */
+    columns: TekGridColumn[];
+    /**
+     * Show export button
+     */
+    showExport: boolean;
+    /**
+     * Show refresh button
+     */
+    showReload: boolean;
+    /**
+     * Export config
+     */
+    exportConfig: ITekGridExportConfig[];
+    /**
+     * Actions to overwrite the default export config
+     */
+    exportActions?: IComponentRender[];
+    private toolbarSlotProps;
+    private gridBase;
+    filterRelationsDatasource: Datasource;
+    filterOperationsDatasource: Datasource;
+    /**
+     * TekTreeGrid class constructor
+     * @param props TekTreeGrid properties
+     */
+    constructor(props: ITekGrid);
+    onCreated(): void;
+    /**
+     * Get Grid columns objects
+     * @param columns Grid columns parameter
+     */
+    protected getColumns(columns: ITekGridColumn[]): TekGridColumn[];
+    columnHasFilterData(column: TekGridColumn): any;
+    getReport(type: string, portrait?: boolean, rowObj?: any): Promise<Window | null>;
+    setSearch(search: string): Promise<any>;
+    /**
+     * Dispatches row click event
+     * @param row Grid row
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    rowClick(row: IDictionary<any>, event: Event, element: HTMLElement): void;
+}

package/types/utils/grid-base/grid-base.d.ts

@@ -0,0 +1,267 @@
+import { IButton } from '@zeedhi/common';
+import { IEventParam } from '@zeedhi/core';
+import { TekGrid, TekTreeGrid } from '../../components';
+export declare class GridBase {
+    private grid;
+    private exportConfigButtons;
+    constructor(grid: TekGrid | TekTreeGrid);
+    private getExportConfigButtons;
+    createToolbarProps(): ({
+        name: string;
+        component: string;
+        cssClass: string;
+        tag: string;
+        text: string;
+        title: string;
+        cssStyle?: undefined;
+        isVisible?: undefined;
+        children?: undefined;
+        label?: undefined;
+        small?: undefined;
+        events?: undefined;
+        outline?: undefined;
+        bottom?: undefined;
+    } | {
+        name: string;
+        component: string;
+        cssClass?: undefined;
+        tag?: undefined;
+        text?: undefined;
+        title?: undefined;
+        cssStyle?: undefined;
+        isVisible?: undefined;
+        children?: undefined;
+        label?: undefined;
+        small?: undefined;
+        events?: undefined;
+        outline?: undefined;
+        bottom?: undefined;
+    } | {
+        name: string;
+        component: string;
+        tag: string;
+        cssStyle: string;
+        isVisible: string;
+        children: ({
+            name: string;
+            component: string;
+            label: string;
+            bottom: boolean;
+            children: {
+                name: string;
+                component: string;
+                icon: boolean;
+                iconName: string;
+                isVisible: string;
+                events: {
+                    click: ({ event }: IEventParam<any>) => void;
+                };
+            }[];
+            cssClass?: undefined;
+            vertical?: undefined;
+            isVisible?: undefined;
+            offsetY?: undefined;
+            activator?: undefined;
+        } | {
+            name: string;
+            component: string;
+            label: string;
+            bottom: boolean;
+            children: {
+                name: string;
+                component: string;
+                icon: boolean;
+                iconName: string;
+                isVisible: string;
+                disabled: string;
+                events: {
+                    click: ({ event }: IEventParam<any>) => void;
+                };
+            }[];
+            cssClass?: undefined;
+            vertical?: undefined;
+            isVisible?: undefined;
+            offsetY?: undefined;
+            activator?: undefined;
+        } | {
+            name: string;
+            component: string;
+            cssClass: string;
+            vertical: boolean;
+            isVisible: string;
+            label?: undefined;
+            bottom?: undefined;
+            children?: undefined;
+            offsetY?: undefined;
+            activator?: undefined;
+        } | {
+            name: string;
+            component: string;
+            label: string;
+            bottom: boolean;
+            children: {
+                name: string;
+                component: string;
+                icon: boolean;
+                iconName: string;
+                isVisible: boolean;
+                events: {
+                    click: () => void;
+                };
+            }[];
+            cssClass?: undefined;
+            vertical?: undefined;
+            isVisible?: undefined;
+            offsetY?: undefined;
+            activator?: undefined;
+        } | {
+            name: string;
+            component: string;
+            label: string;
+            bottom: boolean;
+            children: {
+                name: string;
+                component: string;
+                isVisible: string;
+                iterableComponentName: string;
+                hideGroups: boolean;
+                ignoreColumns: string;
+            }[];
+            cssClass?: undefined;
+            vertical?: undefined;
+            isVisible?: undefined;
+            offsetY?: undefined;
+            activator?: undefined;
+        } | {
+            name: string;
+            component: string;
+            isVisible: string;
+            label?: undefined;
+            bottom?: undefined;
+            children?: undefined;
+            cssClass?: undefined;
+            vertical?: undefined;
+            offsetY?: undefined;
+            activator?: undefined;
+        } | {
+            name: string;
+            component: string;
+            cssClass: string;
+            offsetY: boolean;
+            activator: {
+                name: string;
+                component: string;
+                icon: boolean;
+                iconName: string;
+                isVisible: string;
+            };
+            children: IButton[] | import("@zeedhi/common").IComponentRender[];
+            label?: undefined;
+            bottom?: undefined;
+            vertical?: undefined;
+            isVisible?: undefined;
+        } | {
+            name: string;
+            component: string;
+            cssClass: string;
+            vertical: boolean;
+            label?: undefined;
+            bottom?: undefined;
+            children?: undefined;
+            isVisible?: undefined;
+            offsetY?: undefined;
+            activator?: undefined;
+        })[];
+        cssClass?: undefined;
+        text?: undefined;
+        title?: undefined;
+        label?: undefined;
+        small?: undefined;
+        events?: undefined;
+        outline?: undefined;
+        bottom?: undefined;
+    } | {
+        name: string;
+        component: string;
+        label: string;
+        isVisible: string;
+        small: boolean;
+        events: {
+            click: ({ event }: IEventParam<any>) => void;
+        };
+        cssClass?: undefined;
+        tag?: undefined;
+        text?: undefined;
+        title?: undefined;
+        cssStyle?: undefined;
+        children?: undefined;
+        outline?: undefined;
+        bottom?: undefined;
+    } | {
+        name: string;
+        component: string;
+        label: string;
+        outline: boolean;
+        cssClass: string;
+        isVisible: string;
+        small: boolean;
+        events: {
+            click: ({ event }: IEventParam<any>) => void;
+        };
+        tag?: undefined;
+        text?: undefined;
+        title?: undefined;
+        cssStyle?: undefined;
+        children?: undefined;
+        bottom?: undefined;
+    } | {
+        name: string;
+        component: string;
+        label: string;
+        bottom: boolean;
+        children: {
+            name: string;
+            component: string;
+            icon: boolean;
+            iconName: string;
+            isVisible: string;
+            events: {
+                click: ({ event }: any) => void;
+            };
+        }[];
+        cssClass?: undefined;
+        tag?: undefined;
+        text?: undefined;
+        title?: undefined;
+        cssStyle?: undefined;
+        isVisible?: undefined;
+        small?: undefined;
+        events?: undefined;
+        outline?: undefined;
+    })[];
+    private addButtonClick;
+    private deleteButtonClick;
+    private reloadGrid;
+    private saveChanges;
+    private cancelChanges;
+    private filterClick;
+    private filterModal?;
+    private createFilterFromColumns;
+    hideFilterModal(): void;
+    private getFilterModalComponents;
+    private getHelperValueComponent;
+    private createHelperValueOptions;
+    private helperValuesOptionClick;
+    private setFilterPropsHelperValue;
+    private registerFilterComponentToForm;
+    private clearFilterHelperValue;
+    private loadFilterValues;
+    private applyFilter;
+    getFilterRelationsDatasource(): any;
+    getFilterOperationsDatasource(): any;
+    getFilterOptionsData(prop: string): {
+        text: string;
+        value: string;
+    }[];
+    setSearch(search: string): Promise<any>;
+}

package/types/utils/grid-base/grid-controller.d.ts

@@ -0,0 +1,20 @@
+import { TekGrid } from '../../components/tek-grid/grid';
+import { TekTreeGrid } from '../../components/tek-tree-grid/tree-grid';
+export declare class GridController {
+    private grid;
+    constructor(grid: TekGrid | TekTreeGrid);
+    get gridTitle(): string;
+    get showAddButton(): boolean;
+    get showDeleteButton(): boolean;
+    get showFilterButton(): boolean;
+    get showColumnsButton(): boolean;
+    get columnsButtonIgnore(): string[];
+    get showLayoutOptions(): boolean;
+    get showFirstDivider(): boolean;
+    get showActionsButton(): boolean;
+    get showExportButton(): boolean;
+    get showActionAndExportButton(): boolean;
+    get isEditing(): boolean;
+    get isNotEditing(): boolean;
+    get disableDeleteButton(): boolean;
+}

package/types/utils/index.d.ts

@@ -1,2 +1,4 @@
 import { ReportFilter } from './report-filter/report-filter';
-export { ReportFilter };
+import { GridBase } from './grid-base/grid-base';
+import { GridController } from './grid-base/grid-controller';
+export { ReportFilter, GridBase, GridController };