@simple-table/angular 3.0.0-beta.8

package/dist/cjs/core/src/utils/rowUtils.d.ts

@@ -0,0 +1,136 @@
+import TableRow from "../types/TableRow";
+import Row from "../types/Row";
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import CellValue from "../types/CellValue";
+import RowState from "../types/RowState";
+import { CustomTheme } from "../types/CustomTheme";
+import { GetRowId } from "../types/GetRowId";
+import { GenerateRowIdParams } from "../types/GenerateRowIdParams";
+/**
+ * Calculate the height of a nested grid based on the number of child rows
+ * @param childRowCount - Number of rows in the nested grid
+ * @param rowHeight - Height of each row
+ * @param headerHeight - Height of the header
+ * @param customTheme - Custom theme configuration
+ * @returns Calculated height in pixels (includes padding, borders, row separators, and header border)
+ */
+export declare const calculateNestedGridHeight: ({ childRowCount, rowHeight, headerHeight, customTheme, }: {
+    childRowCount: number;
+    rowHeight: number;
+    headerHeight: number;
+    customTheme: CustomTheme;
+}) => number;
+/**
+ * Calculate the final wrapper height for a nested grid, accounting for custom heights
+ *
+ * @param calculatedHeight - The default calculated height based on child rows
+ * @param customHeight - Optional custom height from nestedTable config (e.g., "200px" or 200)
+ * @param customTheme - Custom theme configuration for padding
+ * @returns Final height in pixels for the wrapper (includes padding)
+ */
+export declare const calculateFinalNestedGridHeight: ({ calculatedHeight, customHeight, customTheme, }: {
+    calculatedHeight: number;
+    customHeight?: string | number;
+    customTheme: CustomTheme;
+}) => number;
+/**
+ * Calculate the inner height for a nested SimpleTable component
+ * This accounts for the padding that's applied to the wrapper
+ *
+ * @param calculatedHeight - The total height of the nested grid row (from calculateNestedGridHeight)
+ * @param customHeight - Optional custom height from nestedTable config (e.g., "200px")
+ * @param customTheme - Custom theme configuration for padding
+ * @returns Height value to pass to the nested SimpleTable (string with units)
+ */
+export declare const calculateNestedTableHeight: ({ calculatedHeight, customHeight, customTheme, }: {
+    calculatedHeight: number;
+    customHeight?: string | number;
+    customTheme: CustomTheme;
+}) => string;
+/**
+ * Get a nested property value from an object using dot notation and array bracket notation
+ * Examples:
+ *   getNestedValue(row, "latest.rank") returns row.latest.rank
+ *   getNestedValue(row, "albums[0].title") returns row.albums[0].title
+ *   getNestedValue(row, "releaseDate[0]") returns row.releaseDate[0]
+ */
+export declare const getNestedValue: (obj: Row, path: Accessor) => CellValue;
+/**
+ * Set a nested property value in an object using dot notation and array bracket notation
+ * Examples:
+ *   setNestedValue(row, "latest.rank", 5) sets row.latest.rank = 5
+ *   setNestedValue(row, "albums[0].title", "New Album") sets row.albums[0].title = "New Album"
+ *   setNestedValue(row, "releaseDate[0]", "2024") sets row.releaseDate[0] = "2024"
+ */
+export declare const setNestedValue: (obj: Row, path: Accessor, value: CellValue) => void;
+/**
+ * Check if an array contains Row objects (vs primitive arrays like string[] or number[])
+ */
+export declare const isRowArray: (data: any) => data is Row[];
+/**
+ * Generate the row ID array from index path and optional custom identifier.
+ *
+ * The row ID is always an array that includes:
+ * - The index at each level of nesting
+ * - The grouping key between levels (for readability)
+ * - An optional custom identifier from getRowId (appended at the end)
+ *
+ * Examples:
+ * - Root row (index 1): [1]
+ * - Nested store (parent index 1, store index 5): [1, "stores", 5]
+ * - With custom ID: [1, "stores", 5, "STORE-101"]
+ * - Deep nesting: [1, "stores", 5, "products", 2, "PROD-24"]
+ *
+ * @param params - Object containing row data, getRowId function, and metadata
+ * @returns An array representing the unique row ID path
+ */
+export declare const generateRowId: (params: GenerateRowIdParams) => (string | number)[];
+/**
+ * Convert a row ID array to a string for use as Map keys, Set members, etc.
+ *
+ * @param rowId - Array of strings/numbers representing the row ID path
+ * @returns A string representation of the row ID
+ */
+export declare const rowIdToString: (rowId: (string | number)[]) => string;
+/**
+ * Get nested rows from a row based on the grouping path
+ */
+export declare const getNestedRows: (row: Row, groupingKey: string) => Row[];
+/**
+ * Check if a row has nested rows for a given grouping key
+ */
+export declare const hasNestedRows: (row: Row, groupingKey?: string) => boolean;
+/**
+ * Determine if a row is expanded based on expandedDepths and manual row overrides
+ * @param rowId - The ID of the row to check
+ * @param depth - The depth level of the row (0-indexed)
+ * @param expandedDepths - Set of depth levels that are expanded
+ * @param expandedRows - Map of row IDs to their depths for rows that user wants expanded
+ * @param collapsedRows - Map of row IDs to their depths for rows that user wants collapsed
+ * @returns true if the row is expanded, false otherwise
+ */
+export declare const isRowExpanded: (rowId: string | number, depth: number, expandedDepths: Set<number>, expandedRows: Map<string, number>, collapsedRows: Map<string, number>) => boolean;
+/**
+ * Flatten rows recursively based on row grouping configuration
+ * Now calculates ALL properties including position and isLastGroupRow
+ * Also injects special state rows for loading/error/empty states (only if renderers are available)
+ * Also injects nested grid rows when a header has nestedTable configuration
+ */
+export declare const flattenRowsWithGrouping: ({ depth, expandedDepths, expandedRows, collapsedRows, rowGrouping, getRowId, rows, displayPositionOffset, rowStateMap, hasLoadingRenderer, hasErrorRenderer, hasEmptyRenderer, headers, rowHeight, headerHeight, customTheme, }: {
+    depth?: number;
+    expandedDepths: Set<number>;
+    expandedRows: Map<string, number>;
+    collapsedRows: Map<string, number>;
+    rowGrouping?: Accessor[];
+    getRowId?: GetRowId;
+    rows: Row[];
+    displayPositionOffset?: number;
+    rowStateMap?: Map<string | number, RowState>;
+    hasLoadingRenderer?: boolean;
+    hasErrorRenderer?: boolean;
+    hasEmptyRenderer?: boolean;
+    headers?: HeaderObject[];
+    rowHeight: number;
+    headerHeight: number;
+    customTheme: CustomTheme;
+}) => TableRow[];

