@ai-table/state 0.0.10 → 0.0.12

package/fesm2022/ai-table-state.mjs

@@ -2,6 +2,7 @@ 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 { isEqual } from 'lodash';
 import { fromUnixTime, subDays } from 'date-fns';
 
 class Positions {
@@ -663,6 +664,13 @@ function removeView$1(aiTable, records, fields, activeViewId) {
     });
     ViewActions.removeView(aiTable, [activeViewId]);
 }
+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) {
@@ -907,6 +915,7 @@ function isEmpty(value) {
     return isUndefinedOrNull(value) || value == '';
 }
 
+const zhIntlCollator = typeof Intl !== 'undefined' ? new Intl.Collator('zh-CN') : undefined;
 class Field {
     stringInclude(str, searchStr) {
         return str.toLowerCase().includes(searchStr.trim().toLowerCase());
@@ -935,6 +944,35 @@ class Field {
             }
         }
     }
+    eq(cv1, cv2) {
+        return isEqual(cv1, cv2);
+    }
+    compare(cellValue1, cellValue2, field) {
+        if (this.eq(cellValue1, cellValue2)) {
+            return 0;
+        }
+        if (cellValue1 == null) {
+            return -1;
+        }
+        if (cellValue2 == null) {
+            return 1;
+        }
+        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;
+    }
 }
 
 class TextField extends Field {
@@ -953,6 +991,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 +1014,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 +1100,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 +1143,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 +1178,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 = {
@@ -1143,24 +1263,48 @@ 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 getSortRecords(aiTable, records, activeView) {
+    if (!activeView?.settings || !activeView.settings.sorts?.length) {
+        return records;
     }
-    return data;
+    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 buildRecordsByView(records, fields, activeView) {
+
+function buildRecordsByView(aiTable, records, fields, activeView) {
     const filteredRecords = getFilteredRecords(records, fields, activeView);
-    return sortByView(filteredRecords, activeView._id);
+    return getSortRecords(aiTable, filteredRecords, activeView);
 }
 function buildFieldsByView(fields, activeView) {
-    return sortByView(fields, activeView._id);
+    return sortByViewPosition(fields, activeView);
 }
 
 /**
  * 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, 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, sortByViewPosition, toRecordSyncElement, toSharedType, toSyncElement, translatePositionToPath, translateToRecordValues, translateToRecords, translateYjsEvent, withView };
 //# sourceMappingURL=ai-table-state.mjs.map