@ai-table/state 0.2.4 → 0.3.0

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, AITableFilterLogical, AITableFilterOperation, AITableFieldType, isEmpty, sortByViewPosition, AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH, AI_TABLE_MIN_FROZEN_COLUMN_COUNT, SortDirection, 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, AITableFilterLogical, AITableFilterOperation, AITableFieldType, isEmpty, sortByViewPosition, idCreator, SortDirection, AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH, AI_TABLE_MIN_FROZEN_COLUMN_COUNT } from '@ai-table/utils';
 import * as i0 from '@angular/core';
 import { signal, Injectable } from '@angular/core';
-import { FieldModelMap, AITableQueries, isSystemField, AITableRowType, AITable, getColumnIndicesSizeMap, AI_TABLE_GROUP_MAX_LEVEL, shortIdCreator, generateNewName, idsCreator, shortIdsCreator, closeExpendCell, setSelection, buildNormalLinearRows, AI_TABLE_GRID_FIELD_SERVICE_MAP, clearSelection, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, isMac, writeToAITable } from '@ai-table/grid';
+import { FieldModelMap, AITableQueries, isSystemField, AITableRowType, shortIdCreator, generateNewName, AI_TABLE_GROUP_MAX_LEVEL, idsCreator, shortIdsCreator, closeExpendCell, setSelection, buildNormalLinearRows, AITable, getColumnIndicesSizeMap, AI_TABLE_GRID_FIELD_SERVICE_MAP, clearSelection, isMac } from '@ai-table/grid';
 import { nanoid } from 'nanoid';
 import * as _ from 'lodash';
 import ___default, { map, unionBy } from 'lodash';
@@ -858,97 +858,6 @@ function getGroupRecordLength(aiTable, recordId, linearRows) {
     return 0;
 }
 
