@ai-table/state 0.0.11 → 0.0.13

package/fesm2022/ai-table-state.mjs

@@ -1,8 +1,48 @@
 import * as Y from 'yjs';
-import { ActionName, AITableQueries, getDefaultFieldValue, idCreator, Actions, FLUSHING, AITableFieldType } from '@ai-table/grid';
 import { isArray, isEmpty as isEmpty$1, isObject, isUndefinedOrNull, TinyDate } from 'ngx-tethys/util';
-import { createDraft, finishDraft } from 'immer';
+import { AITableQueries, getDefaultFieldValue, idCreator, AITableFieldType, Direction as Direction$1, AI_TABLE_GRID_FIELD_SERVICE_MAP } from '@ai-table/grid';
+import _, { isEqual } from 'lodash';
 import { fromUnixTime, subDays } from 'date-fns';
+import { createDraft, finishDraft } from 'immer';
+
+const IS_LOCAL = new WeakSet();
+const IS_REMOTE = new WeakSet();
+const IS_UNDO = new WeakSet();
+const YjsAITable = {
+    isLocal: (aiTable) => {
+        return IS_LOCAL.has(aiTable);
+    },
+    asLocal: (aiTable, fn) => {
+        const wasLocal = YjsAITable.isLocal(aiTable);
+        IS_LOCAL.add(aiTable);
+        fn();
+        if (!wasLocal) {
+            IS_LOCAL.delete(aiTable);
+        }
+    },
+    isRemote: (aiTable) => {
+        return IS_REMOTE.has(aiTable);
+    },
+    asRemote: (aiTable, fn) => {
+        const wasRemote = YjsAITable.isRemote(aiTable);
+        IS_REMOTE.add(aiTable);
+        fn();
+        if (!wasRemote) {
+            Promise.resolve().then(() => IS_REMOTE.delete(aiTable));
+        }
+    },
+    isUndo: (aiTable) => {
+        return IS_UNDO.has(aiTable);
+    },
+    asUndo: (aiTable, fn) => {
+        const wasUndo = YjsAITable.isUndo(aiTable);
+        IS_UNDO.add(aiTable);
+        fn();
+        if (!wasUndo) {
+            Promise.resolve().then(() => IS_UNDO.delete(aiTable));
+        }
+    }
+};
 
 class Positions {
 }
@@ -34,17 +74,29 @@ var AITableFilterOperation;
     AITableFilterOperation["exists"] = "exists";
     AITableFilterOperation["notContain"] = "not_contain";
 })(AITableFilterOperation || (AITableFilterOperation = {}));
