@dcs-tech/ui 0.2.0 → 0.4.0

package/dist/types/components/DataTable/menu/RowMenu.d.ts

@@ -0,0 +1,56 @@
+import React, { type ReactNode } from 'react';
+import type { DataTableDensity, DataTableFontSize } from '../types';
+export interface RowMenuIcon {
+    id: string;
+    label: string;
+    shortLabel: string;
+    icon: ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    onSelect: () => void;
+}
+export interface RowMenuItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    danger?: boolean;
+    tone?: 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    disabled?: boolean;
+    tooltip?: string;
+    onSelect: () => void;
+}
+export interface RowMenuFilterEntry {
+    id: string;
+    field: string;
+    value: string;
+    options: Array<{
+        kind: 'only' | 'add' | 'hide';
+        label: string;
+        onSelect: () => void;
+    }>;
+}
+export interface RowMenuModel {
+    title: string;
+    subtitle?: string;
+    avatar?: ReactNode;
+    icons: RowMenuIcon[];
+    items: RowMenuItem[];
+    danger: RowMenuItem[];
+    filterEntries?: RowMenuFilterEntry[];
+}
+export interface RowMenuPlacement {
+    x: number;
+    y: number;
+    sheet: boolean;
+    alignRight?: boolean;
+}
+interface RowMenuProps {
+    model: RowMenuModel;
+    placement: RowMenuPlacement;
+    onClose: () => void;
+    density?: DataTableDensity;
+    fontSize?: DataTableFontSize;
+}
+export declare function RowMenu({ model, placement, onClose, density, fontSize }: RowMenuProps): React.JSX.Element;
+export default RowMenu;

package/dist/types/components/DataTable/menu/buildRowMenu.d.ts

@@ -0,0 +1,35 @@
+import React, { type ReactNode } from 'react';
+import type { DataTableCardFields, DataTableFilterGroup, DataTableRowMenuConfig, DataTableRowMenuBuiltIn, DataTableRowAction, DataTableColumn } from '../types';
+import type { DataTableLabels } from '../labels';
+import type { RowMenuModel } from './RowMenu';
+export declare function NotEqualIcon(): React.JSX.Element;
+export declare const DEFAULT_BUILT_INS: DataTableRowMenuBuiltIn[];
+export interface RowMenuContext<T> {
+    row: T;
+    rowIndex: number;
+    columnKey: string | null;
+    labels: DataTableLabels;
+    columns: DataTableColumn<T>[];
+    visibleColumns: DataTableColumn<T>[];
+    menu?: DataTableRowMenuConfig<T>;
+    actions: DataTableRowAction<T>[];
+    slots: DataTableCardFields;
+    title: string;
+    subtitle?: string;
+    avatar?: ReactNode;
+    canOpen: boolean;
+    onOpen: () => void;
+    selectable: boolean;
+    selected: boolean;
+    selecting: boolean;
+    selectedRows: T[];
+    onToggleSelect: () => void;
+    canCopy: boolean;
+    onCopy: (text: string, what: 'cell' | 'row' | 'rows', count: number) => void;
+    filtering: boolean;
+    operators?: readonly string[];
+    filterGroup: DataTableFilterGroup;
+    onFilter: (group: DataTableFilterGroup) => void;
+    format: (n: number) => string;
+}
+export declare function buildRowMenu<T>(ctx: RowMenuContext<T>): RowMenuModel;

package/dist/types/components/DataTable/menu/clipboard.d.ts

@@ -0,0 +1,4 @@
+import type { DataTableColumn } from '../types';
+import { type CellTextLabels } from '../cards/cardFields';
+export declare function rowsToTsv<T>(rows: T[], columns: DataTableColumn<T>[], labels: CellTextLabels, withHeader: boolean): string;
+export declare function copyText(text: string): Promise<boolean>;

package/dist/types/components/DataTable/menu/layers.d.ts

@@ -0,0 +1 @@
+export { isTopLayer, ownsFocus, LAYER_ATTR } from '../../Floating';

package/dist/types/components/DataTable/menu/valueFilter.d.ts