-function getFieldPositionInView(viewId, fields, path, newPath) {
-    const targetPosition = fields[newPath[0]].positions[viewId];
-    let newPosition = 0;
-    if (path[0] > newPath[0]) {
-        const prevPath = newPath[0] - 1;
-        if (prevPath >= 0) {
-            const targetPrevField = fields[prevPath];
-            const targetPrevPosition = targetPrevField.positions[viewId];
-            newPosition = (targetPosition + targetPrevPosition) / 2;
-        }
-        else {
-            const firstField = fields[0];
-            newPosition = firstField.positions[viewId] - 0.1;
-        }
-    }
-    else {
-        const nextPath = newPath[0] + 1;
-        if (fields.length > nextPath) {
-            const targetNextField = fields[nextPath];
-            const targetNextPosition = targetNextField.positions[viewId];
-            newPosition = (targetPosition + targetNextPosition) / 2;
-        }
-        else {
-            const lastField = fields[fields.length - 1];
-            const lastPosition = lastField.positions[viewId] + 1;
-            newPosition = (targetPosition + lastPosition) / 2;
-        }
-    }
-    return newPosition;
-}
-function getFieldsSizeMap(fields, activeView) {
-    const fieldsSizeMap = {};
-    fields?.forEach((field) => {
-        fieldsSizeMap[field._id] = field.widths?.[activeView._id];
-    });
-    return fieldsSizeMap;
-}
-
-var AITableStateI18nKey;
-(function (AITableStateI18nKey) {
-    AITableStateI18nKey["copyField"] = "copyField";
-    AITableStateI18nKey["removeRecords"] = "removeRecords";
-    AITableStateI18nKey["copy"] = "copy";
-    AITableStateI18nKey["copySuffix"] = "copySuffix";
-    AITableStateI18nKey["paste"] = "paste";
-    AITableStateI18nKey["invalidPasteContent"] = "invalidPasteContent";
-    AITableStateI18nKey["tableView"] = "tableView";
-    AITableStateI18nKey["editField"] = "editField";
-    AITableStateI18nKey["removeField"] = "removeField";
-    AITableStateI18nKey["pasteOverMaxRecords"] = "pasteOverMaxRecords";
-    AITableStateI18nKey["pasteOverMaxFields"] = "pasteOverMaxFields";
-    AITableStateI18nKey["insertUpward"] = "insertUpward";
-    AITableStateI18nKey["insertDownward"] = "insertDownward";
-    AITableStateI18nKey["upward"] = "upward";
-    AITableStateI18nKey["downward"] = "downward";
-    AITableStateI18nKey["freezeToThisColumn"] = "freezeToThisColumn";
-    AITableStateI18nKey["restoreDefaultFrozenColumn"] = "restoreDefaultFrozenColumn";
-})(AITableStateI18nKey || (AITableStateI18nKey = {}));
-const AITableStateI18nText = {
-    [AITableStateI18nKey.copyField]: '复制列',
-    [AITableStateI18nKey.removeRecords]: '删除行',
-    [AITableStateI18nKey.copy]: '复制',
-    [AITableStateI18nKey.copySuffix]: '副本',
-    [AITableStateI18nKey.paste]: '粘贴',
-    [AITableStateI18nKey.invalidPasteContent]: '粘贴内容不符合当前类型',
-    [AITableStateI18nKey.tableView]: '表格视图',
-    [AITableStateI18nKey.editField]: '编辑列',
-    [AITableStateI18nKey.removeField]: '删除列',
-    [AITableStateI18nKey.pasteOverMaxRecords]: '粘贴数据超过最大行数',
-    [AITableStateI18nKey.pasteOverMaxFields]: '粘贴数据超过最大列数',
-    [AITableStateI18nKey.insertUpward]: '向上插入',
-    [AITableStateI18nKey.insertDownward]: '向下插入',
-    [AITableStateI18nKey.upward]: '行',
-    [AITableStateI18nKey.downward]: '行',
-    [AITableStateI18nKey.freezeToThisColumn]: '冻结至此列',
-    [AITableStateI18nKey.restoreDefaultFrozenColumn]: '恢复默认冻结列'
-};
-const getDefaultI18nTextByKey = (key) => {
-    return AITableStateI18nText[key] || key;
-};
-const getStateI18nTextByKey = (aiTable, key) => {
-    if (aiTable.getI18nTextByKey) {
-        const customText = aiTable.getI18nTextByKey(key);
-        if (customText) {
-            return customText;
-        }
-    }
-    const defaultText = getDefaultI18nTextByKey(key);
-    return defaultText;
-};
-
 function setView(aiTable, value, path) {
     const view = aiTable.views().find((item) => item._id === path[0]);
     if (view) {
@@ -1018,159 +927,6 @@ const ViewActions = {
     setViewFrozenField
 };
 
-function getFrozenFieldId(aiTable) {
-    try {
-        const viewTable = aiTable;
-        const activeViewId = viewTable.activeViewId();
-        const activeView = viewTable.viewsMap()[activeViewId];
-        return activeView?.settings?.frozen_field_id;
-    }
-    catch (error) {
-        return undefined;
-    }
-}
-function calculateAdaptiveFrozenColumnCountCore(config) {
-    const { containerWidth, rowHeadWidth, visibleFields, columnIndicesSizeMap, frozenFieldId, minUnfrozenWidth = AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH } = config;
-    if (visibleFields.length === 0) {
-        return AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
-    }
-    let targetFrozenCount;
-    if (frozenFieldId) {
-        const frozenFieldIndex = visibleFields.findIndex((field) => field._id === frozenFieldId);
-        if (frozenFieldIndex >= 0) {
-            targetFrozenCount = frozenFieldIndex + 1;
-        }
-        else {
-            targetFrozenCount = AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
-        }
-    }
-    else {
-        targetFrozenCount = AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
-    }
-    const availableWidth = containerWidth - rowHeadWidth;
-    const maxFrozenWidth = Math.max(0, availableWidth - minUnfrozenWidth);
-    let currentFrozenWidth = 0;
-    let actualFrozenCount = 0;
-    const maxPossibleCount = Math.min(targetFrozenCount, visibleFields.length);
-    for (let i = 0; i < maxPossibleCount; i++) {
-        const fieldWidth = columnIndicesSizeMap[i];
-        const newFrozenWidth = currentFrozenWidth + fieldWidth;
-        if (newFrozenWidth > maxFrozenWidth) {
-            if (i === 0) {
-                currentFrozenWidth = newFrozenWidth;
-                actualFrozenCount = AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
-            }
-            break;
-        }
-        currentFrozenWidth = newFrozenWidth;
-        actualFrozenCount = i + 1;
-    }
-    // 至少有一列冻结
-    if (actualFrozenCount < AI_TABLE_MIN_FROZEN_COLUMN_COUNT) {
-        actualFrozenCount = AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
-        if (visibleFields.length > 0) {
-            currentFrozenWidth = columnIndicesSizeMap[0];
-        }
-    }
-    return actualFrozenCount;
-}
-function calculateAdaptiveFrozenColumnCount(aiTable, containerWidth, minUnfrozenWidth = 200) {
-    try {
-        if (containerWidth <= 0) {
-            return AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
-        }
-        const frozenFieldId = getFrozenFieldId(aiTable);
-        const visibleFields = AITable.getVisibleFields(aiTable);
-        const columnIndicesSizeMap = getColumnIndicesSizeMap(aiTable, visibleFields);
-        const rowHeadWidth = aiTable.context?.rowHeadWidth?.() || 0;
-        return calculateAdaptiveFrozenColumnCountCore({
-            containerWidth,
-            rowHeadWidth,
-            visibleFields,
-            columnIndicesSizeMap,
-            frozenFieldId,
-            minUnfrozenWidth
-        });
-    }
-    catch (error) {
-        return AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
-    }
-}
-const freezeToThisColumn = (aiTable) => {
-    return {
-        type: 'freezeToThisColumn',
-        name: getStateI18nTextByKey(aiTable, AITableStateI18nKey.freezeToThisColumn),
-        icon: 'frozen',
-        exec: (aiTable, field) => {
-            const currentField = field();
-            const viewTable = aiTable;
-            setViewFrozenField(viewTable, currentField._id);
-        },
-        hidden: (aiTable, field) => {
-            if (aiTable.context?.readonly?.()) {
-                return true;
-            }
-            const currentField = field();
-            const currentFrozenFieldId = getFrozenFieldId(aiTable);
-            return currentFrozenFieldId === currentField._id;
-        },
-        disabled: (aiTable, field) => {
-            try {
-                const currentField = field();
-                const fields = aiTable.gridData().fields;
-                const currentFieldIndex = fields.findIndex((f) => f._id === currentField._id);
-                const visibleFields = AITable.getVisibleFields(aiTable);
-                const columnIndicesSizeMap = getColumnIndicesSizeMap(aiTable, visibleFields);
-                const containerWidth = aiTable.context?.containerRect()?.width || 0;
-                const rowHeadWidth = aiTable.context?.rowHeadWidth?.() || 0;
-                const actualFrozenCount = calculateAdaptiveFrozenColumnCountCore({
-                    containerWidth,
-                    rowHeadWidth,
-                    visibleFields,
-                    columnIndicesSizeMap,
-                    frozenFieldId: currentField._id,
-                    minUnfrozenWidth: AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH
-                });
-                if (actualFrozenCount < currentFieldIndex + 1) {
-                    // 超过可视区域禁用
-                    return true;
-                }
-                const currentFrozenFieldId = getFrozenFieldId(aiTable);
-                if (!currentFrozenFieldId && currentFieldIndex === 0) {
-                    // 默认第一列冻结列禁用
-                    return true;
-                }
-                return false;
-            }
-            catch (error) {
-                return false;
-            }
-        }
-    };
-};
-const restoreDefaultFrozenColumn = (aiTable) => {
-    return {
-        type: 'restoreDefaultFrozenColumn',
-        name: getStateI18nTextByKey(aiTable, AITableStateI18nKey.restoreDefaultFrozenColumn),
-        icon: 'frozen',
-        exec: (aiTable, field) => {
-            const viewTable = aiTable;
-            setViewFrozenField(viewTable, undefined);
-        },
-        hidden: (aiTable, field) => {
-            if (aiTable.context?.readonly?.()) {
-                return true;
-            }
-            const currentField = field();
-            const currentFrozenFieldId = getFrozenFieldId(aiTable);
-            if (!currentFrozenFieldId) {
-                return true;
-            }
-            return currentField._id !== currentFrozenFieldId;
-        }
-    };
-};
-
 function addField(aiTable, field, originId, isDuplicate) {
     const operation = {
         type: ActionName.AddField,
@@ -1187,18 +943,6 @@ function addField(aiTable, field, originId, isDuplicate) {
     }
     aiTable.apply(operation);
 }
-function moveField(aiTable, path, newPath) {
-    if (isPathEqual(path, newPath)) {
-        return;
-    }
-    const fields = aiTable.gridData().fields;
-    const activeView = aiTable.views().find((item) => item._id === aiTable.activeViewId());
-    const sourceField = fields[path[0]];
-    const currentFrozenFieldId = getFrozenFieldId(aiTable);
-    adjustFrozenFieldAfterMove(aiTable, path[0], newPath[0], currentFrozenFieldId);
-    const position = getFieldPositionInView(activeView._id, fields, path, newPath);
-    setField(aiTable, { positions: { ...sourceField.positions, [activeView._id]: position } }, [sourceField._id]);
-}
 function adjustFrozenFieldAfterMove(aiTable, sourceIndex, targetIndex, currentFrozenFieldId) {
     if (!currentFrozenFieldId) {
         return;
@@ -1277,7 +1021,6 @@ function setField(aiTable, value, path) {
 }
 const FieldActions = {
     addField,
-    moveField,
     removeField,
     setField,
     setFieldWidth,
@@ -1450,207 +1193,149 @@ function buildSetRecordPositionsActon(aiTable, positions, path) {
     };
     return action;
 }
-function setRecordPositions(aiTable, positions, path) {
-    const operation = buildSetRecordPositionsActon(aiTable, positions, path);
-    aiTable.apply(operation);
-}
-const PositionsActions = {
-    setRecordPositions
-};
-
-function updateFieldValues$1(aiTable, options) {
-    let operations = [];
-    (options || []).forEach((option) => {
-        const field = AITableQueries.getField(aiTable, [option.path[1]]);
-        const fieldModel = field && FieldModelMap[field.type];
-        if (fieldModel && fieldModel.isValid(option.value)) {
-            const operation = {
-                type: ActionName.UpdateFieldValue,
-                newFieldValue: option.value,
-                path: option.path
-            };
-            operations.push(operation);
-        }
-        else {
-            console.error(`Invalid field value at update field value. invalidFieldType: ${field?.type}, value: ${option.value}, field_id: ${option.path[1]}`);
-        }
-    });
-    aiTable.apply(operations);
-}
-function updateSystemFieldValues(aiTable, options) {
-    const operations = [];
-    (options || []).forEach((option) => {
-        const operation = {
-            type: ActionName.UpdateSystemFieldValue,
-            updatedInfo: option.updatedInfo,
-            path: option.path
-        };
-        operations.push(operation);
+function resetAllRecordsPositions(aiTable) {
+    const activeViewId = aiTable.activeViewId();
+    const activeView = aiTable.views().find((view) => view._id === activeViewId);
+    const records = aiTable.records();
+    const recordsIndexMap = new Map(records.map((item, index) => [item._id, index]));
+    const sortedRecords = sortRecordsByConditions(aiTable, records, activeView, []);
+    const actions = [];
+    const positions = insertAtEnd(0, sortedRecords.length);
+    sortedRecords.forEach((record, index) => {
+        const action = buildSetRecordPositionsActon(aiTable, { [activeView._id]: positions[index] }, [recordsIndexMap.get(record._id)]);
+        actions.push(action);
     });
-    aiTable.apply(operations);
-}
-function addRecord(aiTable, record) {
-    addRecords$1(aiTable, [record]);
+    aiTable.apply(actions);
 }
-function addRecords$1(aiTable, records, options) {
-    const invalidFieldValues = [];
-    const positions = getNewRecordsPosition(aiTable, options);
-    records.forEach((record, index) => {
-        Object.entries(record.values).every(([fieldId, value]) => {
-            const field = AITableQueries.getField(aiTable, [fieldId]);
-            const fieldModel = field && FieldModelMap[field.type];
-            const result = fieldModel ? fieldModel.isValid(value) : false;
-            if (!result) {
-                invalidFieldValues.push(`field_id: ${fieldId}, field_type: ${field?.type}, value: ${value}`);
-            }
-            return result;
-        });
-    });
-    if (invalidFieldValues.length) {
-        console.error(`Invalid field values at add records. invalidFieldValues: ${invalidFieldValues}`);
-        return;
-    }
-    records.forEach((record, index) => {
-        record.positions = positions[index];
-        const operation = {
-            type: ActionName.AddRecord,
-            record
-        };
-        aiTable.apply(operation);
+function resetAllFieldsPositions(aiTable) {
+    const activeViewId = aiTable.activeViewId();
+    const activeView = aiTable.views().find((view) => view._id === activeViewId);
+    const fields = aiTable.fields();
+    const sortedFields = getSortFields(aiTable, fields, activeView);
+    const actions = [];
+    const positions = insertAtEnd(0, sortedFields.length);
+    sortedFields.forEach((item, index) => {
+        const action = buildSetFieldAction(aiTable, { positions: { ...item.positions, [activeView._id]: positions[index] } }, [item._id]);
+        if (action) {
+            actions.push(action);
+        }
     });
+    aiTable.apply(actions);
 }
-function removeRecord(aiTable, path) {
-    const operation = {
-        type: ActionName.RemoveRecord,
-        path
-    };
+function setRecordPositions(aiTable, positions, path) {
+    const operation = buildSetRecordPositionsActon(aiTable, positions, path);
     aiTable.apply(operation);
 }
-const RecordActions = {
-    addRecord,
-    addRecords: addRecords$1,
-    removeRecord,
-    updateFieldValues: updateFieldValues$1,
-    updateSystemFieldValues
+const PositionsActions = {
+    setRecordPositions,
+    resetAllRecordsPositions,
+    resetAllFieldsPositions
 };
 
-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);
+const DEFAULT_INITIAL_GAP = 65536;
+const DEFAULT_PRECISION_THRESHOLD = 1;
+function insertAtStart(firstPosition, count = 1, initialGap = DEFAULT_INITIAL_GAP) {
+    const positions = [];
+    for (let i = 0; i < count; i++) {
+        positions.push(firstPosition - (count - i) * initialGap);
+    }
+    return positions;
 }
-// 折叠
-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 insertAtEnd(lastPosition, count = 1, initialGap = DEFAULT_INITIAL_GAP) {
+    const positions = [];
+    for (let i = 0; i < count; i++) {
+        positions.push(lastPosition + (i + 1) * initialGap);
+    }
+    return positions;
 }
-// 添加分组
-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.');
+function insertBetween(prevPosition, nextPosition, count = 1, precisionThreshold = DEFAULT_PRECISION_THRESHOLD) {
+    const gap = nextPosition - prevPosition;
+    if (gap <= 0) {
+        return {
+            success: false,
+            positions: [],
+            needsReorganization: true,
+            reason: `Invalid gap: ${gap}, previous position ${prevPosition} must be less than next position ${nextPosition}`
+        };
     }
-    // 层级限制
-    if (currentGroups.length >= AI_TABLE_GROUP_MAX_LEVEL) {
-        throw new Error(`The maximum number of groups is ${AI_TABLE_GROUP_MAX_LEVEL}.`);
+    const subGap = gap / (count + 1);
+    if (subGap < precisionThreshold) {
+        return {
+            success: false,
+            positions: [],
+            needsReorganization: true,
+            reason: `Insufficient precision: current gap ${subGap}, but threshold is ${precisionThreshold}`
+        };
     }
-    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 positions = [];
+    for (let i = 0; i < count; i++) {
+        positions.push(prevPosition + (i + 1) * subGap);
     }
-    const newGroups = [...currentGroups];
-    const [movedItem] = newGroups.splice(fromIndex, 1);
-    newGroups.splice(toIndex, 0, movedItem);
-    setViewGroup(aiTable, newGroups);
-}
-// 清空分组
-function clearAllGroups(aiTable) {
-    setViewGroup(aiTable, null);
+    return {
+        success: true,
+        positions,
+        needsReorganization: false,
+        context: {
+            prevPosition,
+            nextPosition,
+            availableGap: gap,
+            subGap,
+            requestedCount: count
+        }
+    };
 }
-const GroupActions = {
-    setViewGroup,
-    setCollapsedGroup,
-    toggleGroupCollapse,
-    addGroupField,
-    removeGroupField,
-    updateGroupFieldDirection,
-    reorderGroupFields,
-    clearAllGroups
-};
 
-const Actions = {
-    ...GeneralActions,
-    ...RecordActions,
-    ...FieldActions,
-    ...ViewActions,
-    ...PositionsActions,
-    ...GroupActions
+var AITableStateI18nKey;
+(function (AITableStateI18nKey) {
+    AITableStateI18nKey["copyField"] = "copyField";
+    AITableStateI18nKey["removeRecords"] = "removeRecords";
+    AITableStateI18nKey["copy"] = "copy";
+    AITableStateI18nKey["copySuffix"] = "copySuffix";
+    AITableStateI18nKey["paste"] = "paste";
+    AITableStateI18nKey["invalidPasteContent"] = "invalidPasteContent";
+    AITableStateI18nKey["tableView"] = "tableView";
+    AITableStateI18nKey["editField"] = "editField";
+    AITableStateI18nKey["removeField"] = "removeField";
+    AITableStateI18nKey["pasteOverMaxRecords"] = "pasteOverMaxRecords";
+    AITableStateI18nKey["pasteOverMaxFields"] = "pasteOverMaxFields";
+    AITableStateI18nKey["insertUpward"] = "insertUpward";
+    AITableStateI18nKey["insertDownward"] = "insertDownward";
+    AITableStateI18nKey["upward"] = "upward";
+    AITableStateI18nKey["downward"] = "downward";
+    AITableStateI18nKey["freezeToThisColumn"] = "freezeToThisColumn";
+    AITableStateI18nKey["restoreDefaultFrozenColumn"] = "restoreDefaultFrozenColumn";
+})(AITableStateI18nKey || (AITableStateI18nKey = {}));
+const AITableStateI18nText = {
+    [AITableStateI18nKey.copyField]: '复制列',
+    [AITableStateI18nKey.removeRecords]: '删除行',
+    [AITableStateI18nKey.copy]: '复制',
+    [AITableStateI18nKey.copySuffix]: '副本',
+    [AITableStateI18nKey.paste]: '粘贴',
+    [AITableStateI18nKey.invalidPasteContent]: '粘贴内容不符合当前类型',
+    [AITableStateI18nKey.tableView]: '表格视图',
+    [AITableStateI18nKey.editField]: '编辑列',
+    [AITableStateI18nKey.removeField]: '删除列',
+    [AITableStateI18nKey.pasteOverMaxRecords]: '粘贴数据超过最大行数',
+    [AITableStateI18nKey.pasteOverMaxFields]: '粘贴数据超过最大列数',
+    [AITableStateI18nKey.insertUpward]: '向上插入',
+    [AITableStateI18nKey.insertDownward]: '向下插入',
+    [AITableStateI18nKey.upward]: '行',
+    [AITableStateI18nKey.downward]: '行',
+    [AITableStateI18nKey.freezeToThisColumn]: '冻结至此列',
+    [AITableStateI18nKey.restoreDefaultFrozenColumn]: '恢复默认冻结列'
+};
+const getDefaultI18nTextByKey = (key) => {
+    return AITableStateI18nText[key] || key;
+};
+const getStateI18nTextByKey = (aiTable, key) => {
+    if (aiTable.getI18nTextByKey) {
+        const customText = aiTable.getI18nTextByKey(key);
+        if (customText) {
+            return customText;
+        }
+    }
+    const defaultText = getDefaultI18nTextByKey(key);
+    return defaultText;
 };
 
 function isPathEqual(path, another) {
@@ -1720,7 +1405,7 @@ function getMaxPosition(data, activeViewId) {
             maxPosition = item.positions[activeViewId];
         }
         return maxPosition;
-    }, 0);
+    }, Number.MIN_SAFE_INTEGER);
 }
 function addView(aiTable, type, viewId) {
     const newId = idCreator();
@@ -1789,108 +1474,122 @@ function sortViews(data) {
     return [...data].sort((a, b) => (a.position ?? data.indexOf(a)) - (b.position ?? data.indexOf(b)));
 }
 
-function findNextRecordForTargetInOriginalRecords(aiTable, targetRecordId) {
+function findNextItemByPosition(aiTable, targetId, items, itemsMap) {
     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;
+    const targetItem = itemsMap[targetId];
+    const targetPosition = targetItem.positions[viewId] || 0;
+    let nextItem = null;
+    for (const item of items) {
+        const pos = item.positions[viewId] || 0;
+        if (pos > targetPosition && (nextItem === null || pos < nextItem.positions[viewId])) {
+            nextItem = item;
         }
     }
-    return nextRecord;
+    return nextItem;
 }
-function findPrevRecordForTargetInOriginalRecords(aiTable, targetRecordId) {
+function findMaxItemByPosition(aiTable, items) {
     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;
+    let maxItem = items[0];
+    for (const item of items) {
+        const pos = item.positions[viewId] || 0;
+        if (pos > maxItem.positions[viewId]) {
+            maxItem = item;
         }
     }
-    return prevRecord;
+    return maxItem;
 }
-function getPositionByAfterOrBeforeRecordId(aiTable, options) {
-    const recordsMap = aiTable.recordsMap();
+function findPrevItemByPosition(aiTable, targetId, items, itemsMap) {
+    const viewId = aiTable.activeViewId();
+    const targetItem = itemsMap[targetId];
+    const targetPosition = targetItem.positions[viewId] || 0;
+    let prevItem = null;
+    for (const item of items) {
+        const pos = item.positions[viewId] || 0;
+        if (pos < targetPosition && (prevItem === null || pos > prevItem.positions[viewId])) {
+            prevItem = item;
+        }
+    }
+    return prevItem;
+}
+function getPreviousAndNextPosition(aiTable, options, items, itemsMap) {
     const activeViewId = aiTable.activeViewId();
-    const originalRecords = aiTable.records();
-    const { afterRecordId, beforeRecordId } = options;
-    let targetPosition = 0;
-    let prevPosition = 0;
-    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;
+    const { afterItemId, beforeItemId } = options;
+    let nextPosition = null;
+    let previousPosition = null;
+    if (afterItemId) {
+        const previousItem = itemsMap[afterItemId];
+        if (!previousItem) {
+            throw new Error(`Target item with id ${afterItemId} not found`);
         }
-        else {
-            // 最后一个
-            targetPosition = getMaxPosition(originalRecords, activeViewId) + 1;
+        previousPosition = previousItem.positions[activeViewId] || 0;
+        const nextItem = findNextItemByPosition(aiTable, afterItemId, items, itemsMap);
+        if (nextItem !== null) {
+            nextPosition = nextItem.positions[activeViewId] || 0;
         }
     }
-    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 if (beforeItemId) {
+        const nextItem = itemsMap[beforeItemId];
+        if (!nextItem) {
+            throw new Error(`Target item with id ${beforeItemId} not found`);
         }
-        else {
-            // 第一个
-            prevPosition = targetPosition - 1;
+        nextPosition = nextItem.positions[activeViewId] || 0;
+        const previousItem = findPrevItemByPosition(aiTable, beforeItemId, items, itemsMap);
+        if (previousItem !== null) {
+            previousPosition = previousItem.positions[activeViewId] || 0;
         }
     }
     else {
-        throw new Error('Either afterRecordId or beforeRecordId must be provided');
+        const maxItem = findMaxItemByPosition(aiTable, items);
+        previousPosition = maxItem.positions[activeViewId] || 0;
     }
     return {
-        targetPosition,
-        prevPosition
+        nextPosition,
+        previousPosition
     };
 }
-function getNewRecordsPosition(aiTable, options) {
-    options = options || {};
-    if (!options.afterRecordId && !options.beforeRecordId) {
-        options.afterRecordId = aiTable.gridData().records[aiTable.gridData().records.length - 1]._id;
+function getCurrentViewPositions(aiTable, options, items, itemsMap) {
+    const { previousPosition, nextPosition } = getPreviousAndNextPosition(aiTable, options, items, itemsMap);
+    const count = options.count || 1;
+    let positions = [];
+    if (options.beforeItemId && previousPosition === null && nextPosition !== null) {
+        positions = insertAtStart(nextPosition, count);
+    }
+    else if (options.afterItemId && nextPosition === null && previousPosition !== null) {
+        positions = insertAtEnd(previousPosition, count);
+    }
+    else if (!options.afterItemId && !options.beforeItemId && nextPosition === null && previousPosition !== null) {
+        positions = insertAtEnd(previousPosition, count);
+    }
+    else {
+        const result = insertBetween(previousPosition, nextPosition, count);
+        positions = result.positions;
+        if (result.reason) {
+            console.log(result.reason);
+        }
+    }
+    return positions;
+}
+function getNewItemsPosition(aiTable, options, items, itemsMap) {
+    let positions = getCurrentViewPositions(aiTable, options, items, itemsMap);
+    if (positions.length === 0) {
+        return [];
     }
-    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);
+        viewsMaxPosition[view._id] = getMaxPosition(items, view._id);
     });
-    const viewPositions = positionsOfItems.map((itemPositions) => {
+    const viewPositions = positions.map((itemPosition) => {
         const viewPositions = {};
         views.forEach((view) => {
             if (view._id === activeViewId) {
-                viewPositions[view._id] = itemPositions;
+                viewPositions[view._id] = itemPosition;
             }
             else {
-                viewsMaxPosition[view._id] += 1;
+                const maxPosition = viewsMaxPosition[view._id];
+                const newMaxPosition = insertAtEnd(maxPosition, 1);
+                viewsMaxPosition[view._id] += newMaxPosition[0];
                 viewPositions[view._id] = viewsMaxPosition[view._id];
             }
         });
@@ -1898,6 +1597,212 @@ function getNewRecordsPosition(aiTable, options) {
     });
     return viewPositions;
 }
+
+function updateFieldValues$1(aiTable, options) {
+    let operations = [];
+    (options || []).forEach((option) => {
+        const field = AITableQueries.getField(aiTable, [option.path[1]]);
+        const fieldModel = field && FieldModelMap[field.type];
+        if (fieldModel && fieldModel.isValid(option.value)) {
+            const operation = {
+                type: ActionName.UpdateFieldValue,
+                newFieldValue: option.value,
+                path: option.path
+            };
+            operations.push(operation);
+        }
+        else {
+            console.error(`Invalid field value at update field value. invalidFieldType: ${field?.type}, value: ${option.value}, field_id: ${option.path[1]}`);
+        }
+    });
+    aiTable.apply(operations);
+}
+function updateSystemFieldValues(aiTable, options) {
+    const operations = [];
+    (options || []).forEach((option) => {
+        const operation = {
+            type: ActionName.UpdateSystemFieldValue,
+            updatedInfo: option.updatedInfo,
+            path: option.path
+        };
+        operations.push(operation);
+    });
+    aiTable.apply(operations);
+}
+function addRecord(aiTable, record) {
+    addRecords$1(aiTable, [record]);
+}
+function addRecords$1(aiTable, records, options) {
+    const invalidFieldValues = [];
+    const viewPositionOptions = {
+        afterItemId: options?.afterRecordId,
+        beforeItemId: options?.beforeRecordId,
+        count: options?.count
+    };
+    let positions = getNewItemsPosition(aiTable, viewPositionOptions, aiTable.records(), aiTable.recordsMap());
+    if (positions.length === 0) {
+        PositionsActions.resetAllRecordsPositions(aiTable);
+        positions = getNewItemsPosition(aiTable, viewPositionOptions, aiTable.records(), aiTable.recordsMap());
+        console.log('Reset all records positions');
+    }
+    records.forEach((record, index) => {
+        Object.entries(record.values).every(([fieldId, value]) => {
+            const field = AITableQueries.getField(aiTable, [fieldId]);
+            const fieldModel = field && FieldModelMap[field.type];
+            const result = fieldModel ? fieldModel.isValid(value) : false;
+            if (!result) {
+                invalidFieldValues.push(`field_id: ${fieldId}, field_type: ${field?.type}, value: ${value}`);
+            }
+            return result;
+        });
+    });
+    if (invalidFieldValues.length) {
+        console.error(`Invalid field values at add records. invalidFieldValues: ${invalidFieldValues}`);
+        return;
+    }
+    records.forEach((record, index) => {
+        record.positions = positions[index];
+        const operation = {
+            type: ActionName.AddRecord,
+            record
+        };
+        aiTable.apply(operation);
+    });
+}
+function removeRecord(aiTable, path) {
+    const operation = {
+        type: ActionName.RemoveRecord,
+        path
+    };
+    aiTable.apply(operation);
+}
+const RecordActions = {
+    addRecord,
+    addRecords: addRecords$1,
+    removeRecord,
+    updateFieldValues: updateFieldValues$1,
+    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,
+    ...GroupActions
+};
+
 function getParentGroupValuesByGroupId(aiTable, groupId) {
     const parentGroups = getParentLinearRowGroups(aiTable, groupId);
     return parentGroups.reduce((pre, cur) => {
@@ -2143,7 +2048,18 @@ function updateFieldValues(aiTable, options, updatedInfo) {
     }
 }
 
-function moveRecords(aiTable, options, updatedInfo) {
+function moveRecords(aiTable, options) {
+    const viewPositionOptions = {
+        afterItemId: options.afterRecordId,
+        beforeItemId: options.beforeRecordId,
+        count: options.recordIds.length
+    };
+    let positions = getCurrentViewPositions(aiTable, viewPositionOptions, aiTable.records(), aiTable.recordsMap());
+    if (positions.length === 0) {
+        PositionsActions.resetAllRecordsPositions(aiTable);
+        positions = getCurrentViewPositions(aiTable, viewPositionOptions, aiTable.records(), aiTable.recordsMap());
+        console.log('Reset all records positions');
+    }
     const activeViewId = aiTable.activeViewId();
     const activeView = aiTable.views().find((view) => view._id === activeViewId);
     const { recordIds, afterRecordId, beforeRecordId } = options;
@@ -2157,19 +2073,13 @@ function moveRecords(aiTable, options, updatedInfo) {
         }
         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;
-    sortedSourceRecords.forEach((record) => {
+    sortedSourceRecords.forEach((record, index) => {
         const sourceIndex = recordsIndexMap.get(record._id);
         if (sourceIndex === undefined) {
             throw new Error(`Record with id ${record._id} not found`);
@@ -2184,9 +2094,7 @@ function moveRecords(aiTable, options, updatedInfo) {
             });
             Actions.updateFieldValues(aiTable, updateFieldValues);
         }
-        Actions.setRecordPositions(aiTable, { [activeViewId]: nextPosition }, [sourceIndex]);
-        prevPosition = nextPosition;
-        nextPosition = (prevPosition + targetPosition) / 2;
+        Actions.setRecordPositions(aiTable, { [activeViewId]: positions[index] }, [sourceIndex]);
     });
 }
 
@@ -2248,29 +2156,96 @@ function mergeSorts(activeView) {
 const FLUSHING = new WeakMap();
 
 function moveFields(aiTable, options) {
-    const { path, newPath } = options;
-    Actions.moveField(aiTable, path, newPath);
+    const viewPositionOptions = {
+        afterItemId: options.afterFieldId,
+        beforeItemId: options.beforeFieldId,
+        count: options.fieldIds.length
+    };
+    let positions = getCurrentViewPositions(aiTable, viewPositionOptions, aiTable.fields(), aiTable.fieldsMap());
+    if (positions.length === 0) {
+        PositionsActions.resetAllFieldsPositions(aiTable);
+        positions = getCurrentViewPositions(aiTable, viewPositionOptions, aiTable.fields(), aiTable.fieldsMap());
+        console.log('Reset all fields positions');
+    }
+    const activeViewId = aiTable.activeViewId();
+    const activeView = aiTable.views().find((view) => view._id === activeViewId);
+    const { fieldIds, afterFieldId, beforeFieldId } = options;
+    const originalFields = aiTable.fields();
+    const fieldsIndexMap = new Map(originalFields.map((field, index) => [field._id, index]));
+    const sourceFields = [];
+    fieldIds.forEach((id) => {
+        const index = fieldsIndexMap.get(id);
+        if (index === undefined) {
+            return;
+        }
+        sourceFields.push(originalFields[index]);
+    });
+    const sortedSourceFields = sortByViewPosition(sourceFields, activeView);
+    const actions = [];
+    sortedSourceFields.forEach((field, index) => {
+        const action = buildSetFieldAction(aiTable, { positions: { ...field.positions, [activeViewId]: positions[index] } }, [field._id]);
+        if (action) {
+            actions.push(action);
+        }
+    });
+    aiTable.apply(actions);
+}
+
+function getFieldPositionInView(viewId, fields, path, newPath) {
+    const targetPosition = fields[newPath[0]].positions[viewId];
+    let newPosition = 0;
+    if (path[0] > newPath[0]) {
+        const prevPath = newPath[0] - 1;
+        if (prevPath >= 0) {
+            const targetPrevField = fields[prevPath];
+            const targetPrevPosition = targetPrevField.positions[viewId];
+            newPosition = (targetPosition + targetPrevPosition) / 2;
+        }
+        else {
+            const firstField = fields[0];
+            newPosition = firstField.positions[viewId] - 0.1;
+        }
+    }
+    else {
+        const nextPath = newPath[0] + 1;
+        if (fields.length > nextPath) {
+            const targetNextField = fields[nextPath];
+            const targetNextPosition = targetNextField.positions[viewId];
+            newPosition = (targetPosition + targetNextPosition) / 2;
+        }
+        else {
+            const lastField = fields[fields.length - 1];
+            const lastPosition = lastField.positions[viewId] + 1;
+            newPosition = (targetPosition + lastPosition) / 2;
+        }
+    }
+    return newPosition;
+}
+function getFieldsSizeMap(fields, activeView) {
+    const fieldsSizeMap = {};
+    fields?.forEach((field) => {
+        fieldsSizeMap[field._id] = field.widths?.[activeView._id];
+    });
+    return fieldsSizeMap;
 }
 
 function addFields(aiTable, options) {
     const { defaultValue, isDuplicate, originId } = options;
-    const fields = aiTable.gridData().fields;
     const fieldsMap = aiTable.fieldsMap();
-    const activeViewId = aiTable.activeViewId();
     const newField = { ...defaultValue };
     if (fieldsMap[newField._id]) {
         newField._id = idCreator();
     }
+    const viewPositionOptions = { count: options.count || 1 };
     if (isDuplicate) {
-        const currentFieldIndex = fields.findIndex((item) => item._id === originId);
-        newField.positions = {
-            ...newField.positions,
-            [activeViewId]: getPosition(fields, activeViewId, currentFieldIndex)
-        };
+        viewPositionOptions.afterItemId = originId;
     }
-    else {
-        newField.positions = createPositions(aiTable.views(), aiTable.activeViewId(), aiTable.gridData().fields);
+    let positions = getNewItemsPosition(aiTable, viewPositionOptions, aiTable.fields(), aiTable.fieldsMap());
+    if (positions.length === 0) {
+        PositionsActions.resetAllFieldsPositions(aiTable);
+        positions = getNewItemsPosition(aiTable, viewPositionOptions, aiTable.fields(), aiTable.fieldsMap());
     }
+    newField.positions = positions[0];
     Actions.addField(aiTable, newField, originId, isDuplicate);
 }
 
@@ -2285,6 +2260,159 @@ const buildRemoveFieldItem = (aiTable, getUpdatedInfo) => {
     };
 };
 
+function getFrozenFieldId(aiTable) {
+    try {
+        const viewTable = aiTable;
+        const activeViewId = viewTable.activeViewId();
+        const activeView = viewTable.viewsMap()[activeViewId];
+        return activeView?.settings?.frozen_field_id;
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+function calculateAdaptiveFrozenColumnCountCore(config) {
+    const { containerWidth, rowHeadWidth, visibleFields, columnIndicesSizeMap, frozenFieldId, minUnfrozenWidth = AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH } = config;
+    if (visibleFields.length === 0) {
+        return AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
+    }
+    let targetFrozenCount;
+    if (frozenFieldId) {
+        const frozenFieldIndex = visibleFields.findIndex((field) => field._id === frozenFieldId);
+        if (frozenFieldIndex >= 0) {
+            targetFrozenCount = frozenFieldIndex + 1;
+        }
+        else {
+            targetFrozenCount = AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
+        }
+    }
+    else {
+        targetFrozenCount = AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
+    }
+    const availableWidth = containerWidth - rowHeadWidth;
+    const maxFrozenWidth = Math.max(0, availableWidth - minUnfrozenWidth);
+    let currentFrozenWidth = 0;
+    let actualFrozenCount = 0;
+    const maxPossibleCount = Math.min(targetFrozenCount, visibleFields.length);
+    for (let i = 0; i < maxPossibleCount; i++) {
+        const fieldWidth = columnIndicesSizeMap[i];
+        const newFrozenWidth = currentFrozenWidth + fieldWidth;
+        if (newFrozenWidth > maxFrozenWidth) {
+            if (i === 0) {
+                currentFrozenWidth = newFrozenWidth;
+                actualFrozenCount = AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
+            }
+            break;
+        }
+        currentFrozenWidth = newFrozenWidth;
+        actualFrozenCount = i + 1;
+    }
+    // 至少有一列冻结
+    if (actualFrozenCount < AI_TABLE_MIN_FROZEN_COLUMN_COUNT) {
+        actualFrozenCount = AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
+        if (visibleFields.length > 0) {
+            currentFrozenWidth = columnIndicesSizeMap[0];
+        }
+    }
+    return actualFrozenCount;
+}
+function calculateAdaptiveFrozenColumnCount(aiTable, containerWidth, minUnfrozenWidth = 200) {
+    try {
+        if (containerWidth <= 0) {
+            return AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
+        }
+        const frozenFieldId = getFrozenFieldId(aiTable);
+        const visibleFields = AITable.getVisibleFields(aiTable);
+        const columnIndicesSizeMap = getColumnIndicesSizeMap(aiTable, visibleFields);
+        const rowHeadWidth = aiTable.context?.rowHeadWidth?.() || 0;
+        return calculateAdaptiveFrozenColumnCountCore({
+            containerWidth,
+            rowHeadWidth,
+            visibleFields,
+            columnIndicesSizeMap,
+            frozenFieldId,
+            minUnfrozenWidth
+        });
+    }
+    catch (error) {
+        return AI_TABLE_MIN_FROZEN_COLUMN_COUNT;
+    }
+}
+const freezeToThisColumn = (aiTable) => {
+    return {
+        type: 'freezeToThisColumn',
+        name: getStateI18nTextByKey(aiTable, AITableStateI18nKey.freezeToThisColumn),
+        icon: 'frozen',
+        exec: (aiTable, field) => {
+            const currentField = field();
+            const viewTable = aiTable;
+            setViewFrozenField(viewTable, currentField._id);
+        },
+        hidden: (aiTable, field) => {
+            if (aiTable.context?.readonly?.()) {
+                return true;
+            }
+            const currentField = field();
+            const currentFrozenFieldId = getFrozenFieldId(aiTable);
+            return currentFrozenFieldId === currentField._id;
+        },
+        disabled: (aiTable, field) => {
+            try {
+                const currentField = field();
+                const fields = aiTable.gridData().fields;
+                const currentFieldIndex = fields.findIndex((f) => f._id === currentField._id);
+                const visibleFields = AITable.getVisibleFields(aiTable);
+                const columnIndicesSizeMap = getColumnIndicesSizeMap(aiTable, visibleFields);
+                const containerWidth = aiTable.context?.containerRect()?.width || 0;
+                const rowHeadWidth = aiTable.context?.rowHeadWidth?.() || 0;
+                const actualFrozenCount = calculateAdaptiveFrozenColumnCountCore({
+                    containerWidth,
+                    rowHeadWidth,
+                    visibleFields,
+                    columnIndicesSizeMap,
+                    frozenFieldId: currentField._id,
+                    minUnfrozenWidth: AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH
+                });
+                if (actualFrozenCount < currentFieldIndex + 1) {
+                    // 超过可视区域禁用
+                    return true;
+                }
+                const currentFrozenFieldId = getFrozenFieldId(aiTable);
+                if (!currentFrozenFieldId && currentFieldIndex === 0) {
+                    // 默认第一列冻结列禁用
+                    return true;
+                }
+                return false;
+            }
+            catch (error) {
+                return false;
+            }
+        }
+    };
+};
+const restoreDefaultFrozenColumn = (aiTable) => {
+    return {
+        type: 'restoreDefaultFrozenColumn',
+        name: getStateI18nTextByKey(aiTable, AITableStateI18nKey.restoreDefaultFrozenColumn),
+        icon: 'frozen',
+        exec: (aiTable, field) => {
+            const viewTable = aiTable;
+            setViewFrozenField(viewTable, undefined);
+        },
+        hidden: (aiTable, field) => {
+            if (aiTable.context?.readonly?.()) {
+                return true;
+            }
+            const currentField = field();
+            const currentFrozenFieldId = getFrozenFieldId(aiTable);
+            if (!currentFrozenFieldId) {
+                return true;
+            }
+            return currentField._id !== currentFrozenFieldId;
+        }
+    };
+};
+
 const withState = (aiTable) => {
     const viewTable = aiTable;
     viewTable.actions = [];
@@ -2472,16 +2600,12 @@ const CopyCellsItem = (aiTable, actions) => {
         shortcutKey: isMac() ? `⌘ + C` : `Ctrl + C`,
         icon: 'copy',
         exec: (aiTable, targetName, position, notifyService) => {
-            const clipboardData = buildClipboardData(aiTable);
-            if (clipboardData) {
-                writeToClipboard(clipboardData).then(() => {
-                    const copiedCellsCount = aiTable.selection().selectedCells.size;
-                    const message = getI18nTextByKey(aiTable, AITableGridI18nKey.copiedCells).replace('{count}', copiedCellsCount.toString());
-                    notifyService.success(message, undefined, {
-                        placement: 'bottomLeft'
-                    });
-                });
-            }
+            document.dispatchEvent(new ClipboardEvent('copy', {
+                clipboardData: new DataTransfer(),
+                bubbles: true,
+                cancelable: true,
+                composed: true
+            }));
         }
     };
 };
@@ -2492,16 +2616,12 @@ const PasteCellsItem = (aiTable, actions) => {
         shortcutKey: isMac() ? `⌘ + V` : `Ctrl + V`,
         icon: 'paste',
         exec: async (aiTable, targetName, position, notifyService) => {
-            writeToAITable(aiTable, actions).then((result) => {
-                if (result.isPasteOverMaxRecords || result.isPasteOverMaxFields) {
-                    return;
-                }
-                if (!result.isPasteSuccess) {
-                    notifyService.error(getStateI18nTextByKey(aiTable, AITableStateI18nKey.invalidPasteContent), undefined, {
-                        placement: 'bottomLeft'
-                    });
-                }
-            });
+            document.dispatchEvent(new ClipboardEvent('paste', {
+                clipboardData: window.dataTransfer,
+                bubbles: true,
+                cancelable: true,
+                composed: true
+            }));
         }
     };
 };
@@ -2512,5 +2632,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, buildLinearRows, buildRecordsByView, buildRecordsWithWillMoveRecords, buildRemoveFieldItem, buildSetFieldAction, buildSetRecordPositionsActon, buildSorts, calculateAdaptiveFrozenColumnCount, checkConditions, createMultiplePositions, createPositions, createSharedType, doFilter, findNextRecordForTargetInOriginalRecords, findPrevRecordForTargetInOriginalRecords, freezeToThisColumn, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getFrozenFieldId, getGroupRecordLength, getMaxPosition, getNewRecordsPosition, getParentGroupValuesByGroupId, getParentLinearRowGroups, getPosition, getPositionByAfterOrBeforeRecordId, getPositions, getPrevRecordIdByAddGroupId, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getStateI18nTextByKey, isPathEqual, isSameParentGroup, mergeSorts, moveFields, moveRecords, removeView, restoreDefaultFrozenColumn, sortRecordsByConditions, 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, buildLinearRows, buildRecordsByView, buildRecordsWithWillMoveRecords, buildRemoveFieldItem, buildSetFieldAction, buildSetRecordPositionsActon, buildSorts, calculateAdaptiveFrozenColumnCount, checkConditions, createMultiplePositions, createPositions, createSharedType, doFilter, freezeToThisColumn, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getFrozenFieldId, getGroupRecordLength, getMaxPosition, getParentGroupValuesByGroupId, getParentLinearRowGroups, getPosition, getPositions, getPrevRecordIdByAddGroupId, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getStateI18nTextByKey, insertAtEnd, insertAtStart, insertBetween, isPathEqual, isSameParentGroup, mergeSorts, moveFields, moveRecords, removeView, restoreDefaultFrozenColumn, sortRecordsByConditions, sortViews, toSharedType, translateYjsEvent, updateFieldAndValues, updateFieldValues, withState };
 //# sourceMappingURL=ai-table-state.mjs.map