@ai-table/state 0.1.41-0 → 0.1.42

package/fesm2022/ai-table-state.mjs

@@ -1,9 +1,10 @@
 import * as Y from 'yjs';
 import { UndoManager } from 'yjs';
-import { getShareTypeNumberPath, ActionName, translateArrayEvent, getSharedRecordIndex, getSharedMapValueIndex, toMapSyncElement, getIdBySystemFieldValuesType, setRecordUpdatedInfo, getPositionsByRecordSyncElement, setRecordPositions as setRecordPositions$1, toRecordSyncElement, AI_TABLE_CONTENT_FIELD_NAME, getValuesByCustomFieldValues, getPositionsBySystemFieldValues, getTrackableEntityBySystemFieldValues, getShortIdBySystemFieldValues, getIdBySystemFieldValues, sortByViewPosition, AITableFilterLogical, AITableFilterOperation, AITableFieldType, isEmpty, AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH, AI_TABLE_MIN_FROZEN_COLUMN_COUNT, idCreator } from '@ai-table/utils';
+import { getShareTypeNumberPath, ActionName, translateArrayEvent, getSharedRecordIndex, getSharedMapValueIndex, toMapSyncElement, getIdBySystemFieldValuesType, setRecordUpdatedInfo, getPositionsByRecordSyncElement, setRecordPositions as setRecordPositions$1, toRecordSyncElement, AI_TABLE_CONTENT_FIELD_NAME, getValuesByCustomFieldValues, getPositionsBySystemFieldValues, getTrackableEntityBySystemFieldValues, getShortIdBySystemFieldValues, getIdBySystemFieldValues, SortDirection, AITableFilterLogical, AITableFilterOperation, AITableFieldType, isEmpty, sortByViewPosition, AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH, AI_TABLE_MIN_FROZEN_COLUMN_COUNT, idCreator } from '@ai-table/utils';
 import * as i0 from '@angular/core';
 import { signal, Injectable } from '@angular/core';
-import { FieldModelMap, AITableQueries, isSystemField, AITable, getColumnIndicesSizeMap, shortIdCreator, generateNewName, getDefaultFieldValue, idsCreator, shortIdsCreator, setSelection, AI_TABLE_GRID_FIELD_SERVICE_MAP, clearSelection, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, isMac, writeToAITable } from '@ai-table/grid';
+import { FieldModelMap, AITableQueries, isSystemField, AITableRowType, AITable, getColumnIndicesSizeMap, shortIdCreator, generateNewName, getDefaultFieldValue, AI_TABLE_GROUP_MAX_LEVEL, idsCreator, shortIdsCreator, closeExpendCell, setSelection, AI_TABLE_GRID_FIELD_SERVICE_MAP, clearSelection, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, isMac, writeToAITable } from '@ai-table/grid';
+import { nanoid } from 'nanoid';
 import * as _ from 'lodash';
 import ___default from 'lodash';
 import { createDraft, finishDraft } from 'immer';
@@ -409,14 +410,35 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImpo
         }] });
 
 function getSortRecords(aiTable, records, activeView, sortKeysMap) {
-    if (!activeView?.settings || !activeView.settings.sorts?.length) {
-        return sortByViewPosition(records, activeView);
-    }
-    const { is_keep_sort, sorts } = activeView.settings;
-    if (is_keep_sort && sorts?.length) {
-        return sortRecordsBySortInfo(aiTable, records, activeView, sortKeysMap);
-    }
-    return sortByViewPosition(records, activeView);
+    const shallowRecords = [...records];
+    const groups = activeView.settings?.groups;
+    return shallowRecords.sort((record1, record2) => {
+        // 分组排序（高优先级）
+        if (groups && groups.length > 0) {
+            const groupCompareResult = compareByGroups(aiTable, record1, record2, groups);
+            if (groupCompareResult !== 0) {
+                return groupCompareResult;
+            }
+        }
+        // sorts排序（中优先级）
+        let shouldSkipPositionSort = false;
+        if (activeView.settings?.sorts?.length) {
+            const { is_keep_sort, sorts } = activeView.settings;
+            if (sorts?.length) {
+                const sortsCompareResult = compareBySorts(record1, record2, sorts, aiTable, sortKeysMap);
+                if (sortsCompareResult !== 0) {
+                    return sortsCompareResult;
+                }
+                shouldSkipPositionSort = Boolean(is_keep_sort);
+            }
+        }
+        // position排序（低优先级）
+        if (shouldSkipPositionSort) {
+            // is_keep_sort为true，禁用position排序
+            return 0;
+        }
+        return compareByPosition(record1, record2, activeView);
+    });
 }
 function sortRecordsBySortInfo(aiTable, records, activeView, sortKeysMap) {
     const shallowRows = [...records];
@@ -443,6 +465,59 @@ function sortRecordsBySortInfo(aiTable, records, activeView, sortKeysMap) {
     }
     return shallowRows;
 }