@@ -0,0 +1,15 @@
+import { type DataTableFilterGroup, type DataTableColumn } from '../types';
+import { type CellTextLabels } from '../cards/cardFields';
+export type DataTableValueFilterKind = 'only' | 'add' | 'hide';
+export interface DataTableCellFilterValue {
+    value: string | number | boolean | null;
+    label: string;
+}
+export declare const VALUE_FILTER_ID_PREFIX = "value-filter:";
+export declare function canFilterByValue(col: DataTableColumn | undefined, operators?: readonly string[]): boolean;
+export declare function cellFilterValues(col: DataTableColumn, row: unknown, labels: CellTextLabels & {
+    chipEmpty: string;
+}): DataTableCellFilterValue[];
+export declare function valueFilterKinds(group: DataTableFilterGroup, col: DataTableColumn, v: DataTableCellFilterValue, operators?: readonly string[]): DataTableValueFilterKind[];
+export declare function applyValueFilter(group: DataTableFilterGroup, col: DataTableColumn, v: DataTableCellFilterValue, kind: DataTableValueFilterKind): DataTableFilterGroup;
+export declare function chipShape(operator: string): 'is' | 'not' | 'empty' | 'notEmpty' | 'op';

package/dist/types/components/DataTable/motion/useRowMotion.d.ts

@@ -0,0 +1,32 @@
+import { type RefObject } from 'react';
+export type RowMotion = 'enter' | 'exit';
+export interface MotionItem<T> {
+    key: string;
+    item: T;
+    motion?: RowMotion;
+}
+export declare const EXIT_MS = 240;
+export declare const ENTER_MS = 1400;
+export declare function prefersReducedMotion(): boolean;
+interface Exit<T> {
+    key: string;
+    item: T;
+    at: number;
+}
+export declare function diffRows(before: string[], after: string[]): {
+    added: string[];
+    removed: Array<{
+        key: string;
+        at: number;
+    }>;
+} | null;
+export declare function mergeExits<T>(items: Array<MotionItem<T>>, exits: Array<Exit<T>>): Array<MotionItem<T>>;
+export declare function useRowMotion<T>(items: T[], keyOf: (item: T) => string, opts: {
+    enabled: boolean;
+    resetKey: string | undefined;
+    containerRef: RefObject<HTMLElement | null>;
+}): {
+    items: Array<MotionItem<T>>;
+    heightOf: (key: string) => number | undefined;
+};
+export {};

package/dist/types/components/DataTable/persistence/adapters.d.ts

@@ -0,0 +1,6 @@
+import type { DataTablePersistence } from '../types';
+export declare function localStorageAdapter(prefix?: string): DataTablePersistence;
+export declare function memoryAdapter(initial?: Record<string, Record<string, any>>): DataTablePersistence & {
+    store: Map<string, Record<string, any>>;
+};
+export declare const defaultPersistence: DataTablePersistence;

package/dist/types/components/DataTable/persistence/reconcile.d.ts

@@ -0,0 +1,64 @@
+import { type DataTableColumnType, type DataTableFilterCondition, type DataTableFilterGroup, type DataTableInitialState, type DataTableLayout, type DataTableSavedFilterIssue, type DataTableSummaryCard, type DataTableView } from '../types';
+export interface PrefsColumn {
+    key: string;
+    type: DataTableColumnType;
+    filterable: boolean;
+    options?: ReadonlySet<string>;
+}
+export interface PrefsVersioning {
+    version?: number;
+    migrate?: (doc: Record<string, any>, fromVersion: number, key: string) => Record<string, any>;
+}
+export interface ViewPrefsContext extends PrefsVersioning {
+    key: string;
+    columns: ReadonlyMap<string, PrefsColumn>;
+    renamed?: Readonly<Record<string, string>>;
+    operators?: readonly string[];
+    layouts: readonly DataTableLayout[];
+    groupable: ReadonlySet<string>;
+    maxGroupDepth: number;
+    templates: ReadonlyMap<string, ReadonlySet<string>>;
+    summaryCards: ReadonlyMap<string, DataTableSummaryCard['kind']>;
+    summaryCharts?: ReadonlyMap<string, readonly string[]>;
+    summaryCounts?: ReadonlyMap<string, readonly number[]>;
+    summaryBreakdowns: ReadonlySet<string>;
+}
+export interface ManagePrefsContext extends PrefsVersioning {
+    key: string;
+    views: ReadonlySet<string>;
+    renamedViews?: Readonly<Record<string, string>>;
+    templates: ReadonlySet<string>;
+}
+export interface PrefsReport {
+    removedColumns: string[];
+    disabledFilters: string[];
+    reset: string[];
+}
+export interface PrefsReconciled {
+    doc: Record<string, any>;
+    changed: boolean;
+    report: PrefsReport;
+}
+export declare const reportsUserChange: (r: PrefsReport) => boolean;
+export declare function viewPrefsContext(view: DataTableView, opts: {
+    key: string;
+    serverMode: boolean;
+    hasGroupsSource: boolean;
+    operators?: readonly string[];
+    summaryBreakdownFields?: readonly string[];
+} & PrefsVersioning): ViewPrefsContext;
+export declare function managePrefsContext(views: DataTableView[], opts: {
+    key: string;
+    renamedViews?: Record<string, string>;
+} & PrefsVersioning): ManagePrefsContext;
+export declare function renamedKey(key: string, renamed: Readonly<Record<string, string>> | undefined): string;
+export declare function renameFilterColumns(group: DataTableFilterGroup, renamed: Readonly<Record<string, string>> | undefined): DataTableFilterGroup;
+export declare function conditionIssue(c: DataTableFilterCondition, ctx: Pick<ViewPrefsContext, 'columns' | 'operators'>): DataTableSavedFilterIssue | null;
+export declare function filterIssue(group: DataTableFilterGroup, ctx: Pick<ViewPrefsContext, 'columns' | 'operators'>): DataTableSavedFilterIssue | null;
+export declare function withoutStaleConditions(group: DataTableFilterGroup, ctx: Pick<ViewPrefsContext, 'columns' | 'operators'>): DataTableFilterGroup;
+export declare function reconcileViewPrefs(saved: Record<string, any>, ctx: ViewPrefsContext): PrefsReconciled;
+export declare function reconcileManagePrefs(saved: Record<string, any>, ctx: ManagePrefsContext): PrefsReconciled;
+export declare function reconcileInitialState(state: DataTableInitialState | undefined, views: DataTableView[], opts: {
+    renamedViews?: Record<string, string>;
+    operators?: readonly string[];
+}): DataTableInitialState | undefined;

