@ai-table/state 0.1.41 → 0.1.43

package/fesm2022/ai-table-state.mjs

@@ -1,9 +1,9 @@
 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, AITableRowType, AITable, getColumnIndicesSizeMap, shortIdCreator, generateNewName, getDefaultFieldValue, AI_TABLE_GROUP_MAX_LEVEL, 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';
@@ -410,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];
@@ -444,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 || {};
@@ -593,57 +667,34 @@ function buildFieldStatType(data, activeView) {
 }
 
 class GroupCalculator {
-    constructor(groups, aiTable, collapseState) {
+    constructor(aiTable, groups, collapseState) {
+        this.aiTable = aiTable;
         this.groups = groups;
         this.groupBreakpoints = new Map();
         this.groupCollapseState = new Set(collapseState || []);
-        this.aiTable = aiTable;
+        this.fieldsMap = this.aiTable.fieldsMap();
     }
-    calculateLinearRows(records, fields) {
-        const sortedRecords = this.sortRecordsByGroup(records, fields);
-        this.detectGroupBreakpoints(sortedRecords, fields);
-        return this.generateLinearRows(sortedRecords, fields);
-    }
-    sortRecordsByGroup(records, fields) {
-        const fieldsMap = new Map(fields.map((field) => [field._id, field]));
-        return [...records].sort((record1, record2) => {
-            return (this.groups.reduce((result, groupField) => {
-                if (result !== 0)
-                    return result;
-                const field = fieldsMap.get(groupField.fieldId);
-                if (!field)
-                    return 0;
-                const value1 = AITableQueries.getFieldValue(this.aiTable, [record1._id, field._id]);
-                const value2 = AITableQueries.getFieldValue(this.aiTable, [record2._id, field._id]);
-                const fieldModel = FieldModelMap[field.type];
-                if (!fieldModel)
-                    return 0;
-                const compareResult = fieldModel.compare(value1, value2, this.aiTable.context.references(), undefined, {
-                    aiTable: this.aiTable,
-                    field
-                });
-                return compareResult * (groupField.desc ? -1 : 1);
-            }, 0) || 1);
-        });
+    calculateLinearRows(records) {
+        this.detectGroupBreakpoints(records);
+        return this.generateLinearRows(records);
     }
     // 检测断点
-    detectGroupBreakpoints(records, fields) {
+    detectGroupBreakpoints(records) {
         this.groupBreakpoints.clear();
         if (records.length === 0)
             return;
-        const fieldsMap = new Map(fields.map((field) => [field._id, field]));
         let previousRecord = null;
         records.forEach((record, index) => {
             if (previousRecord === null) {
                 // 第一条记录，所有分组字段都是断点
                 this.groups.forEach((groupField) => {
-                    this.addBreakpoint(groupField.fieldId, index);
+                    this.addBreakpoint(groupField.field_id, index);
                 });
             }
             else {
                 // 检查每个分组字段是否发生变化
                 this.groups.forEach((groupField, groupIndex) => {
-                    const field = fieldsMap.get(groupField.fieldId);
+                    const field = this.fieldsMap[groupField.field_id];
                     if (!field)
                         return;
                     const prevValue = AITableQueries.getFieldValue(this.aiTable, [previousRecord._id, field._id]);
@@ -658,7 +709,7 @@ class GroupCalculator {
                     if (compareResult !== 0) {
                         // 值发生变化，从当前层级开始的所有层级都是断点
                         for (let i = groupIndex; i < this.groups.length; i++) {
-                            this.addBreakpoint(this.groups[i].fieldId, index);
+                            this.addBreakpoint(this.groups[i].field_id, index);
                         }
                         return;
                     }
@@ -678,9 +729,8 @@ class GroupCalculator {
         }
     }
     // 生成GroupLinearRows
-    generateLinearRows(records, fields) {
+    generateLinearRows(records) {
         const linearRows = [];
-        const fieldsMap = new Map(fields.map((field) => [field._id, field]));
         let lastGroupDepth = -1;
         let currentGroupRecords = [];
         let currentGroupIds = [];
@@ -693,7 +743,7 @@ class GroupCalculator {
         });
         records.forEach((record, index) => {
             // 生成分组标签
-            const groupTabRows = this.generateGroupTabRows(record, index, fieldsMap);
+            const groupTabRows = this.generateGroupTabRows(record, index, records.length);
             if (groupTabRows.length > 0) {
                 // 如果有新的分组标签，先处理上一个分组的结束
                 if (currentGroupRecords.length > 0) {
@@ -740,7 +790,7 @@ class GroupCalculator {
         let groupDisplayRowIndex = 0;
         currentGroupRecords.forEach((record, i) => {
             const recordIndex = currentGroupRecordIndices?.[i] ?? 0;
-            if (this.shouldShowRecord(record, recordIndex)) {
+            if (this.shouldShowRecord(recordIndex)) {
                 groupDisplayRowIndex++;
                 linearRows.push({
                     type: AITableRowType.record,
@@ -752,53 +802,71 @@ class GroupCalculator {
         });
         // 分组未折叠，为每个分组添加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: '',
-                depth: this.groups.length
+                _id: nanoid(),
+                depth: this.groups.length,
+                range: [startRecordIndex, endRecordIndex]
             });
         }
     }
     // 生成分组标签
-    generateGroupTabRows(record, recordIndex, fieldsMap) {
+    generateGroupTabRows(record, recordIndex, totalRecords) {
         const groupTabRows = [];
         this.groups.forEach((groupField, depth) => {
-            const breakpoints = this.groupBreakpoints.get(groupField.fieldId) || [];
+            const breakpoints = this.groupBreakpoints.get(groupField.field_id) || [];
             if (breakpoints.includes(recordIndex)) {
-                const field = fieldsMap.get(groupField.fieldId);
+                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.fieldId, depth, breakpointIndex);
-                const recordCount = this.calculateGroupRecordCount(record, recordIndex, depth);
+                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.fieldId,
+                    fieldId: groupField.field_id,
                     groupValue,
                     isCollapsed: this.groupCollapseState.has(groupId),
-                    recordCount,
+                    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}`;
     }
-    calculateGroupRecordCount(_record, _recordIndex, _depth) {
-        // TODO: 实现精确的分组记录数计算
-        return 1;
-    }
-    shouldShowRecord(_record, recordIndex) {
+    shouldShowRecord(recordIndex) {
         for (let depth = 0; depth < this.groups.length; depth++) {
             const groupField = this.groups[depth];
-            const breakpoints = this.groupBreakpoints.get(groupField.fieldId) || [];
+            const breakpoints = this.groupBreakpoints.get(groupField.field_id) || [];
             // 找到当前记录所属的分组断点
             let belongsToBreakpointIndex = -1;
             for (let i = breakpoints.length - 1; i >= 0; i--) {
@@ -808,7 +876,7 @@ class GroupCalculator {
                 }
             }
             if (belongsToBreakpointIndex >= 0) {
-                const groupId = this.generateGroupId(groupField.fieldId, depth, belongsToBreakpointIndex);
+                const groupId = this.generateGroupId(groupField.field_id, depth, belongsToBreakpointIndex);
                 if (this.groupCollapseState.has(groupId)) {
                     return false; // 父级分组被折叠，不显示记录
                 }
@@ -853,6 +921,28 @@ class GroupCalculator {
     }
 }
 
+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);
@@ -861,14 +951,13 @@ function buildFieldsByView(aiTable, fields, activeView) {
     const sortFields = getSortFields(aiTable, fields, activeView);
     return buildFieldStatType(sortFields, activeView);
 }
-function buildGroupLinearRows(aiTable, records, fields, activeView) {
-    if (activeView?.settings?.groups?.length && fields && aiTable) {
+function buildGroupLinearRows(aiTable, activeView, records) {
+    if (aiTable && activeView?.settings?.groups?.length) {
         try {
             const groups = activeView.settings?.groups;
-            const collapsedGroupIds = activeView.settings?.collapsedGroupIds;
-            const calculator = new GroupCalculator(groups, aiTable, collapsedGroupIds);
-            const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
-            return calculator.calculateLinearRows(filteredRecords, fields);
+            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);
@@ -1651,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]);
@@ -1705,7 +1789,7 @@ function setViewGroup(aiTable, groups) {
     const newSettings = {
         ...currentSettings,
         groups: groups || [],
-        collapsedGroupIds: [] // 重置折叠
+        collapsed_group_ids: [] // 重置折叠
     };
     const operation = {
         type: ActionName.SetView,
@@ -1723,7 +1807,7 @@ function setCollapsedGroup(aiTable, collapsedGroupIds) {
     const currentSettings = view.settings || {};
     const newSettings = {
         ...currentSettings,
-        collapsedGroupIds
+        collapsed_group_ids: collapsedGroupIds
     };
     const operation = {
         type: ActionName.SetView,
@@ -1735,29 +1819,28 @@ function setCollapsedGroup(aiTable, collapsedGroupIds) {
 }
 // 折叠
 function toggleGroupCollapse(aiTable, groupId) {
-    const viewId = aiTable.activeViewId();
-    const view = aiTable.views().find((v) => v._id === viewId);
-    if (!view)
+    const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
+    if (!activeView)
         return;
-    const currentCollapse = view.settings?.collapsedGroupIds || [];
+    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, desc = false) {
-    const view = aiTable.views().find((v) => v._id === aiTable.activeViewId());
-    if (!view)
+function addGroupField(aiTable, fieldId, direction = SortDirection.ascending) {
+    const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
+    if (!activeView)
         return;
-    const currentGroups = view.settings?.groups || [];
+    const currentGroups = activeView.settings?.groups || [];
     // 是否已存在
-    if (currentGroups.some((group) => group.fieldId === fieldId)) {
+    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, { fieldId, desc }];
+    const newGroups = [...currentGroups, { field_id: fieldId, direction }];
     setViewGroup(aiTable, newGroups);
 }
 // 删除分组
@@ -1766,16 +1849,16 @@ function removeGroupField(aiTable, fieldId) {
     if (!view)
         return;
     const currentGroups = view.settings?.groups || [];
-    const newGroups = currentGroups.filter((group) => group.fieldId !== fieldId);
+    const newGroups = currentGroups.filter((group) => group.field_id !== fieldId);
     setViewGroup(aiTable, newGroups.length > 0 ? newGroups : null);
 }
 // 更新排序方向
-function updateGroupFieldDirection(aiTable, fieldId, desc) {
+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.fieldId === fieldId ? { ...group, desc } : group));
+    const newGroups = currentGroups.map((group) => (group.field_id === fieldId ? { ...group, direction } : group));
     setViewGroup(aiTable, newGroups);
 }
 // 重新排序，拖拽顺序
@@ -1821,35 +1904,146 @@ 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 getParentGroupValuesByGroupId(aiTable, groupId) {
+    const parentGroups = getParentLinearRowGroups(aiTable, groupId);
+    return parentGroups.reduce((pre, cur) => {
+        pre[cur.fieldId] = cur.groupValue;
+        return pre;
+    }, {});
+}
+
+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 groups = activeView.settings?.groups;
+    let needCopyGroupValuesMap = null;
+    if (groups?.length && (afterRecordId || beforeRecordId)) {
+        needCopyGroupValuesMap = getParentGroupValuesByGroupId(aiTable, (afterRecordId || beforeRecordId));
+    }
     // 勾选多行顺序可能不一致，需要排序
     const sortedSourceRecords = sortByViewPosition(sourceRecords, activeView);
     let nextPosition = (prevPosition + targetPosition) / 2;
@@ -1858,6 +2052,16 @@ function moveRecords(aiTable, options, updatedInfo) {
         if (sourceIndex === undefined) {
             throw new Error(`Record with id ${record._id} not found`);
         }
+        if (groups?.length && needCopyGroupValuesMap) {
+            const updateFieldValues = [];
+            groups.forEach((group) => {
+                updateFieldValues.push({
+                    path: [record._id, group.field_id],
+                    value: needCopyGroupValuesMap[group.field_id]
+                });
+            });
+            Actions.updateFieldValues(aiTable, updateFieldValues);
+        }
         Actions.setRecordPositions(aiTable, { [activeViewId]: nextPosition }, [sourceIndex]);
         prevPosition = nextPosition;
         nextPosition = (prevPosition + targetPosition) / 2;
@@ -1899,6 +2103,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();
@@ -1906,14 +2114,31 @@ 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) {
+        needCopyGroupValuesMap = getParentGroupValuesByGroupId(aiTable, options.forGroupId);
+    }
+    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);
@@ -1926,9 +2151,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([]),
@@ -2150,11 +2376,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);
         }
     };
 };
@@ -2168,10 +2399,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);
         }
     };
 };
@@ -2222,5 +2459,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, 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, 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, getParentGroupValuesByGroupId, 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