@dcs-tech/ui 0.9.0 → 0.11.0

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

@@ -0,0 +1,34 @@
+import type { RowPins } from '../../../core/logic';
+import type { DisplayItem } from '../grouping/groupModel';
+import type { DataTableRowTransaction } from '../types';
+export interface FoundPinnedRows<T> {
+    rows: readonly T[] | null;
+    ids: string;
+    map: Map<string, T>;
+}
+export declare const newFoundPinnedRows: <T>() => FoundPinnedRows<T>;
+export declare function findPinnedRows<T>(cache: FoundPinnedRows<T>, rows: readonly T[], ids: ReadonlySet<string>, keyOf: (row: T) => string): Map<string, T>;
+export interface PinnedRowLines<T> {
+    top: DisplayItem[];
+    bottom: DisplayItem[];
+    rowById: Map<string, any>;
+    originals: {
+        top: T[];
+        bottom: T[];
+    };
+    keep: (id: string, row: T) => void;
+    applyTransaction: (tx: DataTableRowTransaction<T>) => void;
+}
+export declare const isAppPinnedRow: (row: unknown) => boolean;
+export declare function usePinnedRows<T>(opts: {
+    table: any;
+    pins: RowPins;
+    rows: readonly T[];
+    rowKey?: string;
+    serverMode: boolean;
+    app?: {
+        top?: readonly T[];
+        bottom?: readonly T[];
+    };
+    enabled: boolean;
+}): PinnedRowLines<T>;

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

@@ -0,0 +1,44 @@
+import React, { type RefObject } from 'react';
+import { type RowDropTarget, type TreeDragLine, type TreeDropPlace, type TreeShape } from '../../../core/logic';
+import type { DataTableLabels } from '../labels';
+export interface RowDragHost {
+    on: boolean;
+    blocked: string | null;
+    areaRef: RefObject<HTMLElement | null>;
+    surface?: DragSurface;
+    order: () => string[];
+    moving: (id: string) => string[];
+    titleOf: (id: string) => string;
+    drop: (ids: string[], target: RowDropTarget) => void;
+    tree?: RowDragTree | null;
+    announce: (text: string) => void;
+    labels: DataTableLabels;
+    number: (n: number) => string;
+    onStart?: () => void;
+    onEnd?: () => void;
+    scrollToKey?: (key: string) => void;
+}
+export type DragSurface = 'table' | 'cards' | 'list';
+export interface RowDragTreeLine extends TreeDragLine {
+    closed?: boolean;
+}
+export interface RowDragTree {
+    shape: () => TreeShape;
+    lines: () => readonly RowDragTreeLine[];
+    expand: (id: string) => void;
+    drop: (roots: string[], place: TreeDropPlace) => void;
+}
+export declare const TOUCH_HOLD_MS = 400;
+export declare const TREE_OPEN_MS = 700;
+export declare function useRowDrag(host: RowDragHost): {
+    handleProps: (id: string) => {
+        onPointerDown: (e: React.PointerEvent<HTMLElement>) => void;
+        onTouchStart: (e: React.TouchEvent<HTMLElement>) => void;
+        onContextMenu: (e: React.MouseEvent) => void;
+        onClick: (e: React.MouseEvent) => void;
+    };
+    onKeyDown: (e: React.KeyboardEvent) => boolean;
+    overlay: React.ReactPortal | null;
+    dragging: boolean;
+    cancel: () => void;
+};

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

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

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

@@ -7,5 +7,6 @@ export interface SummaryChartProps {
     locale?: string;
     labels: Partial<ChartLabels> & Pick<ChartLabels, 'count' | 'rest'>;
     onLegendCut?: (hidden: number) => void;
+    animate?: boolean;
 }
-export default function SummaryChart({ item, onSelect, format, locale, labels, onLegendCut }: SummaryChartProps): import("react").JSX.Element;
+export default function SummaryChart({ item, onSelect, format, locale, labels, onLegendCut, animate }: SummaryChartProps): import("react").JSX.Element;

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

