@dcs-tech/ui 0.9.0 → 0.11.0

package/dist/types/core/logic/imageEditor.logic.d.ts

@@ -0,0 +1,132 @@
+import { type ImageCropRect, type ImageSize, type ImageTransform, type ImageTransformInput } from './imageTransform.logic';
+export interface ImageEditorRatio {
+    label: string;
+    value: number;
+}
+export interface ImageEditorCropOptions {
+    ratios?: ImageEditorRatio[];
+    free?: boolean;
+    defaultRatio?: number;
+    shape?: 'rect' | 'circle';
+    minWidth?: number;
+    minHeight?: number;
+}
+export interface ImageEditorOutputOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    mimeType?: string;
+    quality?: number;
+}
+export interface ImageEditorOptions {
+    crop?: boolean | ImageEditorCropOptions;
+    zoom?: boolean | {
+        min?: number;
+        max?: number;
+    };
+    pan?: boolean;
+    rotate?: boolean;
+    straighten?: boolean | {
+        maxDegrees?: number;
+    };
+    flip?: boolean | {
+        horizontal?: boolean;
+        vertical?: boolean;
+    };
+    reset?: boolean;
+    output?: ImageEditorOutputOptions;
+}
+export interface ResolvedImageEditorOptions {
+    crop: {
+        enabled: boolean;
+        ratios: ImageEditorRatio[];
+        free: boolean;
+        initialRatio: number | null;
+        showSelector: boolean;
+        shape: 'rect' | 'circle';
+        minWidth: number;
+        minHeight: number;
+    };
+    zoom: {
+        enabled: boolean;
+        min: number;
+        max: number;
+    };
+    pan: boolean;
+    rotate: boolean;
+    straighten: {
+        enabled: boolean;
+        maxDegrees: number;
+    };
+    flip: {
+        horizontal: boolean;
+        vertical: boolean;
+    };
+    reset: boolean;
+    output: ImageEditorOutputOptions;
+}
+export declare const resolveImageEditorOptions: (options?: ImageEditorOptions) => ResolvedImageEditorOptions;
+export declare const restrictImageTransform: (image: ImageSize, options: ResolvedImageEditorOptions, input: ImageTransformInput, ratio?: number | null) => ImageTransform;
+export interface ImageEditorModel {
+    image: ImageSize;
+    options: ResolvedImageEditorOptions;
+    transform: ImageTransform;
+    ratio: number | null;
+    stage: ImageSize;
+    zoom: number;
+    center: {
+        x: number;
+        y: number;
+    };
+    anchorCrop: ImageCropRect | null;
+}
+export declare const imageEditorScale: (m: ImageEditorModel) => number;
+export interface CreateImageEditorModel {
+    image: ImageSize;
+    stage: ImageSize;
+    options: ResolvedImageEditorOptions;
+    initial?: ImageTransformInput;
+}
+export declare const createImageEditorModel: ({ image, stage, options, initial }: CreateImageEditorModel) => ImageEditorModel;
+export declare const setImageEditorStage: (m: ImageEditorModel, stage: ImageSize) => ImageEditorModel;
+export declare const applyImageEditorOptions: (m: ImageEditorModel, options: ResolvedImageEditorOptions) => ImageEditorModel;
+export declare const resetImageEditor: (m: ImageEditorModel) => ImageEditorModel;
+export declare const rotateImageEditor: (m: ImageEditorModel, direction: "left" | "right") => ImageEditorModel;
+export declare const flipImageEditor: (m: ImageEditorModel, axis: "horizontal" | "vertical") => ImageEditorModel;
+export declare const straightenImageEditor: (m: ImageEditorModel, degrees: number) => ImageEditorModel;
+export declare const setImageEditorRatio: (m: ImageEditorModel, ratio: number | null) => ImageEditorModel;
+export declare const setImageEditorZoom: (m: ImageEditorModel, zoom: number) => ImageEditorModel;
+export declare const moveImageEditorCrop: (m: ImageEditorModel, dx: number, dy: number) => ImageEditorModel;
+export declare const panImageEditor: (m: ImageEditorModel, dx: number, dy: number) => ImageEditorModel;
+export type ImageCropHandle = 'n' | 's' | 'e' | 'w' | 'nw' | 'ne' | 'sw' | 'se';
+export declare const IMAGE_CROP_HANDLES: readonly ImageCropHandle[];
+export declare const resizeImageEditorCrop: (m: ImageEditorModel, handle: ImageCropHandle, dx: number, dy: number) => ImageEditorModel;
+export declare const imageEditorBox: (m: ImageEditorModel) => ImageCropRect;
+export declare const imageEditorViewMatrix: (m: ImageEditorModel) => import("./imageTransform.logic").ImageMatrix;
+export declare const finalImageTransform: (m: ImageEditorModel) => ImageTransform;
+export declare const imageEditorOutputSize: (m: ImageEditorModel) => ImageSize;
+export declare const imageEditorMeetsMinimum: (m: ImageEditorModel) => boolean;
+export declare const imageCanMeetMinimum: (image: ImageSize, options: ResolvedImageEditorOptions) => boolean;
+export type ImageEditorKeyAction = {
+    type: 'move';
+    dx: number;
+    dy: number;
+} | {
+    type: 'resize';
+    dx: number;
+    dy: number;
+} | {
+    type: 'pan';
+    dx: number;
+    dy: number;
+} | {
+    type: 'zoom';
+    factor: number;
+};
+export declare const imageEditorKeyAction: (options: ResolvedImageEditorOptions, event: {
+    key: string;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+}) => ImageEditorKeyAction | null;
+export declare const applyImageEditorKeyAction: (m: ImageEditorModel, action: ImageEditorKeyAction) => ImageEditorModel;

