@stenajs-webui/grid 20.6.11 → 20.7.0

package/dist/config/TableConfig.d.ts

@@ -2,10 +2,10 @@ export declare const tableBorderColor = "var(--lhds-color-ui-300)";
 export declare const tableBorderColorExpanded = "var(--lhds-color-blue-500)";
 export declare const tableBackgroundColorExpanded = "var(--lhds-color-blue-50)";
 export declare const tableBackgroundHoverColorExpanded = "var(--lhds-color-blue-100)";
-export declare const tableBorder: string;
+export declare const tableBorder = "1px solid var(--lhds-color-ui-300)";
 export declare const tableBorderHidden = "1px solid transparent";
 export declare const tableBorderLeft = "var(--swui-expand-highlight-border-width) solid transparent";
-export declare const tableBorderLeftExpanded: string;
+export declare const tableBorderLeftExpanded = "var(--swui-expand-highlight-border-width) solid var(--lhds-color-blue-500)";
 export declare const defaultTableRowHeight = "40px";
 export declare const defaultTableHeadRowHeight = "40px";
 export declare const smallTableRowWidth = "40px";

package/dist/features/grid-cell/hooks/UseEditableCell.d.ts

@@ -1,8 +1,8 @@
 import * as React from "react";
 import { RevertableValue } from "./UseRevertableValue";
-export declare type AllowedInputType = "all" | "numeric" | "alphanumeric" | "letters" | "none";
-declare type OnStartEditingFunc = (keyEvent?: KeyDownEvent) => void;
-declare type TransformEnteredValueFunc<TValue> = (value?: string) => TValue;
+export type AllowedInputType = "all" | "numeric" | "alphanumeric" | "letters" | "none";
+type OnStartEditingFunc = (keyEvent?: KeyDownEvent) => void;
+type TransformEnteredValueFunc<TValue> = (value?: string) => TValue;
 export interface UseEditableCellOptions<TValue> {
     /**
      * Specifies if cell is editable.

package/dist/features/grid-cell/hooks/UseGridCell.d.ts

@@ -2,7 +2,7 @@ import { KeyboardEventHandler } from "react";
 import { MoveDirection } from "../../../util/DirectionCalculator";
 import { KeyDownEvent, UseEditableCellOptions } from "./UseEditableCell";
 import { GridNavigationRequiredProps, UseGridNavigationOptions } from "./UseGridNavigation";
-export declare type UseGridCellOptions<TValue> = UseGridNavigationOptions & UseEditableCellOptions<TValue>;
+export type UseGridCellOptions<TValue> = UseGridNavigationOptions & UseEditableCellOptions<TValue>;
 export interface UseGridCellResult<TValue> {
     /**
      * The current value in the editor. Pass this as value to form field components.

package/dist/features/grid-cell/hooks/UseGridNavigation.d.ts

@@ -61,8 +61,8 @@ export interface GridNavigationRequiredProps {
     onKeyDown: (e: KeyboardEvent) => boolean;
     id: string;
 }
-export declare type CellMoveHandler = (event: OnCellMoveEvent) => void;
-export declare type CellNavigationHandler = (event: OnCellNavigationEvent) => void;
+export type CellMoveHandler = (event: OnCellMoveEvent) => void;
+export type CellNavigationHandler = (event: OnCellNavigationEvent) => void;
 export interface OnCellMoveEvent {
     direction: MoveDirection;
     fromRowIndex: number;
@@ -76,7 +76,7 @@ export interface OnCellNavigationEvent extends OnCellMoveEvent {
     cellDidChange: boolean;
 }
 export declare const useGridNavigation: (options: UseGridNavigationOptions) => UseGridNavigationResult;
-declare type MoveHandler = (direction: MoveDirection) => void;
-declare type FocusOnCellFunc = (tableId: string, pos: CellIndices) => void;
+type MoveHandler = (direction: MoveDirection) => void;
+type FocusOnCellFunc = (tableId: string, pos: CellIndices) => void;
 export declare const focusOnCell: FocusOnCellFunc;
 export {};

package/dist/features/standard-table/components/StandardTable.d.ts

@@ -89,5 +89,5 @@ export interface StandardTableProps<TItem, TColumnKey extends string, TColumnGro
      */
     onSortOrderChange?: StandardTableOnSortOrderChange<TColumnKey>;
 }
