@simple-table/solid 3.0.0-beta.10

package/dist/core/src/utils/nestedGridRowRenderer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Vanilla equivalent of React NestedGridRow: renders a full-width row that contains
+ * a nested SimpleTable when a row has nestedTable config (expandable + nestedTable headers).
+ */
+import type TableRow from "../types/TableRow";
+import type { CustomTheme } from "../types/CustomTheme";
+import type { SimpleTableConfig } from "../types/SimpleTableConfig";
+import { type HeightOffsets } from "./infiniteScrollUtils";
+export interface NestedGridRowRenderContext {
+    rowHeight: number;
+    heightOffsets: HeightOffsets | undefined;
+    customTheme: CustomTheme;
+    theme?: string;
+    rowGrouping?: (string | number)[];
+    depth: number;
+    loadingStateRenderer?: SimpleTableConfig["loadingStateRenderer"];
+    errorStateRenderer?: SimpleTableConfig["errorStateRenderer"];
+    emptyStateRenderer?: SimpleTableConfig["emptyStateRenderer"];
+    icons?: SimpleTableConfig["icons"];
+}
+/**
+ * Creates a nested grid row element: a div with class "st-row st-nested-grid-row"
+ * that contains a nested SimpleTableVanilla instance.
+ * Returns the row element and a cleanup function to destroy the nested table.
+ */
+export declare function createNestedGridRow(tableRow: TableRow, context: NestedGridRowRenderContext): {
+    element: HTMLElement;
+    cleanup: () => void;
+};
+/**
+ * Creates a spacer row for pinned sections: same position/height as a nested grid row
+ * but no inner table (keeps scroll height in sync).
+ */
+export declare function createNestedGridSpacer(tableRow: TableRow, context: Pick<NestedGridRowRenderContext, "rowHeight" | "heightOffsets" | "customTheme">): HTMLElement;

package/dist/core/src/utils/pinnedColumnUtils.d.ts

