@ai-table/state 0.0.14 → 0.0.16

package/fesm2022/ai-table-state.mjs

@@ -1,7 +1,8 @@
 import * as Y from 'yjs';
 import { isArray, isEmpty as isEmpty$1, isObject, isUndefinedOrNull, TinyDate } from 'ngx-tethys/util';
-import { AITableQueries, getDefaultFieldValue, idCreator, AITableFieldType, Direction as Direction$1, AI_TABLE_GRID_FIELD_SERVICE_MAP } from '@ai-table/grid';
-import _, { isEqual } from 'lodash';
+import { AITableQueries, idCreator, AITableFieldType, getDefaultFieldValue, Direction as Direction$1, AI_TABLE_GRID_FIELD_SERVICE_MAP } from '@ai-table/grid';
+import * as _ from 'lodash';
+import ___default, { isEqual } from 'lodash';
 import { fromUnixTime, subDays } from 'date-fns';
 import { createDraft, finishDraft } from 'immer';
 
@@ -46,6 +47,8 @@ const YjsAITable = {
 
 class Positions {
 }
+class RemovePositions {
+}
 var Direction;
 (function (Direction) {
     Direction[Direction["default"] = 0] = "default";
@@ -88,8 +91,8 @@ var ActionName;
     ActionName["SetView"] = "set_view";
     ActionName["AddView"] = "add_view";
     ActionName["RemoveView"] = "remove_view";
-    ActionName["AddRecordPosition"] = "add_record_position";
-    ActionName["RemoveRecordPosition"] = "remove_record_position";
+    ActionName["SetRecordPositions"] = "set_record_positions";
+    ActionName["UpdateSystemFieldValue"] = "update_system_field_value";
 })(ActionName || (ActionName = {}));
 var ExecuteType;
 (function (ExecuteType) {
@@ -98,29 +101,9 @@ var ExecuteType;
     ExecuteType[ExecuteType["Redo"] = 2] = "Redo";
 })(ExecuteType || (ExecuteType = {}));
 
-const createSharedType = () => {
-    const doc = new Y.Doc();
-    const sharedType = doc.getMap('ai-table');
-    return sharedType;
-};
-const initSharedType = (doc, initializeValue) => {
-    const sharedType = doc.getMap('ai-table');
-    toSharedType(sharedType, initializeValue);
-    return sharedType;
-};
-function toSharedType(sharedType, data) {
-    sharedType.doc.transact(() => {
-        const fieldSharedType = new Y.Array();
-        fieldSharedType.insert(0, data.fields.map(toSyncElement));
-        sharedType.set('fields', fieldSharedType);
-        const recordSharedType = new Y.Array();
-        sharedType.set('records', recordSharedType);
-        recordSharedType.insert(0, data.records.map(toRecordSyncElement));
-        const viewsSharedType = new Y.Array();
-        sharedType.set('views', viewsSharedType);
-        viewsSharedType.insert(0, data.views.map(toSyncElement));
-    });
-}
+const POSITIONS_INDEX = 3;
+const UPDATED_AT_INDEX = 4;
+const UPDATED_BY_INDEX = 5;
 function toSyncElement(node) {
     const element = new Y.Map();
     for (const key in node) {
@@ -128,41 +111,21 @@ function toSyncElement(node) {
     }
     return element;
 }
-function toRecordSyncElement(record) {
-    const nonEditableArray = new Y.Array();
+function toRecordSyncElement(record, fields) {
+    const systemFieldValues = new Y.Array();
     // 临时方案：为了解决删除时协同操作无法精准获取删除的 id 的问题，将原来的[idValue] 改为[{'_id': idValue}]
-    // 后续可能改为 YMap 或者通过在 views 中存储 positions 解决
-    nonEditableArray.insert(0, [{ _id: record['_id'] }]);
-    const editableArray = new Y.Array();
-    const editableFields = [];
-    for (const fieldId in record['values']) {
-        editableFields.push(record['values'][fieldId]);
-    }
-    editableArray.insert(0, [...editableFields, record['positions']]);
+    systemFieldValues.insert(0, getSystemFieldValues(record));
+    const customFieldValues = new Y.Array();
+    const valuesArray = [];
+    fields.forEach((field) => {
+        valuesArray.push(record['values'][field._id]);
+    });
+    customFieldValues.insert(0, valuesArray);
     // To save memory, convert map to array.
     const element = new Y.Array();
-    element.insert(0, [nonEditableArray, editableArray]);
+    element.insert(0, [systemFieldValues, customFieldValues]);
     return element;
 }
-
-const translateToRecordValues = (arrayRecord, fields) => {
-    const fieldIds = fields.map((item) => item._id);
-    const recordValue = {};
-    fieldIds.forEach((item, index) => {
-        recordValue[item] = arrayRecord[index] || '';
-    });
-    return recordValue;
-};
-const translateToRecords = (arrayRecords, fields) => {
-    return arrayRecords.map((record) => {
-        const [nonEditableArray, editableArray] = record;
-        return {
-            _id: nonEditableArray[0]['_id'],
-            positions: editableArray[editableArray.length - 1],
-            values: translateToRecordValues(editableArray.slice(0, editableArray.length - 1), fields)
-        };
-    });
-};
 function translatePositionToPath(data, position, activeViewId) {
     let index = data.findIndex((value, index) => {
         if (index === 0) {
@@ -181,6 +144,9 @@ function getShareTypeNumberPath(path) {
 function getSharedRecordId(records, recordIndex) {
     return records && records.get(recordIndex).get(0).get(0)['_id'];
 }
+function getSharedRecord(records, recordIndex) {
+    return records && records.get(recordIndex);
+}
 function getSharedMapValueId(values, index) {
     return values && values.get(index).get('_id');
 }
@@ -206,11 +172,64 @@ function getSharedMapValueIndex(sharedNodes, id) {
     }
     return nodeIndex;
 }
+const getSystemFieldValues = (record) => {
+    return [{ _id: record['_id'] }, record.created_at, record.created_by, record['positions'], record.updated_at, record.updated_by];
+};
+const getCustomFieldValues = (record) => {
+    throw new Error('No implement');
+};
+const getValuesByCustomFieldValues = (customFieldValues, fields) => {
+    const fieldIds = fields.map((item) => item._id);
+    const recordValue = {};
+    fieldIds.forEach((item, index) => {
+        recordValue[item] = customFieldValues[index] || '';
+    });
+    return recordValue;
+};
+const getTrackableEntityBySystemFieldValues = (systemFieldValues) => {
+    return {
+        created_at: systemFieldValues[1],
+        created_by: systemFieldValues[2],
+        updated_at: systemFieldValues[4],
+        updated_by: systemFieldValues[5]
+    };
+};
+const getIdBySystemFieldValues = (systemFieldValues) => {
+    return systemFieldValues[0]['_id'];
+};
+const getIdBySystemFieldValuesType = (systemFieldValuesType) => {
+    return systemFieldValuesType.get(0)['_id'];
+};
+const getPositionsBySystemFieldValues = (systemFieldValues) => {
+    return systemFieldValues[POSITIONS_INDEX];
+};
+const getPositionsByRecordSyncElement = (recordSyncElement) => {
+    const systemFieldType = recordSyncElement.get(0);
+    const positions = systemFieldType.get(POSITIONS_INDEX);
+    return positions;
+};
+const setRecordPositions$1 = (recordSyncElement, newPositions) => {
+    const systemFieldType = recordSyncElement.get(0);
+    systemFieldType.delete(POSITIONS_INDEX);
+    systemFieldType.insert(POSITIONS_INDEX, [newPositions]);
+};
+const setRecordUpdatedInfo = (recordSyncElement, info) => {
+    const systemFieldType = recordSyncElement.get(0);
+    systemFieldType.delete(UPDATED_AT_INDEX, 2);
+    systemFieldType.insert(UPDATED_AT_INDEX, [info.updated_at, info.updated_by]);
+};
 
-const initTable = (sharedType) => {
+const AI_TABLE_CONTENT_FIELD_NAME = 'content';
+
+const createSharedType = (fieldName = AI_TABLE_CONTENT_FIELD_NAME) => {
+    const doc = new Y.Doc();
+    const sharedType = doc.getMap(fieldName);
+    return sharedType;
+};
+const getDataBySharedType = (sharedType) => {
     const data = sharedType.toJSON();
     const fields = data['fields'];
-    const records = translateToRecords(data['records'], fields);
+    const records = getRecordsBySharedJson(data['records'], fields);
     const views = data['views'];
     return {
         records,
@@ -218,6 +237,37 @@ const initTable = (sharedType) => {
         views
     };
 };
+const getSharedTypeByData = (doc, initializeValue) => {
+    const sharedType = doc.getMap(AI_TABLE_CONTENT_FIELD_NAME);
+    toSharedType(sharedType, initializeValue);
+    return sharedType;
+};
+function toSharedType(sharedType, data) {
+    sharedType.doc.transact(() => {
+        const fieldSharedType = new Y.Array();
+        fieldSharedType.insert(0, data.fields.map(toSyncElement));
+        sharedType.set('fields', fieldSharedType);
+        const recordSharedType = new Y.Array();
+        sharedType.set('records', recordSharedType);
+        recordSharedType.insert(0, data.records.map((record) => {
+            return toRecordSyncElement(record, data.fields);
+        }));
+        const viewsSharedType = new Y.Array();
+        sharedType.set('views', viewsSharedType);
+        viewsSharedType.insert(0, data.views.map(toSyncElement));
+    });
+}
+const getRecordsBySharedJson = (recordJsonArray, fields) => {
+    return recordJsonArray.map((record) => {
+        const [systemFieldValues, customFieldValues] = record;
+        return {
+            _id: getIdBySystemFieldValues(systemFieldValues),
+            ...getTrackableEntityBySystemFieldValues(systemFieldValues),
+            positions: getPositionsBySystemFieldValues(systemFieldValues),
+            values: getValuesByCustomFieldValues(customFieldValues, fields)
+        };
+    });
+};
 
 function translateArrayEvent(aiTable, sharedType, event) {
     let offset = 0;
@@ -262,15 +312,18 @@ function translateArrayEvent(aiTable, sharedType, event) {
                     if (isAddOrRemove(targetPath)) {
                         delta.insert?.map((item) => {
                             const data = item.toJSON();
-                            const [fixedField, customField] = data;
-                            const position = customField[customField.length - 1][activeViewId];
+                            const [systemFieldValues, customFieldValues] = data;
+                            const positions = getPositionsBySystemFieldValues(customFieldValues);
+                            const position = positions[activeViewId];
                             const path = translatePositionToPath(aiTable.records(), position, activeViewId);
                             actions.push({
                                 type: ActionName.AddRecord,
                                 path: path,
                                 record: {
-                                    _id: fixedField[0]['_id'],
-                                    values: translateToRecordValues(customField, aiTable.fields())
+                                    _id: getIdBySystemFieldValues(systemFieldValues),
+                                    ...getTrackableEntityBySystemFieldValues(systemFieldValues),
+                                    positions: getPositionsBySystemFieldValues(customFieldValues),
+                                    values: getValuesByCustomFieldValues(customFieldValues, aiTable.fields())
                                 }
                             });
                         });
@@ -279,30 +332,34 @@ function translateArrayEvent(aiTable, sharedType, event) {
                         try {
                             const sharedRecords = sharedType.get('records');
                             const sharedFields = sharedType.get('fields');
+                            let systemFieldOffset = 0;
                             delta.insert?.map((item) => {
                                 const recordIndex = targetPath[0];
                                 const fieldIndex = offset;
                                 const record = aiTable.records()[recordIndex];
-                                if (isPositionOperation(fieldIndex, sharedFields)) {
-                                    for (const key in item) {
-                                        if (!record.positions[key] && record.positions[key] !== 0) {
-                                            actions.push({
-                                                type: ActionName.AddRecordPosition,
-                                                path: [record._id],
-                                                position: {
-                                                    [key]: item[key]
-                                                }
-                                            });
+                                if (isSystemFieldOperation(targetPath)) {
+                                    if (isPositionsOperation(fieldIndex)) {
+                                        const newPositions = {};
+                                        for (const key in item) {
+                                            newPositions[key] = item[key];
                                         }
+                                        actions.push({
+                                            type: ActionName.SetRecordPositions,
+                                            path: [record._id],
+                                            positions: newPositions
+                                        });
+                                        // 此处的循环会包含 updated_at 和 updated_by 各一次，这里只处理 updated_by 同时包含两个字段的修改
                                     }
-                                    for (const key in record.positions) {
-                                        if (!item[key] && item[key] !== 0) {
-                                            actions.push({
-                                                type: ActionName.RemoveRecordPosition,
-                                                path: [key, record._id]
-                                            });
-                                        }
+                                    else if (isUpdatedByOperation(fieldIndex + systemFieldOffset)) {
+                                        const systemFieldValues = getSharedRecord(sharedRecords, recordIndex).get(0).toJSON();
+                                        const { updated_at, updated_by } = getTrackableEntityBySystemFieldValues(systemFieldValues);
+                                        actions.push({
+                                            type: ActionName.UpdateSystemFieldValue,
+                                            path: [record._id],
+                                            updatedInfo: { updated_at, updated_by }
+                                        });
                                     }
+                                    systemFieldOffset++;
                                 }
                                 else {
                                     const recordId = getSharedRecordId(sharedRecords, recordIndex);
@@ -353,8 +410,23 @@ function translateArrayEvent(aiTable, sharedType, event) {
 function isAddOrRemove(targetPath) {
     return targetPath.length === 0;
 }
-function isPositionOperation(fieldIndex, sharedFields) {
-    return fieldIndex === sharedFields.length;
+function isSystemFieldOperation(targetPath) {
+    if (targetPath.length === 2 && targetPath[1] === 0) {
+        return true;
+    }
+    return false;
+}
+function isCustomFieldOperation(targetPath) {
+    if (targetPath.length === 2 && targetPath[1] === 1) {
+        return true;
+    }
+    return false;
+}
+function isPositionsOperation(fieldIndex) {
+    return fieldIndex === POSITIONS_INDEX;
+}
+function isUpdatedByOperation(fieldIndex) {
+    return fieldIndex === UPDATED_BY_INDEX;
 }
 function getRemoveIds(event, type) {
     const ids = [];
@@ -450,7 +522,7 @@ function applyYjsEvents(aiTable, sharedType, events) {
     }
 }
 
-function updateFieldValue$2(sharedType, action) {
+function updateFieldValue$2(aiTable, sharedType, action) {
     const sharedRecords = sharedType.get('records');
     const sharedFields = sharedType.get('fields');
     if (sharedRecords && sharedFields) {
@@ -466,7 +538,7 @@ function updateFieldValue$2(sharedType, action) {
     return sharedType;
 }
 
-function setNode(sharedType, action) {
+function setNode(aiTable, sharedType, action) {
     let sharedNodes;
     if (action.type === ActionName.SetField) {
         sharedNodes = sharedType.get('fields');
@@ -496,27 +568,41 @@ function setNode(sharedType, action) {
     return sharedType;
 }
 
-function addNode(sharedType, action) {
+function addNode(aiTable, sharedType, action) {
     const records = sharedType.get('records');
     const views = sharedType.get('views');
     const fields = sharedType.get('fields');
     switch (action.type) {
         case ActionName.AddRecord:
-            records && records.push([toRecordSyncElement(action.record)]);
+            records && records.push([toRecordSyncElement(action.record, aiTable.fields())]);
             break;
         case ActionName.AddView:
             views && views.push([toSyncElement(action.view)]);
             break;
-        case ActionName.AddRecordPosition:
+        case ActionName.SetRecordPositions:
             if (records) {
                 const recordIndex = getSharedRecordIndex(records, action.path[0]);
                 const record = records.get(recordIndex);
-                const customField = record.get(1);
-                const positionsIndex = customField.length - 1;
-                const positions = customField.get(positionsIndex);
-                const newPositions = { ...positions, ...action.position };
-                customField.delete(positionsIndex);
-                customField.insert(positionsIndex, [newPositions]);
+                const positions = getPositionsByRecordSyncElement(record);
+                const newPositions = { ...positions };
+                for (const key in action.positions) {
+                    if (action.positions[key] === null || action.positions[key] === undefined) {
+                        delete newPositions[key];
+                    }
+                    else {
+                        newPositions[key] = action.positions[key];
+                    }
+                }
+                setRecordPositions$1(record, newPositions);
+            }
+            break;
+        case ActionName.UpdateSystemFieldValue:
+            if (records) {
+                const recordIndex = getSharedRecordIndex(records, action.path[0]);
+                const record = records.get(recordIndex);
+                if (action.updatedInfo.updated_at && action.updatedInfo.updated_at) {
+                    setRecordUpdatedInfo(record, action.updatedInfo);
+                }
             }
             break;
         case ActionName.AddField:
@@ -524,9 +610,11 @@ function addNode(sharedType, action) {
                 fields.push([toSyncElement(action.field)]);
                 const path = action.path[0];
                 for (let value of records) {
-                    const newRecord = getDefaultFieldValue(action.field);
-                    const customField = value.get(1);
-                    customField.insert(path, [newRecord]);
+                    const customFieldValues = value.get(1);
+                    const systemFieldValues = value.get(0);
+                    const recordEntity = aiTable.recordsMap()[getIdBySystemFieldValuesType(systemFieldValues)];
+                    const newFieldValue = recordEntity.values[action.field._id];
+                    customFieldValues.insert(path, [newFieldValue]);
                 }
             }
             break;
@@ -534,7 +622,7 @@ function addNode(sharedType, action) {
     return sharedType;
 }
 
-function removeNode(sharedType, action) {
+function removeNode(aiTable, sharedType, action) {
     const fields = sharedType.get('fields');
     const records = sharedType.get('records');
     const views = sharedType.get('views');
@@ -555,18 +643,6 @@ function removeNode(sharedType, action) {
                 }
             }
             break;
-        case ActionName.RemoveRecordPosition:
-            if (records) {
-                const recordIndex = getSharedRecordIndex(records, action.path[1]);
-                const record = records.get(recordIndex);
-                const customField = record.get(1);
-                const positionsIndex = customField.length - 1;
-                const positions = customField.get(positionsIndex);
-                delete positions[action.path[0]];
-                customField.delete(positionsIndex);
-                customField.insert(positionsIndex, [positions]);
-            }
-            break;
         case ActionName.RemoveField:
             if (fields && records) {
                 const fieldIndex = getSharedMapValueIndex(fields, action.path[0]);
@@ -583,25 +659,25 @@ function removeNode(sharedType, action) {
 }
 
 const actionMappers = {
-    add_record: addNode,
-    update_field_value: updateFieldValue$2,
-    remove_record: removeNode,
-    add_field: addNode,
-    set_field: setNode,
-    remove_field: removeNode,
-    set_view: setNode,
-    add_view: addNode,
-    remove_view: removeNode,
-    add_record_position: addNode,
-    remove_record_position: removeNode
+    [ActionName.AddRecord]: addNode,
+    [ActionName.UpdateFieldValue]: updateFieldValue$2,
+    [ActionName.RemoveRecord]: removeNode,
+    [ActionName.AddField]: addNode,
+    [ActionName.SetField]: setNode,
+    [ActionName.RemoveField]: removeNode,
+    [ActionName.SetView]: setNode,
+    [ActionName.AddView]: addNode,
+    [ActionName.RemoveView]: removeNode,
+    [ActionName.SetRecordPositions]: addNode,
+    [ActionName.UpdateSystemFieldValue]: addNode
 };
-function applyActionOps(sharedType, actions, aiTable) {
+function applyActionOps(aiTable, sharedType, actions) {
     if (actions.length > 0) {
         sharedType.doc.transact(() => {
             actions.forEach((action) => {
                 const apply = actionMappers[action.type];
                 if (apply) {
-                    return apply(sharedType, action);
+                    return apply(aiTable, sharedType, action);
                 }
                 return null;
             });
@@ -1108,6 +1184,19 @@ const apply = (aiTable, records, fields, views, action) => {
             }
             break;
         }
+        case ActionName.UpdateSystemFieldValue: {
+            const [recordId] = action.path;
+            if (recordId && action.updatedInfo) {
+                const recordIndex = aiTable.records().findIndex((item) => item._id === recordId);
+                if (action.updatedInfo.updated_at) {
+                    records[recordIndex].updated_at = action.updatedInfo.updated_at;
+                }
+                if (action.updatedInfo.updated_by) {
+                    records[recordIndex].updated_by = action.updatedInfo.updated_by;
+                }
+            }
+            break;
+        }
         case ActionName.AddRecord: {
             const [recordIndex] = action.path;
             if (recordIndex > -1) {
@@ -1237,23 +1326,23 @@ const apply = (aiTable, records, fields, views, action) => {
             }
             break;
         }
-        case ActionName.AddRecordPosition: {
-            const { position, path } = action;
+        case ActionName.SetRecordPositions: {
+            const { positions, path } = action;
             const record = records.find((item) => item._id === path[0]);
             if (record) {
-                record.positions = {
-                    ...record.positions,
-                    ...position
-                };
+                const newPositions = { ...record.positions };
+                for (const key in positions) {
+                    if (positions[key] === null || positions[key] === undefined) {
+                        delete newPositions[key];
+                    }
+                    else {
+                        newPositions[key] = positions[key];
+                    }
+                }
+                record.positions = newPositions;
             }
             break;
         }
-        case ActionName.RemoveRecordPosition: {
-            const { path } = action;
-            const record = records.find((item) => item._id === path[1]);
-            delete record?.positions[path[0]];
-            break;
-        }
     }
     return {
         records,
@@ -1273,37 +1362,35 @@ const GeneralActions = {
     }
 };
 
-function setRecordPosition(aiTable, position, path) {
+function setRecordPositions(aiTable, positions, path) {
     const operation = {
-        type: ActionName.AddRecordPosition,
-        position,
+        type: ActionName.SetRecordPositions,
+        positions,
         path
     };
     aiTable.apply(operation);
 }
-function removeRecordPosition(aiTable, path) {
+const PositionsActions = {
+    setRecordPositions
+};
+
+function updateFieldValue$1(aiTable, value, path) {
+    const oldValue = AITableQueries.getFieldValue(aiTable, path);
     const operation = {
-        type: ActionName.RemoveRecordPosition,
+        type: ActionName.UpdateFieldValue,
+        fieldValue: oldValue,
+        newFieldValue: value,
         path
     };
     aiTable.apply(operation);
 }
-const PositionActions = {
-    setRecordPosition,
-    removeRecordPosition
-};
-
-function updateFieldValue$1(aiTable, value, path) {
-    const oldValue = AITableQueries.getFieldValue(aiTable, path);
-    if (oldValue !== value) {
-        const operation = {
-            type: ActionName.UpdateFieldValue,
-            fieldValue: oldValue,
-            newFieldValue: value,
-            path
-        };
-        aiTable.apply(operation);
-    }
+function updateSystemFieldValue(aiTable, path, updatedInfo) {
+    const operation = {
+        type: ActionName.UpdateSystemFieldValue,
+        updatedInfo,
+        path
+    };
+    aiTable.apply(operation);
 }
 function addRecord(aiTable, record, path) {
     const operation = {
@@ -1332,7 +1419,8 @@ const RecordActions = {
     addRecord,
     updateFieldValue: updateFieldValue$1,
     moveRecord,
-    removeRecord
+    removeRecord,
+    updateSystemFieldValue
 };
 
 function setView(aiTable, value, path) {
@@ -1386,10 +1474,17 @@ const Actions = {
     ...RecordActions,
     ...FieldActions,
     ...ViewActions,
-    ...PositionActions
+    ...PositionsActions
 };
 
-function addFields(aiTable, options) {
+function updateRecordsUpdatedInfo(aiTable, updatedInfo) {
+    const records = aiTable.records();
+    records.forEach((item) => {
+        Actions.updateSystemFieldValue(aiTable, [item._id], updatedInfo);
+    });
+}
+
+function addFields(aiTable, options, updatedInfo) {
     const { originId, direction = Direction$1.after, defaultValue, isDuplicate, count = 1 } = options;
     const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
     const fields = getSortFields(aiTable, aiTable.fields(), activeView);
@@ -1397,13 +1492,26 @@ function addFields(aiTable, options) {
     if (direction === Direction$1.after) {
         addIndex++;
     }
-    const newRecordIds = getNewIdsByCount(count);
-    newRecordIds.forEach((id, index) => {
+    const newFieldIds = getNewIdsByCount(count);
+    newFieldIds.forEach((id, index) => {
         const newField = { _id: id, ...defaultValue };
         Actions.addField(aiTable, newField, [addIndex + index]);
     });
+    updateRecordsUpdatedInfo(aiTable, updatedInfo);
 }
 
+const buildRemoveFieldItem = (getUpdatedInfo) => {
+    return {
+        type: 'removeField',
+        name: '删除列',
+        icon: 'trash',
+        exec: (aiTable, field) => {
+            Actions.removeField(aiTable, [field()._id]);
+            updateRecordsUpdatedInfo(aiTable, getUpdatedInfo());
+        }
+    };
+};
+
 function createDefaultPositions(views, activeId, data, index) {
     const positions = {};
     const position = getPosition(data, activeId, index);
@@ -1445,7 +1553,7 @@ function addView(aiTable, type) {
     }
     ViewActions.addView(aiTable, newView, [index]);
     aiTable.records().forEach((record) => {
-        PositionActions.setRecordPosition(aiTable, { [newId]: record.positions[originViewId] }, [record._id]);
+        PositionsActions.setRecordPositions(aiTable, { [newId]: record.positions[originViewId] }, [record._id]);
     });
     aiTable.fields().forEach((field) => {
         Actions.setField(aiTable, {
@@ -1459,7 +1567,7 @@ function addView(aiTable, type) {
 }
 function removeView(aiTable, records, fields, activeViewId) {
     records.forEach((record) => {
-        PositionActions.removeRecordPosition(aiTable, [activeViewId, record._id]);
+        PositionsActions.setRecordPositions(aiTable, { [activeViewId]: undefined }, [record._id]);
     });
     fields.forEach((field) => {
         const positions = { ...field.positions };
@@ -1471,7 +1579,7 @@ function removeView(aiTable, records, fields, activeViewId) {
     ViewActions.removeView(aiTable, [activeViewId]);
 }
 
-function addRecords(aiTable, options) {
+function addRecords(aiTable, options, trackableEntity) {
     const { originId, direction = Direction$1.after, isDuplicate, count = 1 } = options;
     const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
     const records = getSortRecords(aiTable, aiTable.records(), activeView);
@@ -1490,7 +1598,7 @@ function addRecords(aiTable, options) {
         });
     }
     newRecordIds.forEach((id, index) => {
-        const newRecord = { _id: id, values: newRecordValues };
+        const newRecord = { _id: id, values: newRecordValues, ...trackableEntity };
         Actions.addRecord(aiTable, newRecord, [addIndex + index]);
     });
 }
@@ -1513,8 +1621,12 @@ function getDefaultRecordValues(aiTable, isDuplicate = false, recordId) {
     return newRecordValues;
 }
 
-function updateFieldValue(aiTable, options) {
-    Actions.updateFieldValue(aiTable, options.value, options.path);
+function updateFieldValue(aiTable, options, updatedInfo) {
+    const oldValue = AITableQueries.getFieldValue(aiTable, options.path);
+    if (!_.isEqual(oldValue, options.value)) {
+        Actions.updateFieldValue(aiTable, options.value, options.path);
+        Actions.updateSystemFieldValue(aiTable, [options.path[0]], updatedInfo);
+    }
 }
 
 const FLUSHING = new WeakMap();
@@ -1546,7 +1658,7 @@ const EditFieldPropertyItem = {
     icon: 'edit',
     exec: (aiTable, field, origin, position) => {
         const fieldService = AI_TABLE_GRID_FIELD_SERVICE_MAP.get(aiTable);
-        const copyField = _.cloneDeep(field());
+        const copyField = ___default.cloneDeep(field());
         if (origin && position) {
             const popoverRef = fieldService?.editFieldProperty(aiTable, {
                 field: copyField,
@@ -1564,14 +1676,6 @@ const EditFieldPropertyItem = {
         return undefined;
     }
 };
-const RemoveFieldItem = {
-    type: 'removeField',
-    name: '删除列',
-    icon: 'trash',
-    exec: (aiTable, field) => {
-        Actions.removeField(aiTable, [field()._id]);
-    }
-};
 
 const VIEW_ACTIONS = [ActionName.SetView, ActionName.AddView, ActionName.RemoveView];
 
@@ -1579,5 +1683,5 @@ const VIEW_ACTIONS = [ActionName.SetView, ActionName.AddView, ActionName.RemoveV
  * Generated bundle index. Do not edit.
  */
 
-export { AITableFilterLogical, AITableFilterOperation, ActionName, Actions, Direction, DividerMenuItem, EditFieldPropertyItem, ExecuteType, FLUSHING, Positions, RemoveFieldItem, VIEW_ACTIONS, ViewOperationMap, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyEvents, applyYjsEvents, buildFieldsByView, buildRecordsByView, createDefaultPositions, createSharedType, doFilter, getDefaultRecordDataByFilter, getDefaultRecordValues, getFilteredRecords, getNewIdsByCount, getPosition, getShareTypeNumberPath, getSharedMapValueId, getSharedMapValueIndex, getSharedRecordId, getSharedRecordIndex, getSortFields, getSortRecords, initSharedType, initTable, isEmpty, isPathEqual, removeView, sortByViewPosition, sortRecordsBySortInfo, toRecordSyncElement, toSharedType, toSyncElement, translatePositionToPath, translateToRecordValues, translateToRecords, translateYjsEvent, updateFieldValue, withState };
+export { AITableFilterLogical, AITableFilterOperation, AI_TABLE_CONTENT_FIELD_NAME, ActionName, Actions, Direction, DividerMenuItem, EditFieldPropertyItem, ExecuteType, FLUSHING, POSITIONS_INDEX, Positions, RemovePositions, UPDATED_AT_INDEX, UPDATED_BY_INDEX, VIEW_ACTIONS, ViewOperationMap, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyEvents, applyYjsEvents, buildFieldsByView, buildRecordsByView, buildRemoveFieldItem, createDefaultPositions, createSharedType, doFilter, getCustomFieldValues, getDataBySharedType, getDefaultRecordDataByFilter, getDefaultRecordValues, getFilteredRecords, getIdBySystemFieldValues, getIdBySystemFieldValuesType, getNewIdsByCount, getPosition, getPositionsByRecordSyncElement, getPositionsBySystemFieldValues, getRecordsBySharedJson, getShareTypeNumberPath, getSharedMapValueId, getSharedMapValueIndex, getSharedRecord, getSharedRecordId, getSharedRecordIndex, getSharedTypeByData, getSortFields, getSortRecords, getSystemFieldValues, getTrackableEntityBySystemFieldValues, getValuesByCustomFieldValues, isEmpty, isPathEqual, removeView, setRecordPositions$1 as setRecordPositions, setRecordUpdatedInfo, sortByViewPosition, sortRecordsBySortInfo, toRecordSyncElement, toSharedType, toSyncElement, translatePositionToPath, translateYjsEvent, updateFieldValue, updateRecordsUpdatedInfo, withState };
 //# sourceMappingURL=ai-table-state.mjs.map