package/dist/cjs/core/src/utils/sortUtils.d.ts

@@ -0,0 +1,8 @@
+import HeaderObject from "../types/HeaderObject";
+import Row from "../types/Row";
+import SortColumn from "../types/SortColumn";
+export declare const handleSort: ({ headers, rows, sortColumn, }: {
+    headers: HeaderObject[];
+    rows: Row[];
+    sortColumn: SortColumn;
+}) => Row[];

package/dist/cjs/core/src/utils/stateRowRenderer.d.ts

@@ -0,0 +1,15 @@
+import type TableRowType from "../types/TableRow";
+import { HeightOffsets } from "./infiniteScrollUtils";
+import { CustomTheme } from "../types/CustomTheme";
+import { LoadingStateRenderer, ErrorStateRenderer, EmptyStateRenderer } from "../types/RowStateRendererProps";
+export interface StateRowRenderContext {
+    index: number;
+    rowHeight: number;
+    heightOffsets: HeightOffsets | undefined;
+    customTheme: CustomTheme;
+    loadingStateRenderer?: LoadingStateRenderer;
+    errorStateRenderer?: ErrorStateRenderer;
+    emptyStateRenderer?: EmptyStateRenderer;
+}
+export declare const createStateRow: (tableRow: TableRowType, context: StateRowRenderContext) => HTMLElement;
+export declare const cleanupStateRow: (rowElement: HTMLElement) => void;

package/dist/cjs/core/src/utils/stickyParentsRenderer.d.ts