package/dist/types/components/DataTable/persistence/useColumnPersistence.d.ts

@@ -0,0 +1,51 @@
+import { type DataTableExportSettings, type DataTableCardFields, type DataTableListFields, type DataTableLayout, type DataTableSavedFilter, type DataTableDisplayPrefs, type DataTablePdfPageSize, type DataTablePdfOrientation, type DataTablePdfFontSize, type DataTablePdfMargins, type DataTablePersistence, type DataTableColumnPinning, type DataTableExportSummaryMode, type DataTableSummaryPrefs, type DataTableExportOptionValues } from '../types';
+import type { PrefsReconciled, PrefsReport } from './reconcile';
+export declare const PREFS_SAVE_DEBOUNCE_MS = 500;
+export declare const EXPORT_SETTINGS_DEFAULTS: DataTableExportSettings;
+export interface TemplateExportPrefs {
+    summary?: DataTableExportSummaryMode;
+    summaryCards?: string[];
+    customColumns?: string[];
+    options?: DataTableExportOptionValues;
+    pdfPageSize?: DataTablePdfPageSize;
+    pdfOrientation?: DataTablePdfOrientation;
+    pdfFontSize?: DataTablePdfFontSize;
+    pdfMargins?: DataTablePdfMargins;
+}
+interface UseColumnPersistenceReturn {
+    saveQuickExportPrefs: (settings: DataTableExportSettings) => void;
+    saveTemplateExportPrefs: (templateId: string, prefs: TemplateExportPrefs) => void;
+    saveCardFields: (slots: DataTableCardFields | undefined) => void;
+    saveListFields: (fields: DataTableListFields | undefined) => void;
+    saveLayout: (layout: DataTableLayout | undefined) => void;
+    saveSavedFilters: (presets: DataTableSavedFilter[]) => void;
+    saveDisplay: (settings: DataTableDisplayPrefs) => void;
+    saveFilterRow: (visible: boolean | undefined) => void;
+    saveGrouping: (levels: string[] | undefined) => void;
+    saveViewParts: (parts: ViewDocParts) => void;
+    loaded: boolean;
+}
+export interface ViewExtras {
+    pinning: DataTableColumnPinning;
+    defaultPinning: DataTableColumnPinning;
+    defaultVisibility?: Record<string, boolean>;
+    defaultOrder?: string[];
+    unauthorized?: string[];
+    setPinning: (p: DataTableColumnPinning) => void;
+    setFilterRow: (visible: boolean) => void;
+    setLayout?: (layout: DataTableLayout) => void;
+    setListFields?: (fields: DataTableListFields) => void;
+    setGrouping?: (levels: string[]) => void;
+    setSummary?: (prefs: DataTableSummaryPrefs) => void;
+}
+export interface ViewDocSync {
+    reconcile: (doc: Record<string, any>, key: string) => PrefsReconciled;
+    previousViewIds: string[];
+    onReport: (report: PrefsReport) => void;
+    version?: number;
+}
+export declare function useColumnPersistence(persistence: DataTablePersistence | null, tableId: string | undefined, viewId: string | undefined, columnVisibility: Record<string, boolean>, columnOrder: string[], columnSizing: Record<string, number>, setColumnVisibility: (vis: Record<string, boolean> | ((prev: Record<string, boolean>) => Record<string, boolean>)) => void, setColumnOrder: (order: string[] | ((prev: string[]) => string[])) => void, setColumnSizing: (sizing: Record<string, number>) => void, setExportSettings?: (s: DataTableExportSettings) => void, setCardFields?: (slots: DataTableCardFields) => void, setSavedFilters?: (filters: DataTableSavedFilter[]) => void, setDisplaySettings?: (s: DataTableDisplayPrefs) => void, setTemplateColumnOverrides?: (overrides: Record<string, TemplateExportPrefs>) => void, enabled?: boolean, onViewReset?: () => void, extra?: ViewExtras, sync?: ViewDocSync): UseColumnPersistenceReturn;
+export type ViewDocParts = Record<string, unknown>;
+export declare function readStoredViewDoc(persistence: DataTablePersistence, key: string, reconcile: (doc: Record<string, any>, key: string) => PrefsReconciled): Promise<Record<string, any> | null>;
+export declare function saveStoredViewParts(persistence: DataTablePersistence, key: string, reconcile: (doc: Record<string, any>, key: string) => PrefsReconciled, parts: ViewDocParts, version?: number): Promise<void>;
+export {};

