ia-table 0.9.2 → 0.10.0

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

@@ -0,0 +1,272 @@
+// SmartGrid API Type Definitions
+
+import {
+  SmartGridInfiniteCache,
+  SmartGridInfiniteRowModel,
+} from "./cache.type";
+import { SmartGridColumnDefinition } from "./columns.type";
+import {
+  SmartGridFilterModel,
+  SmartGridRowNode,
+  SmartGridSortDirection,
+  SmartGridSortModel,
+  SmartGridUpdateData,
+} from "./common.type";
+import { SmartGridStateContext } from "./reducer.type";
+
+export type SmartGridModelType = "normal" | "serverSide" | "infinite";
+
+export type SmartGridPinnedType = "left" | "right" | null;
+
+export type SmartGridFloatingType = "top" | "bottom" | null;
+
+export interface SmartGridRowData {
+  [key: string]: unknown;
+  id?: string | number;
+  isChildRow?: boolean;
+  isChildGroup?: boolean;
+  childIndex?: number;
+  groupingLevel?: number;
+  level?: number;
+  parentRowIndex?: number;
+  parentRowData?: SmartGridRowData;
+  __parentPath?: string;
+  _rowHeight?: number;
+  _isPinnedTop?: boolean;
+  _isPinnedBottom?: boolean;
+  __isAggregationRow?: boolean;
+  __parentId?: string | number;
+}
+
+export interface SmartGridColumnState {
+  colId: string;
+  hide: boolean;
+  width: number;
+  sort: SmartGridSortDirection | null;
+  filter: SmartGridFilterModel | null;
+}
+
+export interface SmartGridPaginationModel {
+  currentPage: number;
+  pageSize: number;
+  totalPages: number;
+  totalRecords: number;
+}
+
+export interface SmartGridDisplayedRowNode extends SmartGridRowNode {
+  rowIndex: number;
+  absoluteRowIndex: number;
+  originalData: SmartGridRowData;
+  rowHeight?: number;
+}
+
+export interface SmartGridCacheState {
+  blockCount: number;
+  cache?: SmartGridInfiniteCache;
+  lastRowKnown: boolean;
+  rowCount: number;
+  status: string;
+}
+
+export interface SmartGridTableModel {
+  getData: () => SmartGridRowData[];
+  modelRef?: {
+    current?: SmartGridInfiniteRowModel;
+  };
+  infiniteCache: SmartGridInfiniteCache | null;
+  getColumnDefs: () => SmartGridColumnDefinition[];
+  getSortModel: () => SmartGridSortModel[];
+  getFilterModel: () => SmartGridFilterModel;
+  getType: () => SmartGridModelType;
+  getRowsToDisplay: () => number;
+  forEachNode: (
+    callback: (node: SmartGridRowNode, index: number) => void
+  ) => void;
+  getRowNode: (id: string | number) => SmartGridRowNode | null;
+  getSelectedRows: () => SmartGridRowData[];
+  getPaginationModel: () => SmartGridPaginationModel;
+  getColumnState: () => SmartGridColumnState[];
+  rowsToDisplay: SmartGridRowData[];
+}
+
+export interface SmartGridDisplayedColumn {
+  colDef: SmartGridColumnDefinition;
+  colId: string;
+  getColId: () => string;
+  isVisible: () => boolean;
+  isPinned: () => SmartGridPinnedType;
+  label: string;
+}
+
+export interface SmartGridSelectedCell {
+  colIndex: number;
+  column: SmartGridColumnDefinition;
+  data: SmartGridRowData;
+  field: string;
+  rowId: string | number;
+  rowIndex: number;
+  value: unknown;
+}
+
+export interface SmartGridFocusedCell extends SmartGridSelectedCell {
+  floating: SmartGridFloatingType;
+}
+
+export interface SmartGridRefreshOptions {
+  purge?: boolean;
+  resetPage?: boolean;
+  userInitiated?: boolean;
+}
+
+export interface SmartGridNotification {
+  message: string;
+  type?: "success" | "error" | "warning" | "info";
+  duration?: number;
+}
+
+export interface SmartGridParamsNode {
+  rowIndex: number;
+  data: SmartGridRowData;
+  api: SmartGridAPI;
+}
+
+export interface SmartGridDisplayedRowAtIndex {
+  data: SmartGridRowData;
+  rowIndex: number;
+  node: SmartGridParamsNode;
+  api: SmartGridAPI;
+}
+
+export interface SmartGridCachedBlockData {
+  [blockId: string]: SmartGridRowData[];
+}
+
+export interface SmartGridCellValueChangedParams {
+  colDef: SmartGridColumnDefinition;
+  column: SmartGridColumnDefinition;
+  data: SmartGridRowData;
+  newValue: unknown;
+  node: {
+    data: SmartGridRowData;
+    id: string | number;
+    level: number;
+    parent?: SmartGridUpdateData;
+    rowIndex: number;
+  };
+  value: unknown;
+}
+
+export interface SmartGridCheckConfiguration {
+  checkedRows?: string[];
+  unCheckedRows?: string[];
+  checkAll?: boolean;
+  searchColumns?: {
+    [key: string]: SmartGridFilterModel[];
+  };
+  unCheckAll?: boolean;
+}
+export interface SmartGridOptions {
+  [key: string]: unknown;
+}
+
+export interface SmartGridGetRowDataParams {
+  data: SmartGridRowData;
+  rowIndex: number;
+  node: SmartGridParamsNode;
+  api: SmartGridAPI;
+}
+export interface SmartGridDisptach {
+  type: string;
+  payload?: unknown;
+}
+
+export interface SmartGridAPI {
+  getInfiniteRowModel: () => SmartGridInfiniteRowModel | null;
+  getInfiniteCache: () => SmartGridInfiniteCache | null;
+  getModel: () => SmartGridTableModel;
+  onCellValueChanged: (params: SmartGridCellValueChangedParams) => void;
+  getPrevAction: () => string;
+  setPrevAction: (value: string) => void;
+  getCheckConfiguration: () => SmartGridCheckConfiguration[];
+  setCheckConfiguration: (config: SmartGridCheckConfiguration[]) => void;
+  addToCheckConfiguration: (item: SmartGridCheckConfiguration) => void;
+  getIsSelectAllRecords: () => boolean;
+  setIsSelectAllRecords: (value: boolean) => void;
+  getSelectedRows: () => SmartGridRowData[];
+  setSelectedRows: (rowIds: (string | number)[]) => void;
+  clearSelection: () => void;
+  selectAll: () => void;
+  refreshCells: () => void;
+  getCache: () => SmartGridInfiniteCache | null;
+  getCacheState: () => SmartGridCacheState | null;
+  getInfiniteCacheInstance: () => SmartGridInfiniteCache | undefined;
+  refreshServerSideStore: (options?: SmartGridRefreshOptions) => void;
+  getCachedBlockData: () => SmartGridCachedBlockData;
+  logCacheSummary: () => void | null;
+  getCachedRowById: (id: string | number) => SmartGridRowData | null;
+  getRowNode: (key: string | number) => Partial<SmartGridRowNode>;
+  setVisibleRange: (startRow: number, endRow: number) => void;
+  refreshCache: (options?: SmartGridRefreshOptions) => boolean;
+  deselectAll: () => void;
+  getRenderedNodes: () => SmartGridDisplayedRowNode[];
+  gridOptionsWrapper: {
+    gridOptions: SmartGridOptions;
+  };
+  getDisplayedRowAtIndex: (
+    index: number,
+    wholeData?: SmartGridRowData[],
+    api?: Partial<SmartGridAPI>
+  ) => SmartGridDisplayedRowAtIndex | null;
+  getTableWidth: () => number;
+  sizeColumnsToFit: () => void;
+  setRowData: (newData: SmartGridRowData[]) => boolean | void;
+  forEachNode: (
+    callback: (node: SmartGridRowNode, index: number) => void
+  ) => void;
+  getColumnDefs: () => SmartGridColumnDefinition[];
+  getAllColumns: () => SmartGridColumnDefinition[];
+  setColumnDefs: (newColumns: SmartGridColumnDefinition) => void;
+  addEventListener: (event: string, listener: Function) => void;
+  removeEventListener: (event: string, listener: Function) => void;
+  getPinnedTopRow: () => SmartGridRowData[] | null;
+  setPinnedTopRowData: (rows: SmartGridRowData[]) => void;
+  getPinnedBottomRow: () => SmartGridRowData[] | null;
+  setPinnedBottomRowData: (rows: SmartGridRowData[]) => void;
+  getRowData: (
+    params: SmartGridGetRowDataParams,
+    columnName: string
+  ) => string | number | boolean;
+  tableId: string;
+  getFocusedCell: () => SmartGridFocusedCell | null;
+  getSelectedCells: () => SmartGridSelectedCell[];
+  getAllDisplayedColumns: () => SmartGridDisplayedColumn[];
+  getDisplayedRowCount: () => number;
+  setFocusedCell: (
+    rowIndex: number,
+    colKey: SmartGridColumnDefinition | string | number,
+    floating?: SmartGridFloatingType
+  ) => boolean;
+  ensureColumnVisible: (
+    colKey: SmartGridColumnDefinition | string | number
+  ) => boolean;
+  getColumnByField: (fieldName: string) => SmartGridColumnDefinition | null;
+  getTableInstance: () =>
+    | {
+        current?: HTMLElement;
+      }
+    | undefined;
+  getFilterModel: () => SmartGridFilterModel;
+  setFilterModel: (field: string, rules: SmartGridFilterModel) => void;
+  getTableDispatcher: () => (action: SmartGridDisptach) => void;
+  getTableStateContext: () => SmartGridStateContext;
+  showNotification: (notification: SmartGridNotification) => void;
+  hideNotification: () => void;
+  applySearch: () => void;
+  getCurrentPageData: () => SmartGridRowData[];
+  getWholeTableData: () => SmartGridRowData[];
+  flashCells: () => void;
+  redrawRows: () => void;
+  refreshClientSideRowModel: () => void;
+  resetRecentSearchChanges: () => void;
+  onFilterChanged: () => void;
+}

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