@@ -0,0 +1,25 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import { PinnedSectionsState } from "../types/PinnedSectionsState";
+import { PanelSection } from "../types/PanelSection";
+export type { PinnedSectionsState, PanelSection };
+/** Root-level columns only, preserving order within each pin group. */
+export declare function partitionRootHeadersByPin(headers: HeaderObject[]): {
+    pinnedLeft: HeaderObject[];
+    unpinned: HeaderObject[];
+    pinnedRight: HeaderObject[];
+};
+export declare function isHeaderEssential(header: HeaderObject, essentialAccessors: ReadonlySet<string>): boolean;
+/** Accessors for every header with `isEssential` in the tree (including nested). */
+export declare function collectEssentialAccessors(headers: HeaderObject[]): Set<string>;
+/** Within one sibling list: all essential columns must form a left prefix. */
+export declare function hasEssentialPrefixOrder(siblings: HeaderObject[], essentialAccessors: ReadonlySet<string>): boolean;
+/** Root array mixes pin sections; validate each pin group separately, then recurse into children. */
+export declare function validateFullHeaderTreeEssentialOrder(headers: HeaderObject[], essentialAccessors: ReadonlySet<string>): boolean;
+export declare function getPinnedSectionsState(headers: HeaderObject[]): PinnedSectionsState;
+/**
+ * Rebuilds root `headers` order and `pinned` flags from section accessor lists.
+ * Clamps essential columns to the left within each section. Returns null if accessors don't match roots.
+ */
+export declare function rebuildHeadersFromPinnedState(headers: HeaderObject[], state: PinnedSectionsState, essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;
+/** Move a root column to another pin section (append within target section). */
+export declare function moveRootColumnPinSide(headers: HeaderObject[], accessor: Accessor, target: Exclude<PanelSection, "main"> | "main", essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;

package/dist/core/src/utils/quickFilterUtils.d.ts

@@ -0,0 +1,14 @@
+import { SmartFilterToken } from "../types/QuickFilterTypes";
+/**
+ * Parses a smart filter query into tokens
+ * Supports:
+ * - Multi-word: "john engineer" → matches rows containing both "john" AND "engineer"
+ * - Phrase: "john doe" → matches exact phrase
+ * - Negation: -inactive → excludes rows containing "inactive"
+ * - Column-specific: name:john → searches only in name column
+ */
+export declare const parseSmartFilter: (query: string) => SmartFilterToken[];
+/**
+ * Checks if a value matches a simple filter (case-insensitive contains)
+ */
+export declare const matchesSimpleFilter: (value: string, filterText: string, caseSensitive: boolean) => boolean;

package/dist/core/src/utils/resizeUtils/autoExpandResize.d.ts

@@ -0,0 +1,21 @@
+import type HeaderObject from "../../types/HeaderObject";
+import type { Pinned } from "../../types/Pinned";
+/**
+ * Handle resize with autoExpandColumns enabled
+ * Columns to the right (or left for right-pinned) shrink proportionally
+ */
+export declare const handleResizeWithAutoExpand: ({ childrenToResize, collapsedHeaders, containerWidth, delta, headers, initialWidthsMap, isParentResize, resizedHeader, reverse, rootPinned, sectionHeaders, sectionWidth, startWidth, }: {
+    childrenToResize?: HeaderObject[] | undefined;
+    collapsedHeaders?: Set<string> | undefined;
+    containerWidth: number;
+    delta: number;
+    headers: HeaderObject[];
+    initialWidthsMap: Map<string, number>;
+    isParentResize?: boolean | undefined;
+    resizedHeader: HeaderObject;
+    reverse: boolean;
+    rootPinned: Pinned | undefined;
+    sectionHeaders: HeaderObject[];
+    sectionWidth: number;
+    startWidth: number;
+}) => void;

package/dist/core/src/utils/resizeUtils/compensation.d.ts

@@ -0,0 +1,11 @@
+import type HeaderObject from "../../types/HeaderObject";
+/**
+ * Distribute compensation among columns proportionally based on available headroom
+ * Used in autoExpandColumns mode
+ * Positive compensation = shrink columns, Negative compensation = grow columns
+ */
+export declare const distributeCompensationProportionally: ({ columnsToShrink, totalCompensation, initialWidthsMap, }: {
+    columnsToShrink: HeaderObject[];
+    totalCompensation: number;
+    initialWidthsMap: Map<string, number>;
+}) => void;

package/dist/core/src/utils/resizeUtils/domUpdates.d.ts

@@ -0,0 +1,15 @@
+import type HeaderObject from "../../types/HeaderObject";
+import type { Pinned } from "../../types/Pinned";
+/**
+ * Get the pinned value from the root header (for nested headers, children inherit from parent)
+ */
+export declare const getRootPinned: (header: HeaderObject, headers: HeaderObject[]) => Pinned | undefined;
+/**
+ * Update column widths and positions directly in the DOM without triggering React re-renders
+ * This is used during resize drag for better performance
+ *
+ * IMPORTANT: Positions are calculated per pinned section (left/main/right each start at 0)
+ * @param collapsedHeaders - Set of collapsed header accessors; only visible children are laid out (matches findLeafHeaders / SectionRenderer).
+ * @param overrideWidths - Optional map of accessor -> width to use for position calculation (e.g. after resize so DOM reflects just-set value)
+ */
+export declare const updateColumnWidthsInDOM: (headers: HeaderObject[], collapsedHeaders?: Set<string>, overrideWidths?: Map<string, number>) => void;

package/dist/core/src/utils/resizeUtils/index.d.ts

@@ -0,0 +1,5 @@
+import type { HandleResizeStartProps } from "../../types/HandleResizeStartProps";
+/**
+ * Handler for when resize dragging starts
+ */
+export declare const handleResizeStart: ({ autoExpandColumns, collapsedHeaders, containerWidth, event, header, headers, onColumnWidthChange, reverse, setHeaders, setIsResizing, startWidth, }: HandleResizeStartProps) => void;

package/dist/core/src/utils/resizeUtils/maxWidth.d.ts

@@ -0,0 +1,9 @@
+import type HeaderObject from "../../types/HeaderObject";
+/**
+ * Calculate the maximum allowable width for a header based on container constraints
+ */
+export declare const calculateMaxHeaderWidth: ({ header, headers, collapsedHeaders, }: {
+    header: HeaderObject;
+    headers: HeaderObject[];
+    collapsedHeaders?: Set<string> | undefined;
+}) => number;

package/dist/core/src/utils/resizeUtils/parentHeaderResize.d.ts

@@ -0,0 +1,11 @@
+import type HeaderObject from "../../types/HeaderObject";
+/**
+ * Handle resizing of parent headers with multiple children
+ */
+export declare const handleParentHeaderResize: ({ delta, leafHeaders, minWidth, startWidth, maxWidth, }: {
+    delta: number;
+    leafHeaders: HeaderObject[];
+    minWidth: number;
+    startWidth: number;
+    maxWidth: number;
+}) => void;

package/dist/core/src/utils/resizeUtils/sectionWidths.d.ts

@@ -0,0 +1,16 @@
+import type HeaderObject from "../../types/HeaderObject";
+/**
+ * Recalculate widths for all sections (left, right, main)
+ * Returns both constrained widths (for display) and raw content widths (for scrolling)
+ */
+export declare const recalculateAllSectionWidths: ({ headers, containerWidth, collapsedHeaders, }: {
+    headers: HeaderObject[];
+    containerWidth?: number | undefined;
+    collapsedHeaders?: Set<string> | undefined;
+}) => {
+    leftWidth: number;
+    rightWidth: number;
+    mainWidth: number;
+    leftContentWidth: number;
+    rightContentWidth: number;
+};

package/dist/core/src/utils/rowFlattening.d.ts

@@ -0,0 +1,30 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import Row from "../types/Row";
+import RowState from "../types/RowState";
+import TableRow from "../types/TableRow";
+import { HeightOffsets } from "./infiniteScrollUtils";
+import { CustomTheme } from "../types/CustomTheme";
+import { GetRowId } from "../types/GetRowId";
+export interface FlattenRowsConfig {
+    rows: Row[];
+    rowGrouping?: Accessor[];
+    getRowId?: GetRowId;
+    expandedRows?: Map<string, number>;
+    collapsedRows?: Map<string, number>;
+    expandedDepths?: Set<number>;
+    rowStateMap?: Map<string | number, RowState>;
+    hasLoadingRenderer?: boolean;
+    hasErrorRenderer?: boolean;
+    hasEmptyRenderer?: boolean;
+    headers?: HeaderObject[];
+    rowHeight?: number;
+    headerHeight?: number;
+    customTheme?: CustomTheme;
+}
+export interface FlattenRowsResult {
+    flattenedRows: TableRow[];
+    heightOffsets: HeightOffsets;
+    paginatableRows: TableRow[];
+    parentEndPositions: number[];
+}
+export declare function flattenRows(config: FlattenRowsConfig): FlattenRowsResult;

package/dist/core/src/utils/rowProcessing.d.ts

@@ -0,0 +1,36 @@
+import { CumulativeHeightMap } from "./infiniteScrollUtils";
+import { Accessor } from "../types/HeaderObject";
+import TableRow from "../types/TableRow";
+import { HeightOffsets } from "./infiniteScrollUtils";
+import { CustomTheme } from "../types/CustomTheme";
+export interface ProcessRowsConfig {
+    flattenedRows: TableRow[];
+    paginatableRows: TableRow[];
+    parentEndPositions: number[];
+    currentPage: number;
+    rowsPerPage: number;
+    shouldPaginate: boolean;
+    serverSidePagination: boolean;
+    contentHeight: number | undefined;
+    rowHeight: number;
+    scrollTop: number;
+    scrollDirection?: "up" | "down" | "none";
+    heightOffsets?: HeightOffsets;
+    customTheme: CustomTheme;
+    enableStickyParents: boolean;
+    rowGrouping?: Accessor[];
+}
+export interface ProcessRowsResult {
+    currentTableRows: TableRow[];
+    rowsToRender: TableRow[];
+    /** Visible range start index into currentTableRows (when virtualized). */
+    renderedStartIndex: number;
+    /** Visible range end index into currentTableRows (when virtualized). */
+    renderedEndIndex: number;
+    stickyParents: TableRow[];
+    regularRows: TableRow[];
+    partiallyVisibleRows: TableRow[];
+    paginatedHeightOffsets: HeightOffsets | undefined;
+    heightMap: CumulativeHeightMap | undefined;
+}
+export declare function processRows(config: ProcessRowsConfig): ProcessRowsResult;

package/dist/core/src/utils/rowSelectionUtils.d.ts

@@ -0,0 +1,39 @@
+import Row from "../types/Row";
+import TableRow from "../types/TableRow";
+import HeaderObject from "../types/HeaderObject";
+/**
+ * Get the set of selected row IDs from an array of table rows
+ */
+export declare const getSelectedRowIds: (tableRows: TableRow[]) => string[];
+/**
+ * Check if a specific row is selected
+ */
+export declare const isRowSelected: (rowId: string, selectedRows: Set<string>) => boolean;
+/**
+ * Check if all rows are selected
+ */
+export declare const areAllRowsSelected: (tableRows: TableRow[], selectedRows: Set<string>) => boolean;
+/**
+ * Toggle selection of a single row
+ */
+export declare const toggleRowSelection: (rowId: string, selectedRows: Set<string>) => Set<string>;
+/**
+ * Select all rows
+ */
+export declare const selectAllRows: (tableRows: TableRow[]) => Set<string>;
+/**
+ * Deselect all rows
+ */
+export declare const deselectAllRows: () => Set<string>;
+/**
+ * Get the selected rows from the table rows array
+ */
+export declare const getSelectedRows: (tableRows: TableRow[], selectedRows: Set<string>) => Row[];
+/**
+ * Get the count of selected rows
+ */
+export declare const getSelectedRowCount: (selectedRows: Set<string>) => number;
+/**
+ * Create a selection header for the checkbox column
+ */
+export declare const createSelectionHeader: (width: number) => HeaderObject;

package/dist/core/src/utils/rowSeparatorRenderer.d.ts

@@ -0,0 +1,12 @@
+import { HeightOffsets } from "./infiniteScrollUtils";
+import { CustomTheme } from "../types/CustomTheme";
+export interface CreateRowSeparatorOptions {
+    position: number;
+    rowHeight: number;
+    displayStrongBorder: boolean;
+    heightOffsets?: HeightOffsets;
+    customTheme?: CustomTheme;
+    isSticky?: boolean;
+}
+export declare const createRowSeparator: (options: CreateRowSeparatorOptions) => HTMLElement;
+export declare const createSpacerRow: (position: number, rowHeight: number, heightOffsets: HeightOffsets | undefined, customTheme: CustomTheme, className: string, height?: number) => HTMLElement;

package/dist/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 | undefined;
+    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 | undefined;
+    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 | undefined;
+    expandedDepths: Set<number>;
+    expandedRows: Map<string, number>;
+    collapsedRows: Map<string, number>;
+    rowGrouping?: string[] | undefined;
+    getRowId?: GetRowId | undefined;
+    rows: Row[];
+    displayPositionOffset?: number | undefined;
+    rowStateMap?: Map<string | number, RowState> | undefined;
+    hasLoadingRenderer?: boolean | undefined;
+    hasErrorRenderer?: boolean | undefined;
+    hasEmptyRenderer?: boolean | undefined;
+    headers?: HeaderObject[] | undefined;
+    rowHeight: number;
+    headerHeight: number;
+    customTheme: CustomTheme;
+}) => TableRow[];

