@dcs-tech/ui 0.8.0 → 0.10.0

package/dist/types/components/Popover/floatingPosition.d.ts

@@ -25,3 +25,7 @@ export declare const visibleBounds: (el: Element) => {
     top: number;
     bottom: number;
 };
+export declare const listOverhang: (list: Element | null | undefined, anchor: Element | null | undefined) => string | undefined;
+export declare const titleWhenCut: (event: {
+    target: EventTarget | null;
+}) => void;

package/dist/types/components/ReorderList/ReorderGroup.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { ReorderGroupMove, ReorderPeer } from './crossListDrag';
+export interface ReorderGroupProps<T = any> {
+    onMove: (move: ReorderGroupMove<T>) => void;
+    children: React.ReactNode;
+}
+interface ReorderGroupContextValue {
+    peers: Set<ReorderPeer>;
+    onMove: (move: ReorderGroupMove) => void;
+    busy: {
+        current: boolean;
+    };
+}
+export declare const useReorderGroup: () => ReorderGroupContextValue | null;
+export declare function ReorderGroup<T = any>({ onMove, children }: ReorderGroupProps<T>): React.JSX.Element;
+export default ReorderGroup;

package/dist/types/components/ReorderList/ReorderList.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+import { type UILabels } from '../UIProvider/UILabelsContext';
+import { type ReorderAxis, type ReorderMove } from './useReorderDrag';
+import type { ReorderWhenFull } from './crossListDrag';
+export type { ReorderAxis, ReorderMove, ReorderWhenFull };
+export type ReorderDragFrom = 'handle' | 'row' | 'both';
+export type ReorderLabels = UILabels['reorder'];
+export interface ReorderHandleProps {
+    tabIndex: number;
+    'aria-label': string;
+    'aria-describedby': string;
+    style: React.CSSProperties;
+    onPointerDown: React.PointerEventHandler<HTMLElement>;
+    onKeyDown: React.KeyboardEventHandler<HTMLElement>;
+    'data-reorder-handle': string;
+}
+export interface ReorderListHandle {
+    move: (key: string | number, step: -1 | 1) => boolean;
+}
+export interface ReorderItemState {
+    index: number;
+    dragging: boolean;
+    canDrag: boolean;
+    handle: React.ReactNode;
+    handleProps: ReorderHandleProps | null;
+}
+export interface ReorderListProps<T> {
+    items: readonly T[];
+    getKey: (item: T, index: number) => string | number;
+    renderItem: (item: T, state: ReorderItemState) => React.ReactNode;
+    onReorder: (items: T[], move: ReorderMove) => void;
+    axis?: ReorderAxis;
+    dragFrom?: ReorderDragFrom;
+    canDrag?: (item: T, index: number) => boolean;
+    isFixed?: (item: T, index: number) => boolean;
+    disabled?: boolean;
+    getItemLabel?: (item: T, index: number) => string;
+    labels?: Partial<ReorderLabels>;
+    className?: string;
+    itemClassName?: string;
+    style?: React.CSSProperties;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    role?: React.AriaRole;
+    itemRole?: React.AriaRole;
+    listId?: string;
+    maxItems?: number;
+    whenFull?: ReorderWhenFull;
+    sortable?: boolean;
+    autoScroll?: boolean;
+    autoScrollSpeed?: number;
+    handleRef?: React.Ref<ReorderListHandle>;
+}
+export declare function ReorderList<T>({ items, getKey, renderItem, onReorder, axis, dragFrom, canDrag, isFixed, disabled, getItemLabel, labels, className, itemClassName, style, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledby, role, itemRole, listId, maxItems, whenFull, sortable, autoScroll, autoScrollSpeed, handleRef, }: ReorderListProps<T>): React.JSX.Element;
+export default ReorderList;

package/dist/types/components/ReorderList/crossListDrag.d.ts

@@ -0,0 +1,61 @@
+import { type ReorderPoint } from '../../core/logic';
+export type ReorderAxis = 'vertical' | 'horizontal' | 'wrap';
+export interface ReorderMove {
+    from: number;
+    to: number;
+}
+export interface ReorderGroupMove<T = any> {
+    item: T;
+    from: {
+        list: string;
+        index: number;
+    };
+    to: {
+        list: string;
+        index: number;
+    };
+}
+export type ReorderWhenFull = 'reject' | 'replace';
+export interface ReorderPeer {
+    id: string;
+    el: () => HTMLElement | null;
+    options: () => {
+        items: readonly any[];
+        getKey: (item: any, index: number) => string | number;
+        isFixed: (item: any, index: number) => boolean;
+        onReorder: (items: any[], move: ReorderMove) => void;
+        axis: ReorderAxis;
+        disabled: boolean;
+        sortable: boolean;
+        maxItems?: number;
+        whenFull: ReorderWhenFull;
+        listLabel?: string;
+    };
+}
+export declare const setRowOffset: (row: HTMLElement, x: number, y: number) => void;
+export interface CrossDragStop {
+    position: number;
+    total: number;
+    list?: string;
+}
+export interface CrossDrag {
+    follow: (x: number, y: number) => void;
+    step: (step: -1 | 1) => CrossDragStop | null;
+    goHome: () => void;
+    settle: () => void;
+    commit: () => void;
+    stop: () => CrossDragStop;
+    span: (vertical: boolean) => {
+        start: number;
+        size: number;
+    };
+    refocus: () => void;
+    clear: () => void;
+}
+export declare function createCrossDrag(args: {
+    peers: readonly ReorderPeer[];
+    sourceEl: HTMLElement;
+    from: number;
+    press: ReorderPoint;
+    onMove?: (move: ReorderGroupMove) => void;
+}): CrossDrag | null;

