@ai-table/state 0.0.9 → 0.0.10

package/fesm2022/ai-table-state.mjs

@@ -1,7 +1,8 @@
 import * as Y from 'yjs';
-import { ActionName, AITableQueries, getDefaultFieldValue, Actions, FLUSHING } from '@ai-table/grid';
-import { isArray } from 'ngx-tethys/util';
+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 { fromUnixTime, subDays } from 'date-fns';
 
 class Positions {
 }
@@ -11,36 +12,39 @@ var Direction;
     Direction[Direction["ascending"] = 1] = "ascending";
     Direction[Direction["descending"] = -1] = "descending";
 })(Direction || (Direction = {}));
-var LogicalOperator;
-(function (LogicalOperator) {
-    LogicalOperator["and"] = "and";
-    LogicalOperator["or"] = "or";
-})(LogicalOperator || (LogicalOperator = {}));
-var FilterOperationSymbol;
-(function (FilterOperationSymbol) {
-    FilterOperationSymbol["eq"] = "eq";
-    FilterOperationSymbol["gte"] = "gte";
-    FilterOperationSymbol["lte"] = "lte";
-    FilterOperationSymbol["gt"] = "gt";
-    FilterOperationSymbol["lt"] = "lt";
-    FilterOperationSymbol["in"] = "in";
-    FilterOperationSymbol["contain"] = "contain";
-    FilterOperationSymbol["ne"] = "ne";
-    FilterOperationSymbol["nin"] = "nin";
-    FilterOperationSymbol["between"] = "between";
-    FilterOperationSymbol["besides"] = "besides";
-    FilterOperationSymbol["empty"] = "empty";
-    FilterOperationSymbol["exists"] = "exists";
-    FilterOperationSymbol["notContain"] = "not_contain";
-})(FilterOperationSymbol || (FilterOperationSymbol = {}));
-class GridSettings {
-}
+var AITableFilterLogical;
+(function (AITableFilterLogical) {
+    AITableFilterLogical["and"] = "and";
+    AITableFilterLogical["or"] = "or";
+})(AITableFilterLogical || (AITableFilterLogical = {}));
+var AITableFilterOperation;
+(function (AITableFilterOperation) {
+    AITableFilterOperation["eq"] = "eq";
+    AITableFilterOperation["gte"] = "gte";
+    AITableFilterOperation["lte"] = "lte";
+    AITableFilterOperation["gt"] = "gt";
+    AITableFilterOperation["lt"] = "lt";
+    AITableFilterOperation["in"] = "in";
+    AITableFilterOperation["contain"] = "contain";
+    AITableFilterOperation["ne"] = "ne";
+    AITableFilterOperation["nin"] = "nin";
+    AITableFilterOperation["between"] = "between";
+    AITableFilterOperation["besides"] = "besides";
+    AITableFilterOperation["empty"] = "empty";
+    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 = {}));
 
 const createSharedType = () => {
     const doc = new Y.Doc();
@@ -163,13 +167,14 @@ const initTable = (sharedType) => {
     };
 };
 