@@ -25,10 +25,11 @@ interface TableSummaryProps {
     loadAll: (card: DataTableSummaryBreakdownCard) => Promise<SummaryBucketView[]>;
     image?: TableSummaryImage;
     rootRef?: Ref<HTMLElement>;
+    animate?: boolean;
 }
 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;
+declare function TableSummary({ strip, cards, open, onToggle, context, status, onSelect, selectable, loadAll, image, rootRef, animate }: TableSummaryProps): React.JSX.Element;
 export default TableSummary;

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

@@ -1,5 +1,5 @@
 import { type GroupLabels, type GroupValue } from '../grouping/groupModel';
-import { type DataTableColumn, type DataTableExportSummary, type DataTableFilterCondition, type DataTableFilterGroup, type DataTableSummaryAnyChart, type DataTableSummaryBreakdown, type DataTableSummaryBreakdownCard, type DataTableSummaryBucket, type DataTableSummaryCard, type DataTableSummaryFigure, type DataTableSummaryFunnelCard, type DataTableSummaryPart, type DataTableSummaryPeriod, type DataTableSummaryPeriodCount, type DataTableSummaryRequest, type DataTableSummaryShow, type DataTableSummarySubline, type DataTableSummaryTrendCard, type DataTableSummaryValueCard, type DataTableSummaryWidth } from '../types';
+import { type DataTableColumn, type DataTableExportSummary, type DataTableFilterCondition, type DataTableFilterGroup, type DataTableSummaryAnyChart, type DataTableSummaryBreakdown, type DataTableSummaryBreakdownCard, type DataTableSummaryBucket, type DataTableSummaryCard, type DataTableSummaryCardContext, type DataTableSummaryFigure, type DataTableSummaryFunnelCard, type DataTableSummaryPart, type DataTableSummaryPeriod, type DataTableSummaryPeriodCount, type DataTableSummaryRange, type DataTableSummaryRequest, type DataTableSummaryShow, type DataTableSummarySubline, type DataTableSummarySum, type DataTableSummaryTrendCard, type DataTableSummaryValueCard, type DataTableSummaryValueFigure, type DataTableSummaryRowFilter, type DataTableSummaryWidth } from '../types';
 import type { ChartSlot } from '../../Charts';
 export declare const SUMMARY_CONDITION_PREFIX = "summary:";
 export declare const summaryConditionId: (cardId: string) => string;