package/dist/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/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/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/index.es.js

@@ -0,0 +1,2 @@
+import{render as e,createComponent as r,use as t,template as n}from"solid-js/web";import{onMount as o,createEffect as d,onCleanup as i}from"solid-js";import{SimpleTableVanilla as a}from"simple-table-core";function c(e,r){var t={};for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&r.indexOf(n)<0&&(t[n]=e[n]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var o=0;for(n=Object.getOwnPropertySymbols(e);o<n.length;o++)r.indexOf(n[o])<0&&Object.prototype.propertyIsEnumerable.call(e,n[o])&&(t[n[o]]=e[n[o]])}return t}function l(t){return n=>{const o=document.createElement("div");return e(()=>r(t,n),o),o}}function s(r){const t=document.createElement("div");return e(()=>r,t),t}function f(r){const t=document.createElement("div");return e(()=>r,t),t.innerHTML}function u(e){return"function"==typeof e}function p(e){const{cellRenderer:r,headerRenderer:t,children:n,nestedTable:o}=e,d=c(e,["cellRenderer","headerRenderer","children","nestedTable"]),i=Object.assign({},d);if(r&&(i.cellRenderer=l(r)),t&&(i.headerRenderer=l(t)),n&&(i.children=n.map(p)),o){const e=Object.assign(Object.assign({},o),{rows:[]});i.nestedTable=m(e)}return i}function m(e){const{defaultHeaders:r,footerRenderer:t,emptyStateRenderer:n,errorStateRenderer:o,loadingStateRenderer:d,tableEmptyStateRenderer:i,headerDropdown:a,columnEditorConfig:m,icons:R}=e,b=c(e,["defaultHeaders","footerRenderer","emptyStateRenderer","errorStateRenderer","loadingStateRenderer","tableEmptyStateRenderer","headerDropdown","columnEditorConfig","icons","ref"]),y=Object.assign(Object.assign({},b),{defaultHeaders:r.map(p)});if(void 0!==t&&(y.footerRenderer=l(t)),void 0!==n)if(u(n))y.emptyStateRenderer=l(n);else{const e=n;y.emptyStateRenderer=()=>s(e)}if(void 0!==o)if(u(o))y.errorStateRenderer=l(o);else{const e=o;y.errorStateRenderer=()=>s(e)}if(void 0!==d)if(u(d))y.loadingStateRenderer=l(d);else{const e=d;y.loadingStateRenderer=()=>s(e)}return void 0!==i&&(y.tableEmptyStateRenderer=null===i?null:s(i)),void 0!==a&&(y.headerDropdown=l(a)),void 0!==m&&(y.columnEditorConfig=function(e){const{rowRenderer:r}=e,t=c(e,["rowRenderer"]);return Object.assign(Object.assign({},t),r?{rowRenderer:l(r)}:{})}(m)),void 0!==R&&(y.icons=function(e){const r={};for(const[t,n]of Object.entries(e))null!=n&&(r[t]="string"==typeof n||n instanceof HTMLElement||n instanceof SVGElement?n:f(n));return r}(R)),y}"function"==typeof SuppressedError&&SuppressedError;var R=n("<div>");function b(e){let r,n=null;return o(()=>{n=new a(r,m(e)),n.mount(),e.ref&&e.ref(n.getAPI())}),d(()=>{n&&n.update(m(e))}),i(()=>{null==n||n.destroy(),n=null}),c=R(),"function"==typeof r?t(r,c):r=c,c;var c}export{b as SimpleTable};
+//# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

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