@@ -0,0 +1,65 @@
+import { SmartGridRowData } from "./api.type";
+
+export type SmartGridCacheAnalytics = {
+  blockEvictions: number;
+  blockLoadTimestamps: number[];
+  blockLoads: number;
+  bytesLoaded: number;
+  cachePurges: number;
+  cacheRefreshes: number;
+  hits: number;
+  lastBlockLoadTime: number;
+  misses: number;
+  startTime: number;
+  totalBlockLoadTime: number;
+};
+
+export type SmartGridCacheBlockParams = Record<string, unknown>;
+
+export type SmartGridCacheBlock = {
+  endRow: number;
+  id: number;
+  infiniteCache: SmartGridInfiniteCache;
+  lastAccessed: number;
+  loadStartedAt: number;
+  params: SmartGridCacheBlockParams;
+  parent: SmartGridInfiniteCache | null;
+  parentCache: SmartGridInfiniteCache | null;
+  rowNodes: {
+    data: SmartGridRowData;
+    id: number;
+    rowIndex: number;
+  }[];
+  rows: unknown;
+  startRow: number;
+  state: string;
+  version: number;
+  _inactiveForPageTransition: boolean;
+  _processingInProgress: boolean;
+  _targetPage: number;
+};
+
+export interface SmartGridInfiniteCache {
+  analytics: SmartGridCacheAnalytics;
+  blockCount: number;
+  blocks: Record<number, SmartGridCacheBlock>;
+  eventListeners: Record<"cacheUpdated", Function[]>;
+  lastRequestedPage: number;
+  lastRowIndexKnown: boolean;
+  params: SmartGridInfiniteCacheParams;
+  rowCount: number;
+  _currentRequestedPage: number;
+}
+
+export interface SmartGridInfiniteRowModel {
+  infiniteCache?: SmartGridInfiniteCache;
+  setViewportRange?: (startRow: number, endRow: number) => void;
+  logCacheSummary?: () => void;
+  [key: string]: unknown;
+}
+
+export interface SmartGridInfiniteCacheParams {
+  datasource: {
+    getWholeData: () => SmartGridRowData[];
+  };
+}

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