package/dist/types/components/DataTable/persistence/useManagePrefs.d.ts

@@ -0,0 +1,23 @@
+import { type DataTableView, type DataTableManageList, type DataTableManagePrefs, type DataTablePersistence } from '../types';
+import type { PrefsReconciled } from './reconcile';
+export interface ResolvedView {
+    config: DataTableView;
+    key: string;
+    index: number;
+    enabled: boolean;
+    locked: boolean;
+}
+export declare function orderIds(ids: string[], saved: DataTableManageList | undefined): string[];
+export declare function isShown(id: string, saved: DataTableManageList | undefined, byDefault: boolean): boolean;
+export declare function withShown(saved: DataTableManageList | undefined, ids: string[], byDefault: (id: string) => boolean, id: string, shown: boolean): DataTableManageList;
+export declare function withOrder(saved: DataTableManageList | undefined, ids: string[], byDefault: (id: string) => boolean, ordered: string[]): DataTableManageList;
+export declare function resolveAllViews(configs: DataTableView[], prefs: DataTableManagePrefs): ResolvedView[];
+export declare function resolveVisibleViews(configs: DataTableView[], prefs: DataTableManagePrefs): ResolvedView[];
+export interface ManageDocSync {
+    reconcile: (doc: Record<string, any>, key: string) => PrefsReconciled;
+    version?: number;
+}
+export declare function useManagePrefs(persistence: DataTablePersistence | null, tableId: string | undefined, sync?: ManageDocSync): {
+    prefs: DataTableManagePrefs;
+    setPrefs: (next: DataTableManagePrefs) => void;
+};

package/dist/types/components/DataTable/persistence/useOrphanPrefs.d.ts

@@ -0,0 +1,3 @@
+import type { DataTablePersistence } from '../types';
+export declare function orphanPrefsKeys(keys: readonly string[], tableId: string, viewIds: readonly string[], renamedFrom: readonly string[]): string[];
+export declare function useOrphanPrefs(persistence: DataTablePersistence | null, tableId: string | undefined, viewIds: readonly string[], renamedFrom: readonly string[]): void;

package/dist/types/components/DataTable/pinning.d.ts

@@ -0,0 +1,10 @@
+import { type RefObject } from 'react';
+import type { DataTableColumnPinning, DataTableColumn } from './types';
+export type PinSide = 'left' | 'right';
+export declare function defaultPinning(columns: DataTableColumn[], opts?: {
+    firstColumn?: boolean;
+}): DataTableColumnPinning;
+export declare function pinSideOf(pinning: DataTableColumnPinning, key: string): PinSide | null;
+export declare function pinColumn(pinning: DataTableColumnPinning, key: string, side: PinSide | null): DataTableColumnPinning;
+export declare function samePinning(a: DataTableColumnPinning, b: DataTableColumnPinning): boolean;
+export declare function usePinOffsets(tableRef: RefObject<HTMLTableElement | null>, active: boolean, key: string): void;

package/dist/types/components/DataTable/rows/PressRow.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface PressRowProps extends React.HTMLAttributes<HTMLElement> {
+    as: 'tr' | 'div';
+    pressable: boolean;
+}
+export declare const PressRow: React.ForwardRefExoticComponent<PressRowProps & React.RefAttributes<HTMLElement>>;
+export {};

