@ai-table/state 0.2.5 → 0.3.1

package/fesm2022/ai-table-state.mjs

@@ -3,7 +3,7 @@ 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, 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, shortIdCreator, generateNewName, AI_TABLE_GROUP_MAX_LEVEL, idsCreator, shortIdsCreator, closeExpendCell, setSelection, buildNormalLinearRows, AITable, getColumnIndicesSizeMap, 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, getI18nTextByKey, AITableGridI18nKey, generateNewFieldName, 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,75 +858,6 @@ function getGroupRecordLength(aiTable, recordId, linearRows) {
     return 0;
 }
 
-function setView(aiTable, value, path) {
-    const view = aiTable.views().find((item) => item._id === path[0]);
-    if (view) {
-        const properties = {};
-        const newProperties = {};
-        for (const key in value) {
-            const k = key;
-            if (JSON.stringify(view[k]) !== JSON.stringify(value[k])) {
-                if (view.hasOwnProperty(k)) {
-                    properties[k] = view[k];
-                }
-                if (newProperties[k] !== null) {
-                    newProperties[k] = value[k];
-                }
-            }
-        }
-        const operation = {
-            type: ActionName.SetView,
-            properties,
-            newProperties,
-            path
-        };
-        aiTable.apply(operation);
-    }
-}
-function addView$1(aiTable, originId, newView, isDuplicate) {
-    const views = sortViews(aiTable.views());
-    const currentIndex = views.findIndex((item) => item._id === originId);
-    if (isDuplicate) {
-        const nextIndex = currentIndex + 1;
-        newView.position = ((views[currentIndex]?.position ?? currentIndex) + (views[nextIndex]?.position ?? nextIndex)) / 2;
-    }
-    else {
-        newView.position = currentIndex + 1;
-    }
-    const operation = {
-        type: ActionName.AddView,
-        view: newView,
-        isDuplicate
-    };
-    aiTable.apply(operation);
-}
-function removeView$1(aiTable, path) {
-    const operation = {
-        type: ActionName.RemoveView,
-        path
-    };
-    aiTable.apply(operation);
-}
-function setViewFrozenField(aiTable, frozenFieldId) {
-    const activeViewId = aiTable.activeViewId();
-    const activeView = aiTable.viewsMap()[activeViewId];
-    const currentSettings = activeView.settings || {};
-    const newSettings = {
-        ...currentSettings,
-        frozen_field_id: frozenFieldId
-    };
-    if (frozenFieldId === undefined) {
-        delete newSettings.frozen_field_id;
-    }
-    setView(aiTable, { settings: newSettings }, [activeViewId]);
-}
-const ViewActions = {
-    setView,
-    addView: addView$1,
-    removeView: removeView$1,
-    setViewFrozenField
-};
-
 function addField(aiTable, field, originId, isDuplicate) {
     const operation = {
         type: ActionName.AddField,
@@ -943,35 +874,6 @@ function addField(aiTable, field, originId, isDuplicate) {
     }
     aiTable.apply(operation);
 }
-function adjustFrozenFieldAfterMove(aiTable, sourceIndex, targetIndex, currentFrozenFieldId) {
-    if (!currentFrozenFieldId) {
-        return;
-    }
-    const fields = aiTable.gridData().fields;
-    const currentFrozenFieldIndex = fields.findIndex((field) => field._id === currentFrozenFieldId);
-    if (currentFrozenFieldIndex === -1) {
-        return;
-    }
-    // 最后冻结列拖动到非冻结区或冻结区，冻结列向左移动
-    if (sourceIndex === currentFrozenFieldIndex && targetIndex !== currentFrozenFieldIndex) {
-        const newFrozenFieldIndex = Math.max(0, currentFrozenFieldIndex - 1);
-        if (newFrozenFieldIndex < fields.length && newFrozenFieldIndex !== currentFrozenFieldIndex) {
-            const newFrozenField = fields[newFrozenFieldIndex];
-            setViewFrozenField(aiTable, newFrozenField._id);
-        }
-        else {
-            // 如果没有前一个字段，恢复默认冻结
-            setViewFrozenField(aiTable, undefined);
-        }
-        return;
-    }
-    // 冻结区拖动到最后冻结列后面，冻结列是被拖动列
-    if (sourceIndex < currentFrozenFieldIndex && targetIndex === currentFrozenFieldIndex) {
-        const newFrozenField = fields[sourceIndex];
-        setViewFrozenField(aiTable, newFrozenField._id);
-        return;
-    }
-}
 function setFieldWidth(aiTable, path, width) {
     const field = AITableQueries.getField(aiTable, path);
     setField(aiTable, { widths: { ...field.widths, [aiTable.activeViewId()]: width } }, [field._id]);
@@ -1185,7 +1087,96 @@ const GeneralActions = {
     }
 };
 
-function buildSetRecordPositionsActon(aiTable, positions, path) {
+function buildSetViewAction(aiTable, value, path) {
+    const view = aiTable.views().find((item) => item._id === path[0]);
+    if (view) {
+        const properties = {};
+        const newProperties = {};
+        for (const key in value) {
+            const k = key;
+            if (JSON.stringify(view[k]) !== JSON.stringify(value[k])) {
+                if (view.hasOwnProperty(k)) {
+                    properties[k] = view[k];
+                }
+                if (newProperties[k] !== null) {
+                    newProperties[k] = value[k];
+                }
+            }
+        }
+        const operation = {
+            type: ActionName.SetView,
+            properties,
+            newProperties,
+            path
+        };
+        return operation;
+    }
+    return null;
+}
+function setView(aiTable, value, path) {
+    const action = buildSetViewAction(aiTable, value, path);
+    if (action) {
+        aiTable.apply(action);
+    }
+}
+function addView$1(aiTable, originId, newView, isDuplicate) {
+    const views = sortViews(aiTable.views());
+    const currentIndex = views.findIndex((item) => item._id === originId);
+    if (isDuplicate) {
+        const prev = currentIndex >= 0 ? (views[currentIndex].position ?? currentIndex) : null;
+        const next = currentIndex + 1 < views.length ? (views[currentIndex + 1].position ?? currentIndex + 1) : null;
+        let newPos;
+        if (prev !== null && next === null) {
+            // 复制最后一个插入最后位置
+            newPos = insertAtEnd(prev, 1)[0];
+        }
+        else if (prev !== null && next !== null) {
+            // 插入中间
+            const result = insertBetween(prev, next, 1);
+            if (result.positions.length) {
+                newPos = result.positions[0];
+            }
+            else {
+                PositionsActions.resetAllViewsPositions(aiTable);
+                const reSort = sortViews(aiTable.views());
+                const idx = reSort.findIndex((item) => item._id === originId);
+                const prev2 = idx >= 0 ? (reSort[idx].position ?? idx) : 0;
+                const next2 = idx + 1 < reSort.length ? (reSort[idx + 1].position ?? idx + 1) : null;
+                newPos = next2 === null ? insertAtEnd(prev2, 1)[0] : insertBetween(prev2, next2, 1).positions[0];
+            }
+        }
+        else {
+            const maxPosition = getMaxPosition(views);
+            newPos = insertAtEnd(maxPosition, 1)[0];
+        }
+        newView.position = newPos;
+    }
+    else {
+        const maxPosition = getMaxPosition(views);
+        newView.position = insertAtEnd(maxPosition, 1)[0];
+    }
+    const operation = {
+        type: ActionName.AddView,
+        view: newView,
+        isDuplicate
+    };
+    aiTable.apply(operation);
+}
+function removeView$1(aiTable, path) {
+    const operation = {
+        type: ActionName.RemoveView,
+        path
+    };
+    aiTable.apply(operation);
+}
+const ViewActions = {
+    setView,
+    addView: addView$1,
+    removeView: removeView$1,
+    buildSetViewAction
+};
+
+function buildSetRecordPositionsAction(aiTable, positions, path) {
     const action = {
         type: ActionName.SetRecordPositions,
         positions,
@@ -1202,7 +1193,7 @@ function resetAllRecordsPositions(aiTable) {
     const actions = [];
     const positions = insertAtEnd(0, sortedRecords.length);
     sortedRecords.forEach((record, index) => {
-        const action = buildSetRecordPositionsActon(aiTable, { [activeView._id]: positions[index] }, [recordsIndexMap.get(record._id)]);
+        const action = buildSetRecordPositionsAction(aiTable, { [activeView._id]: positions[index] }, [recordsIndexMap.get(record._id)]);
         actions.push(action);
     });
     aiTable.apply(actions);
@@ -1222,14 +1213,27 @@ function resetAllFieldsPositions(aiTable) {
     });
     aiTable.apply(actions);
 }
+function resetAllViewsPositions(aiTable) {
+    const views = aiTable.views();
+    const positions = insertAtEnd(0, views.length);
+    const actions = [];
+    views.forEach((v, i) => {
+        const action = buildSetViewAction(aiTable, { position: positions[i] }, [v._id]);
+        if (action) {
+            actions.push(action);
+        }
+    });
+    aiTable.apply(actions);
+}
 function setRecordPositions(aiTable, positions, path) {
-    const operation = buildSetRecordPositionsActon(aiTable, positions, path);
+    const operation = buildSetRecordPositionsAction(aiTable, positions, path);
     aiTable.apply(operation);
 }
 const PositionsActions = {
     setRecordPositions,
     resetAllRecordsPositions,
-    resetAllFieldsPositions
+    resetAllFieldsPositions,
+    resetAllViewsPositions
 };
 
 const DEFAULT_INITIAL_GAP = 65536;
@@ -1400,9 +1404,19 @@ function getPosition(data, activeViewId, index) {
     return getPositions(activeViewId, data, index)[0];
 }
 function getMaxPosition(data, activeViewId) {
-    return data.reduce((maxPosition, item) => {
-        if (item.positions[activeViewId] > maxPosition) {
-            maxPosition = item.positions[activeViewId];
+    const first = data[0];
+    if (first && typeof first === 'object' && 'positions' in first && activeViewId) {
+        return data.reduce((maxPosition, item) => {
+            if (item.positions[activeViewId] > maxPosition) {
+                maxPosition = item.positions[activeViewId];
+            }
+            return maxPosition;
+        }, Number.MIN_SAFE_INTEGER);
+    }
+    return data.reduce((maxPosition, item, index) => {
+        const pos = typeof item.position === 'number' ? item.position : index;
+        if (pos > maxPosition) {
+            maxPosition = pos;
         }
         return maxPosition;
     }, Number.MIN_SAFE_INTEGER);
@@ -1434,7 +1448,7 @@ function addView(aiTable, type, viewId) {
     ViewActions.addView(aiTable, originViewId, newView, type === 'duplicate');
     const actions = [];
     aiTable.records().forEach((record, index) => {
-        const action = buildSetRecordPositionsActon(aiTable, { [newId]: record.positions[originViewId] }, [index]);
+        const action = buildSetRecordPositionsAction(aiTable, { [newId]: record.positions[originViewId] }, [index]);
         actions.push(action);
     });
     aiTable.fields().forEach((field) => {
@@ -1455,7 +1469,7 @@ function removeView(aiTable, records, fields, activeViewId) {
     ViewActions.removeView(aiTable, [activeViewId]);
     const actions = [];
     records.forEach((record, index) => {
-        const action = buildSetRecordPositionsActon(aiTable, { [activeViewId]: undefined }, [index]);
+        const action = buildSetRecordPositionsAction(aiTable, { [activeViewId]: undefined }, [index]);
         actions.push(action);
     });
     fields.forEach((field) => {
@@ -2098,7 +2112,7 @@ function moveRecords(aiTable, options) {
     });
 }
 
-function buildRecordsByView(aiTable, records, fields, activeView, sortKeysMap) {
+function buildRecordsByView(aiTable, records, fields, activeView) {
     const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
     const sorts = buildSorts(activeView);
     const renderRecords = buildRecordsWithWillMoveRecords(filteredRecords, aiTable.recordsWillMove());
@@ -2155,111 +2169,6 @@ function mergeSorts(activeView) {
 
 const FLUSHING = new WeakMap();
 
-function moveFields(aiTable, options) {
-    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 fieldsMap = aiTable.fieldsMap();
-    const newField = { ...defaultValue };
-    if (fieldsMap[newField._id]) {
-        newField._id = idCreator();
-    }
-    const viewPositionOptions = { count: options.count || 1 };
-    if (isDuplicate) {
-        viewPositionOptions.afterItemId = originId;
-    }
-    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);
-}
-
-const buildRemoveFieldItem = (aiTable, getUpdatedInfo) => {
-    return {
-        type: 'removeField',
-        name: getStateI18nTextByKey(aiTable, AITableStateI18nKey.removeField),
-        icon: 'trash',
-        exec: (aiTable, field) => {
-            Actions.removeField(aiTable, [field()._id]);
-        }
-    };
-};
-
 function getFrozenFieldId(aiTable) {
     try {
         const viewTable = aiTable;
@@ -2346,7 +2255,9 @@ const freezeToThisColumn = (aiTable) => {
         exec: (aiTable, field) => {
             const currentField = field();
             const viewTable = aiTable;
-            setViewFrozenField(viewTable, currentField._id);
+            ViewActions.setView(viewTable, {
+                settings: { ...viewTable.viewsMap()[viewTable.activeViewId()].settings, frozen_field_id: currentField._id }
+            }, [viewTable.activeViewId()]);
         },
         hidden: (aiTable, field) => {
             if (aiTable.context?.readonly?.()) {
@@ -2397,7 +2308,9 @@ const restoreDefaultFrozenColumn = (aiTable) => {
         icon: 'frozen',
         exec: (aiTable, field) => {
             const viewTable = aiTable;
-            setViewFrozenField(viewTable, undefined);
+            ViewActions.setView(viewTable, {
+                settings: { ...viewTable.viewsMap()[viewTable.activeViewId()].settings, frozen_field_id: undefined }
+            }, [viewTable.activeViewId()]);
         },
         hidden: (aiTable, field) => {
             if (aiTable.context?.readonly?.()) {
@@ -2413,6 +2326,169 @@ const restoreDefaultFrozenColumn = (aiTable) => {
     };
 };
 
+function moveFields(aiTable, options) {
+    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);
+        }
+    });
+    const currentFrozenFieldId = getFrozenFieldId(aiTable);
+    if (currentFrozenFieldId) {
+        adjustFrozenFieldAfterMove(aiTable, currentFrozenFieldId, sortedSourceFields[0]._id, {
+            afterFieldId,
+            beforeFieldId
+        });
+    }
+    aiTable.apply(actions);
+}
+function adjustFrozenFieldAfterMove(aiTable, currentFrozenFieldId, sourceFieldId, fieldOptions) {
+    const fields = aiTable.gridData().fields;
+    const fieldsIndexMap = aiTable.context?.visibleColumnsIndexMap();
+    const currentFrozenFieldIndex = fieldsIndexMap.get(currentFrozenFieldId);
+    if (currentFrozenFieldIndex === -1) {
+        return;
+    }
+    const { afterFieldId, beforeFieldId } = fieldOptions;
+    const sourceIndex = fieldsIndexMap.get(sourceFieldId);
+    let targetIndex;
+    if (beforeFieldId) {
+        targetIndex = fieldsIndexMap.get(beforeFieldId);
+    }
+    else if (afterFieldId) {
+        targetIndex = fieldsIndexMap.get(afterFieldId);
+    }
+    else {
+        return;
+    }
+    const activeViewId = aiTable.activeViewId();
+    let newFrozenFieldId = null;
+    // 最后冻结列拖动到非冻结区或冻结区，冻结列向左移动
+    if (sourceIndex === currentFrozenFieldIndex && targetIndex !== currentFrozenFieldIndex) {
+        const newFrozenFieldIndex = Math.max(0, currentFrozenFieldIndex - 1);
+        if (newFrozenFieldIndex < fields.length && newFrozenFieldIndex !== currentFrozenFieldIndex) {
+            newFrozenFieldId = fields[newFrozenFieldIndex]._id;
+        }
+        else {
+            // 如果没有前一个字段，恢复默认冻结
+            newFrozenFieldId = undefined;
+        }
+    }
+    // 冻结区拖动到最后冻结列后面，冻结列是被拖动列
+    if (sourceIndex < currentFrozenFieldIndex && targetIndex === currentFrozenFieldIndex) {
+        newFrozenFieldId = fields[sourceIndex]._id;
+    }
+    if (newFrozenFieldId !== null) {
+        ViewActions.setView(aiTable, { settings: { ...aiTable.viewsMap()[activeViewId].settings, frozen_field_id: newFrozenFieldId } }, [
+            activeViewId
+        ]);
+    }
+}
+
+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 maxFieldsCount = aiTable.context?.maxFields();
+    if (maxFieldsCount && aiTable.fields().length >= maxFieldsCount) {
+        console.log(`Warning: ${getI18nTextByKey(aiTable, AITableGridI18nKey.pasteOverMaxRecords)}`);
+        return;
+    }
+    const { defaultValue, isDuplicate, originId } = options;
+    const fieldsMap = aiTable.fieldsMap();
+    const newField = { ...defaultValue };
+    const existNames = aiTable.fields().map((item) => item.name);
+    if (existNames.includes(newField.name)) {
+        newField.name = generateNewFieldName(aiTable, newField, newField.name);
+    }
+    if (fieldsMap[newField._id]) {
+        newField._id = idCreator();
+    }
+    const viewPositionOptions = { count: options.count || 1 };
+    if (isDuplicate) {
+        viewPositionOptions.afterItemId = originId;
+    }
+    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);
+}
+
+const buildRemoveFieldItem = (aiTable, getUpdatedInfo) => {
+    return {
+        type: 'removeField',
+        name: getStateI18nTextByKey(aiTable, AITableStateI18nKey.removeField),
+        icon: 'trash',
+        exec: (aiTable, field) => {
+            Actions.removeField(aiTable, [field()._id]);
+        }
+    };
+};
+
 const withState = (aiTable) => {
     const viewTable = aiTable;
     viewTable.actions = [];
@@ -2600,16 +2676,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
+            }));
         }
     };
 };
@@ -2620,16 +2692,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
+            }));
         }
     };
 };
@@ -2640,5 +2708,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, 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 };
+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, buildSetRecordPositionsAction, 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