package/dist/types/core/logic/imageTransform.logic.d.ts

@@ -0,0 +1,57 @@
+export type ImageQuarterTurn = 0 | 90 | 180 | 270;
+export interface ImageSize {
+    width: number;
+    height: number;
+}
+export interface ImageCropRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ImageOrientation {
+    rotate: ImageQuarterTurn;
+    straighten: number;
+    flipH: boolean;
+    flipV: boolean;
+}
+export interface ImageTransform extends ImageOrientation {
+    crop: ImageCropRect;
+}
+export type ImageTransformInput = Partial<Omit<ImageTransform, 'rotate'>> & {
+    rotate?: number;
+};
+export type ImageMatrix = readonly [a: number, b: number, c: number, d: number, e: number, f: number];
+type Turned = Pick<ImageOrientation, 'rotate' | 'straighten'>;
+export declare const IMAGE_STRAIGHTEN_LIMIT = 45;
+export declare const normalizeQuarterTurn: (degrees: number) => ImageQuarterTurn;
+export declare const clampStraighten: (degrees: number, limit?: number) => number;
+export declare const imageFrameSize: (image: ImageSize, rotate: ImageQuarterTurn) => ImageSize;
+export declare const imageBoundsSize: (image: ImageSize, o: Turned) => ImageSize;
+export declare const fullImageCrop: (image: ImageSize, o: Turned, ratio?: number | null) => ImageCropRect;
+export declare const imageCropFits: (image: ImageSize, o: Turned, crop: ImageCropRect) => boolean;
+export declare const clampImageCrop: (image: ImageSize, o: Turned, crop: ImageCropRect) => ImageCropRect;
+export declare const fitImageCropToRatio: (image: ImageSize, o: Turned, crop: ImageCropRect, ratio: number | null) => ImageCropRect;
+export declare const resolveImageTransform: (image: ImageSize, input?: ImageTransformInput) => ImageTransform;
+export declare const snapImageCrop: (image: ImageSize, transform: ImageTransform, ratio?: number | null) => ImageCropRect;
+export interface ImageOutputLimits {
+    maxWidth?: number;
+    maxHeight?: number;
+}
+export declare const imageOutputSize: (crop: Pick<ImageCropRect, "width" | "height">, limits?: ImageOutputLimits) => ImageSize;
+export interface ImageFrameTarget {
+    scaleX: number;
+    scaleY: number;
+    x: number;
+    y: number;
+}
+export declare const imageMatrix: (image: ImageSize, o: ImageOrientation, target: ImageFrameTarget) => ImageMatrix;
+export declare const imageOutputMatrix: (image: ImageSize, transform: ImageTransform, output: ImageSize) => ImageMatrix;
+export declare const applyImageMatrix: (m: ImageMatrix, p: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+};
+export {};