package/dist/types/components/DataTable/rows/RowActions.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { DataTableActionDisplay, DataTableRowAction } from '../types';
+import type { RowMenuRequest } from './rowPress';
+export declare function primaryActionOf<T>(actions: DataTableRowAction<T>[], row: T): DataTableRowAction<T> | undefined;
+interface RowActionsProps<T> {
+    row: T;
+    rowIndex: number;
+    title: string;
+    actions: DataTableRowAction<T>[];
+    displayMode: DataTableActionDisplay;
+    onMenu?: (at: RowMenuRequest) => void;
+    reserveSlot?: boolean;
+}
+export declare function RowActions<T>({ row, rowIndex, title, actions, displayMode, onMenu, reserveSlot }: RowActionsProps<T>): React.JSX.Element;
+export {};

package/dist/types/components/DataTable/rows/rowPress.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+export declare function isInteractiveTarget(target: EventTarget | null, rowEl: HTMLElement): boolean;
+export declare function isSelectingText(rowEl: HTMLElement): boolean;
+export declare function fieldAt(target: EventTarget | null, rowEl: HTMLElement): string | null;
+export declare const LONG_PRESS_MS = 500;
+export interface RowMenuRequest {
+    x: number;
+    y: number;
+    columnKey: string | null;
+    touch: boolean;
+    alignRight?: boolean;
+}
+export interface RowPressOptions<R> {
+    canOpen: boolean;
+    openOn: 'click' | 'doubleClick';
+    longPress: 'menu' | 'open';
+    menuEnabled: boolean;
+    selecting: boolean;
+    selectable: (row: R) => boolean;
+    onOpen: (row: R) => void;
+    onToggle: (row: R) => void;
+    onMenu: (row: R, at: RowMenuRequest) => void;
+    onOtherClick?: (row: R) => void;
+}
+export interface RowPressHandlers {
+    onMouseDown: (e: React.MouseEvent) => void;
+    onClick: (e: React.MouseEvent) => void;
+    onDoubleClick: (e: React.MouseEvent) => void;
+    onContextMenu: (e: React.MouseEvent) => void;
+    onTouchStart: (e: React.TouchEvent) => void;
+    onTouchMove: (e: React.TouchEvent) => void;
+    onTouchEnd: () => void;
+    onKeyDown: (e: React.KeyboardEvent) => void;
+}
+export declare function useRowPress<R>(opts: RowPressOptions<R>): (row: R) => RowPressHandlers;

package/dist/types/components/DataTable/sharing/Sharing.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { DataTableSharedView, DataTableSharing } from '../types';
+export declare function useSharedViews(sharing: DataTableSharing | undefined, tableId: string | undefined): {
+    views: DataTableSharedView[];
+    reload: () => void;
+};
+export declare const SHARED_PREFIX = "shared:";
+export declare function ViewTabMenu({ label, items }: {
+    label: string;
+    items: Array<{
+        id: string;
+        label: string;
+        onSelect: () => void;
+    }>;
+}): React.JSX.Element | null;
+export declare function ShareViewDialog({ sharing, defaultName, onShare, onClose }: {
+    sharing: DataTableSharing;
+    defaultName: string;
+    onShare: (name: string, audienceIds: string[]) => Promise<void>;
+    onClose: () => void;
+}): React.JSX.Element;

package/dist/types/components/DataTable/split/SplitView.d.ts

@@ -0,0 +1,29 @@
+import React, { type ReactNode } from 'react';
+import type { RowPressHandlers } from '../rows/rowPress';
+import type { CardLine, CardRow, MotionOptions } from '../cards/CardView';
+import type { ListParts } from '../cards/rowParts';
+import { type ScrollApi, type VirtualOptions } from '../virtual/useVirtualLines';
+interface SplitViewProps {
+    rows: CardRow[];
+    lines?: CardLine[];
+    openId: string | null;
+    checkboxes: boolean;
+    onToggle: (id: string) => void;
+    press: (id: string) => RowPressHandlers;
+    renderActions?: (id: string) => ReactNode;
+    pane: ReactNode | null;
+    narrowList: boolean;
+    focusable: boolean;
+    activeKey?: string | null;
+    placeholder?: ReactNode;
+    loading?: boolean;
+    virtual?: VirtualOptions | null;
+    scrollApi?: React.MutableRefObject<ScrollApi | null>;
+    listFooter?: ReactNode;
+    motion?: MotionOptions;
+}
+export declare function SplitItemContent({ parts }: {
+    parts: ListParts;
+}): React.JSX.Element;
+export declare function SplitView({ rows, lines: linesProp, openId, checkboxes, onToggle, press, renderActions, pane, narrowList, focusable, activeKey, placeholder, loading, virtual, scrollApi, listFooter, motion }: SplitViewProps): React.JSX.Element;
+export default SplitView;