package/dist/solid/src/SimpleTable.d.ts

@@ -0,0 +1,19 @@
+import type { SimpleTableSolidProps } from "./types";
+/**
+ * SimpleTable — Solid.js adapter for simple-table-core.
+ *
+ * Accepts the same props as SimpleTableProps (the vanilla user-facing API) but
+ * with Solid component types for all renderer props.
+ *
+ * Pass a callback `ref` prop to receive the full TableAPI imperative interface:
+ *
+ * @example
+ * let tableApi: TableAPI | undefined;
+ *
+ * <SimpleTable
+ *   ref={(api) => (tableApi = api)}
+ *   rows={rows()}
+ *   defaultHeaders={headers}
+ * />
+ */
+export declare function SimpleTable(props: SimpleTableSolidProps): import("solid-js").JSX.Element;

package/dist/solid/src/buildVanillaConfig.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleTableConfig } from "simple-table-core";
+import type { SimpleTableSolidProps } from "./types";
+export declare function buildVanillaConfig(config: SimpleTableSolidProps): SimpleTableConfig;

package/dist/solid/src/index.d.ts

@@ -0,0 +1,3 @@
+export { SimpleTable } from "./SimpleTable";
+export type { SimpleTableSolidProps, TableInstance, SolidHeaderObject, SolidColumnEditorConfig, SolidIconsConfig, SolidIconElement, SolidCellRenderer, SolidHeaderRenderer, SolidFooterRenderer, SolidHeaderDropdown, SolidColumnEditorRowRenderer, SolidLoadingStateRenderer, SolidErrorStateRenderer, SolidEmptyStateRenderer, } from "./types";
+export type { Accessor, AggregationConfig, AggregationType, BoundingBox, Cell, CellChangeProps, CellClickProps, CellRendererProps, CellValue, ChartOptions, ColumnEditorConfig, ColumnEditorRowRenderer, ColumnEditorRowRendererComponents, ColumnEditorRowRendererProps, ColumnEditorSearchFunction, ColumnType, ColumnVisibilityState, Comparator, ComparatorProps, CustomTheme, CustomThemeProps, DragHandlerProps, EmptyStateRenderer, EmptyStateRendererProps, EnumOption, ErrorStateRenderer, ErrorStateRendererProps, ExportToCSVProps, ExportValueGetter, ExportValueProps, FilterCondition, FooterRendererProps, GetRowId, GetRowIdParams, HeaderDropdown, HeaderDropdownProps, HeaderObject, HeaderRenderer, HeaderRendererComponents, HeaderRendererProps, IconsConfig, LoadingStateRenderer, LoadingStateRendererProps, OnRowGroupExpandProps, OnSortProps, QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode, Row, RowButtonProps, RowId, RowSelectionChangeProps, RowState, SetHeaderRenameProps, SharedTableProps, ShowWhen, SimpleTableConfig, SimpleTableProps, SortColumn, TableAPI, TableFilterState, TableHeaderProps, TableRowProps, Theme, UpdateDataProps, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps, } from "simple-table-core";

