@ai-table/state 0.0.66 → 0.0.68

package/fesm2022/ai-table-state.mjs

@@ -1,9 +1,12 @@
 import * as Y from 'yjs';
-import { isArray } from 'ngx-tethys/util';
-import { AITableQueries, FieldModelMap, AITableFilterOperation, AITableFieldType, isSystemField, isEmpty, getDefaultFieldValue, Direction as Direction$1, idsCreator, idCreator, shortIdCreator, generateNewName, shortIdsCreator, AI_TABLE_GRID_FIELD_SERVICE_MAP, AITable, isMac, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, writeToAITable } from '@ai-table/grid';
-import { createDraft, finishDraft } from 'immer';
+import { UndoManager } from 'yjs';
+import { getShareTypeNumberPath, ActionName, translateArrayEvent, getSharedRecordIndex, getSharedMapValueIndex, toMapSyncElement, getIdBySystemFieldValuesType, setRecordUpdatedInfo, getPositionsByRecordSyncElement, setRecordPositions as setRecordPositions$1, toRecordSyncElement, AI_TABLE_CONTENT_FIELD_NAME, getIdBySystemFieldValues, getShortIdBySystemFieldValues, getTrackableEntityBySystemFieldValues, getPositionsBySystemFieldValues, getValuesByCustomFieldValues, AITableFilterLogical, AITableFilterOperation, AITableFieldType, Direction } from '@ai-table/utils';
+import * as i0 from '@angular/core';
+import { signal, Injectable } from '@angular/core';
+import { FieldModelMap, AITableQueries, isSystemField, getDefaultFieldValue, idCreator, shortIdCreator, generateNewName, idsCreator, shortIdsCreator, AI_TABLE_GRID_FIELD_SERVICE_MAP, AITable, isMac, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, writeToAITable } from '@ai-table/grid';
 import * as _ from 'lodash';
-import ___default from 'lodash';
+import ___default, { isEmpty } from 'lodash';
+import { createDraft, finishDraft } from 'immer';
 
 const IS_LOCAL = new WeakSet();
 const IS_REMOTE = new WeakSet();
@@ -44,420 +47,6 @@ const YjsAITable = {
     }
 };
 