+function compareByGroups(aiTable, record1, record2, groups) {
+    return groups.reduce((result, groupField) => {
+        if (result !== 0)
+            return result;
+        const field = aiTable.fieldsMap()[groupField.field_id];
+        if (!field)
+            return 0;
+        const value1 = AITableQueries.getFieldValue(aiTable, [record1._id, field._id]);
+        const value2 = AITableQueries.getFieldValue(aiTable, [record2._id, field._id]);
+        const fieldModel = FieldModelMap[field.type];
+        if (!fieldModel)
+            return 0;
+        const compareResult = fieldModel.compare(value1, value2, aiTable.context.references(), undefined, {
+            aiTable,
+            field
+        });
+        return compareResult * (groupField.direction === SortDirection.ascending ? 1 : -1);
+    }, 0);
+}
+function compareBySorts(record1, record2, sorts, aiTable, sortKeysMap) {
+    return sorts.reduce((acc, rule) => {
+        const field = aiTable.fieldsMap()[rule.sort_by];
+        if (!field || acc !== 0) {
+            return acc;
+        }
+        const fieldMethod = FieldModelMap[field.type];
+        const sortKey = sortKeysMap?.[field.type];
+        const cellValue1 = AITableQueries.getFieldValue(aiTable, [record1._id, field._id]);
+        const cellValue2 = AITableQueries.getFieldValue(aiTable, [record2._id, field._id]);
+        const references = aiTable.context.references();
+        const res = fieldMethod.compare(cellValue1, cellValue2, references, sortKey, {
+            aiTable,
+            field
+        });
+        return res * rule.direction;
+    }, 0);
+}
+function compareByPosition(record1, record2, activeView) {
+    const hasPosition1 = record1.positions && record1.positions[activeView._id] !== undefined;
+    const hasPosition2 = record2.positions && record2.positions[activeView._id] !== undefined;
+    if (hasPosition1 && hasPosition2) {
+        return record1.positions[activeView._id] - record2.positions[activeView._id];
+    }
+    // 如果只有一个有位置信息，有位置的排在前面
+    if (hasPosition1 && !hasPosition2) {
+        return -1;
+    }
+    if (!hasPosition1 && hasPosition2) {
+        return 1;
+    }
+    // 如果都没有位置信息，保持原有顺序
+    return 0;
+}
 
 function getFilteredRecords(aiTable, records, fields, activeView) {
     const { conditions, condition_logical } = activeView.settings || {};
@@ -591,6 +666,283 @@ function buildFieldStatType(data, activeView) {
     });
 }
 