@@ -0,0 +1,30 @@
+import TableRow from "../types/TableRow";
+import HeaderObject from "../types/HeaderObject";
+import { CumulativeHeightMap, HeightOffsets } from "./infiniteScrollUtils";
+import type { SectionScrollController } from "../managers/SectionScrollController";
+import { CustomTheme } from "../types/CustomTheme";
+import { CellRenderContext } from "./bodyCell/types";
+export interface StickyParentsContainerProps {
+    calculatedHeaderHeight: number;
+    heightMap?: CumulativeHeightMap;
+    partiallyVisibleRows: TableRow[];
+    pinnedLeftColumns: HeaderObject[];
+    pinnedLeftWidth: number;
+    pinnedRightColumns: HeaderObject[];
+    pinnedRightWidth: number;
+    scrollTop: number;
+    scrollbarWidth: number;
+    stickyParents: TableRow[];
+}
+export interface StickyParentsRenderContext {
+    collapsedHeaders: Set<string>;
+    customTheme: CustomTheme;
+    editColumns: boolean;
+    headers: HeaderObject[];
+    rowHeight: number;
+    heightOffsets: HeightOffsets | undefined;
+    cellRenderContext: CellRenderContext;
+    sectionScrollController?: SectionScrollController | null;
+}
+export declare const createStickyParentsContainer: (props: StickyParentsContainerProps, context: StickyParentsRenderContext) => HTMLElement | null;
+export declare const cleanupStickyParentsContainer: (container: HTMLElement, sectionScrollController?: SectionScrollController | null) => void;

