@univerjs/sheets 0.15.4 → 0.15.5

package/lib/types/basics/const/command-listener-const.d.ts

@@ -1,4 +1,4 @@
-import { ICommandInfo, IRange } from '@univerjs/core';
+import { ICommandInfo, IRange, IUniverInstanceService } from '@univerjs/core';
 import { IMoveRangeMutationParams } from '../../commands/mutations/move-range.mutation';
 import { IMoveColumnsMutationParams, IMoveRowsMutationParams } from '../../commands/mutations/move-rows-cols.mutation';
 import { IReorderRangeMutationParams } from '../../commands/mutations/reorder-range.mutation';
@@ -139,7 +139,7 @@ export type CommandListenerValueChange = {
     id: SheetValueChangeType.DELETE_WORKSHEET_RANGE_THEME_STYLE;
     params: IWorksheetRangeThemeStyleMutationParams;
 };
-export declare function getValueChangedEffectedRange(commandInfo: ICommandInfo): {
+export declare function getValueChangedEffectedRange(univerInstanceService: IUniverInstanceService, commandInfo: ICommandInfo): {
     unitId: string;
     subUnitId: string;
     range: IRange;

package/lib/types/basics/utils.d.ts

@@ -17,5 +17,6 @@ export declare function generateNullCell(range: IRange[]): IObjectMatrixPrimitiv
 export declare function generateNullCellValue(range: IRange[]): IObjectMatrixPrimitiveType<ICellData>;
 export declare function generateNullCellStyle(ranges: IRange[]): IObjectMatrixPrimitiveType<ICellData>;
 export declare function getActiveWorksheet(instanceService: UniverInstanceService): [Nullable<Workbook>, Nullable<Worksheet>];
+export declare function discreteRangeToRange(discreteRange: IDiscreteRange): IRange;
 export declare function rangeToDiscreteRange(range: IRange, accessor: IAccessor, unitId?: string, subUnitId?: string): IDiscreteRange | null;
 export declare function getVisibleRanges(ranges: IRange[], accessor: IAccessor, unitId?: string, subUnitId?: string): IRange[];

package/lib/types/commands/commands/auto-fill.command.d.ts

@@ -0,0 +1,15 @@
+import { ICommand, IRange } from '@univerjs/core';
+import { AUTO_FILL_APPLY_TYPE } from '../../services/auto-fill/type';
+export interface IAutoFillCommandParams {
+    sourceRange: IRange;
+    targetRange: IRange;
+    unitId?: string;
+    subUnitId?: string;
+    applyType?: AUTO_FILL_APPLY_TYPE;
+}
+export declare const AutoFillCommand: ICommand;
+export interface IAutoClearContentCommand {
+    clearRange: IRange;
+    selectionRange: IRange;
+}
+export declare const AutoClearContentCommand: ICommand;

package/lib/types/commands/commands/refill.command.d.ts

@@ -0,0 +1,6 @@
+import { ICommand } from '@univerjs/core';
+import { AUTO_FILL_APPLY_TYPE } from '../../services/auto-fill/type';
+export interface IRefillCommandParams {
+    type: AUTO_FILL_APPLY_TYPE;
+}
+export declare const RefillCommand: ICommand;

package/lib/types/controllers/auto-fill.controller.d.ts

@@ -0,0 +1,22 @@
+import { Disposable, Injector, IUniverInstanceService } from '@univerjs/core';
+import { IAutoFillService } from '../services/auto-fill/auto-fill.service';
+export declare class AutoFillController extends Disposable {
+    private readonly _univerInstanceService;
+    private readonly _autoFillService;
+    private readonly _injector;
+    private _beforeApplyData;
+    private _copyData;
+    constructor(_univerInstanceService: IUniverInstanceService, _autoFillService: IAutoFillService, _injector: Injector);
+    private _init;
+    quit(): void;
+    private _initDefaultHook;
+    private _presetAndCacheData;
+    private _getApplyData;
+    private _applyFunctions;
+    private _getCopyData;
+    private _getEmptyCopyDataPiece;
+    private _getMergeApplyData;
+    private _fillData;
+    private _shouldDisableSeries;
+    private _getPreferredApplyType;
+}

package/lib/types/controllers/permission/sheet-permission-check.controller.d.ts

@@ -30,4 +30,5 @@ export declare class SheetPermissionCheckController extends Disposable {
     private _permissionCheckByMoveRangeCommand;
     private _permissionCheckBySetRangeValue;
     private _permissionCheckWithFormula;
+    private _permissionCheckByAutoFillCommand;
 }

package/lib/types/facade/f-range.d.ts

@@ -1,5 +1,5 @@
 import { AbsoluteRefType, BorderStyleTypes, BorderType, CellValue, CustomData, ICellData, IDocumentData, IObjectMatrixPrimitiveType, IRange, IStyleData, Nullable, Workbook, Worksheet, Dimension, ICommandService, Injector, RichTextValue, TextStyleValue, WrapStrategy } from '@univerjs/core';
-import { IMergeCellsUtilOptions, SplitDelimiterEnum } from '@univerjs/sheets';
+import { AUTO_FILL_APPLY_TYPE, IMergeCellsUtilOptions, SplitDelimiterEnum } from '@univerjs/sheets';
 import { IFacadeClearOptions } from './f-worksheet';
 import { FHorizontalAlignment, FVerticalAlignment } from './utils';
 import { FBaseInitialable } from '@univerjs/core/facade';
@@ -1591,4 +1591,43 @@ export declare class FRange extends FBaseInitialable {
      * ```
      */
     getRangePermission(): FRangePermission;
+    /**
+     * Fills the target range with data based on the data in the current range.
+     * @param {FRange} targetRange - The range to be filled with data.
+     * @param {AUTO_FILL_APPLY_TYPE} [applyType] - The type of data fill to be applied.
+     * @returns {Promise<boolean>} A promise that resolves to true if the fill operation was successful, false otherwise.
+     * @example
+     * ```ts
+     * // Auto-fill the range D1:D10 based on the data in the range C1:C2
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const fRange = fWorksheet.getRange('A1:A4');
+     *
+     * // Auto-fill without specifying applyType (default behavior)
+     * await fRange.autoFill(fWorksheet.getRange('A1:A20'))
+     *
+     * // Auto-fill with 'COPY' type
+     * await fRange.autoFill(fWorksheet.getRange('A1:A20'), 'COPY')
+     *
+     * // Auto-fill with 'SERIES' type
+     * await fRange.autoFill(fWorksheet.getRange('A1:A20'), 'SERIES')
+     * ```
+     *
+     * ```ts
+     * // Operate on a specific worksheet
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getSheetBySheetId('sheetId');
+     * const fRange = fWorksheet.getRange('A1:A4');
+     *
+     * // Auto-fill without specifying applyType (default behavior)
+     * await fRange.autoFill(fWorksheet.getRange('A1:A20'))
+     *
+     * // Auto-fill with 'COPY' type
+     * await fRange.autoFill(fWorksheet.getRange('A1:A20'), 'COPY')
+     *
+     * // Auto-fill with 'SERIES' type
+     * await fRange.autoFill(fWorksheet.getRange('A1:A20'), 'SERIES')
+     * ```
+     */
+    autoFill(targetRange: FRange, applyType?: AUTO_FILL_APPLY_TYPE): Promise<boolean>;
 }

package/lib/types/index.d.ts

@@ -17,17 +17,18 @@ export type { ICellOverGridPosition, ISheetOverGridPosition } from './basics/cel
 export { checkCellValueType } from './basics/cell-type';
 export { COMMAND_LISTENER_SKELETON_CHANGE, COMMAND_LISTENER_VALUE_CHANGE, type CommandListenerSkeletonChange, type CommandListenerValueChange, getSkeletonChangedEffectedRange, getValueChangedEffectedRange, SheetSkeletonChangeType, SheetValueChangeType, } from './basics/const/command-listener-const';
 export { expandToContinuousRange } from './basics/expand-range';
-export { type IAddWorksheetMergeMutationParams, type IDeleteRangeMutationParams, type IInsertColMutationParams, type IInsertRangeMutationParams, type IInsertRowMutationParams, type IInsertSheetMutationParams, type IRemoveColMutationParams, type IRemoveRowsMutationParams, type IRemoveSheetMutationParams, type IRemoveWorksheetMergeMutationParams, type IWorksheetRangeThemeStyleMutationParams, } from './basics/interfaces/mutation-interface';
+export { type IAddWorksheetMergeMutationParams, type IDeleteRangeMutationParams, type IDiscreteRange, type IInsertColMutationParams, type IInsertRangeMutationParams, type IInsertRowMutationParams, type IInsertSheetMutationParams, type IRemoveColMutationParams, type IRemoveRowsMutationParams, type IRemoveSheetMutationParams, type IRemoveWorksheetMergeMutationParams, type IWorksheetRangeThemeStyleMutationParams, } from './basics/interfaces';
 export { createTopMatrixFromMatrix, createTopMatrixFromRanges, findAllRectangle, rangeMerge, RangeMergeUtil } from './basics/range-merge';
 export { convertPrimaryWithCoordToPrimary, convertSelectionDataToRange, type ISelectionStyle, type ISelectionWidgetConfig, type ISelectionWithCoord, type ISelectionWithStyle, type ISheetRangeLocation, SELECTION_CONTROL_BORDER_BUFFER_COLOR, SELECTION_CONTROL_BORDER_BUFFER_WIDTH, } from './basics/selection';
 export { SplitDelimiterEnum, splitRangeText } from './basics/split-range-text';
 export { findFirstNonEmptyCell } from './basics/utils';
-export { generateNullCell, generateNullCellValue, getVisibleRanges, rangeToDiscreteRange } from './basics/utils';
+export { discreteRangeToRange, generateNullCell, generateNullCellValue, getVisibleRanges, rangeToDiscreteRange } from './basics/utils';
 export { AddRangeProtectionCommand, type IAddRangeProtectionCommandParams } from './commands/commands/add-range-protection.command';
 export { addMergeCellsUtil, AddWorksheetMergeAllCommand, AddWorksheetMergeCommand, AddWorksheetMergeHorizontalCommand, AddWorksheetMergeVerticalCommand, getClearContentMutationParamForRange, getClearContentMutationParamsForRanges, type IMergeCellsUtilOptions, } from './commands/commands/add-worksheet-merge.command';
 export { AddWorksheetProtectionCommand } from './commands/commands/add-worksheet-protection.command';
 export { SetWorksheetRangeThemeStyleCommand } from './commands/commands/add-worksheet-range-theme.command';
 export { AppendRowCommand, type IAppendRowCommandParams } from './commands/commands/append-row.command';
+export { AutoClearContentCommand, AutoFillCommand, type IAutoClearContentCommand, type IAutoFillCommandParams } from './commands/commands/auto-fill.command';
 export { ClearSelectionAllCommand } from './commands/commands/clear-selection-all.command';
 export { ClearSelectionContentCommand, type IClearSelectionContentCommandParams } from './commands/commands/clear-selection-content.command';
 export { ClearSelectionFormatCommand } from './commands/commands/clear-selection-format.command';
@@ -45,6 +46,7 @@ export { type IInsertColCommandParams, type IInsertRowCommandParams, InsertColAf
 export { type IInsertSheetCommandParams, InsertSheetCommand } from './commands/commands/insert-sheet.command';
 export { getMoveRangeUndoRedoMutations, type IMoveRangeCommandParams, MoveRangeCommand } from './commands/commands/move-range.command';
 export { type IMoveColsCommandParams, type IMoveRowsCommandParams, MoveColsCommand, MoveRowsCommand, } from './commands/commands/move-rows-cols.command';
+export { type IRefillCommandParams, RefillCommand } from './commands/commands/refill.command';
 export { RegisterWorksheetRangeThemeStyleCommand } from './commands/commands/register-range-theme.command';
 export type { IRegisterWorksheetRangeThemeStyleCommandParams } from './commands/commands/register-range-theme.command';
 export { RemoveDefinedNameCommand } from './commands/commands/remove-defined-name.command';
@@ -64,7 +66,7 @@ export { type ISetRangeCustomMetadataCommandParams, SetRangeCustomMetadataComman
 export { type ISetRangeValuesCommandParams, SetRangeValuesCommand } from './commands/commands/set-range-values.command';
 export { type ISetRowDataCommandParams, SetRowDataCommand } from './commands/commands/set-row-data.command';
 export { type ISetSpecificRowsVisibleCommandParams, SetRowHiddenCommand, SetSelectedRowsVisibleCommand, SetSpecificRowsVisibleCommand, } from './commands/commands/set-row-visible.command';
-export { type ISetColorCommandParams, type ISetFontFamilyCommandParams, type ISetFontSizeCommandParams, type ISetHorizontalTextAlignCommandParams, type ISetStyleCommandParams, type ISetTextRotationCommandParams, type ISetTextWrapCommandParams, type ISetVerticalTextAlignCommandParams, type IStyleTypeValue, ResetBackgroundColorCommand, ResetTextColorCommand, SetBackgroundColorCommand, SetBoldCommand, SetFontFamilyCommand, SetFontSizeCommand, SetHorizontalTextAlignCommand, SetItalicCommand, SetOverlineCommand, SetStrikeThroughCommand, SetStyleCommand, SetTextColorCommand, SetTextRotationCommand, SetTextWrapCommand, SetUnderlineCommand, SetVerticalTextAlignCommand, } from './commands/commands/set-style.command';
+export { AFFECT_LAYOUT_STYLES, type ISetColorCommandParams, type ISetFontFamilyCommandParams, type ISetFontSizeCommandParams, type ISetHorizontalTextAlignCommandParams, type ISetStyleCommandParams, type ISetTextRotationCommandParams, type ISetTextWrapCommandParams, type ISetVerticalTextAlignCommandParams, type IStyleTypeValue, ResetBackgroundColorCommand, ResetTextColorCommand, SetBackgroundColorCommand, SetBoldCommand, SetFontFamilyCommand, SetFontSizeCommand, SetHorizontalTextAlignCommand, SetItalicCommand, SetOverlineCommand, SetStrikeThroughCommand, SetStyleCommand, SetTextColorCommand, SetTextRotationCommand, SetTextWrapCommand, SetUnderlineCommand, SetVerticalTextAlignCommand, } from './commands/commands/set-style.command';
 export { SetTabColorCommand } from './commands/commands/set-tab-color.command';
 export { type ISetWorkbookNameCommandParams, SetWorkbookNameCommand } from './commands/commands/set-workbook-name.command';
 export { type ISetWorksheetActivateCommandParams, SetWorksheetActivateCommand } from './commands/commands/set-worksheet-activate.command';
@@ -157,6 +159,7 @@ export { getInsertRangeMutations, getRemoveRangeMutations } from './commands/uti
 export { handleInsertRangeMutation } from './commands/utils/handle-range-mutation';
 export { type ISheetCommandSharedParams } from './commands/utils/interface';
 export { getSelectionsService } from './commands/utils/selection-command-util';
+export { AutoFillController } from './controllers/auto-fill.controller';
 export { defaultLargeSheetOperationConfig, type ILargeSheetOperationConfig, type IUniverSheetsConfig, SHEETS_PLUGIN_CONFIG_KEY } from './controllers/config.schema';
 export { MAX_CELL_PER_SHEET_KEY } from './controllers/config/config';
 export { DefinedNameDataController } from './controllers/defined-name-data.controller';
@@ -175,6 +178,10 @@ export type { IRangeThemeStyleJSON } from './model/range-theme-util';
 export { RangeThemeStyle } from './model/range-theme-util';
 export type { IRangeThemeStyleItem } from './model/range-theme-util';
 export { UniverSheetsPlugin } from './plugin';
+export { AutoFillService, IAutoFillService } from './services/auto-fill/auto-fill.service';
+export { default as AutoFillRules } from './services/auto-fill/rules';
+export { default as AutoFillTools } from './services/auto-fill/tools';
+export { type AUTO_FILL_APPLY_FUNCTIONS, AUTO_FILL_APPLY_TYPE, AUTO_FILL_DATA_TYPE, AUTO_FILL_HOOK_TYPE, type IAutoFillCopyDataInType, type IAutoFillCopyDataInTypeIndexInfo, type IAutoFillCopyDataPiece, type IAutoFillLocation, type IAutoFillRule, type IAutoFillRuleConfirmedData, type ISheetAutoFillHook, } from './services/auto-fill/type';
 export { BorderStyleManagerService, type IBorderInfo } from './services/border-style-manager.service';
 export { ExclusiveRangeService, IExclusiveRangeService } from './services/exclusive-range/exclusive-range-service';
 export { SheetLazyExecuteScheduleService } from './services/lazy-execute-schedule.service';

package/lib/types/services/auto-fill/auto-fill.service.d.ts

@@ -0,0 +1,72 @@
+import { IDisposable, IRange, Nullable, Direction, Disposable, ICommandService, Injector, IUndoRedoService, IUniverInstanceService } from '@univerjs/core';
+import { Observable } from 'rxjs';
+import { IAutoFillLocation, IAutoFillRule, ISheetAutoFillHook, AUTO_FILL_APPLY_TYPE } from './type';
+export interface IAutoFillService {
+    applyType$: Observable<AUTO_FILL_APPLY_TYPE>;
+    applyType: AUTO_FILL_APPLY_TYPE;
+    direction: Direction;
+    menu$: Observable<IApplyMenuItem[]>;
+    menu: IApplyMenuItem[];
+    showMenu$: Observable<boolean>;
+    setShowMenu: (show: boolean) => void;
+    setDisableApplyType: (type: AUTO_FILL_APPLY_TYPE, disable: boolean) => void;
+    getRules(): IAutoFillRule[];
+    isFillingStyle(): boolean;
+    autoFillLocation$: Observable<Nullable<IAutoFillLocation>>;
+    autoFillLocation: Nullable<IAutoFillLocation>;
+    setFillingStyle(isFillingStyle: boolean): void;
+    registerRule(rule: IAutoFillRule): void;
+    getAllHooks(): ISheetAutoFillHook[];
+    getActiveHooks(): ISheetAutoFillHook[];
+    addHook(hook: ISheetAutoFillHook): IDisposable;
+    fillData(applyType: AUTO_FILL_APPLY_TYPE): boolean;
+    triggerAutoFill(unitId: string, subUnitId: string, source: IRange, target: IRange, manualApplyType?: AUTO_FILL_APPLY_TYPE): Promise<boolean>;
+}
+export interface IApplyMenuItem {
+    label: string;
+    value: AUTO_FILL_APPLY_TYPE;
+    disable: boolean;
+}
+export declare class AutoFillService extends Disposable implements IAutoFillService {
+    private _commandService;
+    private _undoRedoService;
+    private _univerInstanceService;
+    private readonly _injector;
+    private _rules;
+    private _hooks;
+    private readonly _applyType$;
+    private _isFillingStyle;
+    private _prevUndos;
+    private readonly _autoFillLocation$;
+    readonly autoFillLocation$: Observable<Nullable<IAutoFillLocation>>;
+    private readonly _showMenu$;
+    readonly showMenu$: Observable<boolean>;
+    private _direction;
+    readonly applyType$: Observable<AUTO_FILL_APPLY_TYPE>;
+    private readonly _menu$;
+    readonly menu$: Observable<IApplyMenuItem[]>;
+    constructor(_commandService: ICommandService, _undoRedoService: IUndoRedoService, _univerInstanceService: IUniverInstanceService, _injector: Injector);
+    private _init;
+    private _getOneByPriority;
+    private _initPrevUndo;
+    triggerAutoFill(unitId: string, subUnitId: string, source: IRange, selection: IRange, manualApplyType?: AUTO_FILL_APPLY_TYPE): Promise<boolean>;
+    addHook(hook: ISheetAutoFillHook): IDisposable;
+    registerRule(rule: IAutoFillRule): void;
+    getRules(): IAutoFillRule[];
+    getAllHooks(): ISheetAutoFillHook[];
+    getActiveHooks(): ISheetAutoFillHook[];
+    get applyType(): AUTO_FILL_APPLY_TYPE;
+    set applyType(type: AUTO_FILL_APPLY_TYPE);
+    get menu(): IApplyMenuItem[];
+    get direction(): Direction;
+    set direction(direction: Direction);
+    isFillingStyle(): boolean;
+    setFillingStyle(isFillingStyle: boolean): void;
+    get autoFillLocation(): Nullable<IAutoFillLocation>;
+    set autoFillLocation(location: Nullable<IAutoFillLocation>);
+    setDisableApplyType(type: AUTO_FILL_APPLY_TYPE, disable: boolean): void;
+    setShowMenu(show: boolean): void;
+    fillData(applyType: AUTO_FILL_APPLY_TYPE): boolean;
+    private _getAutoHeightUndoRedos;
+}
+export declare const IAutoFillService: import('@wendellhu/redi').IdentifierDecorator<IAutoFillService>;

package/lib/types/services/auto-fill/rules.d.ts

@@ -0,0 +1,12 @@
+import { IAutoFillRule } from './type';
+declare const AutoFillRules: {
+    dateRule: IAutoFillRule;
+    numberRule: IAutoFillRule;
+    extendNumberRule: IAutoFillRule;
+    chnNumberRule: IAutoFillRule;
+    chnWeek2Rule: IAutoFillRule;
+    chnWeek3Rule: IAutoFillRule;
+    loopSeriesRule: IAutoFillRule;
+    otherRule: IAutoFillRule;
+};
+export default AutoFillRules;

package/lib/types/services/auto-fill/tools.d.ts

@@ -0,0 +1,141 @@
+import { ICellData, IObjectMatrixPrimitiveType, IRange, Nullable, CellValueType, Direction } from '@univerjs/core';
+import { IDiscreteRange } from '../../basics';
+import { IAutoFillCopyDataInTypeIndexInfo } from './type';
+declare function chineseToNumber(chnStr?: Nullable<string>): number;
+declare function sectionToChinese(section: number): string;
+declare function numberToChinese(num: number): string;
+declare function isChnNumber(txt?: string): boolean;
+declare function matchExtendNumber(txt?: string): {
+    isExtendNumber: boolean;
+    matchTxt?: undefined;
+    beforeTxt?: undefined;
+    afterTxt?: undefined;
+} | {
+    isExtendNumber: boolean;
+    matchTxt: number;
+    beforeTxt: string;
+    afterTxt: string;
+};
+declare function isChnWeek1(txt: string): boolean;
+declare function isChnWeek2(txt: string): boolean;
+declare function isChnWeek3(txt: string): boolean;
+declare function getLenS(indexArr: any[], rsd: number): number;
+/**
+ * equal diff
+ */
+declare function isEqualDiff(arr: number[]): boolean;
+declare function getDataIndex(csLen: number, asLen: number, indexArr: number[]): IAutoFillCopyDataInTypeIndexInfo;
+declare function fillCopy(data: Array<Nullable<ICellData>>, len: number): {
+    p: import('@univerjs/core').IDocumentData | null;
+    s: string | import('@univerjs/core').IStyleData | null;
+    v: import('@univerjs/core').CellValue | null;
+    t: CellValueType | null;
+    f: string | null;
+    ref?: Nullable<string>;
+    xf?: Nullable<string>;
+    si: string | null;
+    custom?: import('@univerjs/core').CustomData;
+}[];
+declare function fillCopyStyles(data: Array<Nullable<ICellData>>, len: number): {
+    s: Nullable<string | import('@univerjs/core').IStyleData>;
+}[];
+declare function isEqualRatio(arr: number[]): boolean;
+declare function getXArr(len: number): number[];
+declare function fillSeries(data: Array<Nullable<ICellData>>, len: number, direction: Direction): ICellData[];
+declare function forecast(x: number, yArr: number[], xArr: number[], forward?: boolean): number;
+declare function fillExtendNumber(data: Array<Nullable<ICellData>>, len: number, step: number): ICellData[];
+declare function fillOnlyFormat(data: Array<Nullable<ICellData>>, len: number): ICellData[];
+declare function fillChnWeek(data: Array<Nullable<ICellData>>, len: number, step: number, weekType?: number): ICellData[];
+declare function fillChnNumber(data: Array<Nullable<ICellData>>, len: number, step: number): ICellData[];
+declare function isLoopSeries(txt: string): boolean;
+declare function getLoopSeriesInfo(txt: string): {
+    name: string;
+    series: string[];
+};
+declare function fillLoopSeries(data: Array<Nullable<ICellData>>, len: number, step: number, series: string[]): ICellData[];
+declare function getAutoFillRepeatRange(sourceRange: IRange, targetRange: IRange): {
+    repeatStartCell: {
+        col: number;
+        row: number;
+    };
+    relativeRange: IRange;
+}[];
+/**
+ * Formulas or Boolean values do not need to update cell.v
+ */
+declare function needsUpdateCellValue(cell: ICellData): boolean;
+/**
+ * Remove cell.custom
+ */
+declare function removeCellCustom(cell: Nullable<ICellData>): void;
+declare function reverseIfNeed<T>(data: T[], reverse: boolean): T[];
+declare function generateNullCellValueRowCol(range: IDiscreteRange[]): IObjectMatrixPrimitiveType<ICellData>;
+declare const AutoFillTools: {
+    chnNumChar: {
+        零: number;
+        一: number;
+        二: number;
+        三: number;
+        四: number;
+        五: number;
+        六: number;
+        七: number;
+        八: number;
+        九: number;
+    };
+    chnNumChar2: string[];
+    chnUnitSection: string[];
+    chnUnitChar: string[];
+    chnNameValue: {
+        十: {
+            value: number;
+            secUnit: boolean;
+        };
+        百: {
+            value: number;
+            secUnit: boolean;
+        };
+        千: {
+            value: number;
+            secUnit: boolean;
+        };
+        万: {
+            value: number;
+            secUnit: boolean;
+        };
+        亿: {
+            value: number;
+            secUnit: boolean;
+        };
+    };
+    chineseToNumber: typeof chineseToNumber;
+    sectionToChinese: typeof sectionToChinese;
+    numberToChinese: typeof numberToChinese;
+    isChnNumber: typeof isChnNumber;
+    matchExtendNumber: typeof matchExtendNumber;
+    isChnWeek1: typeof isChnWeek1;
+    isChnWeek2: typeof isChnWeek2;
+    isChnWeek3: typeof isChnWeek3;
+    getLenS: typeof getLenS;
+    isEqualDiff: typeof isEqualDiff;
+    getDataIndex: typeof getDataIndex;
+    fillCopy: typeof fillCopy;
+    fillCopyStyles: typeof fillCopyStyles;
+    isEqualRatio: typeof isEqualRatio;
+    getXArr: typeof getXArr;
+    fillSeries: typeof fillSeries;
+    forecast: typeof forecast;
+    fillExtendNumber: typeof fillExtendNumber;
+    fillOnlyFormat: typeof fillOnlyFormat;
+    fillChnWeek: typeof fillChnWeek;
+    fillChnNumber: typeof fillChnNumber;
+    isLoopSeries: typeof isLoopSeries;
+    getLoopSeriesInfo: typeof getLoopSeriesInfo;
+    fillLoopSeries: typeof fillLoopSeries;
+    getAutoFillRepeatRange: typeof getAutoFillRepeatRange;
+    needsUpdateCellValue: typeof needsUpdateCellValue;
+    removeCellCustom: typeof removeCellCustom;
+    reverseIfNeed: typeof reverseIfNeed;
+    generateNullCellValueRowCol: typeof generateNullCellValueRowCol;
+};
+export default AutoFillTools;

package/lib/types/services/auto-fill/type.d.ts

@@ -0,0 +1,66 @@
+import { Direction, IAccessor, ICellData, IMutationInfo, IObjectMatrixPrimitiveType, Nullable } from '@univerjs/core';
+import { IDiscreteRange } from '../../basics';
+export declare enum AUTO_FILL_APPLY_TYPE {
+    COPY = "COPY",
+    SERIES = "SERIES",
+    ONLY_FORMAT = "ONLY_FORMAT",
+    NO_FORMAT = "NO_FORMAT"
+}
+export declare enum AUTO_FILL_DATA_TYPE {
+    NUMBER = "number",
+    DATE = "date",
+    EXTEND_NUMBER = "extendNumber",
+    CHN_NUMBER = "chnNumber",
+    CHN_WEEK2 = "chnWeek2",
+    CHN_WEEK3 = "chnWeek3",
+    LOOP_SERIES = "loopSeries",
+    FORMULA = "formula",
+    OTHER = "other"
+}
+export declare enum AUTO_FILL_HOOK_TYPE {
+    APPEND = "APPEND",
+    DEFAULT = "DEFAULT",
+    ONLY = "ONLY"
+}
+export interface IAutoFillLocation {
+    source: IDiscreteRange;
+    target: IDiscreteRange;
+    unitId: string;
+    subUnitId: string;
+}
+export interface ISheetAutoFillHook {
+    id: string;
+    priority?: number;
+    type?: AUTO_FILL_HOOK_TYPE;
+    bindUnit?: string;
+    disable?: (location: IAutoFillLocation, direction: Direction, applyType: AUTO_FILL_APPLY_TYPE) => boolean;
+    onBeforeFillData?(location: IAutoFillLocation, direction: Direction): AUTO_FILL_APPLY_TYPE | void;
+    onFillData?(location: IAutoFillLocation, direction: Direction, applyType: AUTO_FILL_APPLY_TYPE): {
+        undos: IMutationInfo[];
+        redos: IMutationInfo[];
+    };
+    onAfterFillData?(location: IAutoFillLocation, direction: Direction, applyType: AUTO_FILL_APPLY_TYPE): boolean | void;
+    onBeforeSubmit?: (location: IAutoFillLocation, direction: Direction, applyType: AUTO_FILL_APPLY_TYPE, cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>) => void;
+}
+export type IAutoFillCopyDataInTypeIndexInfo = number[];
+export interface IAutoFillCopyDataInType {
+    data: Array<Nullable<ICellData>>;
+    index: IAutoFillCopyDataInTypeIndexInfo;
+}
+export interface IAutoFillCopyDataPiece {
+    [key: string]: IAutoFillCopyDataInType[];
+}
+export interface IAutoFillRuleConfirmedData {
+    type?: string;
+    cellData: Nullable<ICellData>;
+}
+export type AUTO_FILL_APPLY_FUNCTIONS = {
+    [key in AUTO_FILL_APPLY_TYPE]?: (dataWithIndex: IAutoFillCopyDataInType, len: number, direction: Direction, copyDataPiece: IAutoFillCopyDataPiece, location?: IAutoFillLocation) => Array<Nullable<ICellData>>;
+};
+export interface IAutoFillRule {
+    type: string;
+    match: (cellData: Nullable<ICellData>, accessor: IAccessor) => boolean;
+    isContinue: (prev: IAutoFillRuleConfirmedData, cur: Nullable<ICellData>) => boolean;
+    applyFunctions?: AUTO_FILL_APPLY_FUNCTIONS;
+    priority: number;
+}

package/lib/types/services/ref-range/util.d.ts

@@ -5,8 +5,8 @@ import { IRemoveRowColCommandInterceptParams } from '../../commands/commands/rem
 import { IMoveRangeMutationParams } from '../../commands/mutations/move-range.mutation';
 import { IMoveColumnsMutationParams, IMoveRowsMutationParams } from '../../commands/mutations/move-rows-cols.mutation';
 import { ISheetCommandSharedParams } from '../../commands/utils/interface';
-import { EffectRefRangeParams, IDeleteRangeMoveLeftCommand, IDeleteRangeMoveUpCommand, IInsertColCommand, IInsertRangeMoveDownCommand, IInsertRangeMoveRightCommand, IInsertRowCommand, IMoveColsCommand, IMoveRangeCommand, IMoveRowsCommand, IOperator, IRemoveRowColCommand, IReorderRangeCommand } from './type';
 import { SheetsSelectionsService } from '../selections/selection.service';
+import { EffectRefRangeParams, IDeleteRangeMoveLeftCommand, IDeleteRangeMoveUpCommand, IInsertColCommand, IInsertRangeMoveDownCommand, IInsertRangeMoveRightCommand, IInsertRowCommand, IMoveColsCommand, IMoveRangeCommand, IMoveRowsCommand, IOperator, IRemoveRowColCommand, IReorderRangeCommand } from './type';
 export declare const handleRangeTypeInput: (range: IRange) => {
     rangeType?: RANGE_TYPE;
     startAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
@@ -118,5 +118,5 @@ export declare function getSeparateEffectedRangesOnCommand(accessor: IAccessor,
     unitId: string;
     subUnitId: string;
     ranges: IRange[];
-};
+} | undefined;
 export {};