sci-pro/es/src/pivot-table/PivotTable.vue.d.ts

import type { StyleValue } from 'vue';
declare type SortOrder = 'asc' | 'desc';
declare type SummaryType = 'sum' | 'count' | 'avg' | 'min' | 'max';
declare type ColumnWidthValue = string | number;
declare type PivotRecord = Record<string, unknown>;
declare type AxisField = {
    dataField: string;
    caption: string;
    sortOrder: SortOrder;
};
declare type MeasureField = {
    dataField: string;
    caption: string;
    summaryType: SummaryType;
    format?: (value: number) => string;
};
declare type AxisSortContext = {
    axis: 'row' | 'column';
    depth: number;
    dataField: string;
    sortOrder: SortOrder;
    aNode: AxisNode;
    bNode: AxisNode;
};
declare type AxisSortMethod = (a: string, b: string, context: AxisSortContext) => number | undefined;
declare type AggregateState = {
    sum: number;
    count: number;
    min: number;
    max: number;
    hasNumber: boolean;
};
declare type AxisNode = {
    key: string;
    value: string;
    path: string[];
    depth: number;
    children: AxisNode[];
};
declare type VisibleAxisNode = {
    key: string;
    path: string[];
    values: string[];
    depth: number;
    hasChildren: boolean;
    isCollapsedGroup: boolean;
    groupControls: Record<number, {
        key: string;
        value: string;
        expanded: boolean;
        hasChildren: boolean;
    }>;
};
declare type HeaderCell = {
    node: AxisNode;
    depth: number;
    colspan: number;
    rowspan: number;
    isLeaf: boolean;
};
declare type TableColumnMeta = {
    key: string;
    kind: 'row' | 'data' | 'row-grand';
    dataField?: string;
};
declare type HeaderCellStyleType = 'row-header' | 'column-header' | 'row-grand-total' | 'column-grand-total';
declare type BodyCellStyleType = 'row-header' | 'data' | 'row-grand-total' | 'column-grand-total' | 'all-grand-total';
declare type HeaderCellStyleParams = {
    rowIndex: number;
    columnIndex: number;
    type: HeaderCellStyleType;
    field?: AxisField;
    header?: HeaderCell;
};
declare type BodyCellStyleParams = {
    rowIndex: number;
    columnIndex: number;
    type: BodyCellStyleType;
    row?: VisibleAxisNode;
    field?: AxisField;
    column?: {
        key: string;
        path: string[];
        value: string;
    };
    isFooter?: boolean;
};
declare const _sfc_main: import("vue").DefineComponent<{
    dataSource: {
        type: ObjectConstructor;
        required: true;
    };
    showBorders: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    height: {
        type: (StringConstructor | NumberConstructor)[];
        required: false;
    };
    showRowGrandTotals: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    showColumnGrandTotals: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    showRowExpandButtons: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    showColumnExpandButtons: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    defaultExpandAll: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    fixedRowHeader: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    rowGrandTotalText: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    columnGrandTotalText: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    noDataText: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    emptyValueText: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    valueFormatter: {
        type: FunctionConstructor;
        required: false;
    };
    columnWidths: {
        type: (ObjectConstructor | ArrayConstructor)[];
        required: false;
    };
    sortMethod: {
        type: FunctionConstructor;
        required: false;
    };
    ellipsis: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    headerCellStyle: {
        type: FunctionConstructor;
        required: false;
    };
    bodyCellStyle: {
        type: FunctionConstructor;
        required: false;
    };
}, {
    emit: (event: "toggle" | "cellClick", ...args: any[]) => void;
    BLANK_LABEL: string;
    PATH_SEPARATOR: string;
    AGG_SEPARATOR: string;
    ROOT_KEY: string;
    AUTO_COLUMN_FONT_SIZE: number;
    AUTO_COLUMN_MAX_WIDTH: number;
    INITIAL_BODY_RENDER_ROWS: number;
    ESTIMATED_ROW_HEIGHT: number;
    FALLBACK_IDLE_BATCH_ROWS: number;
    props: any;
    sourceData: import("vue").ComputedRef<any>;
    fields: import("vue").ComputedRef<any>;
    rowFields: import("vue").ComputedRef<AxisField[]>;
    columnFields: import("vue").ComputedRef<AxisField[]>;
    dataField: import("vue").ComputedRef<MeasureField | undefined>;
    canRenderTable: import("vue").ComputedRef<boolean>;
    defaultNumberFormatter: Intl.NumberFormat;
    headScrollRef: import("vue").Ref<HTMLElement | null>;
    bodyScrollRef: import("vue").Ref<HTMLElement | null>;
    linkedColumnWidths: import("vue").Ref<string[]>;
    headerCompensationRight: import("vue").Ref<number>;
    headerRowRefs: import("vue").Ref<(HTMLElement | null)[]>;
    wrapperStyle: import("vue").ComputedRef<{
        width: string;
        height: any;
    }>;
    headScrollStyle: import("vue").ComputedRef<{
        paddingRight: string;
    }>;
    ellipsisClass: import("vue").ComputedRef<"" | "text-ellipsis">;
    getEllipsisTitle: (value: unknown) => string | undefined;
    rowTree: import("vue").ComputedRef<AxisNode>;
    columnTree: import("vue").ComputedRef<AxisNode>;
    rowExpanded: import("vue").Ref<Set<string> & Omit<Set<string>, keyof Set<any>>>;
    columnExpanded: import("vue").Ref<Set<string> & Omit<Set<string>, keyof Set<any>>>;
    visibleRows: import("vue").ComputedRef<VisibleAxisNode[]>;
    renderedRowCount: import("vue").Ref<number>;
    idleRenderHandle: import("vue").Ref<number | null>;
    idleRenderScheduler: import("vue").Ref<"idle" | "raf" | "timeout" | null>;
    renderedRows: import("vue").ComputedRef<VisibleAxisNode[]>;
    visibleDataColumns: import("vue").ComputedRef<{
        key: string;
        path: string[];
        value: string;
    }[] | {
        key: string;
        path: never[];
        value: any;
    }[]>;
    tableColumns: import("vue").ComputedRef<TableColumnMeta[]>;
    isFieldFixed: (dataField: string) => any;
    fixedLeftByField: import("vue").ComputedRef<Map<string, number>>;
    columnHeaderRows: import("vue").ComputedRef<HeaderCell[][]>;
    rowHeaderRowspan: import("vue").ComputedRef<number>;
    rowHeaderRowspans: import("vue").ComputedRef<any[][]>;
    aggregateMap: import("vue").ComputedRef<Map<string, AggregateState>>;
    fullColumnCount: import("vue").ComputedRef<number>;
    widthCalcSignature: import("vue").ComputedRef<string>;
    cancelIdleBodyRender: () => void;
    enqueueIdleBodyRender: () => void;
    getIdleRenderBatchRows: () => number;
    resetIncrementalBodyRender: (totalRows: number) => void;
    setHeaderRowRef: (el: Element | null, rowIndex: number) => void;
    recomputeHeaderCompensation: () => void;
    parseWidthToPx: (value?: string | undefined) => number;
    normalizeWidth: (value: ColumnWidthValue | undefined) => string | undefined;
    getUserColumnWidth: (index: number, key: string) => string | undefined;
    getLinkedColumnWidth: (index: number, key: string) => string;
    resolveColumnWidthPxByIndex: (index: number) => number;
    getLinkedColStyle: (index: number, key: string) => {
        width?: undefined;
        minWidth?: undefined;
    } | {
        width: string;
        minWidth: string;
    };
    getHeaderTextForColumn: (index: number, column: TableColumnMeta) => any;
    getFirstRowTextForColumn: (index: number, column: TableColumnMeta) => any;
    estimateTextWidthPx: (text: unknown) => number;
    mergeCellStyle: (baseStyle: StyleValue, customStyle?: StyleValue) => StyleValue;
    getHeaderCellStyle: (params: HeaderCellStyleParams, baseStyle?: StyleValue) => StyleValue;
    getBodyCellStyle: (params: BodyCellStyleParams, baseStyle?: StyleValue) => StyleValue;
    getFixedHeaderCellStyle: (rowFieldDataField?: string | undefined) => {
        position?: undefined;
        left?: undefined;
        zIndex?: undefined;
    } | {
        position: string;
        left: string;
        zIndex: number;
    };
    getFixedBodyRowHeadStyle: (dataField: string) => {
        position?: undefined;
        left?: undefined;
        zIndex?: undefined;
    } | {
        position: string;
        left: string;
        zIndex: number;
    };
    getFootStickyStyle: () => {
        position?: undefined;
        left?: undefined;
        zIndex?: undefined;
    } | {
        position: string;
        left: string;
        zIndex: number;
    };
    handleBodyWheel: (event: WheelEvent) => void;
    onBodyScroll: () => void;
    syncLinkedColumnWidths: () => void;
    isColumnExpanded: (key: string) => boolean;
    toggleRow: (key: string) => void;
    toggleColumn: (key: string) => void;
    onHeaderCellClick: (header: HeaderCell, rowIndex: number, columnIndex: number) => void;
    onRowHeaderCellClick: (row: VisibleAxisNode, index: number, rowIndex: number) => void;
    onDataCellClick: (row: VisibleAxisNode, column: {
        key: string;
        path: string[];
        value: string;
    }, rowIndex: number, columnIndex: number) => void;
    onRowGrandTotalCellClick: (row: VisibleAxisNode, rowIndex: number) => void;
    onColumnGrandTotalCellClick: (column: {
        key: string;
        path: string[];
        value: string;
    }, columnIndex: number) => void;
    onAllGrandTotalCellClick: () => void;
    getChangedSetKeys: (prev: Set<string>, next: Set<string>) => string[];
    shouldRenderRowHeaderCell: (row: VisibleAxisNode, index: number, rowIndex: number) => boolean;
    getRowHeaderColspan: (row: VisibleAxisNode, index: number) => number;
    getRowHeaderRowspan: (row: VisibleAxisNode, index: number, rowIndex: number) => any;
    doesRowHeaderCellExist: (row: VisibleAxisNode, index: number) => boolean;
    isCollapsedMergedCell: (row: VisibleAxisNode, index: number) => boolean;
    getRowControl: (row: VisibleAxisNode, index: number) => {
        key: string;
        value: string;
        expanded: boolean;
        hasChildren: boolean;
    };
    hasRowControl: (row: VisibleAxisNode, index: number) => boolean;
    getRowCellText: (row: VisibleAxisNode, index: number) => string;
    findAxisNodeByKey: (root: AxisNode, key: string) => AxisNode | undefined;
    getDescendantExpandableKeys: (node: AxisNode) => string[];
    buildRowHeaderRowspans: (rows: VisibleAxisNode[], axisLength: number) => any[][];
    inferFirstNumericField: (records: PivotRecord[]) => string;
    normalizeDimensionValue: (value: unknown) => string;
    toFiniteNumber: (value: unknown) => number | undefined;
    makePathKey: (path?: string[] | undefined) => string;
    makeAggregateKey: (rowPath: string[], columnPath: string[], measureFieldName: string) => string;
    getAllPrefixes: (path: string[]) => string[][];
    compareByOrder: (a: string, b: string, order: SortOrder, context: AxisSortContext, sortMethod?: AxisSortMethod | undefined) => number;
    buildAxisTree: (records: PivotRecord[], axis: AxisField[], axisType: 'row' | 'column') => AxisNode;
    sortTree: (node: AxisNode, axis: AxisField[], axisType: 'row' | 'column') => void;
    getExpandableKeys: (root: AxisNode) => string[];
    collectVisibleRows: (root: AxisNode, expanded: Set<string>, axisLength: number) => VisibleAxisNode[];
    collectVisibleLeaves: (root: AxisNode, expanded: Set<string>) => AxisNode[];
    collectHeaderRows: (root: AxisNode, expanded: Set<string>) => HeaderCell[][];
    toAxisValues: (path: string[], axisLength: number) => any[];
    resolveSummaryValue: (state: AggregateState | undefined) => number;
    formatMeasureValue: (value: number) => any;
    getDisplayValue: (rowPath: string[], columnPath: string[]) => any;
    getRawSummaryValue: (rowPath: string[], columnPath: string[]) => number;
    readonly Tooltip: {
        new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
            content: {
                type: StringConstructor;
                required: true;
                default: string;
            };
            effect: {
                type: StringConstructor;
                required: false;
                default: string;
            };
            trigger: {
                type: StringConstructor;
                required: false;
                default: string;
            };
            placement: {
                type: StringConstructor;
                required: false;
                default: string;
            };
        }>>, {
            props: any;
            tooltipShow: import("vue").Ref<boolean>;
            content: import("vue").Ref<any>;
            effect: import("vue").Ref<any>;
            trigger: import("vue").Ref<any>;
            placement: import("vue").Ref<any>;
            updatePlacement: import("vue").Ref<any>;
            translateX: import("vue").Ref<any>;
            translateY: import("vue").Ref<any>;
            arrowTranslateX: import("vue").Ref<number>;
            arrowTranslateY: import("vue").Ref<number>;
            target: import("vue").Ref<any>;
            maxWidth: import("vue").Ref<any>;
            openTooltip: (event: MouseEvent, type?: string, resize?: string | undefined) => void;
            closeTooltip: () => void;
            setBoundary: () => void;
            getInset: () => "0px auto auto 0px" | "0 0 auto auto" | "auto auto 0px 0px" | undefined;
            directiveUpdateState: (option: any) => void;
            handelTooltipShow: (e: Event) => void;
            handelTooltipSize: () => void;
            sciTrigger: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
            readonly SciOnlyChild: import("vue").DefineComponent<{}, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
            content: {
                type: StringConstructor;
                required: true;
                default: string;
            };
            effect: {
                type: StringConstructor;
                required: false;
                default: string;
            };
            trigger: {
                type: StringConstructor;
                required: false;
                default: string;
            };
            placement: {
                type: StringConstructor;
                required: false;
                default: string;
            };
        }>>, {
            content: string;
            effect: string;
            trigger: string;
            placement: string;
        }, true, {}, {}, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            content: {
                type: StringConstructor;
                required: true;
                default: string;
            };
            effect: {
                type: StringConstructor;
                required: false;
                default: string;
            };
            trigger: {
                type: StringConstructor;
                required: false;
                default: string;
            };
            placement: {
                type: StringConstructor;
                required: false;
                default: string;
            };
        }>>, {
            props: any;
            tooltipShow: import("vue").Ref<boolean>;
            content: import("vue").Ref<any>;
            effect: import("vue").Ref<any>;
            trigger: import("vue").Ref<any>;
            placement: import("vue").Ref<any>;
            updatePlacement: import("vue").Ref<any>;
            translateX: import("vue").Ref<any>;
            translateY: import("vue").Ref<any>;
            arrowTranslateX: import("vue").Ref<number>;
            arrowTranslateY: import("vue").Ref<number>;
            target: import("vue").Ref<any>;
            maxWidth: import("vue").Ref<any>;
            openTooltip: (event: MouseEvent, type?: string, resize?: string | undefined) => void;
            closeTooltip: () => void;
            setBoundary: () => void;
            getInset: () => "0px auto auto 0px" | "0 0 auto auto" | "auto auto 0px 0px" | undefined;
            directiveUpdateState: (option: any) => void;
            handelTooltipShow: (e: Event) => void;
            handelTooltipSize: () => void;
            sciTrigger: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
            readonly SciOnlyChild: import("vue").DefineComponent<{}, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
        }, {}, {}, {}, {
            content: string;
            effect: string;
            trigger: string;
            placement: string;
        }>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        content: {
            type: StringConstructor;
            required: true;
            default: string;
        };
        effect: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        trigger: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        placement: {
            type: StringConstructor;
            required: false;
            default: string;
        };
    }>>, {
        props: any;
        tooltipShow: import("vue").Ref<boolean>;
        content: import("vue").Ref<any>;
        effect: import("vue").Ref<any>;
        trigger: import("vue").Ref<any>;
        placement: import("vue").Ref<any>;
        updatePlacement: import("vue").Ref<any>;
        translateX: import("vue").Ref<any>;
        translateY: import("vue").Ref<any>;
        arrowTranslateX: import("vue").Ref<number>;
        arrowTranslateY: import("vue").Ref<number>;
        target: import("vue").Ref<any>;
        maxWidth: import("vue").Ref<any>;
        openTooltip: (event: MouseEvent, type?: string, resize?: string | undefined) => void;
        closeTooltip: () => void;
        setBoundary: () => void;
        getInset: () => "0px auto auto 0px" | "0 0 auto auto" | "auto auto 0px 0px" | undefined;
        directiveUpdateState: (option: any) => void;
        handelTooltipShow: (e: Event) => void;
        handelTooltipSize: () => void;
        sciTrigger: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
        readonly SciOnlyChild: import("vue").DefineComponent<{}, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
        content: string;
        effect: string;
        trigger: string;
        placement: string;
    }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("toggle" | "cellClick")[], "toggle" | "cellClick", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    dataSource: {
        type: ObjectConstructor;
        required: true;
    };
    showBorders: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    height: {
        type: (StringConstructor | NumberConstructor)[];
        required: false;
    };
    showRowGrandTotals: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    showColumnGrandTotals: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    showRowExpandButtons: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    showColumnExpandButtons: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    defaultExpandAll: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    fixedRowHeader: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    rowGrandTotalText: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    columnGrandTotalText: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    noDataText: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    emptyValueText: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    valueFormatter: {
        type: FunctionConstructor;
        required: false;
    };
    columnWidths: {
        type: (ObjectConstructor | ArrayConstructor)[];
        required: false;
    };
    sortMethod: {
        type: FunctionConstructor;
        required: false;
    };
    ellipsis: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
    headerCellStyle: {
        type: FunctionConstructor;
        required: false;
    };
    bodyCellStyle: {
        type: FunctionConstructor;
        required: false;
    };
}>> & {
    onToggle?: ((...args: any[]) => any) | undefined;
    onCellClick?: ((...args: any[]) => any) | undefined;
}, {
    ellipsis: boolean;
    showBorders: boolean;
    showRowGrandTotals: boolean;
    showColumnGrandTotals: boolean;
    showRowExpandButtons: boolean;
    showColumnExpandButtons: boolean;
    defaultExpandAll: boolean;
    fixedRowHeader: boolean;
    rowGrandTotalText: string;
    columnGrandTotalText: string;
    noDataText: string;
    emptyValueText: string;
}, {}>;
export default _sfc_main;