package/dist/cjs/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@angular/core"),t=require("simple-table-core");function o(e,t,o,n){var i,r=arguments.length,p=r<3?t:null===n?n=Object.getOwnPropertyDescriptor(t,o):n;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)p=Reflect.decorate(e,t,o,n);else for(var l=e.length-1;l>=0;l--)(i=e[l])&&(p=(r<3?i(p):r>3?i(t,o,p):i(t,o))||p);return r>3&&p&&Object.defineProperty(t,o,p),p}function n(t,o,i){const{defaultHeaders:r,footerRenderer:p,emptyStateRenderer:l,errorStateRenderer:s,loadingStateRenderer:d,tableEmptyStateRenderer:a,headerDropdown:m,columnEditorConfig:h,...u}=t,C=t=>function(t,o,n){return i=>{const r=document.createElement("div"),p=e.createComponent(t,{environmentInjector:n,hostElement:r});return Object.assign(p.instance,i),o.attachView(p.hostView),p.changeDetectorRef.detectChanges(),r}}(t,o,i),v={...u,defaultHeaders:r.map(function e(t){const{cellRenderer:r,headerRenderer:p,children:l,nestedTable:s,...d}=t,a={...d};if(r&&(a.cellRenderer=r.ɵcmp?C(r):r),p&&(a.headerRenderer=p.ɵcmp?C(p):p),l&&(a.children=l.map(e)),s){const e={...s,rows:[]};a.nestedTable=n(e,o,i)}return a})};return void 0!==p&&(v.footerRenderer=p.ɵcmp?C(p):p),void 0!==l&&(v.emptyStateRenderer=l.ɵcmp?C(l):l),void 0!==s&&(v.errorStateRenderer=s.ɵcmp?C(s):s),void 0!==d&&(v.loadingStateRenderer=d.ɵcmp?C(d):d),void 0!==a&&(v.tableEmptyStateRenderer=a),void 0!==m&&(v.headerDropdown=C(m)),void 0!==h&&(v.columnEditorConfig=function(e){const{rowRenderer:t,...o}=e;return{...o,...t?{rowRenderer:C(t)}:{}}}(h)),v}"function"==typeof SuppressedError&&SuppressedError,exports.SimpleTableComponent=class{constructor(){this.tableReady=new e.EventEmitter,this.instance=null,this.hostEl=e.inject(e.ElementRef),this.appRef=e.inject(e.ApplicationRef),this.envInjector=e.inject(e.EnvironmentInjector)}ngOnInit(){const e=this.hostEl.nativeElement.querySelector("div");e&&(this.instance=new t.SimpleTableVanilla(e,n(this.getProps(),this.appRef,this.envInjector)),this.instance.mount(),this.tableReady.emit(this.instance.getAPI()))}ngOnChanges(){this.instance?.update(n(this.getProps(),this.appRef,this.envInjector))}ngOnDestroy(){this.instance?.destroy(),this.instance=null}getAPI(){return this.instance?.getAPI()??null}getProps(){const e={rows:this.rows,defaultHeaders:this.defaultHeaders};return void 0!==this.footerRenderer&&(e.footerRenderer=this.footerRenderer),void 0!==this.loadingStateRenderer&&(e.loadingStateRenderer=this.loadingStateRenderer),void 0!==this.errorStateRenderer&&(e.errorStateRenderer=this.errorStateRenderer),void 0!==this.emptyStateRenderer&&(e.emptyStateRenderer=this.emptyStateRenderer),void 0!==this.tableEmptyStateRenderer&&(e.tableEmptyStateRenderer=this.tableEmptyStateRenderer),void 0!==this.headerDropdown&&(e.headerDropdown=this.headerDropdown),void 0!==this.columnEditorConfig&&(e.columnEditorConfig=this.columnEditorConfig),void 0!==this.onCellClick&&(e.onCellClick=this.onCellClick),void 0!==this.onCellEdit&&(e.onCellEdit=this.onCellEdit),void 0!==this.onSortChange&&(e.onSortChange=this.onSortChange),void 0!==this.onFilterChange&&(e.onFilterChange=this.onFilterChange),void 0!==this.onRowSelectionChange&&(e.onRowSelectionChange=this.onRowSelectionChange),void 0!==this.onRowGroupExpand&&(e.onRowGroupExpand=this.onRowGroupExpand),void 0!==this.onColumnOrderChange&&(e.onColumnOrderChange=this.onColumnOrderChange),void 0!==this.onColumnVisibilityChange&&(e.onColumnVisibilityChange=this.onColumnVisibilityChange),void 0!==this.onColumnWidthChange&&(e.onColumnWidthChange=this.onColumnWidthChange),void 0!==this.onPageChange&&(e.onPageChange=this.onPageChange),void 0!==this.onLoadMore&&(e.onLoadMore=this.onLoadMore),void 0!==this.onGridReady&&(e.onGridReady=this.onGridReady),void 0!==this.rowGrouping&&(e.rowGrouping=this.rowGrouping),void 0!==this.enableRowSelection&&(e.enableRowSelection=this.enableRowSelection),void 0!==this.theme&&(e.theme=this.theme),void 0!==this.quickFilter&&(e.quickFilter=this.quickFilter),void 0!==this.isLoading&&(e.isLoading=this.isLoading),void 0!==this.getRowId&&(e.getRowId=this.getRowId),void 0!==this.shouldPaginate&&(e.shouldPaginate=this.shouldPaginate),void 0!==this.rowsPerPage&&(e.rowsPerPage=this.rowsPerPage),void 0!==this.serverSidePagination&&(e.serverSidePagination=this.serverSidePagination),void 0!==this.totalRowCount&&(e.totalRowCount=this.totalRowCount),void 0!==this.height&&(e.height=this.height),void 0!==this.maxHeight&&(e.maxHeight=this.maxHeight),void 0!==this.columnResizing&&(e.columnResizing=this.columnResizing),void 0!==this.columnReordering&&(e.columnReordering=this.columnReordering),void 0!==this.editColumns&&(e.editColumns=this.editColumns),void 0!==this.selectableCells&&(e.selectableCells=this.selectableCells),void 0!==this.selectableColumns&&(e.selectableColumns=this.selectableColumns),void 0!==this.enableHeaderEditing&&(e.enableHeaderEditing=this.enableHeaderEditing),void 0!==this.onHeaderEdit&&(e.onHeaderEdit=this.onHeaderEdit),void 0!==this.customTheme&&(e.customTheme=this.customTheme),void 0!==this.icons&&(e.icons=this.icons),void 0!==this.externalFilterHandling&&(e.externalFilterHandling=this.externalFilterHandling),void 0!==this.externalSortHandling&&(e.externalSortHandling=this.externalSortHandling),void 0!==this.columnBorders&&(e.columnBorders=this.columnBorders),void 0!==this.rowButtons&&(e.rowButtons=this.rowButtons),void 0!==this.hideFooter&&(e.hideFooter=this.hideFooter),void 0!==this.initialSortColumn&&(e.initialSortColumn=this.initialSortColumn),void 0!==this.initialSortDirection&&(e.initialSortDirection=this.initialSortDirection),void 0!==this.expandAll&&(e.expandAll=this.expandAll),void 0!==this.autoExpandColumns&&(e.autoExpandColumns=this.autoExpandColumns),e}},o([e.Input({required:!0})],exports.SimpleTableComponent.prototype,"rows",void 0),o([e.Input({required:!0})],exports.SimpleTableComponent.prototype,"defaultHeaders",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"footerRenderer",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"loadingStateRenderer",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"errorStateRenderer",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"emptyStateRenderer",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"tableEmptyStateRenderer",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"headerDropdown",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"columnEditorConfig",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onCellClick",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onCellEdit",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onSortChange",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onFilterChange",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onRowSelectionChange",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onRowGroupExpand",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onColumnOrderChange",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onColumnVisibilityChange",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onColumnWidthChange",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onPageChange",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onLoadMore",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onGridReady",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"rowGrouping",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"enableRowSelection",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"theme",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"quickFilter",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"isLoading",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"getRowId",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"shouldPaginate",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"rowsPerPage",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"serverSidePagination",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"totalRowCount",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"height",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"maxHeight",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"columnResizing",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"columnReordering",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"editColumns",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"selectableCells",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"selectableColumns",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"enableHeaderEditing",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"onHeaderEdit",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"customTheme",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"icons",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"externalFilterHandling",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"externalSortHandling",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"columnBorders",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"rowButtons",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"hideFooter",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"initialSortColumn",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"initialSortDirection",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"expandAll",void 0),o([e.Input()],exports.SimpleTableComponent.prototype,"autoExpandColumns",void 0),o([e.Output()],exports.SimpleTableComponent.prototype,"tableReady",void 0),exports.SimpleTableComponent=o([e.Component({selector:"simple-table",standalone:!0,template:"<div #host></div>",styles:[":host { display: block; }"]})],exports.SimpleTableComponent),exports.provideSimpleTable=function(){return e.makeEnvironmentProviders([])};
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/core/src/consts/column-constraints.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Column width constraints for the table
+ * These values control minimum and maximum widths for columns and sections
+ */
+/**
+ * MIN_COLUMN_WIDTH
+ * The minimum width in pixels that any column can have.
+ * This is used as:
+ * - The default minimum width when header.minWidth is undefined
+ * - The absolute minimum in autoExpandColumns mode to prevent columns from becoming too narrow
+ */
+export declare const MIN_COLUMN_WIDTH = 40;
+/**
+ * MAX_SINGLE_PINNED_SECTION_PERCENT
+ * Maximum percentage of container width that a single pinned section can occupy.
+ * When only one section (left OR right) is pinned, it can take up to 60% of the width.
+ * This ensures the main section always has at least 40% of the space.
+ */
+export declare const MAX_SINGLE_PINNED_SECTION_PERCENT = 0.6;
+/**
+ * MAX_DUAL_PINNED_SECTION_PERCENT
+ * Maximum percentage of container width that each pinned section can occupy
+ * when BOTH left and right sections are pinned.
+ * With both sections at 40%, the main section is guaranteed at least 20% of the space.
+ */
+export declare const MAX_DUAL_PINNED_SECTION_PERCENT = 0.4;
+/**
+ * Mobile breakpoints for responsive pinned section constraints
+ */
+export declare const MOBILE_BREAKPOINT_SMALL = 480;
+export declare const MOBILE_BREAKPOINT_MEDIUM = 768;
+/**
+ * Get the maximum allowed width percentage for a single pinned section based on container width.
+ * This is used when only ONE section (left OR right) is pinned.
+ *
+ * @param containerWidth - The table container width in pixels (st-body-container)
+ * @returns The maximum percentage (0-1) of container width that the pinned section can occupy
+ */
+export declare const getMaxSinglePinnedPercent: (containerWidth: number) => number;
+/**
+ * Get the maximum allowed width percentage for pinned sections based on container width
+ * and the number of pinned sections.
+ *
+ * @param containerWidth - The table container width in pixels (st-body-container)
+ * @param hasPinnedLeft - Whether there is a pinned left section
+ * @param hasPinnedRight - Whether there is a pinned right section
+ * @returns The maximum percentage (0-1) of container width that each pinned section can occupy
+ */
+export declare const getMaxPinnedSectionPercent: (containerWidth: number, hasPinnedLeft: boolean, hasPinnedRight: boolean) => number;
+/**
+ * Calculate the maximum width in pixels for a pinned section
+ *
+ * @param containerWidth - The table container width in pixels (st-body-container)
+ * @param hasPinnedLeft - Whether there is a pinned left section
+ * @param hasPinnedRight - Whether there is a pinned right section
+ * @returns The maximum width in pixels for a pinned section
+ */
+export declare const getMaxPinnedSectionWidth: (containerWidth: number, hasPinnedLeft: boolean, hasPinnedRight: boolean) => number;

