ia-table 0.9.2 → 0.10.0

package/dist/components/IATable/types/table.type.ts

@@ -0,0 +1,200 @@
+import { CSSProperties, ReactNode, Ref } from "react";
+import {
+  SmartGridColumnDefinition,
+  SmartGridHeaderStyleParams,
+} from "./columns.type";
+import {
+  SmartGridAPI,
+  SmartGridCellValueChangedParams,
+  SmartGridGetRowDataParams,
+  SmartGridRowData,
+} from "./api.type";
+import { SmartGridSortModel } from "./common.type";
+
+export interface SmartGridTableRef {
+  api: SmartGridAPI;
+}
+
+export interface SmartGridRowDragStartParams {
+  api: SmartGridAPI;
+  type: "rowDragStart";
+  rowIndex: number;
+  rowData: SmartGridRowData;
+}
+
+export interface SmartGridRowDragEndParams {
+  api: SmartGridAPI;
+  type: "rowDragEnd";
+  fromIndex: number;
+  toIndex: number;
+  rowData: SmartGridRowData;
+}
+
+export type SmartGridOnReadyParams = {
+  api: SmartGridAPI;
+  columnApi: SmartGridAPI;
+  type: "gridReady";
+};
+
+export type SmartGridRowGrouOpenParams = {
+  rowId: string;
+  rowIndex: number;
+  api: SmartGridAPI;
+  isExpanded: boolean;
+};
+
+export type SmartGridOnSelectionChangedParams = {
+  api: SmartGridAPI;
+  type: string;
+  source: string;
+};
+
+export type SmartGridRowStyleParams = {
+  api: SmartGridAPI;
+  data: SmartGridRowData;
+  pinned: boolean;
+  node: {
+    rowIndex: number;
+    data: SmartGridRowData;
+    api: SmartGridAPI;
+    pinned: boolean;
+  };
+};
+
+export type SmartGridDefaultColDef = {
+  minWidth: number;
+  headerComponentParams?: {
+    innerHeaderComponent:
+      | ((params: SmartGridHeaderStyleParams) => ReactNode)
+      | null;
+  };
+  headerComponent?: ((params: SmartGridHeaderStyleParams) => ReactNode) | null;
+};
+
+export type SmartGridTableProps = {
+  ref?: Ref<SmartGridTableRef>;
+  data?: SmartGridRowData[];
+  columns: SmartGridColumnDefinition[];
+  height?: number | string;
+  uniqueIdField: string;
+  childKeyField?: string;
+  defaultColDef?: SmartGridDefaultColDef;
+  pinnedTopRowData?: SmartGridRowData[];
+  pinnedBottomRowData?: SmartGridRowData[];
+  getRowStyle?: (params: SmartGridRowStyleParams) => CSSProperties;
+  tableHeader?: string | ReactNode;
+  topRightOptions?: string | ReactNode;
+  bottomLeftOptions?: string | ReactNode;
+  bottomCenterOptions?: string | ReactNode;
+  bottomRightOptions?: string | ReactNode;
+  topLeftOptions?: string | ReactNode;
+  headerHeight?: number | string;
+  onSelectionChanged?: (event: SmartGridOnSelectionChangedParams) => void;
+  onRowDragStart?: (event: SmartGridRowDragStartParams) => void;
+  onRowDragEnd?: (event: SmartGridRowDragEndParams) => void;
+  onCellValueChanged?: (params: SmartGridCellValueChangedParams) => void;
+  onGridReady?: (params: SmartGridOnReadyParams) => void;
+  onRowGroupOpened?: (params: SmartGridRowGrouOpenParams) => void;
+  fetchData?: (
+    manualbody: any,
+    page: any,
+    context: any,
+    pageNo: any,
+    other: any
+  ) => Promise<any>;
+  apiUrl?: string;
+  autoFetch?: boolean;
+  cacheConfig?: {
+    threshold?: number;
+    maxBlocksInCache?: number;
+    cacheOverflowSize?: number;
+    rowHeight?: number;
+    purgeStrategy?: string;
+    enablePersistence?: boolean;
+    persistenceStorageKey?: string;
+    persistenceOptions?: any;
+    force?: boolean;
+  };
+  onScroll?: (event: any) => void;
+  showSaveTableConfig?: boolean;
+  loadTableInstance?: (api: SmartGridAPI) => void;
+  adjustTableHeightServerSide?: boolean;
+  largeDatasetOptions?: {
+    enableIndexedDBCache?: boolean;
+    enableStreamingLoad?: boolean;
+    enableEnhancedWorker?: boolean;
+    binaryFormat?: boolean;
+    extremelyLargeDatasetThreshold?: number;
+  };
+  gridOptions?: any;
+  tableId?: string;
+  alignedGrids?: any[];
+  masterDetail?: boolean;
+  detailCellRenderer?: any;
+  detailRowHeight?: number;
+  infiniteScroll?: boolean;
+  customTabFunction?: any;
+  getRowData?: (params: SmartGridGetRowDataParams, columnName: string) => any;
+  rowDragManaged?: boolean;
+  hidePaginationPageSizeSelector?: boolean;
+  purgeClosedRowNodes?: boolean;
+  detailRendererTable?: boolean;
+  smartGridMenuOptions?: {
+    withColumMenu?: boolean;
+    autoWithColumMenu?: boolean;
+    freezeColumnMenu?: boolean;
+    sortColumnMenu?: boolean;
+    collapseColumnAll?: boolean;
+    expandColumnAll?: boolean;
+    wrapText?: boolean;
+    [key: string]: any;
+  };
+  paginateOriginalRowsOnly?: boolean;
+  isSaveViewEnabled?: boolean;
+  isSavingViewLoading?: boolean;
+  maxSavedViews?: number;
+  deleteViewPromptText?: string;
+  savedViewsOptions?: any[];
+  handleSetDefaultView?: (view: any) => void;
+  handleSavedViewClick?: (view: any) => void;
+  handleEditSaveView?: (view: any) => void;
+  handleSaveAndApply?: (view: any) => void;
+  handleDeleteViewClick?: (view: any) => void;
+  rowHeight?: string;
+  additionalButtons?: string | ReactNode;
+  aboveTableComponent?: string | ReactNode;
+  shouldRenderTable?: boolean;
+  nestedTable?: boolean;
+  nestedTableComponent?: Function | ReactNode;
+  enableNestedTableCloseButton?: boolean;
+  downloadAsExcel?: boolean;
+  downloadAsCSV?: boolean;
+  copyToClipboard?: boolean;
+  onCloseNestedTable?: () => void;
+  downloadExcelHandler?: () => void;
+  downloadCSVHandler?: () => void;
+  copyToClipboardHandler?: () => void;
+  ShowFullText?: boolean;
+  hideNotification?: boolean;
+  isSingleSelect?: boolean;
+  defaultPageSize?: number;
+  paginationPageSize?: number[];
+  enableRowSpan?: boolean;
+  rowSpanColumn?: string | string[];
+  showHeader?: boolean;
+  showFooter?: boolean;
+  showToolbar?: boolean;
+  selectable?: boolean;
+  defaultSort?: SmartGridSortModel;
+  actions?: Record<string, any>;
+  pagination?: boolean;
+  showTableSettingActionTab?: boolean;
+  showTableSettingFormatTab?: boolean;
+  showFilters?: boolean;
+  expandable?: boolean;
+  onCellClicked?: () => void;
+  onCellClick?: () => void;
+  onRowClicked?: () => void;
+  onRowClick?: () => void;
+  [key: string]: any;
+};