-class Positions {
-}
-class RemovePositions {
-}
-var Direction;
-(function (Direction) {
-    Direction[Direction["default"] = 0] = "default";
-    Direction[Direction["ascending"] = 1] = "ascending";
-    Direction[Direction["descending"] = -1] = "descending";
-})(Direction || (Direction = {}));
-var AITableFilterLogical;
-(function (AITableFilterLogical) {
-    AITableFilterLogical["and"] = "and";
-    AITableFilterLogical["or"] = "or";
-})(AITableFilterLogical || (AITableFilterLogical = {}));
-
-var ActionName;
-(function (ActionName) {
-    ActionName["UpdateFieldValue"] = "update_field_value";
-    ActionName["AddRecord"] = "add_record";
-    ActionName["AddField"] = "add_field";
-    ActionName["MoveField"] = "move_field";
-    ActionName["MoveRecord"] = "move_record";
-    ActionName["RemoveField"] = "remove_field";
-    ActionName["RemoveRecord"] = "remove_record";
-    ActionName["SetField"] = "set_field";
-    ActionName["SetView"] = "set_view";
-    ActionName["AddView"] = "add_view";
-    ActionName["RemoveView"] = "remove_view";
-    ActionName["SetRecordPositions"] = "set_record_positions";
-    ActionName["UpdateSystemFieldValue"] = "update_system_field_value";
-})(ActionName || (ActionName = {}));
-var ExecuteType;
-(function (ExecuteType) {
-    ExecuteType[ExecuteType["Execute"] = 0] = "Execute";
-    ExecuteType[ExecuteType["Undo"] = 1] = "Undo";
-    ExecuteType[ExecuteType["Redo"] = 2] = "Redo";
-})(ExecuteType || (ExecuteType = {}));
-
-var SystemFieldIndex;
-(function (SystemFieldIndex) {
-    SystemFieldIndex[SystemFieldIndex["Id"] = 0] = "Id";
-    SystemFieldIndex[SystemFieldIndex["ShortId"] = 1] = "ShortId";
-    SystemFieldIndex[SystemFieldIndex["CreatedAt"] = 2] = "CreatedAt";
-    SystemFieldIndex[SystemFieldIndex["CreatedBy"] = 3] = "CreatedBy";
-    SystemFieldIndex[SystemFieldIndex["Positions"] = 4] = "Positions";
-    SystemFieldIndex[SystemFieldIndex["UpdatedAt"] = 5] = "UpdatedAt";
-    SystemFieldIndex[SystemFieldIndex["UpdatedBy"] = 6] = "UpdatedBy";
-})(SystemFieldIndex || (SystemFieldIndex = {}));
-function toSyncElement(node) {
-    const element = new Y.Map();
-    for (const key in node) {
-        element.set(key, node[key]);
-    }
-    return element;
-}
-function toRecordSyncElement(record, fields) {
-    const systemFieldValues = new Y.Array();
-    // 临时方案：为了解决删除时协同操作无法精准获取删除的 id 的问题，将原来的[idValue] 改为[{'_id': idValue}]
-    systemFieldValues.insert(0, getSystemFieldValues(record));
-    const customFieldValues = new Y.Array();
-    const valuesArray = [];
-    fields.forEach((field) => {
-        let value = record['values'][field._id];
-        // yjs will throw an error if the value is undefined.
-        if (value === undefined) {
-            value = null;
-        }
-        valuesArray.push(value);
-    });
-    customFieldValues.insert(0, valuesArray);
-    // To save memory, convert map to array.
-    const element = new Y.Array();
-    element.insert(0, [systemFieldValues, customFieldValues]);
-    return element;
-}
-function translatePositionToPath(data, position, activeViewId, indexOffset = 0) {
-    let index = data.findIndex((value, index) => {
-        if (index === 0) {
-            return position < value.positions[activeViewId];
-        }
-        return position > data[index - 1].positions[activeViewId] && position < value.positions[activeViewId];
-    });
-    if (index === -1) {
-        index = data.length;
-    }
-    return [index + indexOffset];
-}
-function getShareTypeNumberPath(path) {
-    return path.filter((node) => typeof node === 'number');
-}
-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');
-}
-function getSharedRecordIndex(sharedRecords, recordId) {
-    let recordIndex = -1;
-    for (let index = 0; index < sharedRecords.length; index++) {
-        const sharedRecordId = getSharedRecordId(sharedRecords, index);
-        if (sharedRecordId === recordId) {
-            recordIndex = index;
-            break;
-        }
-    }
-    return recordIndex;
-}
-function getSharedMapValueIndex(sharedNodes, id) {
-    let nodeIndex = -1;
-    for (let index = 0; index < sharedNodes.length; index++) {
-        const sharedId = getSharedMapValueId(sharedNodes, index);
-        if (sharedId === id) {
-            nodeIndex = index;
-            break;
-        }
-    }
-    return nodeIndex;
-}
-const getSystemFieldValues = (record) => {
-    return [
-        { _id: record['_id'] },
-        record.short_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[SystemFieldIndex.CreatedAt],
-        created_by: systemFieldValues[SystemFieldIndex.CreatedBy],
-        updated_at: systemFieldValues[SystemFieldIndex.UpdatedAt],
-        updated_by: systemFieldValues[SystemFieldIndex.UpdatedBy]
-    };
-};
-const getIdBySystemFieldValues = (systemFieldValues) => {
-    return systemFieldValues[SystemFieldIndex.Id]['_id'];
-};
-const getShortIdBySystemFieldValues = (systemFieldValues) => {
-    return systemFieldValues[SystemFieldIndex.ShortId];
-};
-const getIdBySystemFieldValuesType = (systemFieldValuesType) => {
-    return systemFieldValuesType.get(SystemFieldIndex.Id)['_id'];
-};
-const getPositionsBySystemFieldValues = (systemFieldValues) => {
-    return systemFieldValues[SystemFieldIndex.Positions];
-};
-const getPositionsByRecordSyncElement = (recordSyncElement) => {
-    const systemFieldType = recordSyncElement.get(0);
-    const positions = systemFieldType.get(SystemFieldIndex.Positions);
-    return positions;
-};
-const setRecordPositions$1 = (recordSyncElement, newPositions) => {
-    const systemFieldType = recordSyncElement.get(0);
-    systemFieldType.delete(SystemFieldIndex.Positions);
-    systemFieldType.insert(SystemFieldIndex.Positions, [newPositions]);
-};
-const setRecordUpdatedInfo = (recordSyncElement, info) => {
-    const systemFieldType = recordSyncElement.get(0);
-    systemFieldType.delete(SystemFieldIndex.UpdatedAt, 2);
-    systemFieldType.insert(SystemFieldIndex.UpdatedAt, [info.updated_at, info.updated_by]);
-};
-
-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 = getRecordsBySharedJson(data['records'], fields);
-    const views = data['views'];
-    return {
-        records,
-        fields,
-        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),
-            short_id: getShortIdBySystemFieldValues(systemFieldValues),
-            ...getTrackableEntityBySystemFieldValues(systemFieldValues),
-            positions: getPositionsBySystemFieldValues(systemFieldValues),
-            values: getValuesByCustomFieldValues(customFieldValues, fields)
-        };
-    });
-};
-
-function translateArrayEvent(aiTable, sharedType, event) {
-    let offset = 0;
-    let targetPath = getShareTypeNumberPath(event.path);
-    const isRecordsTranslate = event.path.includes('records');
-    const isFieldsTranslate = event.path.includes('fields');
-    const isViewsTranslate = event.path.includes('views');
-    const actions = [];
-    const activeViewId = aiTable.activeViewId();
-    event.changes.delta.forEach((delta) => {
-        if ('retain' in delta) {
-            offset += delta.retain ?? 0;
-        }
-        if ('delete' in delta) {
-            if (isAddOrRemove(targetPath)) {
-                if (isViewsTranslate) {
-                    const removeView = aiTable.views()[offset];
-                    if (removeView) {
-                        actions.push({
-                            type: ActionName.RemoveView,
-                            path: [removeView._id]
-                        });
-                    }
-                }
-                else {
-                    const type = isRecordsTranslate ? ActionName.RemoveRecord : ActionName.RemoveField;
-                    const removeIds = getRemoveIds(event, type);
-                    if (removeIds.length) {
-                        removeIds.forEach((path) => {
-                            actions.push({
-                                type,
-                                path
-                            });
-                        });
-                    }
-                }
-            }
-        }
-        if ('insert' in delta) {
-            if (isArray(delta.insert)) {
-                if (isRecordsTranslate) {
-                    if (isAddOrRemove(targetPath)) {
-                        delta.insert?.map((item) => {
-                            const data = item.toJSON();
-                            const [systemFieldValues, customFieldValues] = data;
-                            const positions = getPositionsBySystemFieldValues(systemFieldValues);
-                            const position = positions[activeViewId];
-                            const path = translatePositionToPath(aiTable.records(), position, activeViewId);
-                            actions.push({
-                                type: ActionName.AddRecord,
-                                path: path,
-                                record: {
-                                    _id: getIdBySystemFieldValues(systemFieldValues),
-                                    short_id: getShortIdBySystemFieldValues(systemFieldValues),
-                                    ...getTrackableEntityBySystemFieldValues(systemFieldValues),
-                                    positions: getPositionsBySystemFieldValues(systemFieldValues),
-                                    values: getValuesByCustomFieldValues(customFieldValues, aiTable.gridData().fields)
-                                }
-                            });
-                        });
-                    }
-                    else {
-                        try {
-                            const sharedRecords = sharedType.get('records');
-                            const sharedFields = sharedType.get('fields');
-                            let systemFieldOffset = 0;
-                            delta.insert?.map((item, index) => {
-                                const recordIndex = targetPath[0];
-                                const fieldIndex = offset + index;
-                                const record = aiTable.records()[recordIndex];
-                                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 同时包含两个字段的修改
-                                    }
-                                    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);
-                                    const fieldId = getSharedMapValueId(sharedFields, fieldIndex);
-                                    const path = [recordId, fieldId];
-                                    const fieldValue = AITableQueries.getFieldValue(aiTable, path);
-                                    // To exclude insert triggered by field inserts.
-                                    if (fieldValue !== item) {
-                                        actions.push({
-                                            type: ActionName.UpdateFieldValue,
-                                            path,
-                                            fieldValue,
-                                            newFieldValue: item
-                                        });
-                                    }
-                                }
-                            });
-                        }
-                        catch (error) { }
-                    }
-                }
-                if (isFieldsTranslate) {
-                    delta.insert?.map((item, index) => {
-                        const data = item.toJSON();
-                        const path = translatePositionToPath(aiTable.gridData().fields, data['positions'][activeViewId], activeViewId, index);
-                        actions.push({
-                            type: ActionName.AddField,
-                            path,
-                            field: data
-                        });
-                    });
-                }
-                if (isViewsTranslate) {
-                    delta.insert?.map((item, index) => {
-                        const data = item.toJSON();
-                        actions.push({
-                            type: ActionName.AddView,
-                            path: [offset + index],
-                            view: data
-                        });
-                    });
-                }
-            }
-        }
-    });
-    return actions;
-}
-function isAddOrRemove(targetPath) {
-    return targetPath.length === 0;
-}
-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 === SystemFieldIndex.Positions;
-}
-function isUpdatedByOperation(fieldIndex) {
-    return fieldIndex === SystemFieldIndex.UpdatedBy;
-}
-function getRemoveIds(event, type) {
-    const ids = [];
-    if (!type) {
-        return ids;
-    }
-    Y.iterateDeletedStructs(event.transaction, event.transaction.deleteSet, 
-    // @param {Item|GC} item
-    (item) => {
-        if (item instanceof Y.Item && item.deleted) {
-            if (type === ActionName.RemoveField && item.parentSub === '_id') {
-                ids.push(item.content.getContent());
-            }
-            if (type === ActionName.RemoveRecord) {
-                const content = item.content.getContent();
-                if (content[0] && content[0]['_id']) {
-                    ids.push([content[0]['_id']]);
-                }
-            }
-        }
-    });
-    return ids;
-}
-
 function translateMapEvent(aiTable, sharedType, event) {
     const isFieldsTranslate = event.path.includes('fields');
     const isViewTranslate = event.path.includes('views');
@@ -506,7 +95,7 @@ function translateMapEvent(aiTable, sharedType, event) {
 
 function translateYjsEvent(aiTable, sharedType, event) {
     if (event instanceof Y.YArrayEvent) {
-        return translateArrayEvent(aiTable, sharedType, event);
+        return translateArrayEvent(sharedType, event);
     }
     if (event instanceof Y.YMapEvent) {
         return translateMapEvent(aiTable, sharedType, event);
@@ -538,8 +127,14 @@ function updateFieldValue$2(aiTable, sharedType, action) {
         if (recordIndex > -1 && fieldIndex > -1) {
             const record = sharedRecords?.get(recordIndex);
             const customField = record.get(1);
-            customField.delete(fieldIndex);
-            customField.insert(fieldIndex, [action.newFieldValue]);
+            if (fieldIndex < customField.length) {
+                customField.delete(fieldIndex);
+                customField.insert(fieldIndex, [action.newFieldValue]);
+            }
+            else {
+                // 幽灵单元格，协同的后端会对这样的数据进行纠正，但是在纠正同步到位之前，前端可能会出现幽灵单元格
+                console.error('Field index out of bounds, cannot update field value');
+            }
         }
     }
     return sharedType;
@@ -584,7 +179,7 @@ function addNode(aiTable, sharedType, action) {
             records && records.push([toRecordSyncElement(action.record, aiTable.fields())]);
             break;
         case ActionName.AddView:
-            views && views.push([toSyncElement(action.view)]);
+            views && views.push([toMapSyncElement(action.view)]);
             break;
         case ActionName.SetRecordPositions:
             if (records) {
@@ -614,16 +209,22 @@ function addNode(aiTable, sharedType, action) {
             break;
         case ActionName.AddField:
             if (fields && records) {
-                const { field, path } = action;
-                const [insertIndex] = path;
-                const fieldSyncElement = toSyncElement(field);
+                const { field } = action;
+                const insertIndex = fields.length;
+                const fieldSyncElement = toMapSyncElement(field);
                 fields.insert(insertIndex, [fieldSyncElement]);
                 for (let value of records) {
                     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(insertIndex, [newFieldValue]);
+                    // 幽灵单元格，暂不处理交给后端统一处理
+                    if (insertIndex <= customFieldValues.length) {
+                        customFieldValues.insert(insertIndex, [newFieldValue]);
+                    }
+                    else {
+                        console.error('Field index out of bounds, cannot initialize record value for new field');
+                    }
                 }
             }
             break;
@@ -695,6 +296,111 @@ function applyActionOps(aiTable, sharedType, actions) {
     return sharedType;
 }
 
+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 = getRecordsBySharedJson(data['records'], fields);
+    const views = data['views'];
+    return {
+        records,
+        fields,
+        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(toMapSyncElement));
+        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(toMapSyncElement));
+    });
+}
+const getRecordsBySharedJson = (recordJsonArray, fields) => {
+    return recordJsonArray.map((record) => {
+        const [systemFieldValues, customFieldValues] = record;
+        return {
+            _id: getIdBySystemFieldValues(systemFieldValues),
+            short_id: getShortIdBySystemFieldValues(systemFieldValues),
+            ...getTrackableEntityBySystemFieldValues(systemFieldValues),
+            positions: getPositionsBySystemFieldValues(systemFieldValues),
+            values: getValuesByCustomFieldValues(customFieldValues, fields)
+        };
+    });
+};
+
+class UndoManagerService {
+    constructor() {
+        this._undoManager = null;
+        this._canUndoCount = signal(0);
+        this._canRedoCount = signal(0);
+        this._aiTable = null;
+    }
+    get undoManager() {
+        return this._undoManager;
+    }
+    get canUndoCount() {
+        return this._canUndoCount;
+    }
+    get canRedoCount() {
+        return this._canRedoCount;
+    }
+    initialize(sharedType, aiTable) {
+        if (!sharedType || !aiTable) {
+            return;
+        }
+        this._aiTable = aiTable;
+        this._undoManager = new UndoManager(sharedType, {
+            trackedOrigins: new Set([aiTable]),
+            captureTimeout: 300
+        });
+        this._undoManager.on('stack-item-added', () => {
+            this._canUndoCount.set(this._undoManager.undoStack.length);
+            this._canRedoCount.set(this._undoManager.redoStack.length);
+        });
+        this._undoManager.on('stack-item-popped', () => {
+            this._canUndoCount.set(this._undoManager.undoStack.length);
+            this._canRedoCount.set(this._undoManager.redoStack.length);
+        });
+    }
+    undo() {
+        if (this._undoManager?.canUndo()) {
+            YjsAITable.asUndo(this._aiTable, () => this._undoManager.undo());
+        }
+    }
+    redo() {
+        if (this._undoManager?.canRedo()) {
+            YjsAITable.asUndo(this._aiTable, () => this._undoManager.redo());
+        }
+    }
+    destroy() {
+        this._undoManager = null;
+        this._canUndoCount.set(0);
+        this._canRedoCount.set(0);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UndoManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UndoManagerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UndoManagerService, decorators: [{
+            type: Injectable
+        }] });
+
 var AITableStateI18nKey;
 (function (AITableStateI18nKey) {
     AITableStateI18nKey["copyField"] = "copyField";
@@ -753,6 +459,7 @@ function generateCopyName(aiTable, existNames, name) {
     return newName;
 }
 
+// import { FieldModelMap } from '../../../../grid/src/utils/field/field';
 function getSortRecords(aiTable, records, activeView, sortKeysMap) {
     if (!activeView?.settings || !activeView.settings.sorts?.length) {
         return sortByViewPosition(records, activeView);
@@ -958,11 +665,10 @@ function getFieldsSizeMap(fields, activeView) {
     return fieldsSizeMap;
 }
 
-function addField(aiTable, field, path, originId, isCopy) {
+function addField(aiTable, field, originId, isCopy) {
     const operation = {
         type: ActionName.AddField,
         field,
-        path,
         originId,
         isCopy
     };
@@ -1054,42 +760,19 @@ const apply = (aiTable, records, fields, views, action) => {
             break;
         }
         case ActionName.AddRecord: {
-            const [recordIndex] = action.path;
-            if (recordIndex > -1) {
-                if (!action.record.positions) {
-                    const activeView = aiTable.views().find((item) => item._id === aiTable.activeViewId());
-                    let index = recordIndex;
-                    if (activeView?.settings?.conditions) {
-                        index = records.length;
-                    }
-                    action.record.positions = createDefaultPositions(aiTable.views(), aiTable.activeViewId(), aiTable.records(), index);
-                }
-                records.splice(recordIndex, 0, action.record);
+            if (!action.record.positions) {
+                action.record.positions = createDefaultPositions(aiTable.views(), aiTable.activeViewId(), aiTable.records(), records.length);
             }
+            records.push(action.record);
             break;
         }
         case ActionName.AddField: {
-            const [fieldIndex] = action.path;
-            if (fieldIndex > -1) {
-                const newField = action.field;
-                if (!newField.positions) {
-                    newField.positions = createDefaultPositions(aiTable.views(), aiTable.activeViewId(), aiTable.gridData().fields, action.path[0]);
-                }
-                fields.splice(fieldIndex, 0, newField);
-                records.forEach((item) => {
-                    item.values[newField._id] =
-                        action.isCopy && action.originId ? item.values[action.originId] : getDefaultFieldValue(action.field);
-                });
-            }
-            break;
-        }
-        case ActionName.MoveRecord: {
-            if (isPathEqual(action.path, action.newPath)) {
-                return;
-            }
-            const record = records[action.path[0]];
-            records.splice(action.path[0], 1);
-            records.splice(action.newPath[0], 0, record);
+            const newField = action.field;
+            fields.push(newField);
+            records.forEach((item) => {
+                item.values[newField._id] =
+                    action.isCopy && action.originId ? item.values[action.originId] : getDefaultFieldValue(action.field);
+            });
             break;
         }
         case ActionName.RemoveField: {
@@ -1156,10 +839,7 @@ const apply = (aiTable, records, fields, views, action) => {
             break;
         }
         case ActionName.AddView: {
-            const [viewIndex] = action.path;
-            if (viewIndex > -1) {
-                views.splice(viewIndex, 0, action.view);
-            }
+            views.push(action.view);
             break;
         }
         case ActionName.RemoveView: {
@@ -1228,13 +908,11 @@ const PositionsActions = {
 };
 
 function updateFieldValue$1(aiTable, value, path) {
-    const oldValue = AITableQueries.getFieldValue(aiTable, path);
     const field = AITableQueries.getField(aiTable, [path[1]]);
     const fieldModel = field && FieldModelMap[field.type];
     if (fieldModel && fieldModel.isValid(value)) {
         const operation = {
             type: ActionName.UpdateFieldValue,
-            fieldValue: oldValue,
             newFieldValue: value,
             path
         };
@@ -1252,7 +930,7 @@ function updateSystemFieldValue(aiTable, path, updatedInfo) {
     };
     aiTable.apply(operation);
 }
-function addRecord(aiTable, record, path) {
+function addRecord(aiTable, record) {
     const invalidFieldValues = [];
     const isValid = Object.entries(record.values).every(([fieldId, value]) => {
         const field = AITableQueries.getField(aiTable, [fieldId]);
@@ -1266,8 +944,7 @@ function addRecord(aiTable, record, path) {
     if (isValid) {
         const operation = {
             type: ActionName.AddRecord,
-            record,
-            path
+            record
         };
         aiTable.apply(operation);
     }
@@ -1275,14 +952,6 @@ function addRecord(aiTable, record, path) {
         console.error(`Invalid field values at add record. invalidFieldValues: ${invalidFieldValues}`);
     }
 }
-function moveRecord(aiTable, path, newPath) {
-    const operation = {
-        type: ActionName.MoveRecord,
-        path,
-        newPath
-    };
-    aiTable.apply(operation);
-}
 function removeRecord(aiTable, path) {
     const operation = {
         type: ActionName.RemoveRecord,
@@ -1293,7 +962,6 @@ function removeRecord(aiTable, path) {
 const RecordActions = {
     addRecord,
     updateFieldValue: updateFieldValue$1,
-    moveRecord,
     removeRecord,
     updateSystemFieldValue
 };
@@ -1323,11 +991,20 @@ function setView(aiTable, value, path) {
         aiTable.apply(operation);
     }
 }
-function addView$1(aiTable, view, path) {
+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,
-        path
+        view: newView,
+        isDuplicate
     };
     aiTable.apply(operation);
 }
@@ -1359,34 +1036,6 @@ function updateRecordsUpdatedInfo(aiTable, 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.gridData().fields, activeView);
-    let addIndex = fields.findIndex((item) => item._id === originId);
-    if (direction === Direction$1.after) {
-        addIndex++;
-    }
-    const newFieldIds = idsCreator(count);
-    newFieldIds.forEach((id, index) => {
-        const newField = { _id: id, ...defaultValue, positions: null };
-        Actions.addField(aiTable, newField, [addIndex + index], options.originId, options.isCopy);
-    });
-    updateRecordsUpdatedInfo(aiTable, updatedInfo);
-}
-
-const buildRemoveFieldItem = (aiTable, getUpdatedInfo) => {
-    return {
-        type: 'removeField',
-        name: getStateI18nTextByKey(aiTable, AITableStateI18nKey.removeField),
-        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);
@@ -1422,21 +1071,21 @@ function getMaxPosition(data, activeViewId) {
     }, 0);
 }
 function addView(aiTable, type, viewId) {
-    let index = aiTable.views().length;
     const newId = idCreator();
     const shortId = shortIdCreator();
-    const allViewNames = aiTable.views().map((item) => item.name);
-    const count = aiTable.views().length || 0;
+    const views = aiTable.views();
+    const allViewNames = views.map((item) => item.name);
+    const count = views.length || 0;
     const newViewName = generateNewName(allViewNames, count, getStateI18nTextByKey(aiTable, AITableStateI18nKey.tableView));
     let newView = {
         _id: newId,
         short_id: shortId,
         name: newViewName
     };
-    let originViewId = aiTable.views()[aiTable.views().length - 1]._id;
-    if (type === 'copy') {
+    let originViewId = views[views.length - 1]._id;
+    if (type === 'duplicate') {
         originViewId = viewId ?? aiTable.activeViewId();
-        const copyView = aiTable.views().find((item) => item._id === originViewId);
+        const copyView = views.find((item) => item._id === originViewId);
         const copyName = copyView.name;
         const copyViewName = generateCopyName(aiTable, allViewNames, copyName);
         newView = {
@@ -1444,9 +1093,8 @@ function addView(aiTable, type, viewId) {
             _id: newId,
             name: copyViewName
         };
-        index = aiTable.views().indexOf(copyView) + 1;
     }
-    ViewActions.addView(aiTable, newView, [index]);
+    ViewActions.addView(aiTable, originViewId, newView, type === 'duplicate');
     aiTable.records().forEach((record) => {
         PositionsActions.setRecordPositions(aiTable, { [newId]: record.positions[originViewId] }, [record._id]);
     });
@@ -1473,13 +1121,51 @@ function removeView(aiTable, records, fields, activeViewId) {
     });
     ViewActions.removeView(aiTable, [activeViewId]);
 }
+function sortViews(data) {
+    return [...data].sort((a, b) => (a.position ?? data.indexOf(a)) - (b.position ?? data.indexOf(b)));
+}
+
+function addFields(aiTable, options, updatedInfo) {
+    const { defaultValue, isDuplicate, isCopy } = options;
+    const fields = aiTable.gridData().fields;
+    const fieldsMap = aiTable.fieldsMap();
+    const activeViewId = aiTable.activeViewId();
+    const newField = { ...defaultValue };
+    if (fieldsMap[newField._id]) {
+        newField._id = idCreator();
+    }
+    if (isDuplicate) {
+        const currentFieldIndex = fields.findIndex((item) => item._id === options.originId);
+        newField.positions = {
+            ...newField.positions,
+            [activeViewId]: getPosition(fields, activeViewId, currentFieldIndex + 1)
+        };
+    }
+    else {
+        newField.positions = createDefaultPositions(aiTable.views(), aiTable.activeViewId(), aiTable.gridData().fields, fields.length);
+    }
+    Actions.addField(aiTable, newField, options.originId, isCopy || isDuplicate);
+    updateRecordsUpdatedInfo(aiTable, updatedInfo);
+}
+
+const buildRemoveFieldItem = (aiTable, getUpdatedInfo) => {
+    return {
+        type: 'removeField',
+        name: getStateI18nTextByKey(aiTable, AITableStateI18nKey.removeField),
+        icon: 'trash',
+        exec: (aiTable, field) => {
+            Actions.removeField(aiTable, [field()._id]);
+            updateRecordsUpdatedInfo(aiTable, getUpdatedInfo());
+        }
+    };
+};
 
 function addRecords(aiTable, options, trackableEntity) {
-    const { originId, direction = Direction$1.after, isDuplicate, count = 1 } = options;
+    const { originId, direction = Direction.after, isDuplicate, count = 1 } = options;
     const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
     const records = getSortRecords(aiTable, aiTable.gridData().records, activeView);
     let addIndex = records.findIndex((item) => item._id === originId);
-    if (direction === Direction$1.after) {
+    if (direction === Direction.after) {
         addIndex++;
     }
     const newRecordIds = idsCreator(count);
@@ -1495,7 +1181,7 @@ function addRecords(aiTable, options, trackableEntity) {
     }
     newRecordIds.forEach((id, index) => {
         const newRecord = { _id: id, short_id: newRecordShortIds[index], values: newRecordValues, ...trackableEntity };
-        Actions.addRecord(aiTable, newRecord, [addIndex + index]);
+        Actions.addRecord(aiTable, newRecord);
     });
 }
 function getDefaultRecordValues(aiTable, isDuplicate = false, recordId) {
@@ -1619,7 +1305,7 @@ const CopyFieldPropertyItem = (aiTable, addFieldFn) => {
             let newFieldName = generateCopyName(aiTable, allFieldNames, copyName);
             const fieldOptions = {
                 originId: field()._id,
-                isCopy: true,
+                isDuplicate: true,
                 defaultValue: {
                     ...field(),
                     _id: idCreator(),
@@ -1689,5 +1375,5 @@ const VIEW_ACTIONS = [ActionName.SetView, ActionName.AddView, ActionName.RemoveV
  * Generated bundle index. Do not edit.
  */
 
-export { AITableFilterLogical, AITableStateI18nKey, AI_TABLE_CONTENT_FIELD_NAME, ActionName, Actions, CopyCellsItem, CopyFieldPropertyItem, Direction, DividerMenuItem, EditFieldPropertyItem, ExecuteType, FLUSHING, PasteCellsItem, Positions, RemovePositions, RemoveRecordsItem, SystemFieldIndex, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyEvents, applyYjsEvents, buildFieldsByView, buildRecordsByView, buildRemoveFieldItem, createDefaultPositions, createSharedType, doFilter, generateCopyName, getCustomFieldValues, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getIdBySystemFieldValues, getIdBySystemFieldValuesType, getMaxPosition, getPosition, getPositionsByRecordSyncElement, getPositionsBySystemFieldValues, getRecordsBySharedJson, getShareTypeNumberPath, getSharedMapValueId, getSharedMapValueIndex, getSharedRecord, getSharedRecordId, getSharedRecordIndex, getSharedTypeByData, getShortIdBySystemFieldValues, getSortFields, getSortRecords, getStateI18nTextByKey, getSystemFieldValues, getTrackableEntityBySystemFieldValues, getValuesByCustomFieldValues, isPathEqual, moveFields, moveRecords, removeView, setRecordPositions$1 as setRecordPositions, setRecordUpdatedInfo, sortByViewPosition, sortRecordsBySortInfo, toRecordSyncElement, toSharedType, toSyncElement, translatePositionToPath, translateYjsEvent, updateFieldValue, updateRecordsUpdatedInfo, withState };
+export { AITableStateI18nKey, Actions, CopyCellsItem, CopyFieldPropertyItem, DividerMenuItem, EditFieldPropertyItem, FLUSHING, PasteCellsItem, RemoveRecordsItem, UndoManagerService, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyEvents, applyYjsEvents, buildFieldsByView, buildRecordsByView, buildRemoveFieldItem, createDefaultPositions, createSharedType, doFilter, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getMaxPosition, getPosition, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getSortRecords, getStateI18nTextByKey, isPathEqual, moveFields, moveRecords, removeView, sortByViewPosition, sortRecordsBySortInfo, sortViews, toSharedType, translateYjsEvent, updateFieldValue, updateRecordsUpdatedInfo, withState };
 //# sourceMappingURL=ai-table-state.mjs.map