package/dist/core/src/consts/general-consts.d.ts

@@ -0,0 +1,13 @@
+export declare const DRAG_THROTTLE_LIMIT = 50;
+export declare const ROW_SEPARATOR_WIDTH = 1;
+export declare const PAGE_SIZE = 20;
+export declare const CSS_VAR_BORDER_WIDTH = "--st-border-width";
+export declare const DEFAULT_BORDER_WIDTH = 1;
+export declare const VIRTUALIZATION_THRESHOLD = 20;
+export declare const OVERSCAN_PIXELS = 800;
+export declare const calculateBufferRowCount: (rowHeight: number) => number;
+export declare const COLUMN_EDIT_WIDTH = 29.5;
+export declare const TABLE_HEADER_CELL_WIDTH_DEFAULT = 150;
+export declare const PINNED_BORDER_WIDTH = 1;
+export declare const CHART_COLUMN_TYPES: string[];
+export declare const OPTIMAL_CHART_COLUMN_WIDTH = 150;

package/dist/core/src/core/SimpleTableVanilla.d.ts

@@ -0,0 +1,71 @@
+import { SimpleTableConfig } from "../types/SimpleTableConfig";
+import { TableAPI } from "../types/TableAPI";
+import "../styles/all-themes.css";
+export declare class SimpleTableVanilla {
+    private container;
+    private config;
+    private customTheme;
+    private mergedColumnEditorConfig;
+    private resolvedIcons;
+    private domManager;
+    private renderOrchestrator;
+    private draggedHeaderRef;
+    private hoveredHeaderRef;
+    private localRows;
+    private headers;
+    private essentialAccessors;
+    private currentPage;
+    private scrollTop;
+    private scrollDirection;
+    private isResizing;
+    private isScrolling;
+    /** True when this render is scroll-driven so body can use position-only updates for existing cells. */
+    private _positionOnlyBody;
+    private firstRenderDone;
+    private internalIsLoading;
+    private scrollbarWidth;
+    private isMainSectionScrollable;
+    private columnEditorOpen;
+    private collapsedHeaders;
+    private expandedDepths;
+    private expandedRows;
+    private collapsedRows;
+    private rowStateMap;
+    private announcement;
+    private cellRegistry;
+    private headerRegistry;
+    private rowIndexMap;
+    private autoScaleManager;
+    private dimensionManager;
+    private scrollManager;
+    private sectionScrollController;
+    private sortManager;
+    private filterManager;
+    private selectionManager;
+    private rowSelectionManager;
+    private windowResizeManager;
+    private handleOutsideClickManager;
+    private scrollbarVisibilityManager;
+    private expandedDepthsManager;
+    private ariaAnnouncementManager;
+    private mounted;
+    private scrollRafId;
+    private scrollEndTimeoutId;
+    private lastScrollTop;
+    private isUpdating;
+    constructor(container: HTMLElement, config: SimpleTableConfig);
+    private rebuildRowIndexMap;
+    private initializeManagers;
+    mount(): void;
+    private setupManagers;
+    private setupEventListeners;
+    private handleScroll;
+    private clearHoveredRows;
+    private updateAriaLiveRegion;
+    private getRenderContext;
+    private getRenderState;
+    private render;
+    update(config: Partial<SimpleTableConfig>): void;
+    destroy(): void;
+    getAPI(): TableAPI;
+}