package/dist/solid/src/types.d.ts

@@ -0,0 +1,53 @@
+import type { Component, JSX } from "solid-js";
+import type { SimpleTableProps, SimpleTableConfig, HeaderObject, TableAPI, CellRendererProps, HeaderRendererProps, FooterRendererProps, LoadingStateRendererProps, ErrorStateRendererProps, EmptyStateRendererProps, HeaderDropdownProps, ColumnEditorRowRendererProps, ColumnEditorConfig } from "simple-table-core";
+export interface TableInstance {
+    mount(): void;
+    update(config: Partial<SimpleTableConfig>): void;
+    destroy(): void;
+    getAPI(): TableAPI;
+}
+export type SolidIconElement = JSX.Element;
+export interface SolidIconsConfig {
+    drag?: SolidIconElement;
+    expand?: SolidIconElement;
+    filter?: SolidIconElement;
+    headerCollapse?: SolidIconElement;
+    headerExpand?: SolidIconElement;
+    next?: SolidIconElement;
+    prev?: SolidIconElement;
+    sortDown?: SolidIconElement;
+    sortUp?: SolidIconElement;
+    pinnedLeftIcon?: SolidIconElement;
+    pinnedRightIcon?: SolidIconElement;
+}
+export type SolidCellRenderer = Component<CellRendererProps>;
+export type SolidHeaderRenderer = Component<HeaderRendererProps>;
+export type SolidFooterRenderer = Component<FooterRendererProps>;
+export type SolidHeaderDropdown = Component<HeaderDropdownProps>;
+export type SolidColumnEditorRowRenderer = Component<ColumnEditorRowRendererProps>;
+export type SolidLoadingStateRenderer = Component<LoadingStateRendererProps> | JSX.Element;
+export type SolidErrorStateRenderer = Component<ErrorStateRendererProps> | JSX.Element;
+export type SolidEmptyStateRenderer = Component<EmptyStateRendererProps> | JSX.Element;
+export interface SolidColumnEditorConfig extends Omit<ColumnEditorConfig, "rowRenderer"> {
+    rowRenderer?: SolidColumnEditorRowRenderer;
+}
+export interface SolidHeaderObject extends Omit<HeaderObject, "cellRenderer" | "headerRenderer" | "children" | "nestedTable"> {
+    cellRenderer?: SolidCellRenderer;
+    headerRenderer?: SolidHeaderRenderer;
+    children?: SolidHeaderObject[];
+    nestedTable?: Omit<SimpleTableSolidProps, "rows">;
+}
+export interface SimpleTableSolidProps extends Omit<SimpleTableProps, "tableRef" | "allowAnimations" | "expandIcon" | "filterIcon" | "headerCollapseIcon" | "headerExpandIcon" | "nextIcon" | "prevIcon" | "sortDownIcon" | "sortUpIcon" | "columnEditorText" | "defaultHeaders" | "footerRenderer" | "emptyStateRenderer" | "errorStateRenderer" | "loadingStateRenderer" | "tableEmptyStateRenderer" | "headerDropdown" | "columnEditorConfig" | "icons"> {
+    defaultHeaders: SolidHeaderObject[];
+    footerRenderer?: SolidFooterRenderer;
+    loadingStateRenderer?: SolidLoadingStateRenderer;
+    errorStateRenderer?: SolidErrorStateRenderer;
+    emptyStateRenderer?: SolidEmptyStateRenderer;
+    tableEmptyStateRenderer?: JSX.Element;
+    headerDropdown?: SolidHeaderDropdown;
+    columnEditorConfig?: SolidColumnEditorConfig;
+    icons?: SolidIconsConfig;
+    /** Callback ref — receives the TableAPI once the table is mounted. */
+    ref?: (api: TableAPI) => void;
+}
+export type { CellRendererProps, HeaderRendererProps, FooterRendererProps, LoadingStateRendererProps, ErrorStateRendererProps, EmptyStateRendererProps, HeaderDropdownProps, ColumnEditorRowRendererProps, };

package/dist/solid/src/utils/wrapSolidRenderer.d.ts

@@ -0,0 +1,20 @@
+import type { Component } from "solid-js";
+/**
+ * Wraps a Solid component into a function that returns an HTMLElement, matching
+ * the vanilla renderer contract expected by simple-table-core.
+ *
+ * Solid's render() is synchronous, so no flushSync equivalent is needed.
+ */
+export declare function wrapSolidRenderer<P extends object>(component: Component<P>): (props: P) => HTMLElement;
+/**
+ * Renders a static Solid JSX node (already evaluated) into an HTMLElement.
+ * Used for props like tableEmptyStateRenderer that are not called with arguments.
+ */
+export declare function wrapSolidNode(node: any): HTMLElement;
+/**
+ * Converts a Solid node to an HTML string.
+ * Used for icon props where vanilla expects string | HTMLElement | SVGSVGElement.
+ */
+export declare function solidNodeToHtmlString(node: any): string;
+/** Returns true if the value is a Solid component (a function). */
+export declare function isSolidComponent(value: unknown): value is Component<any>;