-function translateArrayEvent(aiTable, activeViewId, sharedType, event) {
+function translateArrayEvent(aiTable, sharedType, event) {
     let offset = 0;
     let targetPath = getShareTypeNumberPath(event.path);
     const isRecordsTranslate = event.path.includes('records');
     const isFieldsTranslate = event.path.includes('fields');
     const isViewsTranslate = event.path.includes('views');
     const actions = [];
+    const activeViewId = aiTable.activeViewId();
     event.changes.delta.forEach((delta) => {
         if ('retain' in delta) {
             offset += delta.retain ?? 0;
@@ -220,21 +225,47 @@ function translateArrayEvent(aiTable, activeViewId, sharedType, event) {
                     }
                     else {
                         try {
+                            const sharedRecords = sharedType.get('records');
+                            const sharedFields = sharedType.get('fields');
                             delta.insert?.map((item) => {
                                 const recordIndex = targetPath[0];
                                 const fieldIndex = offset;
-                                const recordId = getSharedRecordId(sharedType.get('records'), recordIndex);
-                                const fieldId = getSharedMapValueId(sharedType.get('fields'), fieldIndex);
-                                const path = [recordId, fieldId];
-                                const fieldValue = AITableQueries.getFieldValue(aiTable, path);
-                                // To exclude insert triggered by field inserts.
-                                if (fieldValue !== item) {
-                                    actions.push({
-                                        type: ActionName.UpdateFieldValue,
-                                        path,
-                                        fieldValue,
-                                        newFieldValue: item
-                                    });
+                                const record = aiTable.records()[recordIndex];
+                                if (isPositionOperation(fieldIndex, sharedFields)) {
+                                    for (const key in item) {
+                                        if (!record.positions[key] && record.positions[key] !== 0) {
+                                            actions.push({
+                                                type: PositionActionName.AddRecordPosition,
+                                                path: [record._id],
+                                                position: {
+                                                    [key]: item[key]
+                                                }
+                                            });
+                                        }
+                                    }
+                                    for (const key in record.positions) {
+                                        if (!item[key] && item[key] !== 0) {
+                                            actions.push({
+                                                type: PositionActionName.RemoveRecordPosition,
+                                                path: [key, record._id]
+                                            });
+                                        }
+                                    }
+                                }
+                                else {
+                                    const recordId = getSharedRecordId(sharedRecords, recordIndex);
+                                    const fieldId = getSharedMapValueId(sharedFields, fieldIndex);
+                                    const path = [recordId, fieldId];
+                                    const fieldValue = AITableQueries.getFieldValue(aiTable, path);
+                                    // To exclude insert triggered by field inserts.
+                                    if (fieldValue !== item) {
+                                        actions.push({
+                                            type: ActionName.UpdateFieldValue,
+                                            path,
+                                            fieldValue,
+                                            newFieldValue: item
+                                        });
+                                    }
                                 }
                             });
                         }
@@ -270,6 +301,9 @@ function translateArrayEvent(aiTable, activeViewId, sharedType, event) {
 function isAddOrRemove(targetPath) {
     return targetPath.length === 0;
 }
+function isPositionOperation(fieldIndex, sharedFields) {
+    return fieldIndex === sharedFields.length;
+}
 function getRemoveIds(event, type) {
     const ids = [];
     if (!type) {
@@ -378,27 +412,27 @@ const YjsAITable = {
     }
 };
 
-function translateYjsEvent(aiTable, activeViewId, sharedType, event) {
+function translateYjsEvent(aiTable, sharedType, event) {
     if (event instanceof Y.YArrayEvent) {
-        return translateArrayEvent(aiTable, activeViewId, sharedType, event);
+        return translateArrayEvent(aiTable, sharedType, event);
     }
     if (event instanceof Y.YMapEvent) {
         return translateMapEvent(aiTable, sharedType, event);
     }
     return [];
 }
-function applyEvents(aiTable, activeViewId, sharedType, events) {
-    events.forEach((event) => translateYjsEvent(aiTable, activeViewId, sharedType, event).forEach((item) => {
+function applyEvents(aiTable, sharedType, events) {
+    events.forEach((event) => translateYjsEvent(aiTable, sharedType, event).forEach((item) => {
         aiTable.apply(item);
     }));
 }
-function applyYjsEvents(aiTable, activeViewId, sharedType, events) {
+function applyYjsEvents(aiTable, sharedType, events) {
     if (YjsAITable.isUndo(aiTable)) {
-        applyEvents(aiTable, activeViewId, sharedType, events);
+        applyEvents(aiTable, sharedType, events);
     }
     else {
         YjsAITable.asRemote(aiTable, () => {
-            applyEvents(aiTable, activeViewId, sharedType, events);
+            applyEvents(aiTable, sharedType, events);
         });
     }
 }
@@ -450,22 +484,33 @@ function setNode(sharedType, action) {
 }
 
 function addNode(sharedType, action) {
+    const records = sharedType.get('records');
+    const views = sharedType.get('views');
+    const fields = sharedType.get('fields');
     switch (action.type) {
         case ActionName.AddRecord:
-            const records = sharedType.get('records');
             records && records.push([toRecordSyncElement(action.record)]);
             break;
         case ViewActionName.AddView:
-            const views = sharedType.get('views');
             views && views.push([toSyncElement(action.view)]);
             break;
+        case PositionActionName.AddRecordPosition:
+            if (records) {
+                const recordIndex = getSharedRecordIndex(records, action.path[0]);
+                const record = records.get(recordIndex);
+                const customField = record.get(1);
+                const positionsIndex = customField.length - 1;
+                const positions = customField.get(positionsIndex);
+                const newPositions = { ...positions, ...action.position };
+                customField.delete(positionsIndex);
+                customField.insert(positionsIndex, [newPositions]);
+            }
+            break;
         case ActionName.AddField:
-            const sharedFields = sharedType.get('fields');
-            const sharedRecords = sharedType.get('records');
-            if (sharedFields && sharedRecords) {
-                sharedFields.push([toSyncElement(action.field)]);
+            if (fields && records) {
+                fields.push([toSyncElement(action.field)]);
                 const path = action.path[0];
-                for (let value of sharedRecords) {
+                for (let value of records) {
                     const newRecord = getDefaultFieldValue(action.field);
                     const customField = value.get(1);
                     customField.insert(path, [newRecord]);
@@ -477,9 +522,11 @@ function addNode(sharedType, action) {
 }
 
 function removeNode(sharedType, action) {
+    const fields = sharedType.get('fields');
+    const records = sharedType.get('records');
+    const views = sharedType.get('views');
     switch (action.type) {
         case ActionName.RemoveRecord:
-            const records = sharedType.get('records');
             if (records) {
                 const recordIndex = getSharedRecordIndex(records, action.path[0]);
                 if (recordIndex > -1) {
@@ -488,7 +535,6 @@ function removeNode(sharedType, action) {
             }
             break;
         case ViewActionName.RemoveView:
-            const views = sharedType.get('views');
             if (views) {
                 const viewIndex = getSharedMapValueIndex(views, action.path[0]);
                 if (viewIndex > -1) {
@@ -496,14 +542,24 @@ function removeNode(sharedType, action) {
                 }
             }
             break;
+        case PositionActionName.RemoveRecordPosition:
+            if (records) {
+                const recordIndex = getSharedRecordIndex(records, action.path[1]);
+                const record = records.get(recordIndex);
+                const customField = record.get(1);
+                const positionsIndex = customField.length - 1;
+                const positions = customField.get(positionsIndex);
+                delete positions[action.path[0]];
+                customField.delete(positionsIndex);
+                customField.insert(positionsIndex, [positions]);
+            }
+            break;
         case ActionName.RemoveField:
-            const sharedFields = sharedType.get('fields');
-            const sharedRecords = sharedType.get('records');
-            if (sharedFields && sharedRecords) {
-                const fieldIndex = getSharedMapValueIndex(sharedFields, action.path[0]);
+            if (fields && records) {
+                const fieldIndex = getSharedMapValueIndex(fields, action.path[0]);
                 if (fieldIndex > -1) {
-                    sharedFields.delete(fieldIndex);
-                    for (let value of sharedRecords) {
+                    fields.delete(fieldIndex);
+                    for (let value of records) {
                         value.get(1).delete(fieldIndex);
                     }
                 }
@@ -523,6 +579,8 @@ const actionMappers = {
     set_view: setNode,
     add_view: addNode,
     remove_view: removeNode,
+    add_record_position: addNode,
+    remove_record_position: removeNode
 };
 function applyActionOps(sharedType, actions, aiTable) {
     if (actions.length > 0) {
@@ -539,13 +597,78 @@ 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;
+    }
+    else {
+        position = index;
+    }
+    return position;
+}
+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;
+    }
+    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;
+}
+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]);
+}
+
 const GeneralViewActions = {
     transform(aiTable, action) {
         const views = createDraft(aiTable.views());
         applyView(aiTable, views, action);
-        aiTable.views.update(() => {
-            return finishDraft(views);
-        });
+        aiTable.views.set(finishDraft(views));
     }
 };
 const applyView = (aiTable, views, action) => {
@@ -589,6 +712,90 @@ const applyView = (aiTable, views, action) => {
         }
     }
 };
+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));
+        }
+        if (action.type === ActionName.AddField) {
+            aiTable.fields.set(finishDraft(fields));
+        }
+    }
+};
+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;
+        }
+        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]);
@@ -636,17 +843,47 @@ const ViewActions = {
     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) => {
-        aiTable.actions.push(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 {
-            Actions.transform(aiTable, action);
+            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);
@@ -660,9 +897,270 @@ const withView = (aiTable) => {
     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');
+            }
+        }
+    }
+}
+
+class TextField extends Field {
+    isMeetFilter(condition, cellValue) {
+        switch (condition.operation) {
+            case AITableFilterOperation.empty:
+                return isEmpty(cellValue);
+            case AITableFilterOperation.exists:
+                return !isEmpty(cellValue);
+            case AITableFilterOperation.contain:
+                return !isEmpty(cellValue) && this.stringInclude(cellValue, condition.value);
+            default:
+                return super.isMeetFilter(condition, cellValue);
+        }
+    }
+    static stringInclude(str, searchStr) {
+        return str.toLowerCase().includes(searchStr.trim().toLowerCase());
+    }
+}
+
+class SelectField extends Field {
+    isMeetFilter(condition, cellValue) {
+        switch (condition.operation) {
+            case AITableFilterOperation.empty:
+                return isEmpty(cellValue);
+            case AITableFilterOperation.exists:
+                return !isEmpty(cellValue);
+            case AITableFilterOperation.in:
+                return Array.isArray(condition.value) && hasIntersect(cellValue, condition.value);
+            case AITableFilterOperation.nin:
+                return Array.isArray(condition.value) && !hasIntersect(cellValue, condition.value);
+            default:
+                return super.isMeetFilter(condition, cellValue);
+        }
+    }
+}
+function hasIntersect(array1, array2) {
+    if (!Array.isArray(array1) || !Array.isArray(array2)) {
+        return false;
+    }
+    const set1 = new Set(array1);
+    const set2 = new Set(array2);
+    for (const ele of set1) {
+        if (set2.has(ele)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+class DateField extends Field {
+    isMeetFilter(condition, cellValue) {
+        const [left, right] = this.getTimeRange(condition.value);
+        switch (condition.operation) {
+            case AITableFilterOperation.empty:
+                return isEmpty(cellValue.timestamp) || cellValue.timestamp === 0;
+            case AITableFilterOperation.exists:
+                return !isEmpty(cellValue.timestamp) && cellValue.timestamp !== 0;
+            case AITableFilterOperation.eq:
+                return left <= cellValue.timestamp && cellValue.timestamp < right;
+            case AITableFilterOperation.gt:
+                return cellValue.timestamp > right;
+            case AITableFilterOperation.lt:
+                return cellValue.timestamp < left;
+            case AITableFilterOperation.between:
+                return left <= cellValue.timestamp && cellValue.timestamp < right;
+            default:
+                return super.isMeetFilter(condition, cellValue);
+        }
+    }
+    getTimeRange(value) {
+        switch (value) {
+            case 'today':
+                return [new TinyDate(new Date()).startOfDay().getUnixTime(), new TinyDate(new Date()).endOfDay().getUnixTime()];
+            case 'current_week':
+                return [
+                    new TinyDate().startOfWeek({ weekStartsOn: 1 }).getUnixTime(),
+                    new TinyDate().endOfWeek({ weekStartsOn: 1 }).getUnixTime()
+                ];
+            case 'yesterday':
+                return [
+                    new TinyDate(subDays(new Date(), 1)).startOfDay().getUnixTime(),
+                    new TinyDate(subDays(new Date(), 1)).endOfDay().getUnixTime()
+                ];
+            case 'current_month':
+                return [new TinyDate().startOfMonth().getUnixTime(), new TinyDate().endOfMonth().getUnixTime()];
+            default:
+                if (isArray(value)) {
+                    return [
+                        new TinyDate(fromUnixTime(value[0])).startOfDay().getUnixTime(),
+                        new TinyDate(fromUnixTime(value[1])).endOfDay().getUnixTime()
+                    ];
+                }
+                return [
+                    new TinyDate(fromUnixTime(value)).startOfDay().getUnixTime(),
+                    new TinyDate(fromUnixTime(value)).endOfDay().getUnixTime()
+                ];
+        }
+    }
+}
+
+class NumberField extends Field {
+    isMeetFilter(condition, cellValue) {
+        switch (condition.operation) {
+            case AITableFilterOperation.empty:
+                return isEmpty(cellValue);
+            case AITableFilterOperation.exists:
+                return !isEmpty(cellValue);
+            case AITableFilterOperation.eq:
+                return !Number.isNaN(condition.value) && cellValue != null && cellValue !== '' && condition.value === cellValue;
+            case AITableFilterOperation.gte:
+                return cellValue != null && cellValue !== '' && cellValue >= condition.value;
+            case AITableFilterOperation.lte:
+                return cellValue != null && cellValue !== '' && cellValue <= condition.value;
+            case AITableFilterOperation.gt:
+                return cellValue != null && cellValue !== '' && cellValue > condition.value;
+            case AITableFilterOperation.lt:
+                return cellValue != null && cellValue !== '' && cellValue < condition.value;
+            case AITableFilterOperation.ne:
+                return cellValue == null || cellValue == '' || Number.isNaN(condition.value) || cellValue !== condition.value;
+            default:
+                return super.isMeetFilter(condition, cellValue);
+        }
+    }
+}
+
+class RateField extends Field {
+    isMeetFilter(condition, cellValue) {
+        switch (condition.operation) {
+            case AITableFilterOperation.empty:
+                return isEmpty(cellValue);
+            case AITableFilterOperation.exists:
+                return !isEmpty(cellValue);
+            case AITableFilterOperation.in:
+                return !isEmpty(cellValue) && condition.value.includes(cellValue.toString());
+            case AITableFilterOperation.nin:
+                return isEmpty(cellValue) || !condition.value.includes(cellValue.toString());
+            default:
+                return super.isMeetFilter(condition, cellValue);
+        }
+    }
+}
+
+const ViewOperationMap = {
+    [AITableFieldType.text]: new TextField(),
+    [AITableFieldType.richText]: new TextField(),
+    [AITableFieldType.select]: new SelectField(),
+    [AITableFieldType.date]: new DateField(),
+    [AITableFieldType.createdAt]: new DateField(),
+    [AITableFieldType.updatedAt]: new DateField(),
+    [AITableFieldType.number]: new NumberField(),
+    [AITableFieldType.rate]: new RateField(),
+    [AITableFieldType.link]: new TextField(),
+    [AITableFieldType.member]: new SelectField(),
+    [AITableFieldType.progress]: new NumberField(),
+    [AITableFieldType.createdBy]: new SelectField(),
+    [AITableFieldType.updatedBy]: new SelectField()
+};
+
+function getFilteredRecords(records, fields, activeView) {
+    const { conditions, condition_logical } = activeView.settings || {};
+    if (!conditions) {
+        return records;
+    }
+    const illegalConditions = conditions.filter((item) => item.operation) || [];
+    if (!illegalConditions.length) {
+        return records;
+    }
+    return records.filter((record) => {
+        return checkConditions(fields, record, { conditions: illegalConditions, condition_logical });
+    });
+}
+function checkConditions(fields, record, filterConditions) {
+    if (!record) {
+        return false;
+    }
+    if (!filterConditions?.conditions) {
+        return true;
+    }
+    const { condition_logical, conditions } = filterConditions;
+    if (condition_logical === AITableFilterLogical.and) {
+        return conditions.every((condition) => doFilterOperations(fields, record, condition));
+    }
+    if (!condition_logical || condition_logical === AITableFilterLogical.or) {
+        return conditions.some((condition) => doFilterOperations(fields, record, condition));
+    }
+    return false;
+}
+function doFilterOperations(fields, record, condition) {
+    const field = fields.find((item) => item._id === condition.field_id);
+    const cellValue = record.values[condition.field_id];
+    try {
+        return field && doFilter(condition, field, cellValue);
+    }
+    catch (error) {
+        return false;
+    }
+}
+function doFilter(condition, field, cellValue) {
+    if (condition.operation === AITableFilterOperation.empty) {
+        return isEmpty(cellValue);
+    }
+    if (condition.operation === AITableFilterOperation.exists) {
+        return !isEmpty(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]);
+    }
+    return data;
+}
+function buildRecordsByView(records, fields, activeView) {
+    const filteredRecords = getFilteredRecords(records, fields, activeView);
+    return sortByView(filteredRecords, activeView._id);
+}
+function buildFieldsByView(fields, activeView) {
+    return sortByView(fields, activeView._id);
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { Direction, FilterOperationSymbol, GeneralViewActions, GridSettings, LogicalOperator, Positions, VIEW_ACTIONS, ViewActionName, ViewActions, YjsAITable, actionMappers, addView, applyActionOps, applyEvents, applyView, applyYjsEvents, createSharedType, getShareTypeNumberPath, getSharedMapValueId, getSharedMapValueIndex, getSharedRecordId, getSharedRecordIndex, initSharedType, initTable, removeView, setView, toRecordSyncElement, toSharedType, toSyncElement, translatePositionToPath, translateToRecordValues, translateToRecords, translateYjsEvent, withView };
+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 };
 //# sourceMappingURL=ai-table-state.mjs.map