-export declare type StandardTableVariant = "relaxed" | "standard" | "condensed" | "compact";
-export declare const StandardTable: <TItem, TColumnKey extends string, TColumnGroupKey extends string>({ tableContext, config, columnOrder, columnGroupOrder, tableId, variant, onKeyDown, onSortOrderChange, appendTooltipTo, ...props }: StandardTableProps<TItem, TColumnKey, TColumnGroupKey>) => JSX.Element;
+export type StandardTableVariant = "relaxed" | "standard" | "condensed" | "compact";
+export declare const StandardTable: <TItem extends {}, TColumnKey extends string, TColumnGroupKey extends string>({ tableContext, config, columnOrder, columnGroupOrder, tableId, variant, onKeyDown, onSortOrderChange, appendTooltipTo, ...props }: StandardTableProps<TItem, TColumnKey, TColumnGroupKey>) => JSX.Element;

package/dist/features/standard-table/components/StandardTableCell.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-export interface StandardTableCellProps<TItem> {
+export interface StandardTableCellProps<TItem extends {}> {
     columnId: string;
     item: TItem;
     rowIndex: number;
@@ -8,4 +8,4 @@ export interface StandardTableCellProps<TItem> {
     borderFromGroup?: boolean | string;
     disableBorderLeft?: boolean;
 }
-export declare const StandardTableCell: React.MemoExoticComponent<(<TItem>({ columnId, item, colIndex, rowIndex, numRows, borderFromGroup, disableBorderLeft, }: StandardTableCellProps<TItem>) => JSX.Element)>;
+export declare const StandardTableCell: React.MemoExoticComponent<(<TItem extends {}>({ columnId, item, colIndex, rowIndex, numRows, borderFromGroup, disableBorderLeft, }: StandardTableCellProps<TItem>) => JSX.Element)>;

package/dist/features/standard-table/components/StandardTableContent.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { StandardTableProps, StandardTableVariant } from "./StandardTable";
-interface Props<TItem, TColumnKey extends string, TColumnGroupKey extends string> extends Omit<StandardTableProps<TItem, TColumnKey, TColumnGroupKey>, "tableContext" | "config"> {
+interface Props<TItem extends {}, TColumnKey extends string, TColumnGroupKey extends string> extends Omit<StandardTableProps<TItem, TColumnKey, TColumnGroupKey>, "tableContext" | "config"> {
     variant: StandardTableVariant;
 }
-export declare const StandardTableContent: React.MemoExoticComponent<(<TItem, TColumnKey extends string, TColumnGroupKey extends string>({ error, bannerError, loading, items, noItemsLabel, noItemsContentRight, noItemsContentBottom, noItemsHeader, colIndexOffset, rowIndexOffset, variant, errorLabel, }: Props<TItem, TColumnKey, TColumnGroupKey>) => JSX.Element)>;
+export declare const StandardTableContent: React.MemoExoticComponent<(<TItem extends {}, TColumnKey extends string, TColumnGroupKey extends string>({ error, bannerError, loading, items, noItemsLabel, noItemsContentRight, noItemsContentBottom, noItemsHeader, colIndexOffset, rowIndexOffset, variant, errorLabel, }: Props<TItem, TColumnKey, TColumnGroupKey>) => JSX.Element)>;
 export {};

package/dist/features/standard-table/components/StandardTableRow.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { RefObject } from "react";
-export interface StandardTableRowProps<TItem> {
+export interface StandardTableRowProps<TItem extends {}> {
     item: TItem;
     idListForEnabledItems: Array<string>;
     rowIndex: number;
@@ -9,4 +9,4 @@ export interface StandardTableRowProps<TItem> {
     alwaysVisible?: boolean;
     shiftPressedRef: RefObject<boolean>;
 }
-export declare const StandardTableRow: React.MemoExoticComponent<(<TItem>({ item, idListForEnabledItems, rowIndex, numRows, colIndexOffset, alwaysVisible, shiftPressedRef, }: StandardTableRowProps<TItem>) => JSX.Element)>;
+export declare const StandardTableRow: React.MemoExoticComponent<(<TItem extends {}>({ item, idListForEnabledItems, rowIndex, numRows, colIndexOffset, alwaysVisible, shiftPressedRef, }: StandardTableRowProps<TItem>) => JSX.Element)>;

package/dist/features/standard-table/components/StandardTableRowList.d.ts

@@ -1,10 +1,10 @@
 import * as React from "react";
 import { StandardTableVariant } from "./StandardTable";
-interface StandardTableContentProps<TItem> {
+interface StandardTableContentProps<TItem extends {}> {
     items?: Array<TItem>;
     colIndexOffset?: number;
     rowIndexOffset?: number;
     variant: StandardTableVariant;
 }
-export declare const StandardTableRowList: React.MemoExoticComponent<(<TItem>({ items, colIndexOffset, rowIndexOffset, }: StandardTableContentProps<TItem>) => JSX.Element)>;
+export declare const StandardTableRowList: React.MemoExoticComponent<(<TItem extends {}>({ items, colIndexOffset, rowIndexOffset, }: StandardTableContentProps<TItem>) => JSX.Element)>;
 export {};

package/dist/features/standard-table/config/StandardTableColumnConfig.d.ts

@@ -4,8 +4,8 @@ import { UseGridCellOptions, UseGridCellResult } from "../../grid-cell/hooks/Use
 import { SortOrderIconVariant } from "../../table-ui/components/table/SortOrderIcon";
 import { StandardTableOnKeyDownArgs } from "./StandardTableConfig";
 import { TextSize } from "@stenajs-webui/core";
-export declare type StandardTableColumnConfig<TItem, TItemValue, TColumnKey extends string> = StandardTableColumnOptions<TItem, TItemValue, TColumnKey> & StandardTableColumnOptionsWithNoGroups & ItemValueResolver<TItem, TItemValue>;
-export declare type StandardTableColumnConfigWithGroups<TItem, TItemValue, TColumnKey extends string> = StandardTableColumnOptions<TItem, TItemValue, TColumnKey> & ItemValueResolver<TItem, TItemValue>;
+export type StandardTableColumnConfig<TItem, TItemValue, TColumnKey extends string> = StandardTableColumnOptions<TItem, TItemValue, TColumnKey> & StandardTableColumnOptionsWithNoGroups & ItemValueResolver<TItem, TItemValue>;
+export type StandardTableColumnConfigWithGroups<TItem, TItemValue, TColumnKey extends string> = StandardTableColumnOptions<TItem, TItemValue, TColumnKey> & ItemValueResolver<TItem, TItemValue>;
 export interface StandardTableColumnOptionsWithNoGroups {
     /**
      * Enable sticky behaviour to the left make elements scroll in behind this column.
@@ -125,16 +125,16 @@ export interface StandardTableColumnOptions<TItem, TItemValue, TColumnKey extend
      */
     summaryCellColSpan?: number;
 }
-export declare type StandardTableSummaryTextProvider<TItem> = (arg: StandardTableSummaryTextProviderArgObject<TItem>) => string;
+export type StandardTableSummaryTextProvider<TItem> = (arg: StandardTableSummaryTextProviderArgObject<TItem>) => string;
 export interface StandardTableSummaryTextProviderArgObject<TItem> {
     items: Array<TItem>;
 }
-export declare type StandardTableSummaryCellRenderer<TItem> = (arg: StandardTableSummaryCellRendererArgObject<TItem>) => ReactNode;
+export type StandardTableSummaryCellRenderer<TItem> = (arg: StandardTableSummaryCellRendererArgObject<TItem>) => ReactNode;
 export interface StandardTableSummaryCellRendererArgObject<TItem> {
     items: Array<TItem>;
     text?: string;
 }
-export declare type StandardTableCellRenderer<TItemValue, TItem> = (arg: StandardTableCellRendererArgObject<TItemValue, TItem>) => ReactNode;
+export type StandardTableCellRenderer<TItemValue, TItem> = (arg: StandardTableCellRendererArgObject<TItemValue, TItem>) => ReactNode;
 export interface StandardTableCellRendererArgObject<TItemValue, TItem> {
     label: string;
     value: TItemValue;
@@ -153,9 +153,9 @@ export interface StandardTableCellRendererArgObject<TItemValue, TItem> {
  * Default renderer. This is defined in config, not for a specific column.
  * Therefor, it can not know "value: TItemValue", since it has not been defined yet.
  */
-export declare type DefaultStandardTableCellRenderer<TItem> = (arg: StandardTableCellRendererArgObject<unknown, TItem>) => ReactNode;
-export declare type BackgroundResolver<TItem> = (item: TItem) => string | undefined;
+export type DefaultStandardTableCellRenderer<TItem> = (arg: StandardTableCellRendererArgObject<unknown, TItem>) => ReactNode;
+export type BackgroundResolver<TItem> = (item: TItem) => string | undefined;
 export interface ItemValueResolver<TItem, TItemValue> {
     itemValueResolver: (item: TItem) => TItemValue;
 }
-export declare const createColumnConfig: <TItem, TItemValue, TColumnKey extends string>(itemValueResolver: (item: TItem) => TItemValue, options?: StandardTableColumnOptions<TItem, TItemValue, TColumnKey> | undefined) => StandardTableColumnConfig<TItem, TItemValue, TColumnKey>;
+export declare const createColumnConfig: <TItem, TItemValue, TColumnKey extends string>(itemValueResolver: (item: TItem) => TItemValue, options?: StandardTableColumnOptions<TItem, TItemValue, TColumnKey>) => StandardTableColumnConfig<TItem, TItemValue, TColumnKey>;

package/dist/features/standard-table/config/StandardTableConfig.d.ts

@@ -11,7 +11,7 @@ export interface StandardTableOnKeyDownArgs<TItem, TColumnKey extends string> {
     columnId: TColumnKey;
     item: TItem;
 }
-export declare type StandardTableConfig<TItem, TColumnKey extends string, TColumnGroupKey extends string = string> = StandardTableConfigWithGroups<TItem, TColumnKey, TColumnGroupKey> | StandardTableConfigWithNoGroups<TItem, TColumnKey>;
+export type StandardTableConfig<TItem, TColumnKey extends string, TColumnGroupKey extends string = string> = StandardTableConfigWithGroups<TItem, TColumnKey, TColumnGroupKey> | StandardTableConfigWithNoGroups<TItem, TColumnKey>;
 export interface StandardTableConfigWithGroups<TItem, TColumnKey extends string, TColumnGroupKey extends string = string> extends StandardTableConfigBase<TItem, TColumnKey> {
     /**
      * Configs for the columns available in the table.
@@ -167,4 +167,4 @@ export interface RowBackgroundResolverColorCombination {
     background: string;
     hoverBackground: string;
 }
-export declare type StickyColumnGroupVariant = "first" | "last" | "both";
+export type StickyColumnGroupVariant = "first" | "last" | "both";

package/dist/features/standard-table/context/GroupConfigsAndIdsForRowsContext.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
 import { GroupConfigAndId } from "../features/column-groups/ColumnGroupFactory";
 export declare const GroupConfigsAndIdsForRowsContext: import("react").Context<GroupConfigAndId<any>[]>;
-export declare const useGroupConfigsAndIdsForRows: <TColumnKey extends string>() => GroupConfigAndId<TColumnKey>[];
+export declare const useGroupConfigsAndIdsForRows: <TColumnKey extends string>() => Array<GroupConfigAndId<TColumnKey>>;
 export declare const useTotalNumColumnsForRows: () => number;

package/dist/features/standard-table/features/checkboxes/UseTableHeadCheckbox.d.ts

@@ -1,4 +1,4 @@
-export declare const useTableHeadCheckbox: <TItem>(items: TItem[] | undefined) => {
+export declare const useTableHeadCheckbox: <TItem>(items: Array<TItem> | undefined) => {
     selectionIsEmpty: boolean;
     allItemsAreSelected: boolean;
     onClickCheckbox: () => void;

package/dist/features/standard-table/features/column-groups/ColumnGroupFactory.d.ts

@@ -4,4 +4,4 @@ export interface GroupConfigAndId<TColumnKey extends string> {
     groupId: string;
     groupConfig: StandardTableColumnGroupConfig<TColumnKey>;
 }
-export declare const createGroupConfigAndIdsForRows: <TItem, TColumnKey extends string, TColumnGroupKey extends string>(columnGroups: Record<TColumnGroupKey, StandardTableColumnGroupConfig<TColumnKey>> | undefined, columnGroupOrder: TColumnGroupKey[] | undefined, columnOrder: TColumnKey[] | undefined) => GroupConfigAndId<TColumnKey>[];
+export declare const createGroupConfigAndIdsForRows: <TItem, TColumnKey extends string, TColumnGroupKey extends string>(columnGroups: StandardTableConfigWithGroups<TItem, TColumnKey, TColumnGroupKey>["columnGroups"] | undefined, columnGroupOrder: StandardTableConfigWithGroups<TItem, TColumnKey, TColumnGroupKey>["columnGroupOrder"] | undefined, columnOrder: StandardTableConfigWithNoGroups<TItem, TColumnKey>["columnOrder"] | undefined) => Array<GroupConfigAndId<TColumnKey>>;

package/dist/features/standard-table/features/column-index-per-column-id/ColumnIndexCalculator.d.ts

@@ -1,5 +1,5 @@
 import { StandardTableConfig } from "../../config/StandardTableConfig";
-export declare type ColumnIndexPerColumnId<TColumnKey extends string> = Record<TColumnKey, number>;
+export type ColumnIndexPerColumnId<TColumnKey extends string> = Record<TColumnKey, number>;
 export interface ColumnIndexPerColumnIdCalculationResult<TColumnKey extends string> {
     columnIndexPerColumnId: ColumnIndexPerColumnId<TColumnKey>;
     numNavigableColumns: number;

package/dist/features/standard-table/features/expand-collapse/UseTableHeadExpandCollapse.d.ts

@@ -1,4 +1,4 @@
-export declare const useTableHeadExpandCollapse: <TItem>(items: TItem[] | undefined) => {
+export declare const useTableHeadExpandCollapse: <TItem>(items: Array<TItem> | undefined) => {
     allItemsAreExpanded: boolean;
     toggleExpanded: () => void;
 };

package/dist/features/standard-table/features/sorting/MultitypeComparator.d.ts

@@ -1,3 +1,3 @@
-declare type ComparableType = number | string | boolean | Date | null | undefined;
+type ComparableType = number | string | boolean | Date | null | undefined;
 export declare const multitypeComparator: (a: ComparableType, b: ComparableType) => number;
 export {};

package/dist/features/standard-table/features/sticky-columns/StickyColumnGroupOffsetCalculator.d.ts

@@ -1,10 +1,10 @@
 import { StandardTableConfig, StandardTableConfigWithGroups } from "../../config/StandardTableConfig";
-export declare type OffsetPerColumn<TColumnKey extends string> = Record<TColumnKey, string>;
+export type OffsetPerColumn<TColumnKey extends string> = Record<TColumnKey, string>;
 /**
  * This methods assumes that the config has already been validated to be correct.
  * @param config
  */
-export declare const calculateOffsetForColumnInStickyColumnGroups: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey, string>) => OffsetPerColumn<TColumnKey>;
-export declare const calculateOffsetForColumns: <TItem, TColumnKey extends string>(columnIds: TColumnKey[], columns: Record<TColumnKey, import("../../config/StandardTableColumnConfig").StandardTableColumnConfigWithGroups<TItem, any, TColumnKey>> | Record<TColumnKey, import("../../config/StandardTableColumnConfig").StandardTableColumnConfig<TItem, any, TColumnKey>>, includeOffsetForCheckboxAndExpand: boolean) => OffsetPerColumn<TColumnKey>;
-export declare const getColumnIdsForLeftSideStickyGroup: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey, string>) => TColumnKey[];
-export declare const getColumnIdsForRightSideStickyGroup: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey, string>) => TColumnKey[];
+export declare const calculateOffsetForColumnInStickyColumnGroups: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey>) => OffsetPerColumn<TColumnKey>;
+export declare const calculateOffsetForColumns: <TItem, TColumnKey extends string>(columnIds: Array<TColumnKey>, columns: StandardTableConfig<TItem, TColumnKey>["columns"], includeOffsetForCheckboxAndExpand: boolean) => OffsetPerColumn<TColumnKey>;
+export declare const getColumnIdsForLeftSideStickyGroup: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey>) => Array<TColumnKey>;
+export declare const getColumnIdsForRightSideStickyGroup: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey>) => Array<TColumnKey>;

package/dist/features/standard-table/features/sticky-columns/StickyColumnGroupValidator.d.ts

@@ -1,4 +1,4 @@
 import { StandardTableConfig, StandardTableConfigWithGroups } from "../../config/StandardTableConfig";
-export declare const ensureConfigHasValidSticky: <TItem, TColumnKey extends string>(config: StandardTableConfig<TItem, TColumnKey, string>) => void;
-export declare const ensureNoColumnsAreSticky: <TItem, TColumnKey extends string>(config: StandardTableConfig<TItem, TColumnKey, string>) => void;
-export declare const ensureAllColumnsInGroupHasFixedWidth: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey, string>, columnGroupIndex: number) => void;
+export declare const ensureConfigHasValidSticky: <TItem extends {}, TColumnKey extends string>(config: StandardTableConfig<TItem, TColumnKey>) => void;
+export declare const ensureNoColumnsAreSticky: <TItem extends {}, TColumnKey extends string>(config: StandardTableConfig<TItem, TColumnKey>) => void;
+export declare const ensureAllColumnsInGroupHasFixedWidth: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey>, columnGroupIndex: number) => void;

package/dist/features/standard-table/features/sticky-columns/StickyPropsPerColumnCalculator.d.ts

@@ -1,5 +1,5 @@
 import { StandardTableConfig, StandardTableConfigWithGroups, StandardTableConfigWithNoGroups } from "../../config/StandardTableConfig";
 import { StickyPropsPerColumn } from "./types";
-export declare const getStickyPropsPerColumn: <TItem, TColumnKey extends string>(config: StandardTableConfig<TItem, TColumnKey, string>) => StickyPropsPerColumn<TColumnKey>;
+export declare const getStickyPropsPerColumn: <TItem, TColumnKey extends string>(config: StandardTableConfig<TItem, TColumnKey>) => StickyPropsPerColumn<TColumnKey>;
 export declare const getStickyPropsPerColumnWithNoGroups: <TItem, TColumnKey extends string>(config: StandardTableConfigWithNoGroups<TItem, TColumnKey>) => StickyPropsPerColumn<TColumnKey>;
-export declare const getStickyPropsPerColumnWithGroups: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey, string>) => StickyPropsPerColumn<TColumnKey>;
+export declare const getStickyPropsPerColumnWithGroups: <TItem, TColumnKey extends string>(config: StandardTableConfigWithGroups<TItem, TColumnKey>) => StickyPropsPerColumn<TColumnKey>;