@@ -0,0 +1,185 @@
+import { CSSProperties } from "react";
+import { SmartGridAPI, SmartGridRowData } from "./api.type";
+import {
+  SmartGridNewSortModel,
+  SmartGridSortModel,
+  SmartGridUpdateData,
+} from "./common.type";
+
+export interface SmartGridValueFormatterParams {
+  value: unknown;
+  data: SmartGridRowData;
+  colDef: SmartGridColumnDefinition;
+}
+export interface SmartGridValueGetterParams {
+  data: SmartGridRowData;
+  node: {
+    data: SmartGridRowData;
+  };
+  colDef: SmartGridColumnDefinition;
+  column: SmartGridColumnDefinition;
+  api: SmartGridAPI;
+  columnApi?: unknown;
+  getValue: (field: string) => unknown;
+}
+
+export type SmartGridCellRenderer = {
+  value: unknown;
+  data: SmartGridRowData;
+  rowIndex: number;
+  colIndex: number;
+  column: SmartGridColumnDefinition;
+  colDef: SmartGridColumnDefinition;
+  node: {
+    data: SmartGridRowData;
+    rowIndex: number;
+    id: string | number;
+    parent: SmartGridUpdateData & {
+      id: string | number;
+      level: number;
+      setExpanded: () => void;
+    };
+    setDataValue: (colId: string, newValue: unknown) => void;
+    childrenMapped: Record<string, string>;
+    allLeafChildren: Record<string, string>;
+    group: boolean;
+    level: number;
+    childIndex: number;
+    isSelected: () => boolean;
+    isExpandable: () => boolean;
+    isExpanded: () => boolean;
+  };
+  api: SmartGridAPI;
+  eGridCell: React.HTMLAttributes<HTMLDivElement>;
+  wholeData: SmartGridRowData[];
+  actions: Record<string, unknown>;
+  setDataValue: (colId: string, newValue: unknown) => void;
+};
+export type SmartGridCellRendererParams = Record<string, unknown>;
+
+export type SmartGridHeaderStyleParams = {
+  column: SmartGridColumnDefinition;
+  displayName: string;
+  enableSorting: boolean;
+  sortState: SmartGridNewSortModel;
+  onSort: (field: string, direction: string) => void;
+  isSearchable: boolean;
+  showSortIcon: boolean;
+  toggleSearchModal: (e: React.MouseEvent<HTMLElement>) => void;
+  hasFilters: boolean;
+  isExpandable: boolean;
+  onToggle: (field: string, isExpandable: boolean) => void;
+  api: SmartGridAPI;
+  availableWidth: number;
+  wrapHeaderText: boolean;
+  menuButtonRef: React.RefObject<HTMLElement>;
+  menuToggle: (e: React.MouseEvent<HTMLElement>) => void;
+  toggleAdvancedSeach: (value: boolean) => void;
+};
+export interface SmartGridColumnDefinition {
+  field: string;
+  headerName?: string;
+  column_name?: string;
+  label?: string;
+  width?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  hide?: boolean;
+  hidden?: boolean;
+  pinned?: "left" | "right" | boolean | null;
+  is_frozen?: boolean;
+  children?: SmartGridColumnDefinition[];
+  parent_id?: string | number;
+  type?: string;
+  cellDataType?: string;
+  valueFormatter?: (params: SmartGridValueFormatterParams) => string;
+  valueGetter?: (params: SmartGridValueGetterParams) => unknown;
+  leftTotalWidth?: number;
+  originalWidth?: number;
+  isAutoWidth?: boolean;
+  filterable?: boolean;
+  isSortable?: boolean;
+  is_sortable?: boolean;
+  resizable?: boolean;
+  align?: "left" | "center" | "right";
+  cellRenderer?: string | ((params: SmartGridCellRenderer) => JSX.Element);
+  cellRendererParams?: SmartGridCellRendererParams;
+  cellClassName?: string;
+  cellStyle?: {
+    textAlign?: "left" | "center" | "right";
+    [key: string]: unknown;
+  };
+  autoHeight?: boolean;
+  wrapHeaderText?: boolean;
+  editable?: boolean;
+  is_editable?: boolean;
+  is_disabled?: boolean;
+  is_searchable?: boolean;
+  isSearchable?: boolean;
+  advanceSearchEnabled?: boolean;
+  sortable?: boolean;
+  rowGroup?: boolean;
+  enableRowGroup?: boolean;
+  rowGroupIndex?: number;
+  aggFunc?: string;
+  columnGroupShow?: "open" | "closed";
+  originalIndex?: number;
+  parentColumns?: string[];
+  hasChildren?: boolean;
+  hasAnyFrozenChildren?: boolean;
+  hasAnyRightPinnedChildren?: boolean;
+  isChildWithoutParent?: boolean;
+  colorClass?: string;
+  isLeaf?: boolean;
+  isStandalone?: boolean;
+  isWithEmptyHeaderName?: boolean;
+  isParentWithChildEmptyHeaderName?: boolean;
+  path?: string[];
+  parentField?: string | null;
+  originalFields?: string[];
+  colId?: string;
+  colSpan?: number;
+  rowSpan?: number;
+  comparator?: (
+    valueA: unknown,
+    valueB: unknown,
+    nodeA: unknown,
+    nodeB: unknown,
+    sortModel: SmartGridSortModel
+  ) => number;
+  headerTooltip?: string;
+  filter?: string | boolean;
+  filterParams?: {
+    filterOptions?: string[];
+    textCustomComparator?: (
+      filter: string,
+      value: unknown,
+      filterText: string
+    ) => boolean;
+    numberCustomComparator?: (filter: number, value: unknown) => boolean;
+    dateCustomComparator?: (
+      filterLocalDateAtMidnight: Date,
+      cellValue: string
+    ) => number;
+    comparator?: (filterValue: unknown, cellValue: unknown) => boolean;
+    [key: string]: unknown;
+  };
+  order_of_display?: number;
+  is_hidden?: boolean;
+  formatter?: string | null;
+  accessor?: string;
+  id?: string;
+  required?: boolean;
+  sub_headers?: SmartGridColumnDefinition[];
+  extra?: {
+    width?: number;
+    is_grouping_key?: boolean;
+    is_disabled?: boolean;
+    isDisabled?: boolean;
+    columnGroupShow?: "open" | "closed";
+    [key: string]: unknown;
+  };
+  headerComponent: React.FC<SmartGridHeaderStyleParams>;
+  headerStyle?: (params: SmartGridHeaderStyleParams) => CSSProperties;
+  [key: string]: unknown;
+}

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