package/dist/types/components/DataTable/summary/ManageSummaryCards.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { type DataTableColumn, type DataTableSummaryConfig, type DataTableSummaryPrefs, type DataTableSummaryStrip } from '../types';
+import type { DataTableLabels } from '../labels';
+import { type SummaryLayout } from './summaryCatalogue';
+interface ManageSummaryCardsProps {
+    strip: DataTableSummaryStrip;
+    config: DataTableSummaryConfig | undefined;
+    layout: SummaryLayout;
+    prefs: DataTableSummaryPrefs | undefined;
+    strips: Record<DataTableSummaryStrip, boolean>;
+    columns: DataTableColumn[];
+    breakdownColumns: DataTableColumn[];
+    onPrefs: (next: DataTableSummaryPrefs) => void;
+    onStrips: (next: Record<DataTableSummaryStrip, boolean>) => void;
+}
+export declare const stripName: (strip: DataTableSummaryStrip, L: DataTableLabels) => string;
+export declare function ManageSummaryCards({ strip: tab, config, layout, prefs, strips, columns, breakdownColumns, onPrefs, onStrips }: ManageSummaryCardsProps): React.JSX.Element;
+export {};

package/dist/types/components/DataTable/summary/SummaryChart.d.ts

@@ -0,0 +1,11 @@
+import { type ChartLabels } from '../../Charts';
+import { type ResolvedSummaryCard } from './summaryModel';
+export interface SummaryChartProps {
+    item: ResolvedSummaryCard;
+    onSelect?: (key: string) => void;
+    format: (n: number) => string;
+    locale?: string;
+    labels: Partial<ChartLabels> & Pick<ChartLabels, 'count' | 'rest'>;
+    onLegendCut?: (hidden: number) => void;
+}
+export default function SummaryChart({ item, onSelect, format, locale, labels, onLegendCut }: SummaryChartProps): import("react").JSX.Element;

package/dist/types/components/DataTable/summary/SummaryControls.d.ts

@@ -0,0 +1,33 @@
+import type { DataTableLabels } from '../labels';
+import { type ChartLabels } from '../../Charts/labels';
+import type { DataTableExportSummaryMode, DataTableSummaryCard } from '../types';
+export declare function Segmented<V extends string | number>({ label, options, value, onChange }: {
+    label: string;
+    options: Array<{
+        value: V;
+        label: string;
+    }>;
+    value: V;
+    onChange: (value: V) => void;
+}): import("react").JSX.Element;
+export declare const chartKindNames: (L: DataTableLabels) => ChartLabels["kinds"];
+export declare const summaryChartLabels: (L: DataTableLabels) => ChartLabels;
+export declare const kindLabel: (kind: DataTableSummaryCard["kind"], L: DataTableLabels) => string;
+export declare function KindChip({ kind }: {
+    kind: DataTableSummaryCard['kind'];
+}): import("react").JSX.Element;
+export interface SummaryChoiceCard {
+    id: string;
+    title: string;
+    kind: DataTableSummaryCard['kind'];
+    copy: number;
+}
+interface SummaryChoiceProps {
+    name: string;
+    mode: DataTableExportSummaryMode;
+    cards: readonly string[];
+    options: SummaryChoiceCard[];
+    onChange: (mode: DataTableExportSummaryMode, cards: string[]) => void;
+}
+export declare function SummaryChoice({ name, mode, cards, options, onChange }: SummaryChoiceProps): import("react").JSX.Element;
+export {};

package/dist/types/components/DataTable/summary/SummaryImage.d.ts

@@ -0,0 +1,12 @@
+import type { ChartLabels } from '../../Charts/labels';
+import type { ResolvedSummaryCard } from './summaryModel';
+export interface SummaryImageMenuProps {
+    item: ResolvedSummaryCard;
+    report?: string;
+    context: string;
+    branding?: string;
+    format: (n: number) => string;
+    locale?: string;
+    labels: Partial<ChartLabels> & Pick<ChartLabels, 'count' | 'rest'>;
+}
+export default function SummaryImageMenu({ item, report, context, branding, format, locale, labels }: SummaryImageMenuProps): import("react").JSX.Element;

package/dist/types/components/DataTable/summary/SummarySeeAll.d.ts