package/dist/types/components/ReorderList/index.d.ts

@@ -0,0 +1,5 @@
+export { ReorderList, default } from './ReorderList';
+export { ReorderGroup } from './ReorderGroup';
+export type { ReorderGroupProps } from './ReorderGroup';
+export type { ReorderGroupMove } from './crossListDrag';
+export type { ReorderListProps, ReorderItemState, ReorderHandleProps, ReorderDragFrom, ReorderAxis, ReorderMove, ReorderLabels, ReorderListHandle, ReorderWhenFull, } from './ReorderList';

package/dist/types/components/ReorderList/useReorderDrag.d.ts

@@ -0,0 +1,28 @@
+import { type KeyboardEvent, type PointerEvent } from 'react';
+import { type ReorderAxis, type ReorderMove, type ReorderWhenFull } from './crossListDrag';
+export type { ReorderAxis, ReorderMove };
+type ReorderEvent = 'pickedUp' | 'moved' | 'dropped' | 'cancelled';
+interface ReorderDragOptions<T> {
+    items: readonly T[];
+    getKey: (item: T, index: number) => string | number;
+    onReorder: (items: T[], move: ReorderMove) => void;
+    isFixed: (item: T, index: number) => boolean;
+    axis: ReorderAxis;
+    disabled: boolean;
+    announce: (event: ReorderEvent, index: number, position: number, total: number, list?: string) => void;
+    listId?: string;
+    listLabel?: string;
+    sortable: boolean;
+    maxItems?: number;
+    whenFull: ReorderWhenFull;
+    canDrag: (item: T, index: number) => boolean;
+    autoScroll: boolean;
+    autoScrollSpeed?: number;
+}
+export declare function useReorderDrag<T>(options: ReorderDragOptions<T>): {
+    listRef: import("react").RefObject<HTMLDivElement | null>;
+    activeKey: string | number | null;
+    press: (e: PointerEvent<HTMLElement>, index: number, kind: "handle" | "row") => void;
+    keyDown: (e: KeyboardEvent<HTMLElement>, index: number) => void;
+    move: (key: string | number, step: -1 | 1) => boolean;
+};

package/dist/types/components/Tooltip/useTooltip.d.ts

@@ -1,5 +1,9 @@
 import React from 'react';
 import type { TooltipProp } from '../../core/types';