package/dist/index.d.ts

@@ -1,273 +1,15 @@
-declare module "ia-table" {
-  import { ComponentType, ReactNode, CSSProperties } from "react";
+import { ComponentType } from "react";
+import { SmartGridTableProps } from "./components/IATable/types/table.type";
 
-  export interface Column<T = any> {
-    /** The field name in the row data object */
-    field: string;
-    /** The column header display name */
-    headerName?: string;
-    /** Width of the column */
-    width?: number | string;
-    /** Minimum width of the column */
-    minWidth?: number | string;
-    /** Maximum width of the column */
-    maxWidth?: number | string;
-    /** Whether the column is sortable */
-    sortable?: boolean;
-    /** Whether the column is searchable */
-    isSearchable?: boolean;
-    /** Whether the column is sortable (alternative to sortable) */
-    isSortable?: boolean;
-    /** Whether to show filter for this column */
-    filter?: boolean | string;
-    /** Custom cell renderer - can be a string reference or a function */
-    cellRenderer?:
-      | string
-      | ((params: {
-          value: any;
-          data: T;
-          rowIndex: number;
-          column: Column<T>;
-        }) => ReactNode);
-    /** Custom header renderer */
-    headerRenderer?: (params: {
-      column: Column<T>;
-      sortDirection?: "asc" | "desc" | null;
-      onSort?: (field: string, direction: "asc" | "desc") => void;
-    }) => ReactNode;
-    /** Custom CSS class for the column */
-    className?: string;
-    /** Custom CSS styles for the column */
-    style?: CSSProperties;
-    /** Whether the column is resizable */
-    resizable?: boolean;
-    /** Whether the column is pinned */
-    pinned?: "left" | "right";
-    /** Allow any additional properties to be added to the column definition */
-    [key: string]: any;
-  }
+// Export all types from the types folder
+export * from "./components/IATable/types/index.type";
 
-  export interface TableProps<T = any> {
-    /** Array of column definitions */
-    columns: Array<Column<T>>;
-    /** Array of row data objects */
-    data?: T[];
-    /** Height of the table (e.g., '100%', 500) */
-    height?: number | string;
-    /** uniqueIdField */
-    uniqueIdField?: string;
-    /** childKeyField */
-    childKeyField?: string;
-    /** Default column definition for all columns */
-    defaultColDef?: {
-      minWidth: number;
-      [key: string]: any;
-    };
-    /** Array of row data to pin at the top */
-    pinnedTopRowData?: T[];
-    /** Array of row data to pin at the bottom */
-    pinnedBottomRowData?: T[];
-    /** Custom header content to display at the top-left corner */
-    tableHeader?: string | ReactNode;
-    /** Custom options to display at the top-right corner */
-    topRightOptions?: string | ReactNode;
-    /** Custom options to display at the bottom-left corner */
-    bottomLeftOptions?: string | ReactNode;
-    /** Custom options to display at the bottom-center */
-    bottomCenterOptions?: string | ReactNode;
-    /** Custom options to display at the bottom-right corner */
-    bottomRightOptions?: string | ReactNode;
-    /** Custom options to display at the top-left corner */
-    topLeftOptions?: string | ReactNode;
-    aboveTableComponent?: string | ReactNode;
-    shouldRenderTable?: boolean;
-    /** Height of each row in pixels or 'default' */
-    rowHeight?: number | string;
-    /** Height of the header row in pixels */
-    headerHeight?: number;
-    /** Custom CSS class for the table */
-    className?: string;
-    /** Custom CSS styles for the table */
-    style?: CSSProperties;
-    /** Whether to show column headers */
-    showHeader?: boolean;
-    /** Whether to show a loading overlay */
-    loading?: boolean;
-    /** Custom loading component or text */
-    loadingOverlayComponent?: ReactNode | string;
-    /** Custom no rows overlay component or text */
-    noRowsOverlayComponent?: ReactNode | string;
-    /** Whether to enable pagination */
-    pagination?: boolean;
-    /** Callback when a row is clicked */
-    onRowClick?: (
-      rowData: T,
-      rowIndex: number,
-      event: React.MouseEvent
-    ) => void;
-    /** Callback when a row is double-clicked */
-    onRowDoubleClick?: (
-      rowData: T,
-      rowIndex: number,
-      event: React.MouseEvent
-    ) => void;
-    /** Callback when sort changes */
-    onSortChanged?: (
-      sortModel: {
-        field: string;
-        sort: "asc" | "desc" | null;
-      }[]
-    ) => void;
-    /** Callback when filter changes */
-    onFilterChanged?: (filterModel: {
-      [field: string]: {
-        filterType: string;
-        type: string;
-        filter: any;
-      };
-    }) => void;
-    /** Callback when rows are selected */
-    onSelectionChanged?: (selectedRows: T[]) => void;
-    /** Callback when cell value changes */
-    onCellValueChanged?: (params: {
-      field: string;
-      newValue: any;
-      oldValue: any;
-      data: T;
-    }) => void;
-    /** Callback when grid is ready */
-    onGridReady?: (params: { api: any; columnApi: any }) => void;
-    /** Callback when row group is opened */
-    onRowGroupOpened?: (params: { node: any }) => void;
-    /** Function to fetch data from server */
-    fetchData?: (
-      manualbody: any,
-      page: any,
-      context: any,
-      page: any,
-      other: any
-    ) => Promise<any>;
-    /** API URL for server-side operations */
-    apiUrl?: string;
-    /** Whether to automatically fetch data on mount */
-    autoFetch?: boolean;
-    /** Cache configuration for large datasets */
-    cacheConfig?: {
-      threshold?: number;
-      maxBlocksInCache?: number;
-      cacheOverflowSize?: number;
-      rowHeight?: number;
-      purgeStrategy?: string;
-      enablePersistence?: boolean;
-      persistenceStorageKey?: string;
-      persistenceOptions?: any;
-      force?: boolean;
-    };
-    /** Callback for scroll events */
-    onScroll?: (event: any) => void;
-    /** Whether to show save table config option */
-    showSaveTableConfig?: boolean;
-    /** Function to receive the API instance */
-    loadTableInstance?: (api: any) => void;
-    /** Whether to adjust table height in server-side mode */
-    adjustTableHeightServerSide?: boolean;
-    /** Advanced options for extremely large datasets */
-    largeDatasetOptions?: {
-      enableIndexedDBCache?: boolean;
-      enableStreamingLoad?: boolean;
-      enableEnhancedWorker?: boolean;
-      binaryFormat?: boolean;
-      extremelyLargeDatasetThreshold?: number;
-    };
-    /** Additional grid options */
-    gridOptions?: any;
-    /** Unique identifier for this grid instance */
-    tableId?: string;
-    /** Array of grid IDs or refs to align with */
-    alignedGrids?: any[];
-    /** Enable master-detail functionality */
-    masterDetail?: boolean;
-    /** Custom renderer for detail content */
-    detailCellRenderer?: any;
-    /** Height of detail rows */
-    detailRowHeight?: number;
-    /** Whether to enable infinite scrolling */
-    infiniteScroll?: boolean;
-    /** Custom tab navigation function */
-    customTabFunction?: any;
-    /** Function to get row data */
-    getRowData?: (params: any, columnName: string) => any;
-    /** Whether to enable row drag management */
-    rowDragManaged?: boolean;
-    /** Whether to hide pagination page size selector */
-    hidePaginationPageSizeSelector?: boolean;
-    /** Whether to purge closed row nodes */
-    purgeClosedRowNodes?: boolean;
-    /** Whether this is a detail renderer table */
-    detailRendererTable?: boolean;
-    /** Options for smart grid menu */
-    smartGridMenuOptions?: {
-      withColumMenu?: boolean;
-      autoWithColumMenu?: boolean;
-      freezeColumnMenu?: boolean;
-      sortColumnMenu?: boolean;
-      collapseColumnAll?: boolean;
-      expandColumnAll?: boolean;
-      wrapText?: boolean;
-      [key: string]: any;
-    };
-    /** Whether to paginate original rows only */
-    paginateOriginalRowsOnly?: boolean;
-    /** Whether save view is enabled */
-    isSaveViewEnabled?: boolean;
-    /** Whether saving view is loading */
-    isSavingViewLoading?: boolean;
-    /** Maximum number of saved views */
-    maxSavedViews?: number;
-    /** Text for delete view prompt */
-    deleteViewPromptText?: string;
-    /** Options for saved views */
-    savedViewsOptions?: any[];
-    /** Function to handle setting default view */
-    handleSetDefaultView?: (view: any) => void;
-    /** Function to handle saved view click */
-    handleSavedViewClick?: (view: any) => void;
-    /** Function to handle edit save view */
-    handleEditSaveView?: (view: any) => void;
-    /** Function to handle save and apply */
-    handleSaveAndApply?: (view: any) => void;
-    /** Function to handle delete view click */
-    handleDeleteViewClick?: (view: any) => void;
-    /** Additional buttons to display */
-    additionalButtons?: any;
-    /** Whether to enable row selection */
-    rowSelection?: "single" | "multiple" | false;
-    /** Key field for row selection (default: 'id') */
-    rowKeyField?: string;
-    /** Custom row class name */
-    getRowClassName?: (params: { rowData: T; rowIndex: number }) => string;
-    /** Custom row style */
-    getRowStyle?: (params: { rowData: T; rowIndex: number }) => CSSProperties;
-    /** Default page size for pagination */
-    defaultPageSize?: number;
-    /** Page size options for pagination */
-    paginationPageSize?: number[];
-    /** Default sort configuration */
-    defaultSort?: { field: string; direction: "asc" | "desc" };
-    /** Whether to enable row spanning */
-    enableRowSpan?: boolean;
-    /** Column to use for row spanning */
-    rowSpanColumn?: string;
-    /** Actions for the table */
-    actions?: Record<string, any>;
-    /** Whether to show toolbar */
-    showToolbar?: boolean;
-    /** Whether rows are selectable */
-    selectable?: boolean;
-    /** Allow any additional properties */
-    [key: string]: any;
-  }
-
-  const IATable: ComponentType<TableProps>;
-  export default IATable;
+// SVG module declarations for library consumers
+declare module "*.svg" {
+  import React from "react";
+  const SVGComponent: React.FC<React.SVGProps<SVGSVGElement>>;
+  export default SVGComponent;
 }
+
+declare const IATable: ComponentType<SmartGridTableProps>;
+export default IATable;