@ai-table/state 0.2.1 → 0.2.3

package/fesm2022/ai-table-state.mjs

@@ -1,9 +1,9 @@
 import * as Y from 'yjs';
 import { UndoManager } from 'yjs';
-import { getShareTypeNumberPath, ActionName, translateArrayEvent, getSharedRecordIndex, getSharedMapValueIndex, toMapSyncElement, getIdBySystemFieldValuesType, setRecordUpdatedInfo, getPositionsByRecordSyncElement, setRecordPositions as setRecordPositions$1, toRecordSyncElement, AI_TABLE_CONTENT_FIELD_NAME, getValuesByCustomFieldValues, getPositionsBySystemFieldValues, getTrackableEntityBySystemFieldValues, getShortIdBySystemFieldValues, getIdBySystemFieldValues, AITableFilterLogical, AITableFilterOperation, AITableFieldType, isEmpty, sortByViewPosition, AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH, AI_TABLE_MIN_FROZEN_COLUMN_COUNT, idCreator, SortDirection } from '@ai-table/utils';
+import { getShareTypeNumberPath, ActionName, translateArrayEvent, getSharedRecordIndex, getSharedMapValueIndex, toMapSyncElement, getIdBySystemFieldValuesType, setRecordUpdatedInfo, getPositionsByRecordSyncElement, setRecordPositions as setRecordPositions$1, toRecordSyncElement, AI_TABLE_CONTENT_FIELD_NAME, getValuesByCustomFieldValues, getPositionsBySystemFieldValues, getTrackableEntityBySystemFieldValues, getShortIdBySystemFieldValues, getIdBySystemFieldValues, AITableFilterLogical, AITableFilterOperation, AITableFieldType, isEmpty, sortByViewPosition, AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH, AI_TABLE_MIN_FROZEN_COLUMN_COUNT, SortDirection, idCreator } from '@ai-table/utils';
 import * as i0 from '@angular/core';
 import { signal, Injectable } from '@angular/core';
-import { FieldModelMap, AITableQueries, isSystemField, AITableRowType, AITable, getColumnIndicesSizeMap, shortIdCreator, generateNewName, getDefaultFieldValue, AI_TABLE_GROUP_MAX_LEVEL, idsCreator, shortIdsCreator, closeExpendCell, setSelection, AI_TABLE_GRID_FIELD_SERVICE_MAP, clearSelection, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, isMac, writeToAITable } from '@ai-table/grid';
+import { FieldModelMap, AITableQueries, isSystemField, AITableRowType, AITable, getColumnIndicesSizeMap, AI_TABLE_GROUP_MAX_LEVEL, shortIdCreator, generateNewName, idsCreator, shortIdsCreator, closeExpendCell, setSelection, buildNormalLinearRows, AI_TABLE_GRID_FIELD_SERVICE_MAP, clearSelection, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, isMac, writeToAITable } from '@ai-table/grid';
 import { nanoid } from 'nanoid';
 import * as _ from 'lodash';
 import ___default, { map, unionBy } from 'lodash';
@@ -409,7 +409,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImpo
             type: Injectable
         }] });
 
