@univerjs-pro/engine-pivot 1.1.0 → 1.3.0

package/lib/types/const.d.ts

@@ -1,4 +1,4 @@
-import { PivotDateGroupFieldDateSystemEnum } from './types';
+import { DateSystem } from '@univerjs/core';
 /**
  * @description blank placeholder for empty cells
  *  the get/set functions are used to allow for customization
@@ -12,7 +12,7 @@ export declare const GlobalConfig: {
     BLANK_PLACEHOLDER: string;
     isDev: boolean;
     defaultSortType: string;
-    dateSystem: PivotDateGroupFieldDateSystemEnum;
+    dateSystem: DateSystem;
     maxLimitItemCount: number;
     otherDataKey: string;
 };
@@ -28,7 +28,7 @@ export declare const setDefaultSortType: (type: "ascending" | "descending" | "de
  * @param value The date system to use, either date1900 ,date1904
  * @returns {void}
  */
-export declare const setDateSystem: (value: PivotDateGroupFieldDateSystemEnum) => PivotDateGroupFieldDateSystemEnum;
+export declare const setDateSystem: (value: DateSystem) => DateSystem;
 /**
  * allows to set the max limit count for row/col fields
  * @param value The max limit count, must be greater than 0, the default value is 1000

package/lib/types/field/base-group-field.d.ts

@@ -1,4 +1,4 @@
-import type { IBaseGroupFieldInfo, IBaseGroupFieldJSON, IPivotTableDateGroupInfo, PivotDataFieldTypeEnum } from '../types';
+import type { IBaseGroupFieldInfo, IBaseGroupFieldJSON, IPivotTableGroupInfo, PivotDataFieldTypeEnum } from '../types';
 import { DataField } from './data-field';
 export declare abstract class BaseGroupField extends DataField {
     protected originalFieldId: string;
@@ -7,9 +7,15 @@ export declare abstract class BaseGroupField extends DataField {
      * @returns {PivotDataFieldTypeEnum} - The group type
      */
     abstract getDataFieldType(): PivotDataFieldTypeEnum;
-    abstract getGroupInfo(): IPivotTableDateGroupInfo;
+    abstract getGroupInfo(): IPivotTableGroupInfo | undefined;
     abstract getOriginFieldId(): string;
     abstract refreshGroupField(originalField: DataField): void;
+    getTupleKey(index: number): string;
+    getTupleItemsMap(): Record<string, number>;
+    getTupleIndexesByKey(key: string): number[];
+    getTupleLabel(key: string): string;
+    getTupleType(key: string): import("..").PivotDataFieldDataTypeEnum;
+    getTupleKeysByLabel(label: string): string[];
     getFieldInfo(): IBaseGroupFieldInfo;
     toJSON(): IBaseGroupFieldJSON;
 }

package/lib/types/field/create-data-field.d.ts

@@ -0,0 +1,3 @@
+import type { IDataFieldJSON } from '../types';
+import { DataField } from './data-field';
+export declare function createDataFieldFromJSON(json: IDataFieldJSON): DataField;

package/lib/types/field/data-field-manager.d.ts

@@ -1,4 +1,4 @@
-import type { IDataFieldManagerBaseJSON, IDataFieldValue, PivotSubtotalTypeEnum } from '../types';
+import type { IDataFieldManagerBaseJSON, IDataFieldValue, IPivotTableRecordFilter, PivotSubtotalTypeEnum } from '../types';
 import { DataField } from './data-field';
 import { FieldsCollection } from './fields-collection';
 type autoDisplayNameFunction = (name: string, subtotalType: PivotSubtotalTypeEnum) => string;