package/dist/features/standard-table/features/sticky-columns/types.d.ts

@@ -1,5 +1,5 @@
-export declare type StickyPropsPerColumn<TColumn extends string> = Record<TColumn, StickyCellProps>;
-declare type StickyCellType = "column" | "first-group" | "last-group";
+export type StickyPropsPerColumn<TColumn extends string> = Record<TColumn, StickyCellProps>;
+type StickyCellType = "column" | "first-group" | "last-group";
 export interface StickyCellProps {
     left: string | undefined;
     right: string | undefined;

package/dist/features/standard-table/features/summary-row/SummaryCellColSpanCalculator.d.ts

@@ -2,6 +2,6 @@ export interface ColumnIdAndColSpan<TColumnKey extends string> {
     columnId: TColumnKey;
     colSpan: number;
 }
-export declare const getColumnsLimitedWithColSpan: <TColumnKey extends string>(columnOrder: TColumnKey[], columns: Record<TColumnKey, {
-    summaryCellColSpan?: number | undefined;
-}>) => ColumnIdAndColSpan<TColumnKey>[];
+export declare const getColumnsLimitedWithColSpan: <TColumnKey extends string>(columnOrder: Array<TColumnKey>, columns: Record<TColumnKey, {
+    summaryCellColSpan?: number;
+}>) => Array<ColumnIdAndColSpan<TColumnKey>>;

package/dist/features/standard-table/features/summary-row/components/StandardTableSummaryRow.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
-interface StandardTableSummaryRowProps<TItem> {
+interface StandardTableSummaryRowProps<TItem extends {}> {
     items: Array<TItem>;
 }
-export declare const StandardTableSummaryRow: React.MemoExoticComponent<(<TItem>({ items, }: StandardTableSummaryRowProps<TItem>) => JSX.Element)>;
+export declare const StandardTableSummaryRow: React.MemoExoticComponent<(<TItem extends {}>({ items, }: StandardTableSummaryRowProps<TItem>) => JSX.Element)>;
 export {};

package/dist/features/standard-table/features/summary-row/components/SummaryRowSwitcher.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-interface SummaryRowSwitcherProps<TItem> {
+interface SummaryRowSwitcherProps<TItem extends {}> {
     items: Array<TItem>;
 }
-export declare const SummaryRowSwitcher: <TItem>({ items, }: SummaryRowSwitcherProps<TItem>) => JSX.Element | null;
+export declare const SummaryRowSwitcher: <TItem extends {}>({ items }: SummaryRowSwitcherProps<TItem>) => JSX.Element | null;
 export {};

package/dist/features/standard-table/helpers/cell-renderers/editable-text-cell/EditableTextCellWithStatus.d.ts

@@ -1,3 +1,3 @@
 import { EntityCrudStatus, ModifiedFieldItemState } from "@stenajs-webui/redux";
 import { StandardTableCellRenderer } from "../../../config/StandardTableColumnConfig";
-export declare const createEditableTextCellWithStatus: <TItemValue, TItem>(warningOnEmpty?: string | ((item: TItem) => string) | undefined, crudStatusProvider?: ((item: TItem) => EntityCrudStatus | undefined) | undefined, modifiedFieldProvider?: ((item: TItem) => ModifiedFieldItemState | undefined) | undefined) => StandardTableCellRenderer<TItemValue, TItem>;
+export declare const createEditableTextCellWithStatus: <TItemValue, TItem>(warningOnEmpty?: string | ((item: TItem) => string), crudStatusProvider?: (item: TItem) => EntityCrudStatus | undefined, modifiedFieldProvider?: (item: TItem) => ModifiedFieldItemState | undefined) => StandardTableCellRenderer<TItemValue, TItem>;

package/dist/features/standard-table/redux/ReducerIdFactory.d.ts

@@ -1,3 +1,3 @@
-declare type ReducerIdSuffix = "selectedIds" | "expandedRows" | "sortOrder" | "fields";
+type ReducerIdSuffix = "selectedIds" | "expandedRows" | "sortOrder" | "fields";
 export declare const getReducerIdFor: (reducerId: string, reducerIdSuffix: ReducerIdSuffix) => string;
 export {};

package/dist/features/standard-table/redux/StandardTableReducer.d.ts

@@ -11,5 +11,5 @@ export interface StandardTableStateFields {
     lastSelectedId?: string;
 }
 export declare const createStandardTableInitialState: <TColumnKey extends string>(sortBy?: TColumnKey | undefined, desc?: boolean, selectedIds?: string[], expandedRows?: string[]) => StandardTableState<TColumnKey>;
-export declare type StandardTableReducer<TColumnKey extends string> = Reducer<StandardTableState<TColumnKey>, StandardTableAction<TColumnKey>>;
-export declare const createStandardTableReducer: <TColumnKey extends string>(reducerId: string, initialState?: Partial<StandardTableState<TColumnKey>> | undefined) => StandardTableReducer<TColumnKey>;
+export type StandardTableReducer<TColumnKey extends string> = Reducer<StandardTableState<TColumnKey>, StandardTableAction<TColumnKey>>;
+export declare const createStandardTableReducer: <TColumnKey extends string>(reducerId: string, initialState?: Partial<StandardTableState<TColumnKey>>) => StandardTableReducer<TColumnKey>;

package/dist/features/standard-table/types/StandardTableEvents.d.ts

@@ -1,4 +1,4 @@
 import * as React from "react";
 import { StandardTableOnKeyDownArgs } from "../config/StandardTableConfig";
-export declare type StandardTableOnKeyDown<TItem, TColumnKey extends string> = (ev: React.KeyboardEvent<HTMLDivElement>, args: StandardTableOnKeyDownArgs<TItem, TColumnKey>) => void;
-export declare type StandardTableOnSortOrderChange<TColumnKey extends string> = (sortOrder: TColumnKey, desc: boolean) => void;
+export type StandardTableOnKeyDown<TItem, TColumnKey extends string> = (ev: React.KeyboardEvent<HTMLDivElement>, args: StandardTableOnKeyDownArgs<TItem, TColumnKey>) => void;
+export type StandardTableOnSortOrderChange<TColumnKey extends string> = (sortOrder: TColumnKey, desc: boolean) => void;

package/dist/features/standard-table/util/ActionsFactory.d.ts

@@ -1,7 +1,7 @@
 import { InternalStandardTableActions } from "../redux/StandardTableActionsAndSelectors";
 import { EntityAction, ReducerIdGateAction, SelectedIdsAction, SortOrderAction } from "@stenajs-webui/redux";
 import { StandardTableStateFields } from "../redux/StandardTableReducer";
-export declare type StandardTableAction<TColumnKey extends string> = ReducerIdGateAction<SortOrderAction<TColumnKey>> | ReducerIdGateAction<SelectedIdsAction> | ReducerIdGateAction<EntityAction<StandardTableStateFields>>;
+export type StandardTableAction<TColumnKey extends string> = ReducerIdGateAction<SortOrderAction<TColumnKey>> | ReducerIdGateAction<SelectedIdsAction> | ReducerIdGateAction<EntityAction<StandardTableStateFields>>;
 export interface StandardTableActions<TColumnKey extends string> {
     setSelectedIds: (ids: Array<string>) => StandardTableAction<TColumnKey>;
     clearSelection: () => StandardTableAction<TColumnKey>;

package/dist/features/standard-table/util/FilterItemsOnEnabledCheckboxes.d.ts

@@ -1,2 +1,2 @@
-export declare type ItemFilterFunc<TItem> = (item: TItem) => boolean;
-export declare const filterItemsOnEnabledCheckboxes: <TItem>(checkboxDisabledResolver?: ((item: TItem) => boolean) | undefined) => ItemFilterFunc<TItem>;
+export type ItemFilterFunc<TItem> = (item: TItem) => boolean;
+export declare const filterItemsOnEnabledCheckboxes: <TItem>(checkboxDisabledResolver?: (item: TItem) => boolean) => ItemFilterFunc<TItem>;

package/dist/features/table-ui/components/table/SortOrderIcon.d.ts

@@ -1,7 +1,7 @@
 import { IconDefinition } from "@fortawesome/fontawesome-svg-core";
 import * as React from "react";
-export declare type SortOrderDirection = "up" | "down";
-export declare type SortOrderIconVariant = "numeric" | "alpha" | "amount";
+export type SortOrderDirection = "up" | "down";
+export type SortOrderIconVariant = "numeric" | "alpha" | "amount";
 interface Props {
     direction: SortOrderDirection;
     iconVariant?: SortOrderIconVariant;