+export declare const hoverSurfaceIsWarm: () => boolean;
+export declare const dismissActiveTooltip: () => void;
+export declare const warmTooltips: () => void;
+export declare const handOverToTooltip: () => void;
 export interface UseTooltipResult {
     triggerProps: {
         onPointerEnter: (event: React.PointerEvent<HTMLElement>) => void;

package/dist/types/components/UIProvider/UILabelsContext.d.ts

@@ -20,6 +20,9 @@ export declare const DEFAULT_UI_LABELS: {
         fixErrors: string;
         submitFailed: string;
     };
+    chipInput: {
+        removeTag: string;
+    };
     input: {
         clear: string;
         showPassword: string;
@@ -38,6 +41,8 @@ export declare const DEFAULT_UI_LABELS: {
         maxReached: string;
         dragToReorder: string;
         fixedPosition: string;
+        selectedOptions: string;
+        reorderInstructions: string;
     };
     suggest: {
         placeholder: string;
@@ -50,6 +55,7 @@ export declare const DEFAULT_UI_LABELS: {
         placeholder: string;
         empty: string;
         name: string;
+        trigger: string;
     };
     datePicker: {
         clear: string;
@@ -57,6 +63,18 @@ export declare const DEFAULT_UI_LABELS: {
         presetRanges: string;
         previousMonth: string;
         nextMonth: string;
+        previousYear: string;
+        nextYear: string;
+        previousYears: string;
+        nextYears: string;
+        month: string;
+        year: string;
+        from: string;
+        to: string;
+        rangeTo: string;
+        selected: string;
+        chooseMonth: string;
+        chooseYear: string;
         presets: {
             today: string;
             yesterday: string;
@@ -99,15 +117,83 @@ export declare const DEFAULT_UI_LABELS: {
         related: string;
         hidden: (count: number) => string;
     };
+    alert: {
+        dismiss: string;
+    };
+    navList: {
+        name: string;
+    };
+    pageProgress: {
+        name: string;
+    };
+    pagination: {
+        name: string;
+        first: string;
+        previous: string;
+        next: string;
+        last: string;
+        page: (n: string) => string;
+        pageOf: (n: string, count: string) => string;
+        range: (from: string, to: string, total: string) => string;
+        noRows: string;
+        perPage: string;
+        rowsPerPage: string;
+    };
+    link: {
+        opensInNewTab: string;
+    };
+    reorder: {
+        item: string;
+        handle: (item: string) => string;
+        instructions: string;
+        pickedUp: (item: string, position: number, total: number) => string;
+        moved: (item: string, position: number, total: number) => string;
+        dropped: (item: string, position: number, total: number) => string;
+        cancelled: (item: string, position: number, total: number) => string;
+        movedToList: (item: string, list: string, position: number, total: number) => string;
+        droppedInList: (item: string, list: string, position: number, total: number) => string;
+    };
     image: {
         image: string;
         images: string;
         add: string;
+        replace: string;
+        drop: string;
         preparing: string;
         remove: string;
         previous: string;
         next: string;
     };
+    imageEditor: {
+        title: string;
+        apply: string;
+        cancel: string;
+        tools: string;
+        zoom: string;
+        pan: string;
+        rotateLeft: string;
+        rotateRight: string;
+        straighten: string;
+        flipHorizontal: string;
+        flipVertical: string;
+        reset: string;
+        ratios: string;
+        free: string;
+        imageAlt: string;
+        cropBox: string;
+        hintMove: string;
+        hintResize: string;
+        hintPan: string;
+        hintZoom: string;
+        status: (width: number, height: number) => string;
+        loading: string;
+        failedCors: string;
+        failedLoad: string;
+        failedRead: string;
+        failedRender: string;
+        imageTooSmall: (width: number, height: number) => string;
+        cropTooSmall: (width: number, height: number) => string;
+    };
 };
 export type UILabels = typeof DEFAULT_UI_LABELS & {
     table?: Partial<DataTableLabels>;

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

@@ -1,3 +1,4 @@
 export { useDebounced, useDebouncedCallback } from './useDebounced';
 export type { DebouncedCallback } from './useDebounced';
 export { usePresence, SURFACE_EXIT_MS } from './usePresence';
+export { useMeasuredState } from './useMeasuredState';

package/dist/types/core/hooks/useMeasuredState.d.ts

@@ -0,0 +1 @@
+export declare function useMeasuredState<T extends object>(initial: T | null): [T | null, (next: T | null) => void];

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

@@ -0,0 +1,3 @@
+import type { TooltipTone } from '../types';
+export type AlertTone = Exclude<TooltipTone, 'default'>;
+export declare function alertRoleFor(tone: AlertTone): 'alert' | 'status';

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

@@ -0,0 +1,2 @@
+export declare function shortcutText(hotkey: string, isApple: boolean): string;
+export declare function isApplePlatform(platform: string): boolean;

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

@@ -23,12 +23,23 @@ export declare function endOfMonth(day: IsoDay): IsoDay;
 export declare function weekdayOf(day: IsoDay): number;
 export declare const isDayInRange: (day: IsoDay, min?: string, max?: string) => boolean;
 export declare function clampDay(day: IsoDay, min?: string, max?: string): IsoDay;
+export declare const DEFAULT_YEARS_BACK = 100;
+export declare const DEFAULT_YEARS_AHEAD = 10;
+export declare function yearOptions(opts: {
+    today: IsoDay;
+    shown: number;
+    back?: number;
+    ahead?: number;
+    min?: string;
+    max?: string;
+}): number[];
 export declare function normalizeTime(value: unknown): string;
 export declare function splitDateValue(value: unknown): {
     day: IsoDay;
     time: string;
 };
 export declare function joinDateValue(day: IsoDay, time?: string): DateValue;
+export declare function expandYear(yy: number, todayYear: number): number;
 export declare function parseDateText(text: unknown, opts?: {
     within?: IsoDay;
     today?: IsoDay;
@@ -137,5 +148,6 @@ export declare function viewForRange(from: IsoDay, to: IsoDay, opts?: {
 export declare function extendDateRange(range: Partial<DayRange> | null | undefined, day: IsoDay): DayRange;
 export declare function calendarNames(locale?: string): {
     months: string[];
+    monthsShort: string[];
     weekdays: string[];
 };

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

@@ -1,4 +1,9 @@
-import type { FieldLayout, FieldSize } from '../types';
+import type { FieldLayout, FieldSize, FieldWidth } from '../types';
+export declare function resolveFieldWidth(width: FieldWidth | undefined, layout: FieldLayout): {
+    classKey?: string;
+    length?: string;
+};
+export declare function warnFieldFullWidth(fullWidth: boolean | undefined): void;
 export declare function buildFieldWrapperClassKeys(opts: {
     layout: FieldLayout;
     size?: FieldSize;

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

@@ -6,6 +6,7 @@ export * from './collapsible.logic';
 export * from './colorScheme';
 export * from './columnOrder.logic';
 export * from './datePicker.logic';
+export * from './periodPicker.logic';
 export * from './timeField.logic';
 export * from './editableTable.logic';
 export * from './fieldControl.logic';
@@ -21,8 +22,13 @@ export * from './popover.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 +42,6 @@ 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';

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[];