package/dist/core/src/core/api/TableAPIImpl.d.ts

@@ -0,0 +1,44 @@
+import { TableAPI } from "../../types/TableAPI";
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import HeaderObject from "../../types/HeaderObject";
+import Row from "../../types/Row";
+import { CustomTheme } from "../../types/CustomTheme";
+import RowState from "../../types/RowState";
+import { SelectionManager } from "../../managers/SelectionManager";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { FlattenRowsResult } from "../../utils/rowFlattening";
+import { ProcessRowsResult } from "../../utils/rowProcessing";
+export interface TableAPIContext {
+    config: SimpleTableConfig;
+    localRows: Row[];
+    effectiveHeaders: HeaderObject[];
+    headers: HeaderObject[];
+    essentialAccessors: Set<string>;
+    customTheme: CustomTheme;
+    currentPage: number;
+    /** Returns current page from live state (use this in API getCurrentPage so it stays correct after setPage). */
+    getCurrentPage: () => number;
+    expandedRows: Map<string, number>;
+    collapsedRows: Map<string, number>;
+    expandedDepths: Set<number>;
+    rowStateMap: Map<string | number, RowState>;
+    headerRegistry: Map<string, any>;
+    cellRegistry?: Map<string, {
+        updateContent: (value: any) => void;
+    }>;
+    columnEditorOpen: boolean;
+    expandedDepthsManager: any;
+    selectionManager: SelectionManager | null;
+    sortManager: SortManager | null;
+    filterManager: FilterManager | null;
+    getCachedFlattenResult?: () => FlattenRowsResult | null;
+    getCachedProcessedResult?: () => ProcessRowsResult | null;
+    onRender: () => void;
+    setHeaders: (headers: HeaderObject[]) => void;
+    setCurrentPage: (page: number) => void;
+    setColumnEditorOpen: (open: boolean) => void;
+}
+export declare class TableAPIImpl {
+    static createAPI(context: TableAPIContext): TableAPI;
+}