@@ -19,10 +19,11 @@ export declare function breakdownPart(card: DataTableSummaryBreakdownCard, partT
 export declare function partOf(buckets: readonly DataTableSummaryBucket[], part: DataTableSummaryPart): DataTableSummaryBreakdown;
 export declare const splits: (card: DataTableSummaryTrendCard) => boolean;
 export declare function summaryCardKey(card: SummaryChartCard | DataTableSummaryValueCard, partTop?: number): string;
-export declare function summaryRequest<T>(cards: DataTableSummaryCard<T>[], columns: DataTableColumn<T>[]): DataTableSummaryRequest;
+export declare function summaryRequest<T>(allCards: DataTableSummaryCard<T>[], columns: DataTableColumn<T>[], ctx?: DataTableSummaryCardContext<T>): DataTableSummaryRequest;
 export declare function ownCondition(group: DataTableFilterGroup, cardId: string): DataTableFilterCondition | undefined;
 export declare function withoutOwnCondition(group: DataTableFilterGroup, cardId: string): DataTableFilterGroup;
-export declare function setSummaryCondition(group: DataTableFilterGroup, cardId: string, condition: DataTableFilterCondition | null): DataTableFilterGroup;
+export declare function setSummaryCondition(group: DataTableFilterGroup, cardId: string, condition: DataTableFilterCondition | null, where?: DataTableSummaryRowFilter['condition']): DataTableFilterGroup;
+export declare function withoutOrphanWhere(group: DataTableFilterGroup): DataTableFilterGroup;
 export declare function breakdownCondition<T>(card: DataTableSummaryBreakdownCard, col: DataTableColumn<T> | undefined, value: GroupValue): DataTableFilterCondition;
 export declare function trendCondition(card: DataTableSummaryTrendCard, period: string): DataTableFilterCondition;
 export declare function funnelCondition(card: DataTableSummaryFunnelCard, stepId: string): DataTableFilterCondition | null;
@@ -30,12 +31,25 @@ export declare const bucketKey: (v: GroupValue) => string;
 export declare const OTHERS_KEY = "\0others";
 export declare function selectedKey(card: SummaryChartCard, cond: DataTableFilterCondition | undefined): string | null;
 export declare function computeFigure<T>(figure: DataTableSummaryFigure<T>, rows: T[]): number;
-export declare function countValues<T>(rows: T[], col: DataTableColumn<T>): DataTableSummaryBucket[];
-export declare function withChildren<T>(answer: DataTableSummaryBreakdown, rows: T[], col: DataTableColumn<T>, within: DataTableColumn<T>): DataTableSummaryBreakdown;
+export declare const cardRows: <T>(card: {
+    where?: DataTableSummaryBreakdownCard<T>["where"];
+}, rows: T[]) => T[];
+export declare function countValues<T>(rows: T[], col: DataTableColumn<T>, sum?: DataTableSummarySum<T>): DataTableSummaryBucket[];
+export declare function withChildren<T>(answer: DataTableSummaryBreakdown, rows: T[], col: DataTableColumn<T>, within: DataTableColumn<T>, sum?: DataTableSummarySum<T>): DataTableSummaryBreakdown;
 export declare const monthOf: (v: unknown) => string | null;
 export declare function lastMonths(n: number, now?: Date): string[];
 export declare function lastDays(n: number, now?: Date): string[];
-export declare function countPeriods<T>(rows: T[], col: DataTableColumn<T>, period: DataTableSummaryPeriod, count: number, now?: Date, split?: DataTableColumn<T>): DataTableSummaryPeriodCount[];
+export declare function trendRangeOf(range: DataTableSummaryRange | null | undefined, period: DataTableSummaryPeriod, count: number, now?: Date): {
+    from: string;
+    to: string;
+    count: number;
+} | null;
+export declare function summaryCardFor<T>(card: DataTableSummaryCard<T>, ctx?: DataTableSummaryCardContext<T>, now?: Date): DataTableSummaryCard<T>;
+export declare function countPeriods<T>(rows: T[], col: DataTableColumn<T>, period: DataTableSummaryPeriod, count: number, now?: Date, split?: DataTableColumn<T>, opts?: {
+    sum?: DataTableSummarySum<T>;
+    range?: Required<DataTableSummaryRange> | null;
+}): DataTableSummaryPeriodCount[];
+export declare const trendPeriods: <T>(card: DataTableSummaryTrendCard<T>, rows: T[], col: DataTableColumn<T>, split?: DataTableColumn<T>, now?: Date) => DataTableSummaryPeriodCount[];
 export declare function figureSeries<T>(rows: T[], figure: DataTableSummaryFigure<T>, col: DataTableColumn<T>, period: DataTableSummaryPeriod, count: number, now?: Date): {
     points: Array<{
         period: string;
@@ -87,6 +101,10 @@ export interface SummaryStepView {
     slot: ChartSlot;
     selectable: boolean;
 }
+export type SummaryFigureView = Pick<DataTableSummaryValueFigure, 'label' | 'text'> & {
+    value: number | null;
+};
+export declare const SUMMARY_FIGURES_FIT = 4;
 export type ResolvedSummaryCard<T = any> = {
     key: string;
     width: DataTableSummaryWidth;
@@ -104,6 +122,7 @@ export type ResolvedSummaryCard<T = any> = {
         points: SummaryPeriodView[];
         previous: number;
     } | null;
+    figures?: SummaryFigureView[];
 } | {
     kind: 'ratio';
     card: DataTableSummaryCard<T> & {
@@ -140,6 +159,9 @@ export type ResolvedSummaryCard<T = any> = {
     reason: string;
 });
 export declare const drawsChart: (item: ResolvedSummaryCard) => boolean;
+export declare const contentHeight: (item: ResolvedSummaryCard) => boolean;
+export declare const summaryFormat: (item: ResolvedSummaryCard, num: (n: number) => string) => ((n: number) => string);
+export declare const figureText: (f: Pick<DataTableSummaryValueFigure, "text">, n: string) => string;
 export declare const shareOf: (value: number, total: number) => number;
 export declare function percentText(p: number): string;
 export declare function sublineText(line: DataTableSummarySubline, n: string): string;

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

@@ -13,6 +13,9 @@ export interface TableSummaryInputs<TData> {
         others: string;
     };
     locale?: string;
+    selectionKey?: unknown;
 }
 export declare function resolveSummaryCards<TData>({ items, columns, serverMode, rowsFor, figures, filterGroup, query, labels, locale }: TableSummaryInputs<TData>): ResolvedSummaryCard<TData>[];
+export declare const SUMMARY_SETTLE_MS = 250;
+export declare const SUMMARY_SLICE_ROWS = 20000;
 export declare function useTableSummary<TData>(inputs: TableSummaryInputs<TData>): ResolvedSummaryCard<TData>[];

package/dist/types/components/DataTable/toolbar/ToolbarMore.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface ToolbarMoreItem {
+    id: string;
+    label: string;
+    icon: React.ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+}
+interface ToolbarMoreProps {
+    items: ToolbarMoreItem[];
+    onPick: (id: string) => void;
+}
+export declare function ToolbarMore({ items, onPick }: ToolbarMoreProps): React.JSX.Element;
+export {};

package/dist/types/components/DataTable/toolbar/useToolbarFit.d.ts

@@ -0,0 +1,10 @@
+import { type RefObject } from 'react';
+export interface ToolbarFitEntry {
+    id: string;
+    priority: number;
+}
+export interface ToolbarFit {
+    overflow: string[];
+    compact: boolean;
+}
+export declare function useToolbarFit(toolbarRef: RefObject<HTMLElement | null>, actionsRef: RefObject<HTMLElement | null>, entries: readonly ToolbarFitEntry[], key: string): ToolbarFit;

package/dist/types/components/DataTable/tree/TreeChips.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function TreeChips({ onExpandAll, onCollapseAll }: {
+    onExpandAll: () => void;
+    onCollapseAll: () => void;
+}): React.JSX.Element;

package/dist/types/components/DataTable/tree/treeExport.d.ts

@@ -0,0 +1,54 @@
+import { type TreeExtraRows } from '../../../core/logic';
+import { type ColumnTextContext } from '../columnValue';
+import type { DataTableColumn } from '../types';
+export declare const TREE_LEVEL_KEY = "__treeLevel";
+export interface TreeLevels<T> {
+    depthOf: (row: T) => number | undefined;
+    isParent: (row: T) => boolean;
+}
+export interface TreeLevelLook {
+    mode: 'column' | 'indent';
+    header: string;
+    text: ColumnTextContext;
+}
+export interface TreeExport<T> {
+    rows: T[];
+    columns: DataTableColumn<T>[];
+    keys: string[];
+    inTotals?: (row: T) => boolean;
+}
+export declare function treeLevelsOf<T>(ordered: ReadonlyArray<{
+    row: T;
+    id: string;
+    depth: number;
+}>, isParent: (id: string) => boolean): {
+    rows: T[];
+    levels: TreeLevels<T>;
+};
+export declare function treeLevelColumns<T>(columns: DataTableColumn<T>[], keys: string[], levels: TreeLevels<T>, look: TreeLevelLook): {
+    columns: DataTableColumn<T>[];
+    keys: string[];
+};
+export declare function treeFileOf<T>(rows: readonly T[], opts: {
+    idOf: (row: T) => string;
+    children?: (row: T) => T[] | null | undefined;
+    parentField?: string;
+    extra?: TreeExtraRows<T>;
+}): {
+    rows: T[];
+    levels: TreeLevels<T>;
+};
+export declare const treeInTotals: <T>(levels: TreeLevels<T>, totals: "leaves" | "all") => ((row: T) => boolean) | undefined;
+export declare function treeExportOf<T>(ordered: Array<{
+    row: {
+        id: string;
+        original: T;
+    };
+    depth: number;
+}> | null, columns: DataTableColumn<T>[], keys: string[], opts: {
+    mode: 'column' | 'indent';
+    totals: 'leaves' | 'all';
+    isParent: (id: string) => boolean;
+    header: string;
+    text: ColumnTextContext;
+}): TreeExport<T> | null;

package/dist/types/components/DataTable/tree/treeMove.d.ts

@@ -0,0 +1 @@
+export declare function withNestedValue<T>(row: T, path: string, value: unknown): T;

package/dist/types/components/DataTable/tree/useTreeChildren.d.ts

@@ -0,0 +1,15 @@
+import type { DataTableDataSource, DataTableQuery } from '../types';
+export declare function useTreeChildren<T>(opts: {
+    dataSource: DataTableDataSource<T> | undefined;
+    active: boolean;
+    query: DataTableQuery | null;
+    rowKey: string | undefined;
+    tick: number;
+}): {
+    enabled: boolean;
+    rows: T[];
+    parents: Map<string, string>;
+    status: (id: string) => "error" | "loading" | "done" | undefined;
+    load: (id: string, parent: T) => void;
+    forget: (id: string) => void;
+};

package/dist/types/components/DataTable/tree/useTreeData.d.ts

@@ -0,0 +1,60 @@
+import { type TreeExpansion, type TreeIndex } from '../../../core/logic';
+import { type ColumnTextContext } from '../columnValue';
+import type { DisplayItem } from '../grouping/groupModel';
+import type { DataTableColumn, DataTableFilterGroup, DataTableTreeDataConfig } from '../types';
+export interface TreeConfig<T> {
+    getChildren?: (row: T) => T[] | null | undefined;
+    parentField?: string;
+    defaultExpanded: boolean | number;
+    filterMode: 'ancestors' | 'matches';
+    totals: 'leaves' | 'all';
+    selectChildren: boolean;
+    exportLevel: 'column' | 'indent';
+    hasChildren?: (row: T) => boolean;
+}
+export declare function resolveTreeConfig<T>(cfg: DataTableTreeDataConfig<T> | undefined, rowKey: string | undefined): TreeConfig<T> | null;
+export declare function createTreeRowSearch<T>(columns: DataTableColumn<T>[], ctx: ColumnTextContext): (row: T, value: string) => boolean;
+export interface TreeMoved<T> {
+    rows: T[];
+    nodes: T[];
+    parentOf: ReadonlyMap<string, string | null>;
+}
+export declare function useTreeSource<T>(opts: {
+    config: TreeConfig<T> | null;
+    rows: T[];
+    rowKey: string | undefined;
+    serverMode: boolean;
+    columns: DataTableColumn<T>[];
+    text: ColumnTextContext;
+    viewId: string;
+    extraParents?: ReadonlyMap<string, string>;
+    moved?: TreeMoved<T> | null;
+}): {
+    on: boolean;
+    index: TreeIndex<T> | null;
+    idOf: (r: T) => string;
+    nodes: T[];
+    treeFilter: ((data: T[], group: DataTableFilterGroup, value: string) => T[]) | undefined;
+    openForMatches: () => ReadonlySet<string>;
+    flatMatches: () => boolean;
+    expansion: TreeExpansion;
+    toggle: (id: string, shownOpen: boolean) => void;
+    open: (id: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    reopenMatches: () => void;
+    descendants: (id: string) => string[];
+};
+export type TreeSource<T> = ReturnType<typeof useTreeSource<T>>;
+export declare function useTreeLines<R extends {
+    id: string;
+}>(tree: TreeSource<any>, rows: R[] | null, opts: {
+    status?: (id: string) => 'loading' | 'error' | 'done' | undefined;
+    canLoad?: (row: R) => boolean;
+}): {
+    lines: DisplayItem[] | null;
+    ordered: () => {
+        row: R;
+        depth: number;
+    }[] | null;
+};