package/dist/types/core/logic/index.d.ts

@@ -5,7 +5,15 @@ export * from './chipinput.logic';
 export * from './collapsible.logic';
 export * from './colorScheme';
 export * from './columnOrder.logic';
+export * from './columnGroups.logic';
+export * from './fitColumns.logic';
+export * from './toolbarOverflow.logic';
+export * from './rowPinning.logic';
+export * from './cellRange.logic';
+export * from './cellTouch.logic';
 export * from './datePicker.logic';
+export * from './eventCalendar.logic';
+export * from './periodPicker.logic';
 export * from './timeField.logic';
 export * from './editableTable.logic';
 export * from './fieldControl.logic';
@@ -16,13 +24,21 @@ export * from './standardSchema.logic';
 export * from './input.logic';
 export * from './keyboard.logic';
 export * from './motion.logic';
+export * from './tween.logic';
 export * from './navigation.logic';
 export * from './popover.logic';
+export * from './dropdownSide.logic';
+export * from './visualViewport.logic';
 export * from './popupList.logic';
 export * from './press.logic';
 export * from './stepper.logic';
+export * from './alert.logic';
+export * from './pagination.logic';
+export * from './commandPalette.logic';
+export * from './pageProgress.logic';
 export * from './quickAddGrid.logic';
 export * from './radio.logic';
+export * from './reorder.logic';
 export * from './select.logic';
 export * from './suggest.logic';
 export * from './switch.logic';
@@ -36,3 +52,12 @@ export * from './tooltip.logic';
 export * from './typography.logic';
 export * from './uiScale.logic';
 export * from './useMergeRefs';
+export * from './inertProps';
+export * from './imageTransform.logic';
+export * from './imageEditor.logic';
+export * from './treeData.logic';
+export * from './rowDrag.logic';
+export * from './treeDrag.logic';
+export * from './pivot.logic';
+export * from './rowActions.logic';
+export * from './icon.logic';

package/dist/types/core/logic/inertProps.d.ts

@@ -0,0 +1,3 @@
+export declare function inertProps(inert: boolean): {
+    inert?: boolean;
+};

package/dist/types/core/logic/pageProgress.logic.d.ts

@@ -0,0 +1,3 @@
+export type PageProgressPhase = 'idle' | 'waiting' | 'running' | 'finishing';
+export type PageProgressEvent = 'activate' | 'deactivate' | 'delayElapsed' | 'finished';
+export declare function nextPageProgressPhase(phase: PageProgressPhase, event: PageProgressEvent): PageProgressPhase;

package/dist/types/core/logic/pagination.logic.d.ts

@@ -0,0 +1,7 @@
+export type PaginationSlot = number | 'gap-start' | 'gap-end';
+export declare function pageCountFor(total: number, pageSize: number): number;
+export declare function pageRowRange(pageIndex: number, pageSize: number, total: number): {
+    from: number;
+    to: number;
+};
+export declare function paginationSlots(pageIndex: number, pageCount: number, siblings?: number): PaginationSlot[];

package/dist/types/core/logic/periodPicker.logic.d.ts