@@ -0,0 +1,17 @@
+import { type ChartLabels } from '../../Charts';
+import type { GroupValue } from '../grouping/groupModel';
+import type { TableSummaryImage } from './TableSummary';
+import { type ResolvedSummaryCard, type SummaryBucketView } from './summaryModel';
+type BreakdownItem = Extract<ResolvedSummaryCard, {
+    kind: 'breakdown';
+}>;
+export interface SummarySeeAllProps {
+    item: BreakdownItem;
+    all: SummaryBucketView[] | 'failed';
+    onClose: () => void;
+    onSelect?: (key: string, value: GroupValue) => void;
+    image?: TableSummaryImage;
+    labels: ChartLabels;
+}
+export default function SummarySeeAll({ item, all, onClose, onSelect, image, labels }: SummarySeeAllProps): import("react").JSX.Element;
+export {};

package/dist/types/components/DataTable/summary/TableSummary.d.ts

@@ -0,0 +1,34 @@
+import React, { type Ref } from 'react';
+import '../../Charts/Charts.css';
+import type { DataTableSummaryBreakdownCard, DataTableSummaryStrip } from '../types';
+import type { GroupValue } from '../grouping/groupModel';
+import { type ResolvedSummaryCard, type SummaryBucketView, type SummaryChartCard } from './summaryModel';
+export interface TableSummaryImage {
+    report?: string;
+    context: string;
+    branding?: string;
+}
+export interface TableSummaryStatus {
+    loading: boolean;
+    failed: boolean;
+    onRetry: () => void;
+}
+interface TableSummaryProps {
+    strip: DataTableSummaryStrip;
+    cards: ResolvedSummaryCard[];
+    open: boolean;
+    onToggle: () => void;
+    context: string;
+    status?: TableSummaryStatus;
+    onSelect: (card: SummaryChartCard, key: string, value?: GroupValue) => void;
+    selectable: (card: SummaryChartCard) => boolean;
+    loadAll: (card: DataTableSummaryBreakdownCard) => Promise<SummaryBucketView[]>;
+    image?: TableSummaryImage;
+    rootRef?: Ref<HTMLElement>;
+}
+type BreakdownItem = Extract<ResolvedSummaryCard, {
+    kind: 'breakdown';
+}>;
+export declare function visibleValues(item: BreakdownItem, cut?: number): number;
+declare function TableSummary({ strip, cards, open, onToggle, context, status, onSelect, selectable, loadAll, image, rootRef }: TableSummaryProps): React.JSX.Element;
+export default TableSummary;

package/dist/types/components/DataTable/summary/summaryCatalogue.d.ts