+class GroupCalculator {
+    constructor(aiTable, groups, collapseState) {
+        this.aiTable = aiTable;
+        this.groups = groups;
+        this.groupBreakpoints = new Map();
+        this.groupCollapseState = new Set(collapseState || []);
+        this.fieldsMap = this.aiTable.fieldsMap();
+    }
+    calculateLinearRows(records) {
+        this.detectGroupBreakpoints(records);
+        return this.generateLinearRows(records);
+    }
+    // 检测断点
+    detectGroupBreakpoints(records) {
+        this.groupBreakpoints.clear();
+        if (records.length === 0)
+            return;
+        let previousRecord = null;
+        records.forEach((record, index) => {
+            if (previousRecord === null) {
+                // 第一条记录，所有分组字段都是断点
+                this.groups.forEach((groupField) => {
+                    this.addBreakpoint(groupField.field_id, index);
+                });
+            }
+            else {
+                // 检查每个分组字段是否发生变化
+                this.groups.forEach((groupField, groupIndex) => {
+                    const field = this.fieldsMap[groupField.field_id];
+                    if (!field)
+                        return;
+                    const prevValue = AITableQueries.getFieldValue(this.aiTable, [previousRecord._id, field._id]);
+                    const currValue = AITableQueries.getFieldValue(this.aiTable, [record._id, field._id]);
+                    const fieldModel = FieldModelMap[field.type];
+                    if (!fieldModel)
+                        return;
+                    const compareResult = fieldModel.compare(prevValue, currValue, this.aiTable.context.references(), undefined, {
+                        aiTable: this.aiTable,
+                        field
+                    });
+                    if (compareResult !== 0) {
+                        // 值发生变化，从当前层级开始的所有层级都是断点
+                        for (let i = groupIndex; i < this.groups.length; i++) {
+                            this.addBreakpoint(this.groups[i].field_id, index);
+                        }
+                        return;
+                    }
+                });
+            }
+            previousRecord = record;
+        });
+    }
+    // 添加断点
+    addBreakpoint(fieldId, recordIndex) {
+        if (!this.groupBreakpoints.has(fieldId)) {
+            this.groupBreakpoints.set(fieldId, []);
+        }
+        const breakpoints = this.groupBreakpoints.get(fieldId);
+        if (!breakpoints.includes(recordIndex)) {
+            breakpoints.push(recordIndex);
+        }
+    }
+    // 生成GroupLinearRows
+    generateLinearRows(records) {
+        const linearRows = [];
+        let lastGroupDepth = -1;
+        let currentGroupRecords = [];
+        let currentGroupIds = [];
+        let currentGroupRecordIndices = []; // 记录当前分组中每个记录的原始索引
+        // 开始添加一个空白行
+        linearRows.push({
+            type: AITableRowType.blank,
+            _id: nanoid(),
+            depth: 0
+        });
+        records.forEach((record, index) => {
+            // 生成分组标签
+            const groupTabRows = this.generateGroupTabRows(record, index, records.length);
+            if (groupTabRows.length > 0) {
+                // 如果有新的分组标签，先处理上一个分组的结束
+                if (currentGroupRecords.length > 0) {
+                    this.handleGroupEnd(currentGroupRecords, linearRows, currentGroupIds, currentGroupRecordIndices);
+                    currentGroupRecords = [];
+                    currentGroupRecordIndices = [];
+                }
+                currentGroupIds = groupTabRows.map((row) => row.groupId);
+                const depths = groupTabRows.filter((d) => d.depth !== undefined).map((d) => d.depth);
+                const minDepth = depths.length > 0 ? Math.min(...depths) : 0;
+                // 如果当前分组的最小深度小于等于上一个分组的深度，说明是同级或上级分组，需添加空白行
+                if (lastGroupDepth >= 0 && minDepth <= lastGroupDepth) {
+                    linearRows.push({
+                        type: AITableRowType.blank,
+                        _id: nanoid(),
+                        depth: minDepth
+                    });
+                }
+                // 只添加未被父级折叠的分组
+                const visibleGroupTabRows = this.filterVisibleGroupTabs(groupTabRows);
+                linearRows.push(...visibleGroupTabRows);
+                lastGroupDepth = depths.length > 0 ? Math.max(...depths) : 0;
+            }
+            // 将记录添加到当前分组
+            currentGroupRecords.push(record);
+            currentGroupRecordIndices.push(index);
+        });
+        // 处理最后一个分组
+        if (currentGroupRecords.length > 0) {
+            this.handleGroupEnd(currentGroupRecords, linearRows, currentGroupIds, currentGroupRecordIndices);
+        }
+        // 添加分组结束的空白行
+        if (lastGroupDepth >= 0) {
+            linearRows.push({
+                type: AITableRowType.blank,
+                _id: nanoid(),
+                depth: 0
+            });
+        }
+        return linearRows;
+    }
+    handleGroupEnd(currentGroupRecords, linearRows, currentGroupIds, currentGroupRecordIndices) {
+        // 分组结束时添加该分组的记录和add行
+        let groupDisplayRowIndex = 0;
+        currentGroupRecords.forEach((record, i) => {
+            const recordIndex = currentGroupRecordIndices?.[i] ?? 0;
+            if (this.shouldShowRecord(recordIndex)) {
+                groupDisplayRowIndex++;
+                linearRows.push({
+                    type: AITableRowType.record,
+                    _id: record._id,
+                    displayIndex: groupDisplayRowIndex,
+                    depth: this.groups.length
+                });
+            }
+        });
+        // 分组未折叠，为每个分组添加add新增行
+        if (currentGroupRecords.length > 0 && this.shouldShowAddRow(currentGroupIds)) {
+            let startRecordIndex = 0;
+            let endRecordIndex = 0;
+            if (currentGroupRecordIndices) {
+                // 当前添加按钮对于的记录范围
+                startRecordIndex = Math.min(...currentGroupRecordIndices);
+                endRecordIndex = Math.max(...currentGroupRecordIndices);
+            }
+            linearRows.push({
+                type: AITableRowType.add,
+                _id: nanoid(),
+                depth: this.groups.length,
+                range: [startRecordIndex, endRecordIndex]
+            });
+        }
+    }
+    // 生成分组标签
+    generateGroupTabRows(record, recordIndex, totalRecords) {
+        const groupTabRows = [];
+        this.groups.forEach((groupField, depth) => {
+            const breakpoints = this.groupBreakpoints.get(groupField.field_id) || [];
+            if (breakpoints.includes(recordIndex)) {
+                const field = this.fieldsMap[groupField.field_id];
+                if (!field)
+                    return;
+                const groupValue = AITableQueries.getFieldValue(this.aiTable, [record._id, field._id]);
+                const breakpointIndex = breakpoints.indexOf(recordIndex);
+                const groupId = this.generateGroupId(groupField.field_id, depth, breakpointIndex);
+                const recordRange = this.calculateGroupRecordRange(groupField.field_id, breakpointIndex, totalRecords);
+                groupTabRows.push({
+                    type: AITableRowType.group,
+                    _id: nanoid(),
+                    depth,
+                    fieldId: groupField.field_id,
+                    groupValue,
+                    isCollapsed: this.groupCollapseState.has(groupId),
+                    range: recordRange,
+                    groupId
+                });
+            }
+        });
+        return groupTabRows;
+    }
+    calculateGroupRecordRange(fieldId, breakpointIndex, totalRecords) {
+        const breakpoints = this.groupBreakpoints.get(fieldId) || [];
+        const startIndex = breakpoints[breakpointIndex] || 0;
+        let endIndex;
+        if (breakpointIndex + 1 < breakpoints.length) {
+            // 如果不是最后一个分组，结束位置是下一个断点的前一个位置
+            endIndex = breakpoints[breakpointIndex + 1] - 1;
+        }
+        else {
+            // 如果是最后一个分组，结束位置是最后一条记录
+            endIndex = totalRecords - 1;
+        }
+        return [startIndex, endIndex];
+    }
+    // 生成分组ID
+    generateGroupId(fieldId, depth, breakpointIndex) {
+        // 通过字段ID、深度和断点索引确保唯一
+        return `${fieldId}_${depth}_${breakpointIndex}`;
+    }
+    shouldShowRecord(recordIndex) {
+        for (let depth = 0; depth < this.groups.length; depth++) {
+            const groupField = this.groups[depth];
+            const breakpoints = this.groupBreakpoints.get(groupField.field_id) || [];
+            // 找到当前记录所属的分组断点
+            let belongsToBreakpointIndex = -1;
+            for (let i = breakpoints.length - 1; i >= 0; i--) {
+                if (breakpoints[i] <= recordIndex) {
+                    belongsToBreakpointIndex = i;
+                    break;
+                }
+            }
+            if (belongsToBreakpointIndex >= 0) {
+                const groupId = this.generateGroupId(groupField.field_id, depth, belongsToBreakpointIndex);
+                if (this.groupCollapseState.has(groupId)) {
+                    return false; // 父级分组被折叠，不显示记录
+                }
+            }
+        }
+        return true;
+    }
+    // 检查当前分组是否应该显示添加行
+    shouldShowAddRow(currentGroupIds) {
+        if (!currentGroupIds || currentGroupIds.length === 0) {
+            return true; // 默认显示
+        }
+        // 检查当前组的所有分组层级是否都展开
+        for (const groupId of currentGroupIds) {
+            if (this.groupCollapseState.has(groupId)) {
+                return false; // 有层级被折叠，不显示添加行
+            }
+        }
+        return true;
+    }
+    // 过滤可见的分组标签
+    filterVisibleGroupTabs(groupTabRows) {
+        const visibleRows = [];
+        for (let i = 0; i < groupTabRows.length; i++) {
+            const currentRow = groupTabRows[i];
+            let show = true;
+            // 检查当前分组标签的所有父级是否都展开
+            const currentDepth = currentRow.depth ?? 0;
+            for (let parentDepth = 0; parentDepth < currentDepth; parentDepth++) {
+                // 找到同一记录索引下的父级分组ID
+                const parentRow = groupTabRows.find((row) => row.depth === parentDepth);
+                if (parentRow && this.groupCollapseState.has(parentRow.groupId)) {
+                    show = false;
+                    break;
+                }
+            }
+            if (show) {
+                visibleRows.push(currentRow);
+            }
+        }
+        return visibleRows;
+    }
+}
+
+function getParentLinearRowGroups(aiTable, targetId) {
+    const linearRows = aiTable.context.linearRows();
+    const targetIndex = aiTable.context.visibleRowsIndexMap().get(targetId);
+    if (targetIndex === -1) {
+        return [];
+    }
+    const targetRow = linearRows[targetIndex];
+    const parentGroups = [];
+    let parentDepthPointer = targetRow.depth - 1;
+    for (let i = targetIndex - 1; i >= 0 && parentDepthPointer >= 0; i--) {
+        const row = linearRows[i];
+        if (row.type === AITableRowType.group) {
+            const rowDepth = row.depth || 0;
+            if (rowDepth <= parentDepthPointer) {
+                parentGroups.push(row);
+                parentDepthPointer--;
+            }
+        }
+    }
+    return parentGroups;
+}
+
 function buildRecordsByView(aiTable, records, fields, activeView, sortKeysMap) {
     const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
     return getSortRecords(aiTable, filteredRecords, activeView, sortKeysMap);
@@ -599,6 +951,20 @@ function buildFieldsByView(aiTable, fields, activeView) {
     const sortFields = getSortFields(aiTable, fields, activeView);
     return buildFieldStatType(sortFields, activeView);
 }
+function buildGroupLinearRows(aiTable, activeView, records) {
+    if (aiTable && activeView?.settings?.groups?.length) {
+        try {
+            const groups = activeView.settings?.groups;
+            const collapsedGroupIds = activeView.settings?.collapsed_group_ids;
+            const calculator = new GroupCalculator(aiTable, groups, collapsedGroupIds);
+            return calculator.calculateLinearRows(records);
+        }
+        catch (error) {
+            console.warn('Grouped build failed, using the default build method:', error);
+        }
+    }
+    return null;
+}
 
 function setView(aiTable, value, path) {
     const view = aiTable.views().find((item) => item._id === path[0]);
@@ -1374,12 +1740,7 @@ function addRecord(aiTable, record) {
 }
 function addRecords$1(aiTable, records, options) {
     const invalidFieldValues = [];
-    const sortRecords = options?.sortRecords ||
-        getSortRecords(aiTable, aiTable.records(), aiTable.views().find((item) => item._id === aiTable.activeViewId()));
-    const targetIndex = options?.targetId
-        ? sortRecords.findIndex((item) => item._id === options.targetId)
-        : options?.targetIndex || sortRecords.length - 1;
-    const positions = createMultiplePositions(aiTable.views(), aiTable.activeViewId(), sortRecords, targetIndex, records.length, options?.isInsertBefore);
+    const positions = getNewRecordsPosition(aiTable, options);
     records.forEach((record, index) => {
         Object.entries(record.values).every(([fieldId, value]) => {
             const field = AITableQueries.getField(aiTable, [fieldId]);
@@ -1419,12 +1780,123 @@ const RecordActions = {
     updateSystemFieldValues
 };
 
+function setViewGroup(aiTable, groups) {
+    const viewId = aiTable.activeViewId();
+    const view = aiTable.views().find((v) => v._id === viewId);
+    if (!view)
+        return;
+    const currentSettings = view.settings || {};
+    const newSettings = {
+        ...currentSettings,
+        groups: groups || [],
+        collapsed_group_ids: [] // 重置折叠
+    };
+    const operation = {
+        type: ActionName.SetView,
+        properties: { settings: currentSettings },
+        newProperties: { settings: newSettings },
+        path: [viewId]
+    };
+    aiTable.apply(operation);
+}
+function setCollapsedGroup(aiTable, collapsedGroupIds) {
+    const viewId = aiTable.activeViewId();
+    const view = aiTable.views().find((v) => v._id === viewId);
+    if (!view)
+        return;
+    const currentSettings = view.settings || {};
+    const newSettings = {
+        ...currentSettings,
+        collapsed_group_ids: collapsedGroupIds
+    };
+    const operation = {
+        type: ActionName.SetView,
+        properties: { settings: currentSettings },
+        newProperties: { settings: newSettings },
+        path: [viewId]
+    };
+    aiTable.apply(operation);
+}
+// 折叠
+function toggleGroupCollapse(aiTable, groupId) {
+    const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
+    if (!activeView)
+        return;
+    const currentCollapse = activeView.settings?.collapsed_group_ids || [];
+    const newCollapse = currentCollapse.includes(groupId) ? currentCollapse.filter((id) => id !== groupId) : [...currentCollapse, groupId];
+    setCollapsedGroup(aiTable, newCollapse);
+}
+// 添加分组
+function addGroupField(aiTable, fieldId, direction = SortDirection.ascending) {
+    const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
+    if (!activeView)
+        return;
+    const currentGroups = activeView.settings?.groups || [];
+    // 是否已存在
+    if (currentGroups.some((group) => group.field_id === fieldId)) {
+        throw new Error('The field has been used for grouping.');
+    }
+    // 层级限制
+    if (currentGroups.length >= AI_TABLE_GROUP_MAX_LEVEL) {
+        throw new Error(`The maximum number of groups is ${AI_TABLE_GROUP_MAX_LEVEL}.`);
+    }
+    const newGroups = [...currentGroups, { field_id: fieldId, direction }];
+    setViewGroup(aiTable, newGroups);
+}
+// 删除分组
+function removeGroupField(aiTable, fieldId) {
+    const view = aiTable.views().find((v) => v._id === aiTable.activeViewId());
+    if (!view)
+        return;
+    const currentGroups = view.settings?.groups || [];
+    const newGroups = currentGroups.filter((group) => group.field_id !== fieldId);
+    setViewGroup(aiTable, newGroups.length > 0 ? newGroups : null);
+}
+// 更新排序方向
+function updateGroupFieldDirection(aiTable, fieldId, direction) {
+    const view = aiTable.views().find((v) => v._id === aiTable.activeViewId());
+    if (!view)
+        return;
+    const currentGroups = view.settings?.groups || [];
+    const newGroups = currentGroups.map((group) => (group.field_id === fieldId ? { ...group, direction } : group));
+    setViewGroup(aiTable, newGroups);
+}
+// 重新排序，拖拽顺序
+function reorderGroupFields(aiTable, fromIndex, toIndex) {
+    const view = aiTable.views().find((v) => v._id === aiTable.activeViewId());
+    if (!view)
+        return;
+    const currentGroups = view.settings?.groups || [];
+    if (fromIndex < 0 || fromIndex >= currentGroups.length || toIndex < 0 || toIndex >= currentGroups.length) {
+        return;
+    }
+    const newGroups = [...currentGroups];
+    const [movedItem] = newGroups.splice(fromIndex, 1);
+    newGroups.splice(toIndex, 0, movedItem);
+    setViewGroup(aiTable, newGroups);
+}
+// 清空分组
+function clearAllGroups(aiTable) {
+    setViewGroup(aiTable, null);
+}
+const GroupActions = {
+    setViewGroup,
+    setCollapsedGroup,
+    toggleGroupCollapse,
+    addGroupField,
+    removeGroupField,
+    updateGroupFieldDirection,
+    reorderGroupFields,
+    clearAllGroups
+};
+
 const Actions = {
     ...GeneralActions,
     ...RecordActions,
     ...FieldActions,
     ...ViewActions,
-    ...PositionsActions
+    ...PositionsActions,
+    ...GroupActions
 };
 
 function moveFields(aiTable, options) {
@@ -1432,35 +1904,131 @@ function moveFields(aiTable, options) {
     Actions.moveField(aiTable, path, newPath);
 }
 
-function moveRecords(aiTable, options, updatedInfo) {
-    const gridRecords = aiTable.gridData().records;
+function findNextRecordForTargetInOriginalRecords(aiTable, targetRecordId) {
+    const viewId = aiTable.activeViewId();
+    const records = aiTable.records();
+    const recordsMap = aiTable.recordsMap();
+    const targetRecord = recordsMap[targetRecordId];
+    const targetPosition = targetRecord.positions[viewId] || 0;
+    let nextRecord = null;
+    for (const record of records) {
+        const pos = record.positions[viewId] || 0;
+        // 找到所有position大于目标position的记录中最小的
+        if (pos > targetPosition && (nextRecord === null || pos < nextRecord.positions[viewId])) {
+            nextRecord = record;
+        }
+    }
+    return nextRecord;
+}
+function findPrevRecordForTargetInOriginalRecords(aiTable, targetRecordId) {
+    const viewId = aiTable.activeViewId();
+    const records = aiTable.records();
+    const recordsMap = aiTable.recordsMap();
+    const targetRecord = recordsMap[targetRecordId];
+    const targetPosition = targetRecord.positions[viewId] || 0;
+    let prevRecord = null;
+    for (const record of records) {
+        const pos = record.positions[viewId] || 0;
+        // 找到所有position小于目标记录position的记录中最大的
+        if (pos < targetPosition && (prevRecord === null || pos > prevRecord.positions[viewId])) {
+            prevRecord = record;
+        }
+    }
+    return prevRecord;
+}
+function getPositionByAfterOrBeforeRecordId(aiTable, options) {
+    const recordsMap = aiTable.recordsMap();
     const activeViewId = aiTable.activeViewId();
-    const activeView = aiTable.views().find((view) => view._id === activeViewId);
-    const { recordIds, newPath } = options;
+    const originalRecords = aiTable.records();
+    const { afterRecordId, beforeRecordId } = options;
     let targetPosition = 0;
     let prevPosition = 0;
-    if (newPath[0] === 0) {
-        targetPosition = gridRecords[0].positions[activeViewId];
-        prevPosition = targetPosition - 1;
+    if (afterRecordId) {
+        // 移动到指定记录之后
+        const targetRecord = recordsMap[afterRecordId];
+        if (!targetRecord) {
+            throw new Error(`Target record with id ${afterRecordId} not found`);
+        }
+        prevPosition = targetRecord.positions[activeViewId] || 0;
+        const nextPosition = findNextRecordForTargetInOriginalRecords(aiTable, afterRecordId);
+        if (nextPosition !== null) {
+            targetPosition = nextPosition.positions[activeViewId] || 0;
+        }
+        else {
+            // 最后一个
+            targetPosition = getMaxPosition(originalRecords, activeViewId) + 1;
+        }
     }
-    else if (newPath[0] >= gridRecords.length) {
-        targetPosition = getMaxPosition(gridRecords, activeViewId) + 1;
-        prevPosition = gridRecords[gridRecords.length - 1].positions[activeViewId];
+    else if (beforeRecordId) {
+        // 移动到指定记录之前
+        const targetRecord = recordsMap[beforeRecordId];
+        if (!targetRecord) {
+            throw new Error(`Target record with id ${beforeRecordId} not found`);
+        }
+        targetPosition = targetRecord.positions[activeViewId] || 0;
+        const previousPosition = findPrevRecordForTargetInOriginalRecords(aiTable, beforeRecordId);
+        if (previousPosition !== null) {
+            prevPosition = previousPosition.positions[activeViewId] || 0;
+        }
+        else {
+            // 第一个
+            prevPosition = targetPosition - 1;
+        }
     }
     else {
-        targetPosition = gridRecords[newPath[0]].positions[activeViewId];
-        prevPosition = gridRecords[newPath[0] - 1].positions[activeViewId];
+        throw new Error('Either afterRecordId or beforeRecordId must be provided');
     }
-    const records = aiTable.records();
-    const recordsIndexMap = new Map(records.map((row, index) => [row._id, index]));
+    return {
+        targetPosition,
+        prevPosition
+    };
+}
+function getNewRecordsPosition(aiTable, options) {
+    options = options || {};
+    if (!options.afterRecordId && !options.beforeRecordId) {
+        options.afterRecordId = aiTable.gridData().records[aiTable.gridData().records.length - 1]._id;
+    }
+    options.count = options.count || 1;
+    const { targetPosition, prevPosition } = getPositionByAfterOrBeforeRecordId(aiTable, options);
+    const interval = (targetPosition - prevPosition) / ((options.count || 1) + 1);
+    const positionsOfItems = ___default.range(prevPosition + interval, targetPosition, interval);
+    const views = aiTable.views();
+    const activeViewId = aiTable.activeViewId();
+    const viewsMaxPosition = {};
+    views.forEach((view) => {
+        viewsMaxPosition[view._id] = getMaxPosition(aiTable.records(), view._id);
+    });
+    const viewPositions = positionsOfItems.map((itemPositions) => {
+        const viewPositions = {};
+        views.forEach((view) => {
+            if (view._id === activeViewId) {
+                viewPositions[view._id] = itemPositions;
+            }
+            else {
+                viewsMaxPosition[view._id] += 1;
+                viewPositions[view._id] = viewsMaxPosition[view._id];
+            }
+        });
+        return viewPositions;
+    });
+    return viewPositions;
+}
+
+function moveRecords(aiTable, options, updatedInfo) {
+    const activeViewId = aiTable.activeViewId();
+    const activeView = aiTable.views().find((view) => view._id === activeViewId);
+    const { recordIds, afterRecordId, beforeRecordId } = options;
+    const originalRecords = aiTable.records();
+    const recordsIndexMap = new Map(originalRecords.map((row, index) => [row._id, index]));
     const sourceRecords = [];
-    recordIds.forEach((idPath) => {
-        const index = recordsIndexMap.get(idPath[0]);
+    recordIds.forEach((id) => {
+        const index = recordsIndexMap.get(id);
         if (index === undefined) {
-            throw new Error(`Record with id ${idPath[0]} not found`);
+            throw new Error(`Record with id ${id} not found`);
         }
-        sourceRecords.push(records[index]);
+        sourceRecords.push(originalRecords[index]);
     });
+    let { targetPosition, prevPosition } = getPositionByAfterOrBeforeRecordId(aiTable, { afterRecordId, beforeRecordId });
     // 勾选多行顺序可能不一致，需要排序
     const sortedSourceRecords = sortByViewPosition(sourceRecords, activeView);
     let nextPosition = (prevPosition + targetPosition) / 2;
@@ -1510,6 +2078,10 @@ const buildRemoveFieldItem = (aiTable, getUpdatedInfo) => {
 
 function addRecords(aiTable, trackableEntity, options) {
     options = options || {};
+    const newRecords = [];
+    const activeViewId = aiTable.activeViewId();
+    const activeView = aiTable.viewsMap()[activeViewId];
+    const groups = activeView.settings?.groups;
     let { originId, isDuplicate, count = 1 } = options;
     const recordCount = aiTable.records().length;
     const maxRecordCount = aiTable.context?.maxRecords();
@@ -1517,14 +2089,35 @@ function addRecords(aiTable, trackableEntity, options) {
         count = maxRecordCount - recordCount;
         options.count = count;
     }
-    const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
     const newRecordIds = idsCreator(count);
     const newRecordShortIds = shortIdsCreator(count);
     const newRecordValues = getDefaultRecordValues(aiTable, isDuplicate, originId);
-    const newRecords = [];
     const hiddenRecordIds = [];
+    let needCopyGroupValuesMap = null;
+    if (groups?.length && options.forGroupId) {
+        const parentGroups = getParentLinearRowGroups(aiTable, options.forGroupId);
+        needCopyGroupValuesMap = parentGroups.reduce((pre, cur) => {
+            pre[cur.fieldId] = cur.groupValue;
+            return pre;
+        }, {});
+    }
+    const records = aiTable.gridData().records;
     newRecordIds.forEach((id, index) => {
-        const record = { _id: id, short_id: newRecordShortIds[index], values: newRecordValues, ...trackableEntity };
+        const record = {
+            _id: id,
+            short_id: newRecordShortIds[index],
+            values: newRecordValues,
+            ...trackableEntity,
+            positions: {
+                [activeViewId]: getMaxPosition(records, activeViewId) + 1
+            }
+        };
+        if (needCopyGroupValuesMap) {
+            groups?.forEach((group) => {
+                // 复制分组字段值
+                record.values[group.field_id] = needCopyGroupValuesMap[group.field_id];
+            });
+        }
         const checkResult = checkConditions(aiTable, aiTable.fields(), record);
         if (!checkResult) {
             hiddenRecordIds.push(id);
@@ -1537,9 +2130,10 @@ function addRecords(aiTable, trackableEntity, options) {
         });
     }
     Actions.addRecords(aiTable, newRecords, options);
-    const recentAddRecord = options.isInsertBefore ? newRecords[newRecords.length - 1] : newRecords[0];
+    const recentAddRecord = options.beforeRecordId ? newRecords[newRecords.length - 1] : newRecords[0];
     const activeRecordId = recentAddRecord._id;
     const activeFieldId = aiTable.gridData().fields[0]._id;
+    closeExpendCell(aiTable);
     setSelection(aiTable, {
         selectedRecords: new Set([]),
         selectedFields: new Set([]),
@@ -1761,11 +2355,16 @@ const InsertUpwardRecords = (aiTable, actions) => {
         count: 1,
         exec: (aiTable, targetName, position, notifyService, count) => {
             let selectedRecordIds = AITable.getActiveRecordIds(aiTable);
-            actions.addRecord({
-                targetId: selectedRecordIds[0],
-                count,
-                isInsertBefore: true
-            });
+            const aiViewTable = aiTable;
+            const activeView = aiViewTable.viewsMap()[aiViewTable.activeViewId()];
+            const addRecordOptions = {
+                beforeRecordId: selectedRecordIds[0],
+                count
+            };
+            if (activeView?.settings?.groups?.length) {
+                addRecordOptions.forGroupId = selectedRecordIds[0];
+            }
+            actions.addRecord(addRecordOptions);
         }
     };
 };
@@ -1779,10 +2378,16 @@ const InsertDownwardRecords = (aiTable, actions) => {
         isInputNumber: true,
         exec: (aiTable, targetName, position, notifyService, count) => {
             let selectedRecordIds = AITable.getActiveRecordIds(aiTable);
-            actions.addRecord({
-                targetId: selectedRecordIds[0],
+            const aiViewTable = aiTable;
+            const activeView = aiViewTable.viewsMap()[aiViewTable.activeViewId()];
+            const addRecordOptions = {
+                afterRecordId: selectedRecordIds[0],
                 count
-            });
+            };
+            if (activeView?.settings?.groups?.length) {
+                addRecordOptions.forGroupId = selectedRecordIds[0];
+            }
+            actions.addRecord(addRecordOptions);
         }
     };
 };
@@ -1833,5 +2438,5 @@ const VIEW_ACTIONS = [ActionName.SetView, ActionName.AddView, ActionName.RemoveV
  * Generated bundle index. Do not edit.
  */
 
-export { AITableStateI18nKey, AITableStateI18nText, Actions, CopyCellsItem, CopyFieldPropertyItem, DividerMenuItem, EditFieldPropertyItem, FLUSHING, InsertDownwardRecords, InsertUpwardRecords, PasteCellsItem, RemoveRecordsItem, UndoManagerService, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyActions, applyEvents, applyYjsEvents, buildFieldsByView, buildRecordsByView, buildRemoveFieldItem, buildSetFieldAction, buildSetRecordPositionsActon, calculateAdaptiveFrozenColumnCount, checkConditions, createMultiplePositions, createPositions, createSharedType, doFilter, freezeToThisColumn, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getFrozenFieldId, getMaxPosition, getPosition, getPositions, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getSortRecords, getStateI18nTextByKey, isPathEqual, moveFields, moveRecords, removeView, restoreDefaultFrozenColumn, sortRecordsBySortInfo, sortViews, toSharedType, translateYjsEvent, updateFieldAndValues, updateFieldValues, withState };
+export { AITableStateI18nKey, AITableStateI18nText, Actions, CopyCellsItem, CopyFieldPropertyItem, DividerMenuItem, EditFieldPropertyItem, FLUSHING, GroupCalculator, InsertDownwardRecords, InsertUpwardRecords, PasteCellsItem, RemoveRecordsItem, UndoManagerService, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyActions, applyEvents, applyYjsEvents, buildFieldsByView, buildGroupLinearRows, buildRecordsByView, buildRemoveFieldItem, buildSetFieldAction, buildSetRecordPositionsActon, calculateAdaptiveFrozenColumnCount, checkConditions, createMultiplePositions, createPositions, createSharedType, doFilter, findNextRecordForTargetInOriginalRecords, findPrevRecordForTargetInOriginalRecords, freezeToThisColumn, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getFrozenFieldId, getMaxPosition, getNewRecordsPosition, getParentLinearRowGroups, getPosition, getPositionByAfterOrBeforeRecordId, getPositions, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getSortRecords, getStateI18nTextByKey, isPathEqual, moveFields, moveRecords, removeView, restoreDefaultFrozenColumn, sortRecordsBySortInfo, sortViews, toSharedType, translateYjsEvent, updateFieldAndValues, updateFieldValues, withState };
 //# sourceMappingURL=ai-table-state.mjs.map