@@ -0,0 +1,86 @@
+import type { DateDisplayFormat, DateTextOrder } from '../types';
+import { type DateHighlightAction, type IsoDay } from './datePicker.logic';
+export type IsoPeriod = string;
+export type PeriodMode = 'month' | 'year';
+export interface PeriodBounds {
+    min: IsoPeriod;
+    max: IsoPeriod;
+}
+export declare const PERIOD_COLUMNS = 3;
+export declare const PERIOD_PAGE_SIZE = 12;
+export declare function toPeriod(value: unknown, mode: PeriodMode, bound?: 'start' | 'end'): IsoPeriod;
+export declare function shiftPeriod(period: IsoPeriod, mode: PeriodMode, n: number): IsoPeriod;
+export declare function resolvePeriodBounds(opts: {
+    mode: PeriodMode;
+    min?: string;
+    max?: string;
+    yearRange?: {
+        back?: number;
+        ahead?: number;
+    };
+    today?: IsoDay;
+}): PeriodBounds;
+export declare const isPeriodInBounds: (period: IsoPeriod, bounds: PeriodBounds) => boolean;
+export declare function clampPeriod(period: IsoPeriod, bounds: PeriodBounds): IsoPeriod;
+export declare function openingPeriod(value: unknown, opts: {
+    mode: PeriodMode;
+    bounds: PeriodBounds;
+    today?: IsoDay;
+}): IsoPeriod;
+export interface PeriodCell {
+    period: IsoPeriod;
+    year: number;
+    month: number;
+    isCurrent: boolean;
+    isSelected: boolean;
+    isHighlighted: boolean;
+    inRange: boolean;
+    isRangeStart: boolean;
+    isRangeEnd: boolean;
+    disabled: boolean;
+}
+export interface PeriodGridView {
+    firstYear: number;
+    lastYear: number;
+    rows: PeriodCell[][];
+    canPagePrev: boolean;
+    canPageNext: boolean;
+}
+export declare function buildPeriodGrid(opts: {
+    mode: PeriodMode;
+    cursor: IsoPeriod;
+    bounds: PeriodBounds;
+    today?: IsoDay;
+    selected?: IsoPeriod;
+    rangeFrom?: IsoPeriod;
+    rangeTo?: IsoPeriod;
+}): PeriodGridView;
+export declare function movePeriodCursor(from: IsoPeriod, action: DateHighlightAction, opts: {
+    mode: PeriodMode;
+    bounds: PeriodBounds;
+}): IsoPeriod;
+export declare function extendPeriodRange(range: {
+    from?: IsoPeriod;
+    to?: IsoPeriod;
+}, picked: IsoPeriod, mode: PeriodMode): {
+    from: IsoPeriod;
+    to: IsoPeriod;
+};
+export interface PeriodTextOptions {
+    mode: PeriodMode;
+    within?: IsoPeriod;
+    today?: IsoDay;
+    order?: DateTextOrder;
+    monthNames?: string[];
+    monthNamesShort?: string[];
+}
+export declare function parsePeriodText(text: unknown, opts: PeriodTextOptions): IsoPeriod | null;
+export declare function parsePeriodRangeText(text: unknown, opts: PeriodTextOptions): {
+    from: IsoPeriod;
+    to: IsoPeriod;
+} | null;
+export declare function formatPeriodText(value: unknown, mode: PeriodMode, opts?: {
+    locale?: string;
+    monthNames?: string[];
+}): string;
+export declare function periodPlaceholder(mode: PeriodMode, format?: DateDisplayFormat): string;

package/dist/types/core/logic/pivot.logic.d.ts