@@ -0,0 +1,64 @@
+import { type DataTableAuthorize, type DataTableSummaryPeriod, type DataTableColumn, type DataTableSummaryBreakdownCard, type DataTableSummaryCard, type DataTableSummaryChart, type DataTableSummaryConfig, type DataTableSummaryPlacement, type DataTableSummaryPrefs, type DataTableSummaryTrendCard, type DataTableSummaryShow, type DataTableSummaryStrip, type DataTableSummaryUserCard, type DataTableSummaryWidth } from '../types';
+import type { DataTableLabels } from '../labels';
+import { type SummaryItem } from './summaryModel';
+export interface SummaryEntry<T = any> {
+    key: string;
+    strip: DataTableSummaryStrip;
+    on: boolean;
+    card: DataTableSummaryCard<T>;
+    width: DataTableSummaryWidth;
+    own: boolean;
+    copy: number;
+    defaultTitle: string;
+}
+export type SummaryLayout<T = any> = Record<DataTableSummaryStrip, SummaryEntry<T>[]>;
+export type SummaryArrangement = Record<DataTableSummaryStrip, DataTableSummaryPlacement[]>;
+export declare function summaryBreakdownColumns<T>(columns: DataTableColumn<T>[], opts: {
+    serverMode: boolean;
+    fields?: readonly string[];
+}): DataTableColumn<T>[];
+export declare const userCardTitle: (column: DataTableColumn | undefined, key: string, byColumn: (header: string) => string) => string;
+export declare function userCard(own: DataTableSummaryUserCard, title: string): DataTableSummaryBreakdownCard;
+export declare const defaultWidth: (card: DataTableSummaryCard) => DataTableSummaryWidth;
+export declare function placedCard<T>(card: DataTableSummaryCard<T>, p: DataTableSummaryPlacement): DataTableSummaryCard<T>;
+export declare const trendCountAllowed: (period: DataTableSummaryPeriod, count: number) => boolean;
+export declare function trendCounts(card: DataTableSummaryTrendCard): readonly number[];
+export declare function trendRange(period: DataTableSummaryPeriod, count: number): {
+    unit: 'day' | 'month' | 'year';
+    n: number;
+};
+export declare function trendRangeName(period: DataTableSummaryPeriod, count: number, L: Pick<DataTableLabels, 'summaryDays' | 'summaryMonths' | 'summaryYears'>, num?: (n: number) => string): string;
+export declare function defaultArrangement(config: DataTableSummaryConfig | undefined, own?: readonly DataTableSummaryUserCard[]): SummaryArrangement;
+export declare function summaryArrangement(config: DataTableSummaryConfig | undefined, prefs: DataTableSummaryPrefs | undefined): SummaryArrangement;
+export interface SummaryCatalogueContext<T> {
+    columns: DataTableColumn<T>[];
+    authorize?: DataTableAuthorize;
+    breakdownColumns: ReadonlySet<string>;
+    byColumn: (header: string) => string;
+}
+export declare function summaryCards<T>(config: DataTableSummaryConfig<T> | undefined, prefs: DataTableSummaryPrefs | undefined, ctx: SummaryCatalogueContext<T>): Map<string, {
+    card: DataTableSummaryCard<T>;
+    own: boolean;
+}>;
+export declare function summaryLayout<T>(config: DataTableSummaryConfig<T> | undefined, prefs: DataTableSummaryPrefs | undefined, ctx: SummaryCatalogueContext<T>): SummaryLayout<T>;
+export declare const shownItems: <T>(entries: SummaryEntry<T>[]) => SummaryItem<T>[];
+export declare const allEntries: <T>(layout: SummaryLayout<T>) => SummaryEntry<T>[];
+export type SummaryPlacementChange = Partial<Pick<DataTableSummaryPlacement, 'title' | 'chart' | 'show' | 'count' | 'width'>>;
+export declare function arrangementPrefs(config: DataTableSummaryConfig | undefined, prefs: DataTableSummaryPrefs | undefined, next: SummaryArrangement): DataTableSummaryPrefs;
+export declare const placementCount: (a: SummaryArrangement) => number;
+export declare const withPlacementOn: (prefs: DataTableSummaryPrefs | undefined, config: DataTableSummaryConfig | undefined, key: string, on: boolean) => DataTableSummaryPrefs;
+export declare function withPlacementChange(prefs: DataTableSummaryPrefs | undefined, config: DataTableSummaryConfig | undefined, key: string, change: SummaryPlacementChange): DataTableSummaryPrefs;
+export declare function withStripOrder(prefs: DataTableSummaryPrefs | undefined, config: DataTableSummaryConfig | undefined, order: Record<DataTableSummaryStrip, string[]>): DataTableSummaryPrefs;
+export declare const newPlacementKey: () => string;
+export declare const newUserCardId: () => string;
+export declare function withDuplicate(prefs: DataTableSummaryPrefs | undefined, config: DataTableSummaryConfig | undefined, key: string, strip: DataTableSummaryStrip, copyKey?: string): DataTableSummaryPrefs;
+export declare function withMove(prefs: DataTableSummaryPrefs | undefined, config: DataTableSummaryConfig | undefined, key: string, strip: DataTableSummaryStrip): DataTableSummaryPrefs;
+export declare const withoutCopy: (prefs: DataTableSummaryPrefs | undefined, config: DataTableSummaryConfig | undefined, key: string) => DataTableSummaryPrefs;
+export interface SummaryUserCardDraft {
+    column: string;
+    chart: DataTableSummaryChart;
+    show?: DataTableSummaryShow;
+    strip: DataTableSummaryStrip;
+}
+export declare function withUserCard(prefs: DataTableSummaryPrefs | undefined, config: DataTableSummaryConfig | undefined, draft: SummaryUserCardDraft, id?: string): DataTableSummaryPrefs;
+export declare function withoutUserCard(prefs: DataTableSummaryPrefs | undefined, config: DataTableSummaryConfig | undefined, id: string): DataTableSummaryPrefs;

package/dist/types/components/DataTable/summary/summaryChartData.d.ts

@@ -0,0 +1,9 @@
+import { type ChartData, type ChartDataWords, type ChartKind } from '../../Charts/chartData';
+import type { ChartImageChart } from '../../Charts/chartImage';
+import { type ResolvedSummaryCard, type SummaryBucketView } from './summaryModel';
+export declare function bucketValues(item: Extract<ResolvedSummaryCard, {
+    kind: 'breakdown';
+}>, buckets: readonly SummaryBucketView[]): ChartData;
+export declare function summaryData(item: ResolvedSummaryCard): ChartData;
+export declare const summaryKind: (item: ResolvedSummaryCard) => ChartKind;
+export declare const summaryChartData: (item: ResolvedSummaryCard, words: ChartDataWords) => ChartImageChart;