-var ViewActionName;
-(function (ViewActionName) {
-    ViewActionName["SetView"] = "set_view";
-    ViewActionName["AddView"] = "add_view";
-    ViewActionName["RemoveView"] = "remove_view";
-})(ViewActionName || (ViewActionName = {}));
-var PositionActionName;
-(function (PositionActionName) {
-    PositionActionName["AddRecordPosition"] = "add_record_position";
-    PositionActionName["RemoveRecordPosition"] = "remove_record_position";
-})(PositionActionName || (PositionActionName = {}));
+
+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["AddRecordPosition"] = "add_record_position";
+    ActionName["RemoveRecordPosition"] = "remove_record_position";
+})(ActionName || (ActionName = {}));
+var ExecuteType;
+(function (ExecuteType) {
+    ExecuteType[ExecuteType["Execute"] = 0] = "Execute";
+    ExecuteType[ExecuteType["Undo"] = 1] = "Undo";
+    ExecuteType[ExecuteType["Redo"] = 2] = "Redo";
+})(ExecuteType || (ExecuteType = {}));
 
 const createSharedType = () => {
     const doc = new Y.Doc();
@@ -185,7 +237,7 @@ function translateArrayEvent(aiTable, sharedType, event) {
                     const removeView = aiTable.views()[offset];
                     if (removeView) {
                         actions.push({
-                            type: ViewActionName.RemoveView,
+                            type: ActionName.RemoveView,
                             path: [removeView._id]
                         });
                     }
@@ -235,7 +287,7 @@ function translateArrayEvent(aiTable, sharedType, event) {
                                     for (const key in item) {
                                         if (!record.positions[key] && record.positions[key] !== 0) {
                                             actions.push({
-                                                type: PositionActionName.AddRecordPosition,
+                                                type: ActionName.AddRecordPosition,
                                                 path: [record._id],
                                                 position: {
                                                     [key]: item[key]
@@ -246,7 +298,7 @@ function translateArrayEvent(aiTable, sharedType, event) {
                                     for (const key in record.positions) {
                                         if (!item[key] && item[key] !== 0) {
                                             actions.push({
-                                                type: PositionActionName.RemoveRecordPosition,
+                                                type: ActionName.RemoveRecordPosition,
                                                 path: [key, record._id]
                                             });
                                         }
@@ -287,7 +339,7 @@ function translateArrayEvent(aiTable, sharedType, event) {
                     delta.insert?.map((item, index) => {
                         const data = item.toJSON();
                         actions.push({
-                            type: ViewActionName.AddView,
+                            type: ActionName.AddView,
                             path: [offset + index],
                             view: data
                         });
@@ -359,7 +411,7 @@ function translateMapEvent(aiTable, sharedType, event) {
                 const k = key;
                 properties[k] = value;
             }
-            const type = isFieldsTranslate ? ActionName.SetField : ViewActionName.SetView;
+            const type = isFieldsTranslate ? ActionName.SetField : ActionName.SetView;
             return [
                 {
                     type,
@@ -373,45 +425,6 @@ function translateMapEvent(aiTable, sharedType, event) {
     return [];
 }
 
-const IS_LOCAL = new WeakSet();
-const IS_REMOTE = new WeakSet();
-const IS_UNDO = new WeakSet();
-const YjsAITable = {
-    isLocal: (aiTable) => {
-        return IS_LOCAL.has(aiTable);
-    },
-    asLocal: (aiTable, fn) => {
-        const wasLocal = YjsAITable.isLocal(aiTable);
-        IS_LOCAL.add(aiTable);
-        fn();
-        if (!wasLocal) {
-            IS_LOCAL.delete(aiTable);
-        }
-    },
-    isRemote: (aiTable) => {
-        return IS_REMOTE.has(aiTable);
-    },
-    asRemote: (aiTable, fn) => {
-        const wasRemote = YjsAITable.isRemote(aiTable);
-        IS_REMOTE.add(aiTable);
-        fn();
-        if (!wasRemote) {
-            Promise.resolve().then(() => IS_REMOTE.delete(aiTable));
-        }
-    },
-    isUndo: (aiTable) => {
-        return IS_UNDO.has(aiTable);
-    },
-    asUndo: (aiTable, fn) => {
-        const wasUndo = YjsAITable.isUndo(aiTable);
-        IS_UNDO.add(aiTable);
-        fn();
-        if (!wasUndo) {
-            Promise.resolve().then(() => IS_UNDO.delete(aiTable));
-        }
-    }
-};
-
 function translateYjsEvent(aiTable, sharedType, event) {
     if (event instanceof Y.YArrayEvent) {
         return translateArrayEvent(aiTable, sharedType, event);
@@ -437,7 +450,7 @@ function applyYjsEvents(aiTable, sharedType, events) {
     }
 }
 
-function updateFieldValue(sharedType, action) {
+function updateFieldValue$2(sharedType, action) {
     const sharedRecords = sharedType.get('records');
     const sharedFields = sharedType.get('fields');
     if (sharedRecords && sharedFields) {
@@ -458,7 +471,7 @@ function setNode(sharedType, action) {
     if (action.type === ActionName.SetField) {
         sharedNodes = sharedType.get('fields');
     }
-    if (action.type === ViewActionName.SetView) {
+    if (action.type === ActionName.SetView) {
         sharedNodes = sharedType.get('views');
     }
     if (sharedNodes) {
@@ -491,10 +504,10 @@ function addNode(sharedType, action) {
         case ActionName.AddRecord:
             records && records.push([toRecordSyncElement(action.record)]);
             break;
-        case ViewActionName.AddView:
+        case ActionName.AddView:
             views && views.push([toSyncElement(action.view)]);
             break;
-        case PositionActionName.AddRecordPosition:
+        case ActionName.AddRecordPosition:
             if (records) {
                 const recordIndex = getSharedRecordIndex(records, action.path[0]);
                 const record = records.get(recordIndex);
@@ -534,7 +547,7 @@ function removeNode(sharedType, action) {
                 }
             }
             break;
-        case ViewActionName.RemoveView:
+        case ActionName.RemoveView:
             if (views) {
                 const viewIndex = getSharedMapValueIndex(views, action.path[0]);
                 if (viewIndex > -1) {
@@ -542,7 +555,7 @@ function removeNode(sharedType, action) {
                 }
             }
             break;
-        case PositionActionName.RemoveRecordPosition:
+        case ActionName.RemoveRecordPosition:
             if (records) {
                 const recordIndex = getSharedRecordIndex(records, action.path[1]);
                 const record = records.get(recordIndex);
@@ -571,7 +584,7 @@ function removeNode(sharedType, action) {
 
 const actionMappers = {
     add_record: addNode,
-    update_field_value: updateFieldValue,
+    update_field_value: updateFieldValue$2,
     remove_record: removeNode,
     add_field: addNode,
     set_field: setNode,
@@ -597,343 +610,92 @@ function applyActionOps(sharedType, actions, aiTable) {
     return sharedType;
 }
 
-function createDefaultPositions(views, activeId, data, index) {
-    const positions = {};
-    const position = getPosition(data, activeId, index);
-    const maxPosition = data[data.length - 1].positions[activeId];
-    views.forEach((element) => {
-        positions[element._id] = element._id === activeId ? position : maxPosition + 1;
-    });
-    return positions;
-}
-function getPosition(data, activeViewId, index) {
-    let position = data.length - 1;
-    if (index !== 0 && index !== data.length) {
-        const previousViewPosition = data[index - 1].positions[activeViewId];
-        const nextViewPosition = data[index].positions[activeViewId];
-        position = (previousViewPosition + nextViewPosition) / 2;
+function isEmpty(value) {
+    if (isArray(value)) {
+        return isEmpty$1(value);
     }
-    else {
-        position = index;
+    if (isObject(value)) {
+        return Reflect.ownKeys(value).length === 0;
     }
-    return position;
+    return isUndefinedOrNull(value) || value == '';
 }
-function addView$1(aiTable, type) {
-    let index = aiTable.views().length;
-    const newId = idCreator();
-    let newView = {
-        _id: newId,
-        name: '表格视图 ' + index
-    };
-    let originViewId = aiTable.views()[aiTable.views().length - 1]._id;
-    if (type === 'copy') {
-        originViewId = aiTable.activeViewId();
-        const copyView = aiTable.views().find((item) => item._id === aiTable.activeViewId());
-        newView = {
-            ...copyView,
-            _id: newId,
-            name: copyView.name + '-副本'
-        };
-        index = aiTable.views().indexOf(copyView) + 1;
+function getNewIdsByCount(count) {
+    if (count <= 0)
+        return [];
+    const newIds = [];
+    for (let i = 0; i < count; i++) {
+        newIds.push(idCreator());
     }
-    ViewActions.addView(aiTable, newView, [index]);
-    aiTable.records().forEach((record) => {
-        PositionActions.addRecordPosition(aiTable, { [newId]: record.positions[originViewId] }, [record._id]);
-    });
-    aiTable.fields().forEach((field) => {
-        Actions.setField(aiTable, {
-            positions: {
-                ...field.positions,
-                [newId]: field.positions[originViewId]
-            }
-        }, [field._id]);
-    });
-    return newView;
+    return newIds;
 }
-function removeView$1(aiTable, records, fields, activeViewId) {
-    records.forEach((record) => {
-        PositionActions.removeRecordPosition(aiTable, [activeViewId, record._id]);
-    });
-    fields.forEach((field) => {
-        const positions = { ...field.positions };
-        delete positions[activeViewId];
-        Actions.setField(aiTable, {
-            positions
-        }, [field._id]);
-    });
-    ViewActions.removeView(aiTable, [activeViewId]);
+function isPathEqual(path, another) {
+    return path.length === another.length && path.every((n, i) => n === another[i]);
+}
+function sortByViewPosition(data, activeView) {
+    const hasPositions = data.every((item) => item.positions && item.positions);
+    if (hasPositions) {
+        return [...data].sort((a, b) => a.positions[activeView._id] - b.positions[activeView._id]);
+    }
+    return data;
 }
 
-const GeneralViewActions = {
-    transform(aiTable, action) {
-        const views = createDraft(aiTable.views());
-        applyView(aiTable, views, action);
-        aiTable.views.set(finishDraft(views));
+const zhIntlCollator = typeof Intl !== 'undefined' ? new Intl.Collator('zh-CN') : undefined;
+class Field {
+    stringInclude(str, searchStr) {
+        return str.toLowerCase().includes(searchStr.trim().toLowerCase());
     }
-};
-const applyView = (aiTable, views, action) => {
-    switch (action.type) {
-        case ViewActionName.SetView: {
-            const view = views.find((item) => item._id === action.path[0]);
-            if (view) {
-                for (const key in action.newProperties) {
-                    const k = key;
-                    const value = action.newProperties[k];
-                    if (value == null) {
-                        delete view[k];
-                    }
-                    else {
-                        view[k] = value;
-                    }
-                }
-                // properties that were previously defined, but are now missing, must be deleted
-                for (const key in action.properties) {
-                    if (!action.newProperties.hasOwnProperty(key)) {
-                        delete view[key];
-                    }
-                }
+    isMeetFilter(condition, cellValue) {
+        switch (condition.operation) {
+            case AITableFilterOperation.empty:
+            case AITableFilterOperation.exists: {
+                return this.isEmptyOrNot(condition.operation, cellValue);
             }
-            break;
-        }
-        case ViewActionName.AddView: {
-            const [viewIndex] = action.path;
-            if (viewIndex > -1) {
-                views.splice(viewIndex, 0, action.view);
+            default: {
+                return true;
             }
-            break;
         }
-        case ViewActionName.RemoveView: {
-            const [viewId] = action.path;
-            const viewIndex = views.findIndex((item) => item._id === viewId);
-            if (viewIndex > -1) {
-                views.splice(viewIndex, 1);
+    }
+    isEmptyOrNot(operation, cellValue) {
+        switch (operation) {
+            case AITableFilterOperation.empty: {
+                return isEmpty(cellValue);
+            }
+            case AITableFilterOperation.exists: {
+                return !isEmpty(cellValue);
+            }
+            default: {
+                throw new Error('compare operator type error');
             }
-            break;
         }
     }
-};
-const GeneralActions = {
-    transform(aiTable, action) {
-        const records = createDraft(aiTable.records());
-        const fields = createDraft(aiTable.fields());
-        apply(aiTable, records, fields, action);
-        if (action.type === ActionName.AddRecord) {
-            aiTable.records.set(finishDraft(records));
+    eq(cv1, cv2) {
+        return isEqual(cv1, cv2);
+    }
+    compare(cellValue1, cellValue2, field) {
+        if (this.eq(cellValue1, cellValue2)) {
+            return 0;
         }
-        if (action.type === ActionName.AddField) {
-            aiTable.fields.set(finishDraft(fields));
+        if (cellValue1 == null) {
+            return -1;
         }
-    }
-};
-const apply = (aiTable, records, fields, action) => {
-    switch (action.type) {
-        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);
-            }
-            break;
+        if (cellValue2 == null) {
+            return 1;
         }
-        case ActionName.AddField: {
-            const [fieldIndex] = action.path;
-            if (fieldIndex > -1) {
-                const newField = action.field;
-                newField.positions = createDefaultPositions(aiTable.views(), aiTable.activeViewId(), aiTable.fields(), action.path[0]);
-                fields.splice(fieldIndex, 0, newField);
-                const newRecord = {
-                    [newField._id]: getDefaultFieldValue(action.field)
-                };
-                records.forEach((item) => {
-                    item.values = {
-                        ...item.values,
-                        ...newRecord
-                    };
-                });
-            }
-            break;
-        }
-    }
-};
-const GeneralPositionActions = {
-    transform(aiTable, action) {
-        const records = createDraft(aiTable.records());
-        const fields = createDraft(aiTable.fields());
-        applyPosition(aiTable, records, action);
-        aiTable.records.update(() => {
-            return finishDraft(records);
-        });
-        aiTable.fields.update(() => {
-            return finishDraft(fields);
-        });
-    }
-};
-const applyPosition = (aiTable, records, action) => {
-    switch (action.type) {
-        case PositionActionName.AddRecordPosition: {
-            const { position, path } = action;
-            const record = records.find((item) => item._id === path[0]);
-            if (record) {
-                record.positions = {
-                    ...record.positions,
-                    ...position
-                };
-            }
-            break;
-        }
-        case PositionActionName.RemoveRecordPosition: {
-            const { path } = action;
-            const record = records.find((item) => item._id === path[1]);
-            delete record?.positions[path[0]];
-            break;
-        }
-    }
-};
-
-function setView(aiTable, value, path) {
-    const view = aiTable.views().find((item) => item._id === path[0]);
-    if (view) {
-        const properties = {};
-        const newProperties = {};
-        for (const key in value) {
-            const k = key;
-            if (JSON.stringify(view[k]) !== JSON.stringify(value[k])) {
-                if (view.hasOwnProperty(k)) {
-                    properties[k] = view[k];
-                }
-                if (newProperties[k] !== null) {
-                    newProperties[k] = value[k];
-                }
-            }
-        }
-        const operation = {
-            type: ViewActionName.SetView,
-            properties,
-            newProperties,
-            path
-        };
-        aiTable.apply(operation);
-    }
-}
-function addView(aiTable, view, path) {
-    const operation = {
-        type: ViewActionName.AddView,
-        view,
-        path
-    };
-    aiTable.apply(operation);
-}
-function removeView(aiTable, path) {
-    const operation = {
-        type: ViewActionName.RemoveView,
-        path
-    };
-    aiTable.apply(operation);
-}
-const ViewActions = {
-    setView,
-    addView,
-    removeView
-};
-
-function addRecordPosition(aiTable, position, path) {
-    const operation = {
-        type: PositionActionName.AddRecordPosition,
-        position,
-        path
-    };
-    aiTable.apply(operation);
-}
-function removeRecordPosition(aiTable, path) {
-    const operation = {
-        type: PositionActionName.RemoveRecordPosition,
-        path
-    };
-    aiTable.apply(operation);
-}
-const PositionActions = {
-    addRecordPosition,
-    removeRecordPosition
-};
-
-const VIEW_ACTIONS = [ViewActionName.SetView, ViewActionName.AddView, ViewActionName.RemoveView];
-const POSITION_ACTIONS = [PositionActionName.AddRecordPosition, PositionActionName.RemoveRecordPosition];
-
-const withView = (aiTable) => {
-    const viewTable = aiTable;
-    viewTable.apply = (action) => {
-        const sharedActions = viewTable.actions;
-        sharedActions.push(action);
-        if (VIEW_ACTIONS.includes(action.type)) {
-            GeneralViewActions.transform(viewTable, action);
-        }
-        else if (POSITION_ACTIONS.includes(action.type)) {
-            GeneralPositionActions.transform(viewTable, action);
-        }
-        else {
-            if (action.type === ActionName.AddField || action.type === ActionName.AddRecord) {
-                GeneralActions.transform(viewTable, action);
-            }
-            else {
-                Actions.transform(aiTable, action);
-            }
-        }
-        if (!FLUSHING.get(aiTable)) {
-            FLUSHING.set(aiTable, true);
-            Promise.resolve().then(() => {
-                FLUSHING.set(aiTable, false);
-                aiTable.onChange();
-                aiTable.actions = [];
-            });
-        }
-    };
-    return aiTable;
-};
-
-function isEmpty(value) {
-    if (isArray(value)) {
-        return isEmpty$1(value);
-    }
-    if (isObject(value)) {
-        return Reflect.ownKeys(value).length === 0;
-    }
-    return isUndefinedOrNull(value) || value == '';
-}
-
-class Field {
-    stringInclude(str, searchStr) {
-        return str.toLowerCase().includes(searchStr.trim().toLowerCase());
-    }
-    isMeetFilter(condition, cellValue) {
-        switch (condition.operation) {
-            case AITableFilterOperation.empty:
-            case AITableFilterOperation.exists: {
-                return this.isEmptyOrNot(condition.operation, cellValue);
-            }
-            default: {
-                return true;
-            }
-        }
-    }
-    isEmptyOrNot(operation, cellValue) {
-        switch (operation) {
-            case AITableFilterOperation.empty: {
-                return isEmpty(cellValue);
-            }
-            case AITableFilterOperation.exists: {
-                return !isEmpty(cellValue);
-            }
-            default: {
-                throw new Error('compare operator type error');
-            }
+        let str1 = this.cellValueToString(cellValue1, field);
+        let str2 = this.cellValueToString(cellValue2, field);
+        if (str1 === str2) {
+            return 0;
         }
+        if (str1 == null) {
+            return -1;
+        }
+        if (str2 == null) {
+            return 1;
+        }
+        str1 = str1.trim();
+        str2 = str2.trim();
+        // test pinyin sort
+        return str1 === str2 ? 0 : zhIntlCollator ? zhIntlCollator.compare(str1, str2) : str1.localeCompare(str2, 'zh-CN') > 0 ? 1 : -1;
     }
 }
 
@@ -953,6 +715,12 @@ class TextField extends Field {
     static stringInclude(str, searchStr) {
         return str.toLowerCase().includes(searchStr.trim().toLowerCase());
     }
+    eq(cv1, cv2) {
+        return this.cellValueToString(cv1) === this.cellValueToString(cv2);
+    }
+    cellValueToString(cellValue) {
+        return cellValue;
+    }
 }
 
 class SelectField extends Field {
@@ -970,6 +738,28 @@ class SelectField extends Field {
                 return super.isMeetFilter(condition, cellValue);
         }
     }
+    cellValueToString(cellValue, field) {
+        return this.arrayValueToString(this.cellValueToArray(cellValue, field));
+    }
+    cellValueToArray(cellValue, field) {
+        if (!cellValue) {
+            return null;
+        }
+        const result = [];
+        for (let i = 0, l = cellValue.length; i < l; i++) {
+            const option = this.findOptionById(field, cellValue[i]);
+            if (option) {
+                result.push(option.text);
+            }
+        }
+        return result;
+    }
+    findOptionById(field, id) {
+        return field.settings.options.find(option => option._id === id) || null;
+    }
+    arrayValueToString(cellValues) {
+        return cellValues && cellValues.length ? cellValues.join(', ') : null;
+    }
 }
 function hasIntersect(array1, array2) {
     if (!Array.isArray(array1) || !Array.isArray(array2)) {
@@ -1034,6 +824,24 @@ class DateField extends Field {
                 ];
         }
     }
+    cellValueToString(_cellValue) {
+        return null;
+    }
+    static _compare(cellValue1, cellValue2) {
+        if (isEmpty(cellValue1?.timestamp) && isEmpty(cellValue2?.timestamp)) {
+            return 0;
+        }
+        if (isEmpty(cellValue1?.timestamp)) {
+            return -1;
+        }
+        if (isEmpty(cellValue2?.timestamp)) {
+            return 1;
+        }
+        return cellValue1.timestamp === cellValue2.timestamp ? 0 : cellValue1.timestamp > cellValue2.timestamp ? 1 : -1;
+    }
+    compare(cellValue1, cellValue2) {
+        return DateField._compare(cellValue1, cellValue2);
+    }
 }
 
 class NumberField extends Field {
@@ -1059,6 +867,24 @@ class NumberField extends Field {
                 return super.isMeetFilter(condition, cellValue);
         }
     }
+    cellValueToString(_cellValue) {
+        return null;
+    }
+    static _compare(cellValue1, cellValue2) {
+        if (isEmpty(cellValue1) && isEmpty(cellValue2)) {
+            return 0;
+        }
+        if (isEmpty(cellValue1)) {
+            return -1;
+        }
+        if (isEmpty(cellValue2)) {
+            return 1;
+        }
+        return cellValue1 === cellValue2 ? 0 : cellValue1 > cellValue2 ? 1 : -1;
+    }
+    compare(cellValue1, cellValue2) {
+        return NumberField._compare(cellValue1, cellValue2);
+    }
 }
 
 class RateField extends Field {
@@ -1076,6 +902,24 @@ class RateField extends Field {
                 return super.isMeetFilter(condition, cellValue);
         }
     }
+    cellValueToString(_cellValue) {
+        return null;
+    }
+    static _compare(cellValue1, cellValue2) {
+        if (isEmpty(cellValue1) && isEmpty(cellValue2)) {
+            return 0;
+        }
+        if (isEmpty(cellValue1)) {
+            return -1;
+        }
+        if (isEmpty(cellValue2)) {
+            return 1;
+        }
+        return cellValue1 === cellValue2 ? 0 : cellValue1 > cellValue2 ? 1 : -1;
+    }
+    compare(cellValue1, cellValue2) {
+        return RateField._compare(cellValue1, cellValue2);
+    }
 }
 
 const ViewOperationMap = {
@@ -1094,7 +938,38 @@ const ViewOperationMap = {
     [AITableFieldType.updatedBy]: new SelectField()
 };
 
-function getFilteredRecords(records, fields, activeView) {
+function getSortRecords(aiTable, records, activeView) {
+    if (!activeView?.settings || !activeView.settings.sorts?.length) {
+        return records;
+    }
+    const { is_keep_sort, sorts } = activeView.settings;
+    if (is_keep_sort && sorts?.length) {
+        return sortRecordsBySortInfo(aiTable, records, activeView);
+    }
+    return sortByViewPosition(records, activeView);
+}
+function sortRecordsBySortInfo(aiTable, records, activeView) {
+    const shallowRows = [...records];
+    if (activeView.settings?.sorts?.length) {
+        shallowRows.sort((prev, current) => {
+            return activeView.settings.sorts.reduce((acc, rule) => {
+                const field = aiTable.fieldsMap()[rule.sort_by];
+                if (!field || acc !== 0) {
+                    return acc;
+                }
+                const fieldMethod = ViewOperationMap[field.type];
+                const cellValue1 = AITableQueries.getFieldValue(aiTable, [prev._id, field._id]);
+                const cellValue2 = AITableQueries.getFieldValue(aiTable, [current._id, field._id]);
+                const res = fieldMethod.compare(cellValue1, cellValue2, field);
+                return res * rule.direction;
+            }, 0);
+        });
+        return shallowRows;
+    }
+    return shallowRows;
+}
+
+function getFilteredRecords(aiTable, records, fields, activeView) {
     const { conditions, condition_logical } = activeView.settings || {};
     if (!conditions) {
         return records;
@@ -1103,7 +978,11 @@ function getFilteredRecords(records, fields, activeView) {
     if (!illegalConditions.length) {
         return records;
     }
+    const recordsWillHidden = aiTable.recordsWillHidden();
     return records.filter((record) => {
+        if (recordsWillHidden && recordsWillHidden.length && recordsWillHidden.includes(record._id)) {
+            return true;
+        }
         return checkConditions(fields, record, { conditions: illegalConditions, condition_logical });
     });
 }
@@ -1142,25 +1021,563 @@ function doFilter(condition, field, cellValue) {
     }
     return ViewOperationMap[field.type].isMeetFilter(condition, cellValue);
 }
-
-function sortByView(data, activeViewId) {
-    const hasPositions = data.every((item) => item.positions && item.positions);
-    if (hasPositions) {
-        return [...data].sort((a, b) => a.positions[activeViewId] - b.positions[activeViewId]);
+function getDefaultRecordDataByFilter(recordValues, conditions, conditionLogical) {
+    if (conditions.length === 1) {
+        // recordValues[conditions[0].field_id] = conditions[0].value;
     }
-    return data;
+    else {
+        //...
+    }
+    return recordValues;
+}
+
+function getSortFields(aiTable, fields, activeView) {
+    return sortByViewPosition(fields, activeView);
+}
+
+function buildRecordsByView(aiTable, records, fields, activeView) {
+    const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
+    return getSortRecords(aiTable, filteredRecords, activeView);
+}
+function buildFieldsByView(aiTable, fields, activeView) {
+    return getSortFields(aiTable, fields, activeView);
+}
+
+function addField(aiTable, field, path) {
+    const operation = {
+        type: ActionName.AddField,
+        field,
+        path
+    };
+    aiTable.apply(operation);
+}
+function moveField(aiTable, path, newPath) {
+    const operation = {
+        type: ActionName.MoveField,
+        path,
+        newPath
+    };
+    aiTable.apply(operation);
 }
-function buildRecordsByView(records, fields, activeView) {
-    const filteredRecords = getFilteredRecords(records, fields, activeView);
-    return sortByView(filteredRecords, activeView._id);
+function removeField(aiTable, path) {
+    const operation = {
+        type: ActionName.RemoveField,
+        path
+    };
+    aiTable.apply(operation);
 }
-function buildFieldsByView(fields, activeView) {
-    return sortByView(fields, activeView._id);
+function setField(aiTable, value, path) {
+    const field = AITableQueries.getField(aiTable, path);
+    if (field) {
+        const properties = {};
+        const newProperties = {};
+        for (const key in value) {
+            const k = key;
+            if (JSON.stringify(field[k]) !== JSON.stringify(value[k])) {
+                if (field.hasOwnProperty(k)) {
+                    properties[k] = field[k];
+                }
+                if (newProperties[k] !== null) {
+                    newProperties[k] = value[k];
+                }
+            }
+        }
+        const operation = {
+            type: ActionName.SetField,
+            properties,
+            newProperties,
+            path
+        };
+        aiTable.apply(operation);
+    }
 }
+const FieldActions = {
+    addField,
+    moveField,
+    removeField,
+    setField
+};
+
+const apply = (aiTable, records, fields, views, action) => {
+    switch (action.type) {
+        case ActionName.UpdateFieldValue: {
+            const [recordId, fieldId] = action.path;
+            if (recordId && fieldId) {
+                const recordIndex = aiTable.records().findIndex((item) => item._id === recordId);
+                records[recordIndex].values[fieldId] = action.newFieldValue;
+            }
+            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);
+            }
+            break;
+        }
+        case ActionName.AddField: {
+            const [fieldIndex] = action.path;
+            if (fieldIndex > -1) {
+                const newField = action.field;
+                newField.positions = createDefaultPositions(aiTable.views(), aiTable.activeViewId(), aiTable.fields(), action.path[0]);
+                fields.splice(fieldIndex, 0, newField);
+                const newRecord = {
+                    [newField._id]: getDefaultFieldValue(action.field)
+                };
+                records.forEach((item) => {
+                    item.values = {
+                        ...item.values,
+                        ...newRecord
+                    };
+                });
+            }
+            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);
+            break;
+        }
+        case ActionName.MoveField: {
+            if (isPathEqual(action.path, action.newPath)) {
+                return;
+            }
+            const field = fields[action.path[0]];
+            fields.splice(action.path[0], 1);
+            fields.splice(action.newPath[0], 0, field);
+            break;
+        }
+        case ActionName.RemoveField: {
+            const [fieldId] = action.path;
+            const fieldIndex = aiTable.fields().findIndex((item) => item._id === fieldId);
+            if (fieldIndex > -1) {
+                fields.splice(fieldIndex, 1);
+                records.forEach((item) => {
+                    delete item.values[fieldId];
+                });
+            }
+            break;
+        }
+        case ActionName.RemoveRecord: {
+            const [recordId] = action.path;
+            const recordIndex = aiTable.records().findIndex((item) => item._id === recordId);
+            if (recordIndex > -1) {
+                records.splice(recordIndex, 1);
+            }
+            break;
+        }
+        case ActionName.SetField: {
+            const field = fields.find((item) => item._id === action.path[0]);
+            if (field) {
+                for (const key in action.newProperties) {
+                    const k = key;
+                    const value = action.newProperties[k];
+                    if (value == null) {
+                        delete field[k];
+                    }
+                    else {
+                        field[k] = value;
+                    }
+                }
+                // properties that were previously defined, but are now missing, must be deleted
+                for (const key in action.properties) {
+                    if (!action.newProperties.hasOwnProperty(key)) {
+                        delete field[key];
+                    }
+                }
+            }
+            break;
+        }
+        case ActionName.SetView: {
+            const view = views.find((item) => item._id === action.path[0]);
+            if (view) {
+                for (const key in action.newProperties) {
+                    const k = key;
+                    const value = action.newProperties[k];
+                    if (value == null) {
+                        delete view[k];
+                    }
+                    else {
+                        view[k] = value;
+                    }
+                }
+                // properties that were previously defined, but are now missing, must be deleted
+                for (const key in action.properties) {
+                    if (!action.newProperties.hasOwnProperty(key)) {
+                        delete view[key];
+                    }
+                }
+            }
+            break;
+        }
+        case ActionName.AddView: {
+            const [viewIndex] = action.path;
+            if (viewIndex > -1) {
+                views.splice(viewIndex, 0, action.view);
+            }
+            break;
+        }
+        case ActionName.RemoveView: {
+            const [viewId] = action.path;
+            const viewIndex = views.findIndex((item) => item._id === viewId);
+            if (viewIndex > -1) {
+                views.splice(viewIndex, 1);
+            }
+            break;
+        }
+        case ActionName.AddRecordPosition: {
+            const { position, path } = action;
+            const record = records.find((item) => item._id === path[0]);
+            if (record) {
+                record.positions = {
+                    ...record.positions,
+                    ...position
+                };
+            }
+            break;
+        }
+        case ActionName.RemoveRecordPosition: {
+            const { path } = action;
+            const record = records.find((item) => item._id === path[1]);
+            delete record?.positions[path[0]];
+            break;
+        }
+    }
+    return {
+        records,
+        fields,
+        views
+    };
+};
+const GeneralActions = {
+    transform(aiTable, action) {
+        const records = createDraft(aiTable.records());
+        const fields = createDraft(aiTable.fields());
+        const views = createDraft(aiTable.views());
+        apply(aiTable, records, fields, views, action);
+        aiTable.fields.set(finishDraft(fields));
+        aiTable.records.set(finishDraft(records));
+        aiTable.views.set(finishDraft(views));
+    }
+};
+
+function setRecordPosition(aiTable, position, path) {
+    const operation = {
+        type: ActionName.AddRecordPosition,
+        position,
+        path
+    };
+    aiTable.apply(operation);
+}
+function removeRecordPosition(aiTable, path) {
+    const operation = {
+        type: ActionName.RemoveRecordPosition,
+        path
+    };
+    aiTable.apply(operation);
+}
+const PositionActions = {
+    setRecordPosition,
+    removeRecordPosition
+};
+
+function updateFieldValue$1(aiTable, value, path) {
+    const field = AITableQueries.getFieldValue(aiTable, path);
+    if (field !== value) {
+        const operation = {
+            type: ActionName.UpdateFieldValue,
+            fieldValue: field,
+            newFieldValue: value,
+            path
+        };
+        aiTable.apply(operation);
+    }
+}
+function addRecord(aiTable, record, path) {
+    const operation = {
+        type: ActionName.AddRecord,
+        record,
+        path
+    };
+    aiTable.apply(operation);
+}
+function moveRecord(aiTable, path, newPath) {
+    const operation = {
+        type: ActionName.MoveRecord,
+        path,
+        newPath
+    };
+    aiTable.apply(operation);
+}
+function removeRecord(aiTable, path) {
+    const operation = {
+        type: ActionName.RemoveRecord,
+        path
+    };
+    aiTable.apply(operation);
+}
+const RecordActions = {
+    addRecord,
+    updateFieldValue: updateFieldValue$1,
+    moveRecord,
+    removeRecord
+};
+
+function setView(aiTable, value, path) {
+    const view = aiTable.views().find((item) => item._id === path[0]);
+    if (view) {
+        const properties = {};
+        const newProperties = {};
+        for (const key in value) {
+            const k = key;
+            if (JSON.stringify(view[k]) !== JSON.stringify(value[k])) {
+                if (view.hasOwnProperty(k)) {
+                    properties[k] = view[k];
+                }
+                if (newProperties[k] !== null) {
+                    newProperties[k] = value[k];
+                }
+            }
+        }
+        const operation = {
+            type: ActionName.SetView,
+            properties,
+            newProperties,
+            path
+        };
+        aiTable.apply(operation);
+    }
+}
+function addView$1(aiTable, view, path) {
+    const operation = {
+        type: ActionName.AddView,
+        view,
+        path
+    };
+    aiTable.apply(operation);
+}
+function removeView$1(aiTable, path) {
+    const operation = {
+        type: ActionName.RemoveView,
+        path
+    };
+    aiTable.apply(operation);
+}
+const ViewActions = {
+    setView,
+    addView: addView$1,
+    removeView: removeView$1
+};
+
+const Actions = {
+    ...GeneralActions,
+    ...RecordActions,
+    ...FieldActions,
+    ...ViewActions,
+    ...PositionActions
+};
+
+function addFields(aiTable, options) {
+    const { originId, direction = Direction$1.after, defaultValue, isDuplicate, count = 1 } = options;
+    const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
+    const fields = getSortFields(aiTable, aiTable.fields(), activeView);
+    let addIndex = fields.findIndex((item) => item._id === originId);
+    if (direction === Direction$1.after) {
+        addIndex++;
+    }
+    const newRecordIds = getNewIdsByCount(count);
+    newRecordIds.forEach((id, index) => {
+        const newField = { _id: id, ...defaultValue };
+        Actions.addField(aiTable, newField, [addIndex + index]);
+    });
+}
+
+function createDefaultPositions(views, activeId, data, index) {
+    const positions = {};
+    const position = getPosition(data, activeId, index);
+    const maxPosition = data[data.length - 1].positions[activeId];
+    views.forEach((element) => {
+        positions[element._id] = element._id === activeId ? position : maxPosition + 1;
+    });
+    return positions;
+}
+function getPosition(data, activeViewId, index) {
+    let position = data.length - 1;
+    if (index !== 0 && index !== data.length) {
+        const previousViewPosition = data[index - 1].positions[activeViewId];
+        const nextViewPosition = data[index].positions[activeViewId];
+        position = (previousViewPosition + nextViewPosition) / 2;
+    }
+    else {
+        position = index;
+    }
+    return position;
+}
+function addView(aiTable, type) {
+    let index = aiTable.views().length;
+    const newId = idCreator();
+    let newView = {
+        _id: newId,
+        name: '表格视图 ' + index
+    };
+    let originViewId = aiTable.views()[aiTable.views().length - 1]._id;
+    if (type === 'copy') {
+        originViewId = aiTable.activeViewId();
+        const copyView = aiTable.views().find((item) => item._id === aiTable.activeViewId());
+        newView = {
+            ...copyView,
+            _id: newId,
+            name: copyView.name + '-副本'
+        };
+        index = aiTable.views().indexOf(copyView) + 1;
+    }
+    ViewActions.addView(aiTable, newView, [index]);
+    aiTable.records().forEach((record) => {
+        PositionActions.setRecordPosition(aiTable, { [newId]: record.positions[originViewId] }, [record._id]);
+    });
+    aiTable.fields().forEach((field) => {
+        Actions.setField(aiTable, {
+            positions: {
+                ...field.positions,
+                [newId]: field.positions[originViewId]
+            }
+        }, [field._id]);
+    });
+    return newView;
+}
+function removeView(aiTable, records, fields, activeViewId) {
+    records.forEach((record) => {
+        PositionActions.removeRecordPosition(aiTable, [activeViewId, record._id]);
+    });
+    fields.forEach((field) => {
+        const positions = { ...field.positions };
+        delete positions[activeViewId];
+        Actions.setField(aiTable, {
+            positions
+        }, [field._id]);
+    });
+    ViewActions.removeView(aiTable, [activeViewId]);
+}
+
+function addRecords(aiTable, options) {
+    const { originId, direction = Direction$1.after, isDuplicate, count = 1 } = options;
+    const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
+    const records = getSortRecords(aiTable, aiTable.records(), activeView);
+    let addIndex = records.findIndex((item) => item._id === originId);
+    if (direction === Direction$1.after) {
+        addIndex++;
+    }
+    const newRecordIds = getNewIdsByCount(count);
+    const newRecordValues = getDefaultRecordValues(aiTable, isDuplicate, originId);
+    // TODO: 判断如果存在筛选条件，且 newRecordValues 中没有一项满足筛选条件
+    // 把 id 添加到 RECORDS_WILL_HIDDEN 中
+    if (activeView.settings?.conditions?.length) {
+        aiTable.recordsWillHidden?.update((value) => {
+            value.push(...newRecordIds);
+            return [...value];
+        });
+    }
+    newRecordIds.forEach((id, index) => {
+        const newRecord = { _id: id, values: newRecordValues };
+        Actions.addRecord(aiTable, newRecord, [addIndex + index]);
+    });
+}
+function getDefaultRecordValues(aiTable, isDuplicate = false, recordId) {
+    let newRecordValues = {};
+    if (isDuplicate && recordId) {
+        newRecordValues = aiTable.recordsMap()[recordId].values;
+    }
+    else {
+        const activeView = aiTable.viewsMap()[aiTable.activeViewId()];
+        const fields = getSortFields(aiTable, aiTable.fields(), activeView);
+        fields.map((item) => {
+            newRecordValues[item._id] = getDefaultFieldValue(item);
+        });
+        const { conditions, condition_logical } = activeView.settings || {};
+        if (conditions && conditions.length) {
+            newRecordValues = getDefaultRecordDataByFilter(newRecordValues, conditions, condition_logical);
+        }
+    }
+    return newRecordValues;
+}
+
+function updateFieldValue(aiTable, options) {
+    Actions.updateFieldValue(aiTable, options.value, options.path);
+}
+
+const FLUSHING = new WeakMap();
+
+const withState = (aiTable) => {
+    const viewTable = aiTable;
+    viewTable.actions = [];
+    viewTable.apply = (action) => {
+        viewTable.actions.push(action);
+        Actions.transform(viewTable, action);
+        if (!FLUSHING.get(viewTable)) {
+            FLUSHING.set(viewTable, true);
+            Promise.resolve().then(() => {
+                FLUSHING.set(viewTable, false);
+                viewTable.onChange();
+                viewTable.actions = [];
+            });
+        }
+    };
+    return aiTable;
+};
+
+const DividerMenuItem = {
+    type: 'divider'
+};
+const EditFieldPropertyItem = {
+    type: 'editFieldProperty',
+    name: '编辑列',
+    icon: 'edit',
+    exec: (aiTable, field, origin, position) => {
+        const fieldService = AI_TABLE_GRID_FIELD_SERVICE_MAP.get(aiTable);
+        const copyField = _.cloneDeep(field());
+        if (origin && position) {
+            const popoverRef = fieldService?.editFieldProperty(aiTable, {
+                field: copyField,
+                isUpdate: true,
+                origin: origin,
+                position
+            });
+            if (popoverRef && fieldService && !fieldService.aiFieldConfig?.fieldPropertyEditor) {
+                popoverRef.componentInstance.setField.subscribe((value) => {
+                    Actions.setField(aiTable, value.field, value.path);
+                });
+            }
+            return popoverRef;
+        }
+        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];
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AITableFilterLogical, AITableFilterOperation, Direction, GeneralActions, GeneralPositionActions, GeneralViewActions, POSITION_ACTIONS, PositionActionName, PositionActions, Positions, VIEW_ACTIONS, ViewActionName, ViewActions, ViewOperationMap, YjsAITable, actionMappers, addRecordPosition, addView$1 as addView, apply, applyActionOps, applyEvents, applyPosition, applyView, applyYjsEvents, buildFieldsByView, buildRecordsByView, createDefaultPositions, createSharedType, doFilter, getFilteredRecords, getPosition, getShareTypeNumberPath, getSharedMapValueId, getSharedMapValueIndex, getSharedRecordId, getSharedRecordIndex, initSharedType, initTable, isEmpty, removeRecordPosition, removeView$1 as removeView, sortByView, toRecordSyncElement, toSharedType, toSyncElement, translatePositionToPath, translateToRecordValues, translateToRecords, translateYjsEvent, withView };
+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 };
 //# sourceMappingURL=ai-table-state.mjs.map