@@ -0,0 +1,100 @@
+export type PivotKey = string | number | boolean | null;
+export type PivotAggName = 'sum' | 'count' | 'avg' | 'min' | 'max' | 'first' | 'last';
+export declare const PIVOT_AGGS: readonly PivotAggName[];
+export declare const PIVOT_NUMBER_AGGS: readonly PivotAggName[];
+export declare const isPivotAggName: (agg: unknown) => agg is PivotAggName;
+export type PivotAggFn<T> = (values: unknown[], rows: T[]) => unknown;
+export interface PivotSpec<T> {
+    rows: ReadonlyArray<(row: T) => PivotKey>;
+    columns: ReadonlyArray<(row: T) => PivotKey>;
+    values: ReadonlyArray<{
+        valueOf: (row: T) => unknown;
+        agg: PivotAggName | PivotAggFn<T>;
+    }>;
+}
+export interface PivotNode {
+    id: number;
+    key: PivotKey;
+    path: PivotKey[];
+    depth: number;
+    parent: PivotNode | null;
+    children: Map<PivotKey, PivotNode>;
+}
+export interface PivotCube {
+    rows: PivotNode;
+    columns: PivotNode;
+    rowFields: number;
+    columnFields: number;
+    values: number;
+    figures: (row: PivotNode, column: PivotNode) => readonly unknown[] | undefined;
+}
+export declare function pivotKeyId(k: PivotKey): string;
+export declare function pivotNumber(v: unknown): number | null;
+export declare const isPivotBlank: (v: unknown) => boolean;
+export interface PivotBuilder<T> {
+    add: (rows: readonly T[], from?: number, to?: number) => void;
+    done: () => PivotCube;
+}
+export declare function pivotBuilder<T>(spec: PivotSpec<T>): PivotBuilder<T>;
+export declare function computePivot<T>(rows: readonly T[], spec: PivotSpec<T>): PivotCube;
+export interface PivotCellInput {
+    row: readonly PivotKey[];
+    column: readonly PivotKey[];
+    values: readonly unknown[];
+}
+export declare function pivotCubeFromCells(cells: readonly PivotCellInput[], dims: {
+    rowFields: number;
+    columnFields: number;
+    values: number;
+}): PivotCube;
+export declare function comparePivotKeys(a: PivotKey, b: PivotKey): number;
+export declare function comparePivotFigures(a: unknown, b: unknown): number;
+export interface PivotColumn {
+    id: string;
+    node: PivotNode;
+    value: number;
+    total: boolean;
+}
+export interface PivotHeaderGroup {
+    id: string;
+    node: PivotNode;
+    total: boolean;
+    children: Array<PivotHeaderGroup | PivotColumn>;
+}
+export declare const isPivotHeaderGroup: (x: PivotHeaderGroup | PivotColumn) => x is PivotHeaderGroup;
+export interface PivotLine {
+    id: string;
+    node: PivotNode;
+    kind: 'leaf' | 'subtotal' | 'grand';
+}
+export interface PivotLayoutOptions {
+    rowSubtotals: boolean;
+    columnTotals: boolean;
+    grandTotal: boolean;
+    maxColumns: number;
+    compareRowKey?: (field: number, a: PivotKey, b: PivotKey) => number;
+    compareColumnKey?: (field: number, a: PivotKey, b: PivotKey) => number;
+}
+export interface PivotLayout {
+    columns: PivotColumn[];
+    header: Array<PivotHeaderGroup | PivotColumn>;
+    lines: PivotLine[];
+    grand: PivotLine | null;
+    capped: {
+        shown: number;
+        total: number;
+    } | null;
+}
+export declare const pivotColumnId: (path: readonly PivotKey[], value: number) => string;
+export declare const pivotLineId: (path: readonly PivotKey[]) => string;
+export declare function layoutPivot(cube: PivotCube, opts: PivotLayoutOptions): PivotLayout;
+export type PivotSort = {
+    field: number;
+    desc: boolean;
+} | {
+    column: PivotColumn;
+    desc: boolean;
+};
+export declare function orderPivotLines(cube: PivotCube, layout: PivotLayout, sorts: readonly PivotSort[], opts?: {
+    compareRowKey?: (field: number, a: PivotKey, b: PivotKey) => number;
+}): PivotLine[];

package/dist/types/core/logic/reorder.logic.d.ts

@@ -0,0 +1,49 @@
+export interface ReorderSlot {
+    start: number;
+    size: number;
+}
+export interface ReorderRange {
+    min: number;
+    max: number;
+}
+export declare function moveItem<T>(items: readonly T[], from: number, to: number): T[];
+export declare function reorderRange(fixed: readonly boolean[], from: number): ReorderRange;
+export declare function reorderTarget(slots: readonly ReorderSlot[], from: number, offset: number, range: ReorderRange): number;
+export declare function reorderShift(slots: readonly ReorderSlot[], from: number, to: number, index: number): number;
+export declare function reorderDropOffset(slots: readonly ReorderSlot[], from: number, to: number): number;
+export declare function reorderDragLimits(slots: readonly ReorderSlot[], from: number, range: ReorderRange): ReorderRange;
+export declare function stepReorderIndex(current: number, step: -1 | 1, range: ReorderRange): number;
+export declare function autoScrollStep(pointer: number, edgeStart: number, edgeEnd: number, zone: number, maxStep: number): number;
+export interface ReorderPoint {
+    x: number;
+    y: number;
+}
+export interface ReorderSize {
+    width: number;
+    height: number;
+}
+export interface ReorderFlow {
+    axis: 'vertical' | 'horizontal' | 'wrap';
+    width: number;
+    gapX: number;
+    gapY: number;
+}
+export declare function flowPositions(sizes: readonly ReorderSize[], flow: ReorderFlow): ReorderPoint[];
+export declare function flowExtent(sizes: readonly ReorderSize[], flow: ReorderFlow): ReorderSize;
+export declare function insertItem<T>(items: readonly T[], index: number, item: T): T[];
+export declare function insertionPoints(sizes: readonly ReorderSize[], dragged: ReorderSize, flow: ReorderFlow, range: ReorderRange): ReorderPoint[];
+export declare function nearestPoint(points: readonly ReorderPoint[], at: ReorderPoint): number;
+export interface ReorderAcceptRules {
+    from?: number;
+    sortable?: boolean;
+    maxItems?: number;
+    replaceWhenFull?: boolean;
+}
+export declare function acceptedRange(fixed: readonly boolean[], rules: ReorderAcceptRules): ReorderRange | null;
+export interface ReorderStop {
+    list: number;
+    index: number;
+}
+export declare function stepAcrossLists(ranges: ReadonlyArray<ReorderRange | null>, current: ReorderStop, step: -1 | 1): ReorderStop;
+export declare function reorderSelectedValues<V>(value: readonly V[], shown: readonly V[]): V[];
+export declare function fixedSelectValues<V>(value: readonly V[], fixedItems: number, defaultSelected: readonly V[]): Set<V>;