package/dist/core/src/core/dom/DOMManager.d.ts

@@ -0,0 +1,50 @@
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+export interface DOMElements {
+    rootElement: HTMLElement;
+    wrapperContainer: HTMLElement;
+    contentWrapper: HTMLElement;
+    content: HTMLElement;
+    headerContainer: HTMLElement;
+    bodyContainer: HTMLElement;
+    footerContainer: HTMLElement;
+    ariaLiveRegion: HTMLElement;
+}
+export interface DOMRefs {
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightRef: {
+        current: HTMLDivElement | null;
+    };
+    mainHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    headerContainerRef: {
+        current: HTMLDivElement | null;
+    };
+    tableBodyContainerRef: {
+        current: HTMLDivElement | null;
+    };
+    horizontalScrollbarRef: {
+        current: HTMLElement | null;
+    };
+}
+export declare class DOMManager {
+    private elements;
+    private refs;
+    constructor();
+    createDOMStructure(container: HTMLElement, config: SimpleTableConfig): DOMElements;
+    updateTheme(theme: string): void;
+    getElements(): DOMElements | null;
+    getRefs(): DOMRefs;
+    destroy(container: HTMLElement): void;
+}

package/dist/core/src/core/initialization/TableInitializer.d.ts

@@ -0,0 +1,30 @@
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import { CustomTheme } from "../../types/CustomTheme";
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+export interface ResolvedIcons {
+    drag: string | HTMLElement | SVGSVGElement;
+    expand: string | HTMLElement | SVGSVGElement;
+    filter: string | HTMLElement | SVGSVGElement;
+    headerCollapse: string | HTMLElement | SVGSVGElement;
+    headerExpand: string | HTMLElement | SVGSVGElement;
+    next: string | HTMLElement | SVGSVGElement;
+    prev: string | HTMLElement | SVGSVGElement;
+    sortDown: string | HTMLElement | SVGSVGElement;
+    sortUp: string | HTMLElement | SVGSVGElement;
+}
+export interface MergedColumnEditorConfig {
+    text: string;
+    searchEnabled: boolean;
+    searchPlaceholder: string;
+    allowColumnPinning: boolean;
+    searchFunction?: (header: HeaderObject, searchText: string) => boolean;
+    rowRenderer?: any;
+}
+export declare class TableInitializer {
+    static resolveIcons(config: SimpleTableConfig): ResolvedIcons;
+    static mergeCustomTheme(config: SimpleTableConfig): CustomTheme;
+    static mergeColumnEditorConfig(config: SimpleTableConfig): MergedColumnEditorConfig;
+    static buildEssentialAccessors(headers: HeaderObject[]): Set<string>;
+    static getInitialCollapsedHeaders(headers: HeaderObject[]): Set<Accessor>;
+    static getInitialExpandedDepths(config: SimpleTableConfig): Set<number>;
+}

package/dist/core/src/core/rendering/RenderOrchestrator.d.ts