@@ -6,6 +6,7 @@ export declare abstract class DataFieldManager {
     dataFields: Record<string, DataField>;
     collections: Record<string, FieldsCollection>;
     constructor();
+    compileRecordFilter(_filter: IPivotTableRecordFilter): (value: IDataFieldValue) => boolean;
     createDataFieldId(): string;
     getAutoDisplayNameFunction(): autoDisplayNameFunction | null;
     getNoUsedDataFieldIds(excludeCollectionToken: string): string[];

package/lib/types/field/data-field.d.ts

@@ -1,5 +1,6 @@
-import type { IDataFieldInfo, IDataFieldJSON, IDataFieldValue } from '../types';
-import { PivotDataFieldDataTypeEnum, PivotDataFieldTypeEnum } from '../types';
+import type { IDataFieldInfo, IDataFieldValue } from '../types/interface';
+import type { IDataFieldJSON } from '../types/json-types';
+import { PivotDataFieldDataTypeEnum, PivotDataFieldTypeEnum } from '../types/enum';
 /**
  * Represents a data field in a pivot table , it match the excel pivot cache field data structure.
  * @param {string} id - The unique identifier of the data field.
@@ -59,6 +60,10 @@ export declare class DataField {
      * @property {boolean} hasText - Whether the data field has text value.
      */
     hasText: boolean;
+    /** Whether the data field contains boolean values. */
+    hasBoolean: boolean;
+    /** Whether the data field contains formula error values. */
+    hasError: boolean;
     /**
      * @property {string} format - The format of the data field. only date field has format property, the format is the date format string.
      */
@@ -88,6 +93,21 @@ export declare class DataField {
      */
     private _itemsMap;
     private _keyCounter;
+    private readonly _tupleItemsMap;
+    private readonly _tupleIndexMap;
+    private readonly _tupleLabels;
+    private readonly _tupleTypes;
+    private readonly _recordTupleKeys;
+    private readonly _tupleKeysByLabel;
+    private readonly _overflowRecordIndexes;
+    private _tupleKeyCounter;
+    private _tupleItemCounter;
+    getTupleKey(index: number): string;
+    getTupleItemsMap(): Record<string, number>;
+    getTupleIndexesByKey(key: string): number[];
+    getTupleLabel(key: string): string;
+    getTupleType(key: string): PivotDataFieldDataTypeEnum;
+    getTupleKeysByLabel(label: string): string[];
     constructor(id: string, name: string, hexCode: string);
     /**
      * - Returns the name of the data field.
@@ -115,7 +135,7 @@ export declare class DataField {
     getDataFieldType(): PivotDataFieldTypeEnum;
     /**
      * - Returns the shared key with the data field item, this can be combined in the tuple group with other data field item key to create a unique path.
-     * @param {string} dataIndex the index in data records
+     * @param {string} key the item key
      * @returns {string} key with field and item info
      */
     getItemSharedKey(key: string): string;
@@ -144,6 +164,7 @@ export declare class DataField {
      * @returns {void}
      */
     addRecord(record: IDataFieldValue, index: number): void;
+    private _addTupleRecord;
     getIndexesByKey(key: string): number[];
     getAllIndexMap(): Record<string, number[]>;
     /**
@@ -156,6 +177,8 @@ export declare class DataField {
     private _updateBlankItemKey;
     private _updateStringItemKey;
     private _updateNumberItemKey;
+    private _updateBooleanItemKey;
+    private _updateErrorItemKey;
     private _updateOtherItemKey;
     private _updateItemKey;
     getItemsMap(): Record<string, number>;

package/lib/types/field/date-group-field.d.ts

@@ -1,15 +1,21 @@
-import type { IDateGroupFieldInfo, IDateGroupFieldJSON, IPivotTableDateGroupInfo } from '../types';
+import type { IDateGroupFieldInfo, IExcelDateGroupFieldSpec, IExcelDateGrouping, IPivotTableDateGroupInfo } from '../types/interface';
+import type { IDateGroupFieldJSON } from '../types/json-types';
 import type { DataField } from './data-field';
-import { PivotDataFieldTypeEnum, PivotDateGroupFieldDateTypeEnum } from '../types';
+import { PivotDataFieldTypeEnum, PivotDateGroupFieldDateTypeEnum } from '../types/enum';
 import { BaseGroupField } from './base-group-field';
+export declare const EXCEL_DATE_BEFORE_KEY = -1;
+export declare const EXCEL_DATE_AFTER_KEY = 1000000000;
+export declare function normalizeExcelDateGrouping(grouping: IExcelDateGrouping, originalField: DataField): IExcelDateGrouping | undefined;
 export declare class DateGroupField extends BaseGroupField {
     private _dataIsValid;
     private _dateType;
-    constructor(id: string, name: string, hexCode: string, originalFieldId: string, dateType?: PivotDateGroupFieldDateTypeEnum);
+    private _excelLike?;
+    constructor(id: string, name: string, hexCode: string, originalFieldId: string, dateType?: PivotDateGroupFieldDateTypeEnum, excelLike?: IExcelDateGroupFieldSpec);
     setDateType(dateType: PivotDateGroupFieldDateTypeEnum): void;
     getDateType(): PivotDateGroupFieldDateTypeEnum;
     getDateGroupValid(): boolean;
     refreshGroupField(originalField: DataField): void;
+    private _refreshExcelLike;
     getGroupInfo(): IPivotTableDateGroupInfo;
     getDataFieldType(): PivotDataFieldTypeEnum;
     getOriginFieldId(): string;

package/lib/types/field/fields-collection.d.ts

@@ -1,6 +1,6 @@
 import type { IDataFieldInfo, IFieldsCollectionJSON } from '../types';
+import type { DataField } from './data-field';
 import type { DataFieldManager } from './data-field-manager';
-import { DataField } from './data-field';
 /**
  * Represents the collection of fields in the pivot table. which one to one with a pivot table.
  * @description The collection of fields in the pivot table. The fields collection uses shared the base data field id.For Grouped fields or calculated fields, it will save in custom field.
@@ -61,6 +61,7 @@ export declare class FieldsCollection {
     getDisplayName(fieldId: string): string;
     setDisplayName(fieldId: string, fieldName: string, displayNameRecord?: Record<string, string>): void;
     getUniqueDataFieldName(displayName: string, displayNameRecord?: Record<string, string>): string;
+    static getUniqueDataFieldName(displayName: string, record: Record<string, string>): string;
     /**
      * @description remove the field from the collection.
      */

package/lib/types/field/manual-group-field.d.ts

@@ -0,0 +1,26 @@
+import type { IManualGrouping } from '../types/interface';
+import type { IManualGroupFieldJSON } from '../types/json-types';
+import type { DataField } from './data-field';
+import { PivotDataFieldTypeEnum } from '../types/enum';
+import { BaseGroupField } from './base-group-field';
+export declare function normalizeManualGrouping(grouping: IManualGrouping, sourceField?: DataField, existingGrouping?: IManualGrouping): IManualGrouping | undefined;
+export declare class ManualGroupField extends BaseGroupField {
+    private _grouping;
+    private _dataIsValid;
+    private _recordKeys;
+    private _displayNames;
+    constructor(id: string, name: string, hexCode: string, originalFieldId: string, grouping: IManualGrouping);
+    getManualGroupValid(): boolean;
+    getGrouping(): IManualGrouping;
+    setGrouping(grouping: IManualGrouping): void;
+    reset(): void;
+    getItemKey(index: number): string;
+    getDisplayNameByKey(key: string): string;
+    refreshGroupField(originalField: DataField): void;
+    private _getMemberType;
+    getGroupInfo(): undefined;
+    getDataFieldType(): PivotDataFieldTypeEnum.textGroupField;
+    getOriginFieldId(): string;
+    toJSON(): IManualGroupFieldJSON;
+    fromJSON(data: IManualGroupFieldJSON): void;
+}

package/lib/types/field/number-group-field.d.ts

@@ -0,0 +1,22 @@
+import type { INumberGrouping, IPivotTableNumberGroupInfo } from '../types/interface';
+import type { INumberGroupFieldJSON } from '../types/json-types';
+import type { DataField } from './data-field';
+import { PivotDataFieldTypeEnum } from '../types/enum';
+import { BaseGroupField } from './base-group-field';
+export declare const NUMBER_GROUP_BEFORE_KEY = "__number_before__";
+export declare const NUMBER_GROUP_AFTER_KEY = "__number_after__";
+export declare function normalizeNumberGrouping(grouping: INumberGrouping, originalField: DataField): INumberGrouping | undefined;
+export declare function getDefaultNumberGrouping(originalField: DataField): INumberGrouping | undefined;
+export declare class NumberGroupField extends BaseGroupField {
+    private _grouping;
+    private _dataIsValid;
+    private _bounds;
+    constructor(id: string, name: string, hexCode: string, originalFieldId: string, grouping: INumberGrouping);
+    getNumberGroupValid(): boolean;
+    refreshGroupField(originalField: DataField): void;
+    getGroupInfo(): IPivotTableNumberGroupInfo;
+    getDataFieldType(): PivotDataFieldTypeEnum.numberGroupField;
+    getOriginFieldId(): string;
+    toJSON(): INumberGroupFieldJSON;
+    fromJSON(data: INumberGroupFieldJSON): void;
+}

package/lib/types/index.d.ts

@@ -1,16 +1,21 @@
 export { GlobalConfig, setDateSystem, setMaxLimitItemCount, } from './const';
 export { BaseGroupField } from './field/base-group-field';
+export { createDataFieldFromJSON } from './field/create-data-field';
 export { DataField } from './field/data-field';
 export { DataFieldManager } from './field/data-field-manager';
-export { DateGroupField } from './field/date-group-field';
+export { DateGroupField, EXCEL_DATE_AFTER_KEY, EXCEL_DATE_BEFORE_KEY, normalizeExcelDateGrouping, } from './field/date-group-field';
 export { FieldsCollection } from './field/fields-collection';
+export { ManualGroupField, normalizeManualGrouping } from './field/manual-group-field';
+export { getDefaultNumberGrouping, normalizeNumberGrouping, NUMBER_GROUP_AFTER_KEY, NUMBER_GROUP_BEFORE_KEY, NumberGroupField, } from './field/number-group-field';
 export { isValueFilterOperator } from './filter-util';
 export { isErrorValue, isPrefixValue, LabelViewItem, PivotView, PivotViewItem, } from './layout/pivot-view';
 export { PivotTable } from './pivot/pivot-table';
 export { createLabelField, createValueField, PivotTableLabelField, PivotTableValueField, } from './pivot/table-field';
-export { PivotCallbackEnum, PivotDataFieldDataTypeEnum, PivotDataFieldSortOperatorEnum, PivotDataFieldSortTypeEnum, PivotDataFieldTypeEnum, PivotDateGroupFieldDateSystemEnum, PivotDateGroupFieldDateTypeEnum, PivotErrorTypeEnum, PivotFilterTypeEnum, PivotLayoutTypeEnum, PivotShowAsBaseItemTypeEnum, PivotShowAsTypeEnum, PivotSubtotalPositionEnum, PivotSubtotalTypeEnum, PivotTableFiledAreaEnum, PivotTableValuePositionEnum, ST_PivotFilterOperatorEnum, } from './types/enum';
-export type { IDataFieldValue, IDateValue, IPivotTableDateGroupInfo, IPivotTableFilterInfo, IPivotTableManualFilter, IPivotTableShowDataAsInfo, IPivotTableSortInfo, IPivotTableValueFilter, IValueFilterInfoItem, } from './types/interface';
-export type { IBaseGroupFieldJSON, IDataFieldManagerBaseJSON, IFieldsCollectionJSON, IPivotTableLabelFieldJSON, IPivotTableSnapshot, IPivotTableValueFieldJSON, } from './types/json-types';
+export { getPivotRecordMember, isPivotTableFilterRestrictive } from './record-filter';
+export { isDateValue, isRecordErrorValue } from './record-value';
+export { PivotCallbackEnum, PivotDataFieldDataTypeEnum, PivotDataFieldSortOperatorEnum, PivotDataFieldSortTypeEnum, PivotDataFieldTypeEnum, PivotDateGroupFieldDateTypeEnum, PivotDateGroupingMode, PivotErrorTypeEnum, PivotExcelDateGroupUnit, PivotFilterTypeEnum, PivotLayoutTypeEnum, PivotShowAsBaseItemTypeEnum, PivotShowAsTypeEnum, PivotSubtotalPositionEnum, PivotSubtotalTypeEnum, PivotTableFiledAreaEnum, PivotTableValuePositionEnum, ST_PivotFilterOperatorEnum, } from './types/enum';
+export type { IDataFieldInfo, IDataFieldValue, IDateValue, IErrorValue, IExcelDateGrouping, IManualGroup, IManualGrouping, INumberGrouping, IPivotTableDateGroupInfo, IPivotTableFilterInfo, IPivotTableGroupInfo, IPivotTableManualFilter, IPivotTableNumberGroupInfo, IPivotTableRecordFilter, IPivotTableShowDataAsInfo, IPivotTableSortInfo, IPivotTableValueFilter, IValueFilterInfoItem, } from './types/interface';
+export type { IBaseGroupFieldJSON, IDataFieldManagerBaseJSON, IFieldsCollectionJSON, IManualGroupFieldJSON, INumberGroupFieldJSON, IPivotTableLabelFieldJSON, IPivotTableSnapshot, IPivotTableValueFieldJSON, } from './types/json-types';
 export { PivotTableChangeTypeEnum } from './types/json-types';
 export type { IPivotTableAddFieldChange, IPivotTableChangeSet, IPivotTableRemoveFieldChange, IPivotTableRenameFieldChange, IPivotTableSetCollapseChange, IPivotTableSetFilterInfoChange, IPivotTableSetFormatChange, IPivotTableSetLayoutChange, IPivotTableSetOptionsChange, IPivotTableSetShowDataAsChange, IPivotTableSetSortInfoChange, IPivotTableSetSubtotalTypeChange, IPivotTableSetValueFilterChange, IPivotTableUpdatePositionChange, IPivotTableUpdateValuePositionChange, IPivotUpdateSourceChange, } from './types/json-types';
 export type { IPivotViewCellData, IPivotViewValueType, } from './types/layout-type';
@@ -18,4 +23,5 @@ export { PivotViewCellValueTypeEnum } from './types/layout-type';
 export type { IPivotViewInfo } from './types/layout-type';
 export { PivotCellStyleTypeEnum } from './types/layout-type';
 export type { ILabelViewHeaderMapItem, IPivotTableOptions, IPivotViewJSON, } from './types/layout-type';
-export { excelDateToUnixMilliseconds, generateHexNumber, getAutoDisplayName, isBaseGroupField, isDateGroupField, isDateGroupFieldJSON, isDateValue, isManualPivotFilter, } from './util';
+export { createPivotSortCompare } from './util';
+export { excelDateToUnixMilliseconds, generateHexNumber, getAutoDisplayName, getPivotDateGroupingMode, isBaseGroupField, isDateGroupField, isDateGroupFieldJSON, isManualPivotFilter, } from './util';

package/lib/types/layout/pivot-view.d.ts

@@ -1,5 +1,5 @@
 import type { PivotModel } from '../pivot/model';
-import type { ILabelViewHeaderMapItem, ILabelViewItemJSON, IPageViewItemJSON, IPageViewItemRange, IPivotTableDateGroupInfo, IPivotTableValueFieldQueryData, IPivotViewCellData, IPivotViewErrorValue, IPivotViewInfo, IPivotViewItemData, IPivotViewItemJSON, IPivotViewJSON, IPivotViewPrefixValue, IPivotViewValueType, PivotCellStyleTypeEnum } from '../types';
+import type { ILabelViewHeaderMapItem, ILabelViewItemJSON, IPageViewItemJSON, IPageViewItemRange, IPivotTableGroupInfo, IPivotTableValueFieldQueryData, IPivotViewCellData, IPivotViewErrorValue, IPivotViewInfo, IPivotViewItemData, IPivotViewItemJSON, IPivotViewJSON, IPivotViewPrefixValue, IPivotViewValueType, PivotCellStyleTypeEnum } from '../types';
 /**
  * @class PivotView
  * @description the view of pivot table, which contains the page, row, col, data view, the page view separation the pivot table to two areas, the row and col view as the header of data area
@@ -25,10 +25,6 @@ export declare class PivotView {
      * the corner view of the pivot table
      */
     cornerView: PivotViewItem;
-    /**
-     * the version of the pivot view, it will be used to check the view is the latest
-     */
-    version: number;
     /**
      * the format map of the table field id, it will be used to store the format of the pivot view
      */
@@ -36,16 +32,13 @@ export declare class PivotView {
     /**
      * the group info map of the table field id, it will be used to store the group info of the pivot view
      */
-    groupInfo: Record<string, IPivotTableDateGroupInfo>;
-    constructor();
-    setVersion(version?: number): void;
-    setGroupInfo(groupInfo: Record<string, IPivotTableDateGroupInfo>): void;
+    groupInfo: Record<string, IPivotTableGroupInfo>;
+    setGroupInfo(groupInfo: Record<string, IPivotTableGroupInfo>): void;
     /**
      * - the func effect is to set the format code , for label view, it will used to format the header , such as date type data, in the data view, it will used to format the data of show data as
      * @param model the pivot model, it will be used to set the format of the pivot view
      */
     setFormat(model: PivotModel, valueQueryInfo: IPivotTableValueFieldQueryData[]): void;
-    getVersion(): number;
     toJSON(): IPivotViewJSON;
     formJSON(data: IPivotViewJSON): void;
 }

package/lib/types/pivot/model.d.ts

@@ -92,9 +92,10 @@ export declare class PivotModel {
     /**
      * - Set the options of the pivot table.
      * @param {IPivotTableOptions} options  - The options to be set.
+     * @param {boolean} replace - Replace a complete options snapshot instead of merging a patch.
      * @returns {void}
      */
-    setOptions(options: IPivotTableOptions): void;
+    setOptions(options: IPivotTableOptions, replace?: boolean): void;
     /**
      *  - Get the options of the pivot table. It is a copy of the options.
      * @returns {IPivotTableOptions} - The options of the pivot table.

package/lib/types/pivot/pivot-table.d.ts

@@ -15,7 +15,6 @@ import { PivotTableLabelField, PivotTableValueField } from './table-field';
  */
 export declare class PivotTable {
     dataFieldsCollection: FieldsCollection;
-    private _viewVersion;
     private _model;
     _bufferModel?: PivotModel;
     private _tupleGroupCache?;
@@ -38,6 +37,11 @@ export declare class PivotTable {
     static unRegisterCallbackWithEvent(event: PivotCallbackEnum, callback: (id?: string) => void): void;
     constructor(dataFieldsCollection: FieldsCollection, model?: PivotModel, id?: string);
     updateDataFieldsCollection(dataFieldsCollection: FieldsCollection): void;
+    /** Evaluate raw-record constraints without changing the report or its aggregate cache. */
+    getFilteredRecordIndexes(sourceFieldId: string, excludedCondition: 'selection' | 'dateRange'): {
+        isAll: boolean;
+        list: number[];
+    };
     private _getModel;
     startCollectChangeset(): void;
     endCollectChangeset(): IPivotTableChangeSet[];
@@ -146,7 +150,7 @@ export declare class PivotTable {
      * @returns {PivotTableLabelField|PivotTableValueField} the added field
      */
     addFieldWithSourceId(dataFieldId: string, area: PivotTableFiledAreaEnum, index?: number, provideTableFieldId?: string): PivotTableLabelField | PivotTableValueField | undefined;
-    setOptions(options: IPivotTableOptions): void;
+    setOptions(options: IPivotTableOptions, replace?: boolean): void;
     setLayout(layout: PivotLayoutTypeEnum): void;
     getLayout(): PivotLayoutTypeEnum;
     /**
@@ -250,12 +254,6 @@ export declare class PivotTable {
      * @returns {boolean} Whether the target is a row field.
      */
     setRowCollapseLevel(fieldId: string): boolean;
-    /**
-     * - get the pivot view need query or not
-     * @param {number} viewVersion
-     * @returns {boolean} - need query or not
-     */
-    getNeedQuery(viewVersion: number): boolean;
     /**
      * @description Get the field position information by the field id.
      * @param {string} fieldId the field id

package/lib/types/record-filter.d.ts

@@ -0,0 +1,7 @@
+import type { RecordValue } from '@univerjs/core';
+import type { IDataFieldValue, IPivotTableFilterInfo, IPivotTableRecordFilter } from './types/interface';
+export declare function getPivotRecordMember(value: IDataFieldValue): RecordValue;
+export declare function isPivotRecordFilter(filterInfo: IPivotTableFilterInfo | undefined): filterInfo is IPivotTableRecordFilter;
+export declare function isPivotTableFilterRestrictive(filterInfo: IPivotTableFilterInfo): boolean;
+export declare function isPivotRecordFilterRestrictive(filterInfo: IPivotTableRecordFilter): boolean;
+export declare function clonePivotTableFilterInfo(filterInfo: IPivotTableFilterInfo | undefined): IPivotTableFilterInfo | undefined;

package/lib/types/record-value.d.ts

@@ -0,0 +1,3 @@
+import type { IDataFieldValue, IDateValue, IErrorValue } from './types/interface';
+export declare function isDateValue(value: IDataFieldValue): value is IDateValue;
+export declare function isRecordErrorValue(value: IDataFieldValue): value is IErrorValue;

package/lib/types/summary/node-tree.d.ts

@@ -19,6 +19,8 @@ export declare class NodeTree {
      * @property {string} name - The name of the node tree.
      */
     name: string;
+    displayName: string;
+    displayPaths: string[];
     fieldId: string;
     collapse: boolean;
     sortedList: string[];
@@ -43,7 +45,7 @@ export declare class NodeTree {
     setLeaf(): void;
     getIsLeaf(): boolean;
     setName(name: string): void;
-    addNode(node: NodeTree, path: string, sortMap: Record<string, number> | undefined, sortType: PivotDataFieldSortOperatorEnum): void;
+    addNode(node: NodeTree, path: string, sortMap: Record<string, number> | undefined, sortType: PivotDataFieldSortOperatorEnum, displayName?: string): void;
     sortNode(path: string, sortedMap: Record<string, number>, sortType: PivotDataFieldSortOperatorEnum): void;
     sortChildrenByValue(fieldId: string, sortType: PivotDataFieldSortOperatorEnum, getValue: (index: number) => number | undefined, compareLabels: (a: string, b: string) => number): void;
     resetSort(): void;

package/lib/types/summary/show-data-as.d.ts

@@ -23,6 +23,7 @@ export declare class ShowDataAsResolver {
     private readonly _parentFieldIndexes;
     private readonly _parentFieldIndexByValueField;
     private readonly _peerIndexesByValueField;
+    private readonly _peerUnionsByValueField;
     private readonly _derivedValuesByValueField;
     constructor(_summaryManager: SummaryManager, _queryData: IPivotTableQueryData);
     prepare(): void;

package/lib/types/summary/tuple-group.d.ts

@@ -35,6 +35,7 @@ export declare class TupleGroup {
      * @property The colDeep, the deep of col fields.
      */
     colDeep: number;
+    private _fieldsCollection?;
     constructor();
     /**
      * - prepare the measuresMap and dimensionMap, it will prepare the measuresMap and dimensionMap based on the query data

package/lib/types/types/enum.d.ts

@@ -171,7 +171,11 @@ export declare enum PivotFilterTypeEnum {
     /**
      *- the manual filter
      */
-    ManualFilter = 3
+    ManualFilter = 3,
+    /**
+     * An internal typed predicate evaluated against raw pivot records.
+     */
+    RecordFilter = 4
 }
 /**
  * Enum for pivot table field types.
@@ -701,6 +705,21 @@ export declare enum PivotDataFieldTypeEnum {
      */
     customGroupField = 5
 }
+/** Date-grouping semantics for a single pivot table. */
+export declare enum PivotDateGroupingMode {
+    Legacy = "legacy",
+    ExcelLike = "excel-like"
+}
+/** Individual calendar units used by Excel-like date grouping. */
+export declare enum PivotExcelDateGroupUnit {
+    Year = "year",
+    Quarter = "quarter",
+    Month = "month",
+    Day = "day",
+    Hour = "hour",
+    Minute = "minute",
+    Second = "second"
+}
 /**
  * Enum for representing different date group field types in a pivot table.
  */
@@ -761,7 +780,3 @@ export declare enum PivotDateGroupFieldDateTypeEnum {
      */
     YearMonthDate = "year-month-date"
 }
-export declare enum PivotDateGroupFieldDateSystemEnum {
-    Date1900 = "date1900",
-    Date1904 = "date1904"
-}

package/lib/types/types/interface.d.ts

@@ -1,4 +1,5 @@
-import type { PivotDataFieldDataTypeEnum, PivotDataFieldSortOperatorEnum, PivotDataFieldTypeEnum, PivotDateGroupFieldDateTypeEnum, PivotFilterTypeEnum, PivotShowAsBaseItemTypeEnum, PivotShowAsTypeEnum, PivotSubtotalTypeEnum, ST_PivotFilterOperatorEnum } from './enum';
+import type { RecordSelection, RecordValue } from '@univerjs/core';
+import type { PivotDataFieldDataTypeEnum, PivotDataFieldSortOperatorEnum, PivotDataFieldTypeEnum, PivotDateGroupFieldDateTypeEnum, PivotExcelDateGroupUnit, PivotFilterTypeEnum, PivotShowAsBaseItemTypeEnum, PivotShowAsTypeEnum, PivotSubtotalTypeEnum, ST_PivotFilterOperatorEnum } from './enum';
 export interface IDateValue {
     /**
      * @description the date value,  it stores the number of seconds since January 1, 1970, 00:00:00 UTC, it is same to excel date value
@@ -9,11 +10,14 @@ export interface IDateValue {
      */
     f: string;
 }
+export interface IErrorValue {
+    error: string;
+}
 type IBlankValue = null | undefined;
 /**
  * Represents the value of a data field in a pivot table data field
  */
-export type IDataFieldValue = string | number | boolean | IDateValue | IBlankValue;
+export type IDataFieldValue = string | number | boolean | IDateValue | IErrorValue | IBlankValue;
 export interface IDataFieldInfo {
     id: string;
     name: string;
@@ -41,6 +45,34 @@ export interface IDateGroupFieldInfo extends IBaseGroupFieldInfo {
      * @description the date type of the date group field
      */
     dateType?: PivotDateGroupFieldDateTypeEnum;
+    excelLike?: IExcelDateGroupFieldSpec;
+}
+export interface IExcelDateGrouping {
+    units: PivotExcelDateGroupUnit[];
+    autoStart: boolean;
+    autoEnd: boolean;
+    start?: number;
+    end?: number;
+    daysInterval?: number;
+}
+export interface IExcelDateGroupFieldSpec extends Omit<IExcelDateGrouping, 'units'> {
+    unit: PivotExcelDateGroupUnit;
+    groupByDate?: boolean;
+}
+export interface INumberGrouping {
+    autoStart: boolean;
+    autoEnd: boolean;
+    start?: number;
+    end?: number;
+    interval: number;
+}
+export interface IManualGroup {
+    id: string;
+    name: string;
+    members: RecordValue[];
+}
+export interface IManualGrouping {
+    groups: IManualGroup[];
 }
 export interface IPivotField {
     id: string;
@@ -67,12 +99,18 @@ export interface IPivotTuple {
     max: number;
     squareSum: number;
 }
-export type IPivotTableFilterInfo = IPivotTableManualFilter | IPivotTableCustomFilter | IPivotTableValueFilter;
+export type IPivotTableFilterInfo = IPivotTableManualFilter | IPivotTableCustomFilter | IPivotTableValueFilter | IPivotTableRecordFilter;
 export type IPivotTableSortInfo = IPivotTableLabelSortInfo | IPivotTableValueSortInfo | IPivotTableLabelCustomSortInfo;
 export interface IPivotTableDateGroupInfo {
     type: PivotDataFieldTypeEnum.dateGroupField;
     dateType: PivotDateGroupFieldDateTypeEnum;
+    excelLike?: IExcelDateGroupFieldSpec;
+}
+export interface IPivotTableNumberGroupInfo {
+    type: PivotDataFieldTypeEnum.numberGroupField;
+    grouping: INumberGrouping;
 }
+export type IPivotTableGroupInfo = IPivotTableDateGroupInfo | IPivotTableNumberGroupInfo;
 export interface IPivotTableLabelSortInfo {
     type: PivotDataFieldSortOperatorEnum;
     sortLocale?: string;
@@ -125,6 +163,11 @@ export interface IPivotTableValueFilter {
     /** Whether a count/percent rank filter keeps the bottom values instead of the top values. */
     isBottom?: boolean;
 }
+export interface IPivotTableRecordFilter {
+    type: PivotFilterTypeEnum.RecordFilter;
+    selection?: RecordSelection;
+    dateRange?: IPivotDateRange;
+}
 export interface IPivotTableShowDataAsInfo {
     type: PivotShowAsTypeEnum;
     baseFieldId: string;
@@ -172,6 +215,10 @@ export interface IPivotTableQueryData {
      * The query info of filter fields in the pivot table.
      */
     filterQueryInfo: IPivotTableLabelFieldQueryData[];
+    /**
+     * The query info of hidden fields in the pivot table.
+     */
+    hiddenQueryInfo?: IPivotTableLabelFieldQueryData[];
     /**
      * The query info of value fields in the pivot table.
      */
@@ -236,4 +283,8 @@ export interface IValueFilterInfoItem {
      */
     filterInfo: IPivotTableValueFilter;
 }
+export interface IPivotDateRange {
+    startDate: number;
+    endDate: number;
+}
 export {};

package/lib/types/types/json-types.d.ts

@@ -1,5 +1,5 @@
 import type { PivotDataFieldDataTypeEnum, PivotDataFieldTypeEnum, PivotDateGroupFieldDateTypeEnum, PivotLayoutTypeEnum, PivotSubtotalTypeEnum, PivotTableFiledAreaEnum, PivotTableValuePositionEnum } from './enum';
-import type { IPivotTableFilterInfo, IPivotTableShowDataAsInfo, IPivotTableSortInfo, IPivotTableValueFilter, IValueFilterInfoItem } from './interface';
+import type { IExcelDateGroupFieldSpec, IManualGrouping, INumberGrouping, IPivotTableFilterInfo, IPivotTableShowDataAsInfo, IPivotTableSortInfo, IPivotTableValueFilter, IValueFilterInfoItem } from './interface';
 import type { IPivotTableOptions } from './layout-type';
 export interface IPivotTableValueFieldJSON {
     dataFieldId: string;
@@ -106,6 +106,15 @@ export interface IDateGroupFieldJSON extends IBaseGroupFieldJSON {
      * @description the date type of the date group field
      */
     dateType?: PivotDateGroupFieldDateTypeEnum;
+    excelLike?: IExcelDateGroupFieldSpec;
+}
+export interface INumberGroupFieldJSON extends IBaseGroupFieldJSON {
+    dataFieldType: PivotDataFieldTypeEnum.numberGroupField;
+    grouping: INumberGrouping;
+}
+export interface IManualGroupFieldJSON extends IBaseGroupFieldJSON {
+    dataFieldType: PivotDataFieldTypeEnum.textGroupField;
+    grouping: IManualGrouping;
 }
 export interface IDataFieldManagerBaseJSON {
     collections: Record<string, IFieldsCollectionJSON>;

package/lib/types/types/layout-type.d.ts

@@ -1,8 +1,8 @@
 import type { PivotView } from '../layout/pivot-view';
 import type { NodeTree } from '../summary/node-tree';
 import type { SummaryManager } from '../summary/summary-manager';
-import type { PivotErrorTypeEnum, PivotSubtotalPositionEnum } from './enum';
-import type { IPivotTableDateGroupInfo, IPivotTableQueryData, IPivotTableValueFieldQueryData, IValueFilterInfoItem } from './interface';
+import type { PivotDateGroupingMode, PivotErrorTypeEnum, PivotSubtotalPositionEnum } from './enum';
+import type { IPivotTableGroupInfo, IPivotTableQueryData, IPivotTableValueFieldQueryData, IValueFilterInfoItem } from './interface';
 export interface IPivotViewItemData {
     [row: number]: IPivotViewColData;
 }
@@ -161,6 +161,8 @@ export declare enum PivotCellStyleTypeEnum {
  * Represents the data structure for a pivot table config, which is match CT_pivotTableDefinition
  */
 export interface IPivotTableOptions {
+    /** Missing in older snapshots; readers treat it as Legacy without rewriting the snapshot. */
+    dateGroupingMode?: PivotDateGroupingMode;
     /**
      * The page wrap, it is the wrap of page, the page will wrap to next row when the wrapCursor is equal to pageWrap
      */
@@ -290,8 +292,7 @@ export interface IPivotViewJSON {
     colView: ILabelViewItemJSON;
     dataView: IPivotViewItemJSON;
     cornerView: IPivotViewItemJSON;
-    version: number;
     formatMap: Record<string, string>;
-    groupInfo: Record<string, IPivotTableDateGroupInfo>;
+    groupInfo: Record<string, IPivotTableGroupInfo>;
 }
 export {};

package/lib/types/util.d.ts

@@ -2,18 +2,19 @@ import type { BaseGroupField } from './field/base-group-field';
 import type { DataField } from './field/data-field';
 import type { DateGroupField } from './field/date-group-field';
 import type { PivotErrorTypeEnum, ST_PivotFilterOperatorEnum } from './types/enum';
-import type { IDataFieldValue, IDateValue, IPivotTableCustomFilter, IPivotTableDateGroupInfo, IPivotTableFilterInfo, IPivotTableLabelCustomSortInfo, IPivotTableManualFilter, IPivotTableSortInfo, IValueFilterInfoItem } from './types/interface';
+import type { IPivotTableCustomFilter, IPivotTableDateGroupInfo, IPivotTableFilterInfo, IPivotTableLabelCustomSortInfo, IPivotTableManualFilter, IPivotTableSortInfo, IValueFilterInfoItem } from './types/interface';
 import type { IBaseGroupFieldJSON, IDataFieldJSON, IDateGroupFieldJSON } from './types/json-types';
+import type { IPivotTableOptions } from './types/layout-type';
 import type { IMeasuresMapItem, ITupleItem } from './types/summary-type';
 import { PivotTuple } from './summary/pivot-tuple';
-import { PivotDataFieldDataTypeEnum, PivotDateGroupFieldDateTypeEnum, PivotSubtotalTypeEnum, PivotTableFiledAreaEnum } from './types/enum';
+import { PivotDataFieldDataTypeEnum, PivotDateGroupFieldDateTypeEnum, PivotDateGroupingMode, PivotSubtotalTypeEnum, PivotTableFiledAreaEnum } from './types/enum';
 import { PivotCellStyleTypeEnum } from './types/layout-type';
+export declare function getPivotDateGroupingMode(options?: IPivotTableOptions): PivotDateGroupingMode;
 /**
  * - judge the value is date like type
  * @param {IDataFieldValue} value the date like value
  * @returns {boolean} - return true if the value is date like type
  */
-export declare function isDateValue(value: IDataFieldValue): value is IDateValue;
 /**
  * - judge the value is blank
  * @param {any} value the value to be test