package/dist/types/core/logic/rowActions.logic.d.ts

@@ -0,0 +1,7 @@
+export declare const MAX_VISIBLE_ACTIONS_CHOICES: readonly [1, 2, 3, 4, 5];
+export declare function isMaxVisibleActions(value: unknown): value is number;
+export interface RowActionButtons {
+    count: number;
+    primaryOnly: boolean;
+}
+export declare function rowActionButtons(surface: 'table' | 'card', choice: unknown, viewInline: number | undefined): RowActionButtons;

package/dist/types/core/logic/rowDrag.logic.d.ts

@@ -0,0 +1,36 @@
+export type RowDragBlock = 'sorted' | 'filtered' | 'searched' | 'grouped';
+export declare function rowDragBlock(state: {
+    sorted: boolean;
+    filtered: boolean;
+    searched: boolean;
+    grouped: boolean;
+}): RowDragBlock | null;
+export type RowDropTarget = {
+    before: string;
+} | {
+    after: string;
+};
+export interface RowMove<T> {
+    rows: T[];
+    removedAt: number[];
+    addedAt: number[];
+}
+export declare function moveRows<T>(rows: readonly T[], idOf: (row: T) => string, moving: ReadonlySet<string>, target: RowDropTarget): RowMove<T> | null;
+export interface RowSlotRect {
+    id: string;
+    top: number;
+    bottom: number;
+}
+export declare function dropTargetAt(rects: readonly RowSlotRect[], y: number): RowDropTarget | null;
+export declare function normalizeDropTarget(order: readonly string[], target: RowDropTarget): RowDropTarget;
+export declare function keyboardDrop(order: readonly string[], moving: ReadonlySet<string>): {
+    rest: string[];
+    slot: number;
+    total: number;
+};
+export declare function slotTarget(rest: readonly string[], slot: number): RowDropTarget | null;
+export interface RowSlotBox extends RowSlotRect {
+    left: number;
+    right: number;
+}
+export declare function gridDropTargetAt(boxes: readonly RowSlotBox[], x: number, y: number): RowDropTarget | null;

package/dist/types/core/logic/rowPinning.logic.d.ts

@@ -0,0 +1,12 @@
+export type RowPinSide = 'top' | 'bottom';
+export interface RowPins {
+    top: string[];
+    bottom: string[];
+}
+export declare const NO_ROW_PINS: RowPins;
+export declare const ROW_PINS_MAX = 50;
+export declare function rowPinSide(pins: RowPins, id: string): RowPinSide | null;
+export declare function pinRowTo(pins: RowPins, id: string, side: RowPinSide | null): RowPins;
+export declare function normalizeRowPins(value: unknown): RowPins;
+export declare function sameRowPins(a: RowPins, b: RowPins): boolean;
+export declare function hasRowPins(pins: RowPins): boolean;

package/dist/types/core/logic/slidingHighlight.logic.d.ts