-function sortRecordsByConditions(aiTable, records, activeView, sorts, sortKeysMap) {
+function sortRecordsByConditions(aiTable, records, activeView, sorts) {
+    const sortKeysMap = aiTable.sortKeysMap;
     const shallowRecords = [...records];
     return shallowRecords.sort((record1, record2) => {
         if (sorts.length) {
@@ -429,8 +430,8 @@ function compareBySorts(record1, record2, sorts, aiTable, sortKeysMap) {
         }
         const fieldMethod = FieldModelMap[field.type];
         const sortKey = sortKeysMap?.[field.type];
-        const cellValue1 = AITableQueries.getFieldValue(aiTable, [record1._id, field._id]);
-        const cellValue2 = AITableQueries.getFieldValue(aiTable, [record2._id, field._id]);
+        const cellValue1 = AITableQueries.getFieldValue(aiTable, [record1._id, field._id], record1);
+        const cellValue2 = AITableQueries.getFieldValue(aiTable, [record2._id, field._id], record2);
         const references = aiTable.context.references();
         const res = fieldMethod.compare(cellValue1, cellValue2, references, sortKey, {
             aiTable,
@@ -634,8 +635,8 @@ class GroupCalculator {
                     const field = this.fieldsMap[groupField.field_id];
                     if (!field)
                         return;
-                    const prevValue = AITableQueries.getFieldValue(this.aiTable, [previousRecord._id, field._id]);
-                    const currValue = AITableQueries.getFieldValue(this.aiTable, [record._id, field._id]);
+                    const prevValue = AITableQueries.getFieldValue(this.aiTable, [previousRecord._id, field._id], previousRecord);
+                    const currValue = AITableQueries.getFieldValue(this.aiTable, [record._id, field._id], record);
                     const fieldModel = FieldModelMap[field.type];
                     if (!fieldModel)
                         return;
@@ -762,7 +763,7 @@ class GroupCalculator {
                 const groupId = this.generateGroupId(groupField.field_id, depth, breakpointIndex);
                 const isParentCollapsed = this.isParentGroupCollapsed(depth, recordIndex);
                 if (!isParentCollapsed) {
-                    const groupValue = AITableQueries.getFieldValue(this.aiTable, [record._id, field._id]);
+                    const groupValue = AITableQueries.getFieldValue(this.aiTable, [record._id, field._id], record);
                     const recordRange = this.calculateGroupRecordRange(groupField.field_id, breakpointIndex, totalRecords);
                     groupTabRows.push({
                         type: AITableRowType.group,
@@ -822,8 +823,8 @@ class GroupCalculator {
     }
 }
 
-function getParentLinearRowGroups(aiTable, targetId) {
-    const linearRows = aiTable.context.linearRows();
+function getParentLinearRowGroups(aiTable, targetId, linearRows) {
+    linearRows = linearRows || aiTable.context.linearRows();
     const targetIndex = aiTable.context.visibleRowsIndexMap().get(targetId);
     if (targetIndex === -1) {
         return [];
@@ -841,57 +842,113 @@ function getParentLinearRowGroups(aiTable, targetId) {
             }
         }
     }
-    return parentGroups;
+    return parentGroups.reverse();
 }
-
-function buildRecordsByView(aiTable, records, fields, activeView, sortKeysMap) {
-    const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
-    const sorts = buildSorts(activeView);
-    return sortRecordsByConditions(aiTable, filteredRecords, activeView, sorts, sortKeysMap);
+function isSameParentGroup(aiTable, recordId, originGroupLinearRows, tmpNewGroupLinearRows) {
+    const originalParentLinearRowGroups = getParentLinearRowGroups(aiTable, recordId, originGroupLinearRows);
+    const newParentLinearRowGroups = getParentLinearRowGroups(aiTable, recordId, tmpNewGroupLinearRows);
+    return ___default.join(___default.map(originalParentLinearRowGroups, 'groupValue'), ':') !== ___default.join(___default.map(newParentLinearRowGroups, 'groupValue'), ':');
 }
-function buildFieldsByView(aiTable, fields, activeView) {
-    const sortFields = getSortFields(aiTable, fields, activeView);
-    return buildFieldStatType(sortFields, activeView);
+function getGroupRecordLength(aiTable, recordId, linearRows) {
+    const parentLinearRowGroups = getParentLinearRowGroups(aiTable, recordId, linearRows);
+    const parentGroup = parentLinearRowGroups[parentLinearRowGroups.length - 1];
+    if (parentGroup && parentGroup.range) {
+        return parentGroup.range[1] - parentGroup.range[0] + 1;
+    }
+    return 0;
 }
-function buildGroupLinearRows(aiTable, activeView, records) {
-    if (aiTable && activeView?.settings?.groups?.length) {
-        try {
-            const groups = activeView.settings?.groups;
-            const collapsedGroupIds = activeView.settings?.collapsed_group_ids;
-            const calculator = new GroupCalculator(aiTable, groups, collapsedGroupIds);
-            return calculator.calculateLinearRows(records);
+
+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;
         }
-        catch (error) {
-            console.warn('Grouped build failed, using the default build method:', error);
+        else {
+            const firstField = fields[0];
+            newPosition = firstField.positions[viewId] - 0.1;
         }
     }
-    return null;
-}
-function buildSorts(activeView) {
-    const groups = activeView.settings?.groups || [];
-    const isKeepSort = activeView.settings?.is_keep_sort;
-    if (groups.length > 0 && !isKeepSort) {
-        return groups.map((group) => ({
-            sort_by: group.field_id,
-            direction: group.direction
-        }));
-    }
-    else if (isKeepSort) {
-        return mergeSorts(activeView);
+    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 [];
+    return newPosition;
 }
-function mergeSorts(activeView) {
-    const groups = activeView.settings?.groups || [];
-    const sorts = activeView.settings?.sorts || [];
-    const groupsAsSorts = map(groups, (group) => ({
-        sort_by: group.field_id,
-        direction: group.direction
-    }));
-    const mergedSorts = unionBy(groupsAsSorts, sorts, 'sort_by');
-    return mergedSorts;
+function getFieldsSizeMap(fields, activeView) {
+    const fieldsSizeMap = {};
+    fields?.forEach((field) => {
+        fieldsSizeMap[field._id] = field.widths?.[activeView._id];
+    });
+    return fieldsSizeMap;
 }
 
+var AITableStateI18nKey;
+(function (AITableStateI18nKey) {
+    AITableStateI18nKey["copyField"] = "copyField";
+    AITableStateI18nKey["removeRecords"] = "removeRecords";
+    AITableStateI18nKey["copy"] = "copy";
+    AITableStateI18nKey["copySuffix"] = "copySuffix";
+    AITableStateI18nKey["paste"] = "paste";
+    AITableStateI18nKey["invalidPasteContent"] = "invalidPasteContent";
+    AITableStateI18nKey["tableView"] = "tableView";
+    AITableStateI18nKey["editField"] = "editField";
+    AITableStateI18nKey["removeField"] = "removeField";
+    AITableStateI18nKey["pasteOverMaxRecords"] = "pasteOverMaxRecords";
+    AITableStateI18nKey["pasteOverMaxFields"] = "pasteOverMaxFields";
+    AITableStateI18nKey["insertUpward"] = "insertUpward";
+    AITableStateI18nKey["insertDownward"] = "insertDownward";
+    AITableStateI18nKey["upward"] = "upward";
+    AITableStateI18nKey["downward"] = "downward";
+    AITableStateI18nKey["freezeToThisColumn"] = "freezeToThisColumn";
+    AITableStateI18nKey["restoreDefaultFrozenColumn"] = "restoreDefaultFrozenColumn";
+})(AITableStateI18nKey || (AITableStateI18nKey = {}));
+const AITableStateI18nText = {
+    [AITableStateI18nKey.copyField]: '复制列',
+    [AITableStateI18nKey.removeRecords]: '删除行',
+    [AITableStateI18nKey.copy]: '复制',
+    [AITableStateI18nKey.copySuffix]: '副本',
+    [AITableStateI18nKey.paste]: '粘贴',
+    [AITableStateI18nKey.invalidPasteContent]: '粘贴内容不符合当前类型',
+    [AITableStateI18nKey.tableView]: '表格视图',
+    [AITableStateI18nKey.editField]: '编辑列',
+    [AITableStateI18nKey.removeField]: '删除列',
+    [AITableStateI18nKey.pasteOverMaxRecords]: '粘贴数据超过最大行数',
+    [AITableStateI18nKey.pasteOverMaxFields]: '粘贴数据超过最大列数',
+    [AITableStateI18nKey.insertUpward]: '向上插入',
+    [AITableStateI18nKey.insertDownward]: '向下插入',
+    [AITableStateI18nKey.upward]: '行',
+    [AITableStateI18nKey.downward]: '行',
+    [AITableStateI18nKey.freezeToThisColumn]: '冻结至此列',
+    [AITableStateI18nKey.restoreDefaultFrozenColumn]: '恢复默认冻结列'
+};
+const getDefaultI18nTextByKey = (key) => {
+    return AITableStateI18nText[key] || key;
+};
+const getStateI18nTextByKey = (aiTable, key) => {
+    if (aiTable.getI18nTextByKey) {
+        const customText = aiTable.getI18nTextByKey(key);
+        if (customText) {
+            return customText;
+        }
+    }
+    const defaultText = getDefaultI18nTextByKey(key);
+    return defaultText;
+};
+
 function setView(aiTable, value, path) {
     const view = aiTable.views().find((item) => item._id === path[0]);
     if (view) {
@@ -961,127 +1018,6 @@ const ViewActions = {
     setViewFrozenField
 };
 
-function buildSetRecordPositionsActon(aiTable, positions, path) {
-    const action = {
-        type: ActionName.SetRecordPositions,
-        positions,
-        path
-    };
-    return action;
-}
-function setRecordPositions(aiTable, positions, path) {
-    const operation = buildSetRecordPositionsActon(aiTable, positions, path);
-    aiTable.apply(operation);
-}
-const PositionsActions = {
-    setRecordPositions
-};
-
-var AITableStateI18nKey;
-(function (AITableStateI18nKey) {
-    AITableStateI18nKey["copyField"] = "copyField";
-    AITableStateI18nKey["removeRecords"] = "removeRecords";
-    AITableStateI18nKey["copy"] = "copy";
-    AITableStateI18nKey["copySuffix"] = "copySuffix";
-    AITableStateI18nKey["paste"] = "paste";
-    AITableStateI18nKey["invalidPasteContent"] = "invalidPasteContent";
-    AITableStateI18nKey["tableView"] = "tableView";
-    AITableStateI18nKey["editField"] = "editField";
-    AITableStateI18nKey["removeField"] = "removeField";
-    AITableStateI18nKey["pasteOverMaxRecords"] = "pasteOverMaxRecords";
-    AITableStateI18nKey["pasteOverMaxFields"] = "pasteOverMaxFields";
-    AITableStateI18nKey["insertUpward"] = "insertUpward";
-    AITableStateI18nKey["insertDownward"] = "insertDownward";
-    AITableStateI18nKey["upward"] = "upward";
-    AITableStateI18nKey["downward"] = "downward";
-    AITableStateI18nKey["freezeToThisColumn"] = "freezeToThisColumn";
-    AITableStateI18nKey["restoreDefaultFrozenColumn"] = "restoreDefaultFrozenColumn";
-})(AITableStateI18nKey || (AITableStateI18nKey = {}));
-const AITableStateI18nText = {
-    [AITableStateI18nKey.copyField]: '复制列',
-    [AITableStateI18nKey.removeRecords]: '删除行',
-    [AITableStateI18nKey.copy]: '复制',
-    [AITableStateI18nKey.copySuffix]: '副本',
-    [AITableStateI18nKey.paste]: '粘贴',
-    [AITableStateI18nKey.invalidPasteContent]: '粘贴内容不符合当前类型',
-    [AITableStateI18nKey.tableView]: '表格视图',
-    [AITableStateI18nKey.editField]: '编辑列',
-    [AITableStateI18nKey.removeField]: '删除列',
-    [AITableStateI18nKey.pasteOverMaxRecords]: '粘贴数据超过最大行数',
-    [AITableStateI18nKey.pasteOverMaxFields]: '粘贴数据超过最大列数',
-    [AITableStateI18nKey.insertUpward]: '向上插入',
-    [AITableStateI18nKey.insertDownward]: '向下插入',
-    [AITableStateI18nKey.upward]: '行',
-    [AITableStateI18nKey.downward]: '行',
-    [AITableStateI18nKey.freezeToThisColumn]: '冻结至此列',
-    [AITableStateI18nKey.restoreDefaultFrozenColumn]: '恢复默认冻结列'
-};
-const getDefaultI18nTextByKey = (key) => {
-    return AITableStateI18nText[key] || key;
-};
-const getStateI18nTextByKey = (aiTable, key) => {
-    if (aiTable.getI18nTextByKey) {
-        const customText = aiTable.getI18nTextByKey(key);
-        if (customText) {
-            return customText;
-        }
-    }
-    const defaultText = getDefaultI18nTextByKey(key);
-    return defaultText;
-};
-
-function isPathEqual(path, another) {
-    return path.length === another.length && path.every((n, i) => n === another[i]);
-}
-function generateCopyName(aiTable, existNames, name) {
-    const copyText = getStateI18nTextByKey(aiTable, AITableStateI18nKey.copySuffix);
-    let newName = `${name} ${copyText}`;
-    let index = 2;
-    while (existNames.includes(newName)) {
-        newName = `${name} ${copyText} ${index}`;
-        index++;
-    }
-    return newName;
-}
-
-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 getFrozenFieldId(aiTable) {
     try {
         const viewTable = aiTable;
@@ -1348,130 +1284,6 @@ const FieldActions = {
     setFieldStatType
 };
 
-function createPositions(views, activeId, data, index) {
-    return createMultiplePositions(views, activeId, data, index)[0];
-}
-function createMultiplePositions(views, activeId, data, targetIndex = data.length - 1, count = 1, isInsertUpward = false) {
-    const positionsOfItems = getPositions(activeId, data, targetIndex, count, isInsertUpward);
-    const viewsMaxPosition = {};
-    views.forEach((view) => {
-        viewsMaxPosition[view._id] = getMaxPosition(data, view._id);
-    });
-    const positions = positionsOfItems.map((itemPositions) => {
-        const viewPositions = {};
-        views.forEach((view) => {
-            if (view._id === activeId) {
-                viewPositions[view._id] = itemPositions;
-            }
-            else {
-                viewsMaxPosition[view._id] += 1;
-                viewPositions[view._id] = viewsMaxPosition[view._id];
-            }
-        });
-        return viewPositions;
-    });
-    return positions;
-}
-function getPositions(activeId, data, targetIndex = data.length - 1, count = 1, isInsertBefore = false) {
-    let startPosition = data[data.length - 1].positions[activeId];
-    let endPosition = startPosition + count + 1;
-    if (data[targetIndex]) {
-        if (isInsertBefore) {
-            endPosition = data[targetIndex].positions[activeId];
-            startPosition = targetIndex - 1 >= 0 ? data[targetIndex - 1].positions[activeId] : endPosition - count - 1;
-        }
-        else {
-            startPosition = data[targetIndex].positions[activeId];
-            endPosition =
-                targetIndex + 1 < data.length
-                    ? data[targetIndex + 1].positions[activeId]
-                    : data[targetIndex].positions[activeId] + count + 1;
-        }
-    }
-    const step = (endPosition - startPosition) / (count + 1);
-    const positions = ___default.range(startPosition + step, endPosition, step);
-    return positions;
-}
-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];
-        }
-        return maxPosition;
-    }, 0);
-}
-function addView(aiTable, type, viewId) {
-    const newId = idCreator();
-    const shortId = shortIdCreator();
-    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 = views[views.length - 1]._id;
-    if (type === 'duplicate') {
-        originViewId = viewId ?? aiTable.activeViewId();
-        const copyView = views.find((item) => item._id === originViewId);
-        const copyName = copyView.name;
-        const copyViewName = generateCopyName(aiTable, allViewNames, copyName);
-        newView = {
-            ...copyView,
-            _id: newId,
-            name: copyViewName
-        };
-    }
-    ViewActions.addView(aiTable, originViewId, newView, type === 'duplicate');
-    const actions = [];
-    aiTable.records().forEach((record, index) => {
-        const action = buildSetRecordPositionsActon(aiTable, { [newId]: record.positions[originViewId] }, [index]);
-        actions.push(action);
-    });
-    aiTable.fields().forEach((field) => {
-        const action = buildSetFieldAction(aiTable, {
-            positions: {
-                ...field.positions,
-                [newId]: field.positions[originViewId]
-            }
-        }, [field._id]);
-        if (action) {
-            actions.push(action);
-        }
-    });
-    aiTable.apply(actions);
-    return newView;
-}
-function removeView(aiTable, records, fields, activeViewId) {
-    ViewActions.removeView(aiTable, [activeViewId]);
-    const actions = [];
-    records.forEach((record, index) => {
-        const action = buildSetRecordPositionsActon(aiTable, { [activeViewId]: undefined }, [index]);
-        actions.push(action);
-    });
-    fields.forEach((field) => {
-        const positions = { ...field.positions };
-        delete positions[activeViewId];
-        const action = buildSetFieldAction(aiTable, {
-            positions
-        }, [field._id]);
-        if (action) {
-            actions.push(action);
-        }
-    });
-    aiTable.apply(actions);
-}
-function sortViews(data) {
-    return [...data].sort((a, b) => (a.position ?? data.indexOf(a)) - (b.position ?? data.indexOf(b)));
-}
-
-const FLUSHING = new WeakMap();
-
 const apply = (aiTable, records, fields, views, action) => {
     switch (action.type) {
         case ActionName.UpdateFieldValue: {
@@ -1502,9 +1314,9 @@ const apply = (aiTable, records, fields, views, action) => {
         case ActionName.AddField: {
             const newField = action.field;
             fields.push(newField);
+            const defaultValue = FieldModelMap[newField.type].getDefaultValue();
             records.forEach((item) => {
-                item.values[newField._id] =
-                    action.isDuplicate && action.originId ? item.values[action.originId] : getDefaultFieldValue(action.field);
+                item.values[newField._id] = action.isDuplicate && action.originId ? item.values[action.originId] : defaultValue;
             });
             break;
         }
@@ -1630,6 +1442,22 @@ const GeneralActions = {
     }
 };
 
+function buildSetRecordPositionsActon(aiTable, positions, path) {
+    const action = {
+        type: ActionName.SetRecordPositions,
+        positions,
+        path
+    };
+    return action;
+}
+function setRecordPositions(aiTable, positions, path) {
+    const operation = buildSetRecordPositionsActon(aiTable, positions, path);
+    aiTable.apply(operation);
+}
+const PositionsActions = {
+    setRecordPositions
+};
+
 function updateFieldValues$1(aiTable, options) {
     let operations = [];
     (options || []).forEach((option) => {
@@ -1825,9 +1653,140 @@ const Actions = {
     ...GroupActions
 };
 
-function moveFields(aiTable, options) {
-    const { path, newPath } = options;
-    Actions.moveField(aiTable, path, newPath);
+function isPathEqual(path, another) {
+    return path.length === another.length && path.every((n, i) => n === another[i]);
+}
+function generateCopyName(aiTable, existNames, name) {
+    const copyText = getStateI18nTextByKey(aiTable, AITableStateI18nKey.copySuffix);
+    let newName = `${name} ${copyText}`;
+    let index = 2;
+    while (existNames.includes(newName)) {
+        newName = `${name} ${copyText} ${index}`;
+        index++;
+    }
+    return newName;
+}
+
+function createPositions(views, activeId, data, index) {
+    return createMultiplePositions(views, activeId, data, index)[0];
+}
+function createMultiplePositions(views, activeId, data, targetIndex = data.length - 1, count = 1, isInsertUpward = false) {
+    const positionsOfItems = getPositions(activeId, data, targetIndex, count, isInsertUpward);
+    const viewsMaxPosition = {};
+    views.forEach((view) => {
+        viewsMaxPosition[view._id] = getMaxPosition(data, view._id);
+    });
+    const positions = positionsOfItems.map((itemPositions) => {
+        const viewPositions = {};
+        views.forEach((view) => {
+            if (view._id === activeId) {
+                viewPositions[view._id] = itemPositions;
+            }
+            else {
+                viewsMaxPosition[view._id] += 1;
+                viewPositions[view._id] = viewsMaxPosition[view._id];
+            }
+        });
+        return viewPositions;
+    });
+    return positions;
+}
+function getPositions(activeId, data, targetIndex = data.length - 1, count = 1, isInsertBefore = false) {
+    let startPosition = data[data.length - 1].positions[activeId];
+    let endPosition = startPosition + count + 1;
+    if (data[targetIndex]) {
+        if (isInsertBefore) {
+            endPosition = data[targetIndex].positions[activeId];
+            startPosition = targetIndex - 1 >= 0 ? data[targetIndex - 1].positions[activeId] : endPosition - count - 1;
+        }
+        else {
+            startPosition = data[targetIndex].positions[activeId];
+            endPosition =
+                targetIndex + 1 < data.length
+                    ? data[targetIndex + 1].positions[activeId]
+                    : data[targetIndex].positions[activeId] + count + 1;
+        }
+    }
+    const step = (endPosition - startPosition) / (count + 1);
+    const positions = ___default.range(startPosition + step, endPosition, step);
+    return positions;
+}
+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];
+        }
+        return maxPosition;
+    }, 0);
+}
+function addView(aiTable, type, viewId) {
+    const newId = idCreator();
+    const shortId = shortIdCreator();
+    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 = views[views.length - 1]._id;
+    if (type === 'duplicate') {
+        originViewId = viewId ?? aiTable.activeViewId();
+        const copyView = views.find((item) => item._id === originViewId);
+        const copyName = copyView.name;
+        const copyViewName = generateCopyName(aiTable, allViewNames, copyName);
+        newView = {
+            ...copyView,
+            _id: newId,
+            name: copyViewName
+        };
+    }
+    ViewActions.addView(aiTable, originViewId, newView, type === 'duplicate');
+    const actions = [];
+    aiTable.records().forEach((record, index) => {
+        const action = buildSetRecordPositionsActon(aiTable, { [newId]: record.positions[originViewId] }, [index]);
+        actions.push(action);
+    });
+    aiTable.fields().forEach((field) => {
+        const action = buildSetFieldAction(aiTable, {
+            positions: {
+                ...field.positions,
+                [newId]: field.positions[originViewId]
+            }
+        }, [field._id]);
+        if (action) {
+            actions.push(action);
+        }
+    });
+    aiTable.apply(actions);
+    return newView;
+}
+function removeView(aiTable, records, fields, activeViewId) {
+    ViewActions.removeView(aiTable, [activeViewId]);
+    const actions = [];
+    records.forEach((record, index) => {
+        const action = buildSetRecordPositionsActon(aiTable, { [activeViewId]: undefined }, [index]);
+        actions.push(action);
+    });
+    fields.forEach((field) => {
+        const positions = { ...field.positions };
+        delete positions[activeViewId];
+        const action = buildSetFieldAction(aiTable, {
+            positions
+        }, [field._id]);
+        if (action) {
+            actions.push(action);
+        }
+    });
+    aiTable.apply(actions);
+}
+function sortViews(data) {
+    return [...data].sort((a, b) => (a.position ?? data.indexOf(a)) - (b.position ?? data.indexOf(b)));
 }
 
 function findNextRecordForTargetInOriginalRecords(aiTable, targetRecordId) {
@@ -1964,87 +1923,12 @@ function getPrevRecordIdByAddGroupId(aiTable, groupId) {
     }
     return null;
 }
-
-function moveRecords(aiTable, options, updatedInfo) {
-    const activeViewId = aiTable.activeViewId();
-    const activeView = aiTable.views().find((view) => view._id === activeViewId);
-    const { recordIds, afterRecordId, beforeRecordId } = options;
-    const originalRecords = aiTable.records();
-    const recordsIndexMap = new Map(originalRecords.map((row, index) => [row._id, index]));
-    const sourceRecords = [];
-    recordIds.forEach((id) => {
-        const index = recordsIndexMap.get(id);
-        if (index === undefined) {
-            throw new Error(`Record with id ${id} not found`);
-        }
-        sourceRecords.push(originalRecords[index]);
-    });
-    let { targetPosition, prevPosition } = getPositionByAfterOrBeforeRecordId(aiTable, {
-        afterRecordId,
-        beforeRecordId
+function buildRecordsWithWillMoveRecords(records, willMoveRecordsMap) {
+    return records.map((record) => {
+        return (willMoveRecordsMap.get(record._id) || record);
     });
-    const groups = activeView.settings?.groups;
-    let needCopyGroupValuesMap = null;
-    if (groups?.length && (afterRecordId || beforeRecordId)) {
-        needCopyGroupValuesMap = getParentGroupValuesByGroupId(aiTable, (afterRecordId || beforeRecordId));
-    }
-    // 勾选多行顺序可能不一致，需要排序
-    const sortedSourceRecords = sortByViewPosition(sourceRecords, activeView);
-    let nextPosition = (prevPosition + targetPosition) / 2;
-    sortedSourceRecords.forEach((record) => {
-        const sourceIndex = recordsIndexMap.get(record._id);
-        if (sourceIndex === undefined) {
-            throw new Error(`Record with id ${record._id} not found`);
-        }
-        if (groups?.length && needCopyGroupValuesMap) {
-            const updateFieldValues = [];
-            groups.forEach((group) => {
-                updateFieldValues.push({
-                    path: [record._id, group.field_id],
-                    value: needCopyGroupValuesMap[group.field_id]
-                });
-            });
-            Actions.updateFieldValues(aiTable, updateFieldValues);
-        }
-        Actions.setRecordPositions(aiTable, { [activeViewId]: nextPosition }, [sourceIndex]);
-        prevPosition = nextPosition;
-        nextPosition = (prevPosition + targetPosition) / 2;
-    });
-}
-
-function addFields(aiTable, options) {
-    const { defaultValue, isDuplicate, originId } = options;
-    const fields = aiTable.gridData().fields;
-    const fieldsMap = aiTable.fieldsMap();
-    const activeViewId = aiTable.activeViewId();
-    const newField = { ...defaultValue };
-    if (fieldsMap[newField._id]) {
-        newField._id = idCreator();
-    }
-    if (isDuplicate) {
-        const currentFieldIndex = fields.findIndex((item) => item._id === originId);
-        newField.positions = {
-            ...newField.positions,
-            [activeViewId]: getPosition(fields, activeViewId, currentFieldIndex)
-        };
-    }
-    else {
-        newField.positions = createPositions(aiTable.views(), aiTable.activeViewId(), aiTable.gridData().fields);
-    }
-    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 addRecords(aiTable, trackableEntity, options) {
     options = options || {};
     const newRecords = [];
@@ -2117,13 +2001,8 @@ function getDefaultRecordValues(aiTable, isDuplicate = false, recordId) {
         const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
         const fields = getSortFields(aiTable, aiTable.fields(), activeView);
         fields.map((field) => {
-            const customGetDefaultFieldValue = aiTable.context?.aiFieldConfig()?.customFields?.[field.type]?.getDefaultFieldValue;
-            if (customGetDefaultFieldValue) {
-                newRecordValues[field._id] = customGetDefaultFieldValue(field);
-            }
-            else {
-                newRecordValues[field._id] = getDefaultFieldValue(field);
-            }
+            const defaultValue = FieldModelMap[field.type].getDefaultValue();
+            newRecordValues[field._id] = defaultValue;
         });
         const { conditions, condition_logical } = activeView.settings || {};
         if (conditions && conditions.length) {
@@ -2160,12 +2039,98 @@ function updateWillHiddenRecordIds(aiTable, needUpdateOptions, updatedInfo) {
         return value;
     });
 }
+function updateWillMoveRecords(aiTable, needUpdateOptions, updatedInfo) {
+    const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
+    const groups = activeView.settings?.groups ?? [];
+    const sorts = activeView.settings?.sorts ?? [];
+    const sortFieldSet = new Set();
+    const isKeepSort = activeView.settings?.is_keep_sort;
+    if (isKeepSort) {
+        sorts.forEach((sort) => {
+            sortFieldSet.add(sort.sort_by);
+        });
+    }
+    groups.forEach((group) => {
+        sortFieldSet.add(group.field_id);
+    });
+    const updateRecordsMap = new Map();
+    needUpdateOptions.forEach((option) => {
+        const [recordId, fieldId] = option.path;
+        if (sortFieldSet.has(fieldId)) {
+            let record = updateRecordsMap.get(recordId) || _.cloneDeep(aiTable.recordsMap()[recordId]);
+            record.values[fieldId] = option.value;
+            if (updatedInfo) {
+                record = {
+                    ...record,
+                    ...updatedInfo
+                };
+            }
+            updateRecordsMap.set(recordId, record);
+        }
+    });
+    if (updateRecordsMap.size === 0) {
+        return;
+    }
+    const visibleRowsIndexMap = aiTable.context.visibleRowsIndexMap();
+    const tmpNewRecords = aiTable.records().map((record) => {
+        const newRecord = updateRecordsMap.get(record._id);
+        if (newRecord) {
+            return newRecord;
+        }
+        return record;
+    });
+    const willMoveRecordMap = new Map();
+    const allSorts = buildSorts(activeView);
+    const tmpNewSortedRecords = sortRecordsByConditions(aiTable, tmpNewRecords, activeView, allSorts);
+    let originGroupLinearRows = aiTable.context.linearRows();
+    const tmpNewGroupLinearRows = buildLinearRows(aiTable, activeView, tmpNewSortedRecords) ?? [];
+    updateRecordsMap.forEach((updateSortFieldRecord, recordId) => {
+        const originalRecordIndex = visibleRowsIndexMap.get(recordId);
+        const newRecordOfIndex = tmpNewGroupLinearRows[originalRecordIndex];
+        if (recordId !== newRecordOfIndex?._id) {
+            const originalRecord = aiTable.recordsWillMove().get(recordId) || aiTable.recordsMap()[recordId];
+            willMoveRecordMap.set(recordId, originalRecord);
+        }
+        else {
+            /**
+             * 处理以下场景
+             * group1 - true
+             *  group2 - 1
+             *    record1    true   1
+             *    record2    true   1
+             *
+             * record1 true --> false 变更后的实际分组为
+             *
+             * group3 - false
+             *  group4 - 1
+             *    record1    false   1
+             * group1 - true
+             *  group2 - 1
+             *    record2    true   1
+             *
+             * 或者由下变为上面的数据时同理（ record1 false --> true）
+             */
+            const originParentGroupRecordsCount = getGroupRecordLength(aiTable, recordId, originGroupLinearRows);
+            const tmpNewParentGroupRecordsCount = getGroupRecordLength(aiTable, recordId, tmpNewGroupLinearRows);
+            if ((originParentGroupRecordsCount > 1 || tmpNewParentGroupRecordsCount > 1) &&
+                isSameParentGroup(aiTable, recordId, originGroupLinearRows, tmpNewGroupLinearRows)) {
+                const originalRecord = aiTable.recordsWillMove().get(recordId) || aiTable.recordsMap()[recordId];
+                willMoveRecordMap.set(recordId, originalRecord);
+            }
+            else {
+                willMoveRecordMap.delete(recordId);
+            }
+        }
+    });
+    aiTable.recordsWillMove.set(willMoveRecordMap);
+}
 function updateFieldValues(aiTable, options, updatedInfo) {
     const needUpdateOptions = options.filter((option) => {
         const oldValue = AITableQueries.getFieldValue(aiTable, option.path);
         return !_.isEqual(oldValue, option.value);
     });
     updateWillHiddenRecordIds(aiTable, needUpdateOptions, updatedInfo);
+    updateWillMoveRecords(aiTable, needUpdateOptions, updatedInfo);
     Actions.updateFieldValues(aiTable, needUpdateOptions);
     if (updatedInfo) {
         const needUpdateSystemOptions = needUpdateOptions.map((option) => {
@@ -2178,6 +2143,148 @@ function updateFieldValues(aiTable, options, updatedInfo) {
     }
 }
 
+function moveRecords(aiTable, options, updatedInfo) {
+    const activeViewId = aiTable.activeViewId();
+    const activeView = aiTable.views().find((view) => view._id === activeViewId);
+    const { recordIds, afterRecordId, beforeRecordId } = options;
+    const originalRecords = aiTable.records();
+    const recordsIndexMap = new Map(originalRecords.map((row, index) => [row._id, index]));
+    const sourceRecords = [];
+    recordIds.forEach((id) => {
+        const index = recordsIndexMap.get(id);
+        if (index === undefined) {
+            throw new Error(`Record with id ${id} not found`);
+        }
+        sourceRecords.push(originalRecords[index]);
+    });
+    let { targetPosition, prevPosition } = getPositionByAfterOrBeforeRecordId(aiTable, {
+        afterRecordId,
+        beforeRecordId
+    });
+    const groups = activeView.settings?.groups;
+    let needCopyGroupValuesMap = null;
+    if (groups?.length && (afterRecordId || beforeRecordId)) {
+        needCopyGroupValuesMap = getParentGroupValuesByGroupId(aiTable, (afterRecordId || beforeRecordId));
+    }
+    // 勾选多行顺序可能不一致，需要排序
+    const sortedSourceRecords = sortByViewPosition(sourceRecords, activeView);
+    let nextPosition = (prevPosition + targetPosition) / 2;
+    sortedSourceRecords.forEach((record) => {
+        const sourceIndex = recordsIndexMap.get(record._id);
+        if (sourceIndex === undefined) {
+            throw new Error(`Record with id ${record._id} not found`);
+        }
+        if (groups?.length && needCopyGroupValuesMap) {
+            const updateFieldValues = [];
+            groups.forEach((group) => {
+                updateFieldValues.push({
+                    path: [record._id, group.field_id],
+                    value: needCopyGroupValuesMap[group.field_id]
+                });
+            });
+            Actions.updateFieldValues(aiTable, updateFieldValues);
+        }
+        Actions.setRecordPositions(aiTable, { [activeViewId]: nextPosition }, [sourceIndex]);
+        prevPosition = nextPosition;
+        nextPosition = (prevPosition + targetPosition) / 2;
+    });
+}
+
+function buildRecordsByView(aiTable, records, fields, activeView, sortKeysMap) {
+    const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
+    const sorts = buildSorts(activeView);
+    const renderRecords = buildRecordsWithWillMoveRecords(filteredRecords, aiTable.recordsWillMove());
+    return sortRecordsByConditions(aiTable, renderRecords, activeView, sorts);
+}
+function buildFieldsByView(aiTable, fields, activeView) {
+    const sortFields = getSortFields(aiTable, fields, activeView);
+    return buildFieldStatType(sortFields, activeView);
+}
+function buildLinearRows(aiTable, activeView, records) {
+    if (aiTable && activeView?.settings?.groups?.length) {
+        try {
+            const groups = activeView.settings?.groups;
+            let collapsedGroupIds = [];
+            if (!aiTable.context.groupCollapseDisabled()) {
+                collapsedGroupIds = activeView.settings?.collapsed_group_ids || [];
+            }
+            const calculator = new GroupCalculator(aiTable, groups, collapsedGroupIds);
+            return calculator.calculateLinearRows(records);
+        }
+        catch (error) {
+            console.warn('Grouped build failed, using the default build method:', error);
+            return null;
+        }
+    }
+    else {
+        return buildNormalLinearRows(records);
+    }
+}
+function buildSorts(activeView) {
+    const groups = activeView.settings?.groups || [];
+    const isKeepSort = activeView.settings?.is_keep_sort;
+    if (groups.length > 0 && !isKeepSort) {
+        return groups.map((group) => ({
+            sort_by: group.field_id,
+            direction: group.direction
+        }));
+    }
+    else if (isKeepSort) {
+        return mergeSorts(activeView);
+    }
+    return [];
+}
+function mergeSorts(activeView) {
+    const groups = activeView.settings?.groups || [];
+    const sorts = activeView.settings?.sorts || [];
+    const groupsAsSorts = map(groups, (group) => ({
+        sort_by: group.field_id,
+        direction: group.direction
+    }));
+    const mergedSorts = unionBy(groupsAsSorts, sorts, 'sort_by');
+    return mergedSorts;
+}
+
+const FLUSHING = new WeakMap();
+
+function moveFields(aiTable, options) {
+    const { path, newPath } = options;
+    Actions.moveField(aiTable, path, newPath);
+}
+
+function addFields(aiTable, options) {
+    const { defaultValue, isDuplicate, originId } = options;
+    const fields = aiTable.gridData().fields;
+    const fieldsMap = aiTable.fieldsMap();
+    const activeViewId = aiTable.activeViewId();
+    const newField = { ...defaultValue };
+    if (fieldsMap[newField._id]) {
+        newField._id = idCreator();
+    }
+    if (isDuplicate) {
+        const currentFieldIndex = fields.findIndex((item) => item._id === originId);
+        newField.positions = {
+            ...newField.positions,
+            [activeViewId]: getPosition(fields, activeViewId, currentFieldIndex)
+        };
+    }
+    else {
+        newField.positions = createPositions(aiTable.views(), aiTable.activeViewId(), aiTable.gridData().fields);
+    }
+    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 = [];
@@ -2405,5 +2512,5 @@ const VIEW_ACTIONS = [ActionName.SetView, ActionName.AddView, ActionName.RemoveV
  * Generated bundle index. Do not edit.
  */
 
-export { AITableStateI18nKey, AITableStateI18nText, Actions, CopyCellsItem, CopyFieldPropertyItem, DividerMenuItem, EditFieldPropertyItem, FLUSHING, GroupCalculator, InsertDownwardRecords, InsertUpwardRecords, PasteCellsItem, RemoveRecordsItem, UndoManagerService, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyActions, applyEvents, applyYjsEvents, buildFieldsByView, buildGroupLinearRows, buildRecordsByView, buildRemoveFieldItem, buildSetFieldAction, buildSetRecordPositionsActon, buildSorts, calculateAdaptiveFrozenColumnCount, checkConditions, createMultiplePositions, createPositions, createSharedType, doFilter, findNextRecordForTargetInOriginalRecords, findPrevRecordForTargetInOriginalRecords, freezeToThisColumn, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getFrozenFieldId, getMaxPosition, getNewRecordsPosition, getParentGroupValuesByGroupId, getParentLinearRowGroups, getPosition, getPositionByAfterOrBeforeRecordId, getPositions, getPrevRecordIdByAddGroupId, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getStateI18nTextByKey, isPathEqual, mergeSorts, moveFields, moveRecords, removeView, restoreDefaultFrozenColumn, sortRecordsByConditions, sortViews, toSharedType, translateYjsEvent, updateFieldAndValues, updateFieldValues, withState };
+export { AITableStateI18nKey, AITableStateI18nText, Actions, CopyCellsItem, CopyFieldPropertyItem, DividerMenuItem, EditFieldPropertyItem, FLUSHING, GroupCalculator, InsertDownwardRecords, InsertUpwardRecords, PasteCellsItem, RemoveRecordsItem, UndoManagerService, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyActions, applyEvents, applyYjsEvents, buildFieldsByView, buildLinearRows, buildRecordsByView, buildRecordsWithWillMoveRecords, buildRemoveFieldItem, buildSetFieldAction, buildSetRecordPositionsActon, buildSorts, calculateAdaptiveFrozenColumnCount, checkConditions, createMultiplePositions, createPositions, createSharedType, doFilter, findNextRecordForTargetInOriginalRecords, findPrevRecordForTargetInOriginalRecords, freezeToThisColumn, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getFrozenFieldId, getGroupRecordLength, getMaxPosition, getNewRecordsPosition, getParentGroupValuesByGroupId, getParentLinearRowGroups, getPosition, getPositionByAfterOrBeforeRecordId, getPositions, getPrevRecordIdByAddGroupId, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getStateI18nTextByKey, isPathEqual, isSameParentGroup, mergeSorts, moveFields, moveRecords, removeView, restoreDefaultFrozenColumn, sortRecordsByConditions, sortViews, toSharedType, translateYjsEvent, updateFieldAndValues, updateFieldValues, withState };
 //# sourceMappingURL=ai-table-state.mjs.map