@@ -0,0 +1,62 @@
+import { SmartGridRowData } from "./api.type";
+
+export type SmartGridSortDirection = "asc" | "desc" | "none";
+
+export type SmartGridUpdateData = {
+  data: SmartGridRowData;
+  setData: (data: SmartGridRowData) => void;
+  setDataValue: (field: string, value: unknown, callback?: () => void) => void;
+};
+
+export interface SmartGridRowNode extends SmartGridUpdateData {
+  id: string | number;
+  childIndex?: number;
+  selected: boolean;
+  rowIndex?: number;
+  absoluteRowIndex?: number;
+  originalData?: SmartGridRowData;
+  rowHeight?: number;
+  setSelected: (selected: boolean, clearSelection?: boolean) => void;
+  isGroup?: () => boolean;
+}
+
+export interface SmartGridOldSortModel {
+  colId: string;
+  sort: SmartGridSortDirection;
+}
+
+export interface SmartGridNewSortModel {
+  column: string;
+  order: string;
+}
+
+export type SmartGridSortModel =
+  | SmartGridOldSortModel
+  | SmartGridNewSortModel
+  | null;
+
+export type SmartGridStringFilter = {
+  column: string;
+  pattern: string;
+  search_type: string;
+  operator?: string;
+};
+
+export type SmartGridRangeFilter = {
+  column: string;
+  min_val: number;
+  max_val: number;
+  search_type: string;
+  operator?: string;
+};
+
+export interface SmartGridFilterModel {
+  pattern: string;
+  search_type: string;
+  column?: string;
+  field?: string;
+  min_val?: number;
+  max_val?: number;
+  type?: string;
+  operator?: string;
+}

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

@@ -0,0 +1,7 @@
+// Export all types from all type files using wildcard exports
+export * from "./api.type";
+export * from "./cache.type";
+export * from "./columns.type";
+export * from "./common.type";
+export * from "./reducer.type";
+export * from "./table.type";

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

@@ -0,0 +1,3 @@
+export interface SmartGridStateContext {
+  [key: string]: any;
+}

package/dist/components/IATable/types/svg.d.ts

@@ -0,0 +1,5 @@
+declare module "*.svg" {
+  import React from "react";
+  const SVGComponent: React.FC<React.SVGProps<SVGSVGElement>>;
+  export default SVGComponent;
+}