@@ -0,0 +1,123 @@
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import { CustomTheme } from "../../types/CustomTheme";
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import Row from "../../types/Row";
+import RowState from "../../types/RowState";
+import { DimensionManager } from "../../managers/DimensionManager";
+import { ScrollManager } from "../../managers/ScrollManager";
+import type { SectionScrollController } from "../../managers/SectionScrollController";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { SelectionManager } from "../../managers/SelectionManager";
+import { RowSelectionManager } from "../../managers/RowSelectionManager";
+import { FlattenRowsResult } from "../../utils/rowFlattening";
+import { ProcessRowsResult } from "../../utils/rowProcessing";
+import { MergedColumnEditorConfig, ResolvedIcons } from "../initialization/TableInitializer";
+export interface RenderContext {
+    cellRegistry: Map<string, any>;
+    collapsedHeaders: Set<Accessor>;
+    collapsedRows: Map<string, number>;
+    config: SimpleTableConfig;
+    customTheme: CustomTheme;
+    dimensionManager: DimensionManager | null;
+    draggedHeaderRef: {
+        current: HeaderObject | null;
+    };
+    effectiveHeaders: HeaderObject[];
+    essentialAccessors: Set<string>;
+    expandedDepths: Set<number>;
+    expandedRows: Map<string, number>;
+    filterManager: FilterManager | null;
+    getCollapsedRows: () => Map<string, number>;
+    getCollapsedHeaders?: () => Set<Accessor>;
+    getExpandedRows: () => Map<string, number>;
+    getRowStateMap: () => Map<string | number, RowState>;
+    headerRegistry: Map<string, any>;
+    headers: HeaderObject[];
+    hoveredHeaderRef: {
+        current: HeaderObject | null;
+    };
+    internalIsLoading: boolean;
+    isResizing: boolean;
+    localRows: Row[];
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    mainHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    onRender: () => void;
+    pinnedLeftHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightRef: {
+        current: HTMLDivElement | null;
+    };
+    resolvedIcons: ResolvedIcons;
+    rowSelectionManager: RowSelectionManager | null;
+    rowStateMap: Map<string | number, RowState>;
+    scrollManager: ScrollManager | null;
+    sectionScrollController: SectionScrollController | null;
+    selectionManager: SelectionManager | null;
+    setCollapsedHeaders: (headers: Set<Accessor>) => void;
+    setCollapsedRows: (rows: Map<string, number>) => void;
+    setColumnEditorOpen: (open: boolean) => void;
+    setCurrentPage: (page: number) => void;
+    setExpandedRows: (rows: Map<string, number>) => void;
+    setHeaders: (headers: HeaderObject[]) => void;
+    setIsResizing: (value: boolean) => void;
+    setRowStateMap: (map: Map<string | number, any>) => void;
+    sortManager: SortManager | null;
+    /** When true, body cells that stay visible get only position updates (no content/selection recalc). Used during vertical scroll for performance. */
+    positionOnlyBody?: boolean;
+}
+export interface RenderState {
+    currentPage: number;
+    scrollTop: number;
+    scrollDirection: "up" | "down" | "none";
+    scrollbarWidth: number;
+    isMainSectionScrollable: boolean;
+    columnEditorOpen: boolean;
+}
+export declare class RenderOrchestrator {
+    private tableRenderer;
+    private lastHeadersRef;
+    private lastRowsRef;
+    private flattenedRowsCache;
+    private lastProcessedResult;
+    constructor();
+    getCachedFlattenResult(): FlattenRowsResult | null;
+    getLastProcessedResult(): ProcessRowsResult | null;
+    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
+    computeEffectiveHeaders(headers: HeaderObject[], config: SimpleTableConfig, customTheme: CustomTheme, containerWidth?: number): HeaderObject[];
+    render(elements: {
+        bodyContainer: HTMLElement;
+        content: HTMLElement;
+        contentWrapper: HTMLElement;
+        footerContainer: HTMLElement;
+        headerContainer: HTMLElement;
+        rootElement: HTMLElement;
+        wrapperContainer: HTMLElement;
+    }, refs: {
+        mainBodyRef: {
+            current: HTMLDivElement | null;
+        };
+        tableBodyContainerRef: {
+            current: HTMLDivElement | null;
+        };
+    }, context: RenderContext, state: RenderState, mergedColumnEditorConfig: MergedColumnEditorConfig): void;
+    private renderHeader;
+    private renderBody;
+    private renderFooter;
+    private renderColumnEditor;
+    private renderHorizontalScrollbar;
+    private registerSectionPanes;
+    private buildRendererDeps;
+    cleanup(): void;
+}