@@ -0,0 +1,20 @@
+export interface HighlightBox {
+    offset: number;
+    size: number;
+}
+export type HighlightMove = 'slide' | 'fade' | 'appear' | 'follow' | 'stay';
+export interface HighlightJumpRule {
+    maxSteps?: number;
+    maxDistance?: number;
+}
+export declare const HIGHLIGHT_MAX_STEPS = 4;
+export declare const HIGHLIGHT_MAX_DISTANCE = 320;
+export interface ChooseHighlightMoveInput {
+    from: HighlightBox | null;
+    to: HighlightBox | null;
+    sameItem: boolean;
+    fromVisible: boolean;
+    rule?: HighlightJumpRule | false;
+}
+export declare function chooseHighlightMove({ from, to, sameItem, fromVisible, rule }: ChooseHighlightMoveInput): HighlightMove;
+export declare function spanVisible(box: HighlightBox, start: number, end: number): boolean;

package/dist/types/core/logic/toolbarOverflow.logic.d.ts

@@ -0,0 +1,21 @@
+export interface ToolbarFitItem {
+    id: string;
+    width: number;
+    priority: number;
+}
+export interface ToolbarFitInput {
+    available: number;
+    pinned?: number;
+    moreWidth: number;
+    items: readonly ToolbarFitItem[];
+    shrinkable?: {
+        full: number;
+        compact: number;
+    };
+}
+export interface ToolbarFitResult {
+    overflow: string[];
+    compact: boolean;
+}
+export declare function fitToolbarItems({ available, pinned, moreWidth, items, shrinkable }: ToolbarFitInput): ToolbarFitResult;
+export declare function sameOverflow(a: readonly string[], b: readonly string[]): boolean;

package/dist/types/core/logic/treeData.logic.d.ts

@@ -0,0 +1,44 @@
+export interface TreeIndex<T> {
+    nodes: T[];
+    parentOf: Map<string, string | null>;
+    childrenOf: Map<string, string[]>;
+}
+export interface TreeSource<T> {
+    children?: (row: T) => readonly T[] | null | undefined;
+    parentId?: (row: T) => string | null | undefined;
+}
+export declare function treeIndexOf<T>(rows: readonly T[], idOf: (row: T) => string, source: TreeSource<T>): TreeIndex<T>;
+export declare function treeDescendants(childrenOf: ReadonlyMap<string, readonly string[]>, id: string): string[];
+export declare function treeAncestors(parentOf: ReadonlyMap<string, string | null>, id: string): string[];
+export type TreeFilterMode = 'ancestors' | 'matches';
+export interface TreeKept<T> {
+    kept: T[];
+    matched: Set<string>;
+    open: Set<string>;
+}
+export declare function keepTreeMatches<T>(rows: readonly T[], idOf: (row: T) => string, tree: Pick<TreeIndex<T>, 'parentOf' | 'childrenOf'>, matches: (row: T) => boolean, mode?: TreeFilterMode): TreeKept<T>;
+export interface TreeBuckets<R> {
+    roots: R[];
+    children: Map<string, R[]>;
+}
+export declare function treeBuckets<R>(rows: readonly R[], idOf: (row: R) => string, parentOf: (id: string) => string | null | undefined, flat?: boolean): TreeBuckets<R>;
+export interface TreeLine<R> {
+    row: R;
+    id: string;
+    depth: number;
+    hasChildren: boolean;
+    expanded: boolean;
+}
+export declare function flattenTree<R>(buckets: TreeBuckets<R>, idOf: (row: R) => string, isExpanded: (id: string, depth: number) => boolean, hasChildren?: (row: R, id: string) => boolean): Array<TreeLine<R>>;
+export interface TreeExpansion {
+    base: boolean | number;
+    toggled: ReadonlyMap<string, boolean>;
+    force: boolean;
+}
+export declare function isTreeRowExpanded(state: TreeExpansion, id: string, depth: number, forcedOpen?: ReadonlySet<string>): boolean;
+export declare function toggleTreeRow(state: TreeExpansion, id: string, shownOpen: boolean): TreeExpansion;
+export interface TreeExtraRows<T> {
+    rows: readonly T[];
+    parentOf: (id: string) => string | null | undefined;
+}
+export declare function treeFileLines<T>(rows: readonly T[], idOf: (row: T) => string, source: TreeSource<T>, extra?: TreeExtraRows<T>): Array<TreeLine<T>>;