@ai-table/state 0.0.28 → 0.0.30

package/fesm2022/ai-table-state.mjs

@@ -1,10 +1,9 @@
 import * as Y from 'yjs';
-import { isArray, isEmpty as isEmpty$1, isObject, isUndefinedOrNull, TinyDate, isString } from 'ngx-tethys/util';
-import { AITableQueries, AITableFieldType, isSystemField, getDefaultFieldValue, Direction as Direction$1, idsCreator, idCreator, shortIdCreator, shortIdsCreator, AI_TABLE_GRID_FIELD_SERVICE_MAP, getDetailByTargetName } from '@ai-table/grid';
-import * as _ from 'lodash';
-import ___default, { isEqual } from 'lodash';
-import { fromUnixTime, subDays } from 'date-fns';
+import { isArray } from 'ngx-tethys/util';
+import { AITableQueries, ViewOperationMap, isSystemField, AITableFieldType, isEmpty, getDefaultFieldValue, Direction as Direction$1, idsCreator, idCreator, shortIdCreator, shortIdsCreator, AI_TABLE_GRID_FIELD_SERVICE_MAP, AITable } from '@ai-table/grid';
 import { createDraft, finishDraft } from 'immer';
+import * as _ from 'lodash';
+import ___default from 'lodash';
 
 const IS_LOCAL = new WeakSet();
 const IS_REMOTE = new WeakSet();
@@ -60,23 +59,6 @@ var 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 ActionName;
 (function (ActionName) {
@@ -706,15 +688,6 @@ function applyActionOps(aiTable, sharedType, actions) {
     return sharedType;
 }
 
-function isEmpty(value) {
-    if (isArray(value)) {
-        return isEmpty$1(value);
-    }
-    if (isObject(value)) {
-        return Reflect.ownKeys(value).length === 0;
-    }
-    return isUndefinedOrNull(value) || value === '';
-}
 function isPathEqual(path, another) {
     return path.length === another.length && path.every((n, i) => n === another[i]);
 }
@@ -726,396 +699,17 @@ function sortByViewPosition(data, activeView) {
     return data;
 }
 
-const zhIntlCollator = typeof Intl !== 'undefined' ? new Intl.Collator('zh-CN') : undefined;
-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');
-            }
-        }
-    }
-    eq(cv1, cv2) {
-        return isEqual(cv1, cv2);
-    }
-    compare(cellValue1, cellValue2, field, references) {
-        if (this.eq(cellValue1, cellValue2)) {
-            return 0;
-        }
-        if (cellValue1 == null) {
-            return -1;
-        }
-        if (cellValue2 == null) {
-            return 1;
-        }
-        let str1 = this.cellValueToString(cellValue1, field, references);
-        let str2 = this.cellValueToString(cellValue2, field, references);
-        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 {
-    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());
-    }
-    eq(cv1, cv2) {
-        return this.cellValueToString(cv1) === this.cellValueToString(cv2);
-    }
-    cellValueToString(cellValue) {
-        return cellValue;
-    }
-}
-
-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$1(cellValue, condition.value);
-            case AITableFilterOperation.nin:
-                return Array.isArray(condition.value) && !hasIntersect$1(cellValue, condition.value);
-            default:
-                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$1(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()
-                ];
-        }
-    }
-    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 {
-    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);
-        }
-    }
-    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 {
-    isMeetFilter(condition, cellValue) {
-        switch (condition.operation) {
-            case AITableFilterOperation.empty:
-                return isEmpty(cellValue);
-            case AITableFilterOperation.exists:
-                return !isEmpty(cellValue);
-            case AITableFilterOperation.in:
-                const isContain = condition.value.some((item) => String(item) === String(cellValue));
-                return !isEmpty(cellValue) && isContain;
-            case AITableFilterOperation.nin:
-                const noContain = condition.value.every((item) => String(item) !== String(cellValue));
-                return isEmpty(cellValue) || noContain;
-            default:
-                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);
-    }
-}
-
-class LinkField extends Field {
-    isMeetFilter(condition, cellValue) {
-        const cellTextValue = this.cellValueToString(cellValue);
-        switch (condition.operation) {
-            case AITableFilterOperation.empty:
-                return isEmpty(cellTextValue);
-            case AITableFilterOperation.exists:
-                return !isEmpty(cellTextValue);
-            case AITableFilterOperation.contain:
-                return !isEmpty(cellTextValue) && this.stringInclude(cellTextValue, condition.value);
-            default:
-                return super.isMeetFilter(condition, cellTextValue);
-        }
-    }
-    eq(cv1, cv2) {
-        return this.cellValueToString(cv1) === this.cellValueToString(cv2);
-    }
-    compare(cellValue1, cellValue2, field) {
-        const cellTextValue1 = this.cellValueToString(cellValue1);
-        const cellTextValue2 = this.cellValueToString(cellValue2);
-        return super.compare(cellTextValue1, cellTextValue2, field);
-    }
-    cellValueToString(cellValue) {
-        if (isString(cellValue)) {
-            return cellValue;
-        }
-        if (isObject(cellValue)) {
-            return cellValue.text;
-        }
-        return '';
-    }
-}
-
-class MemberField 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);
-        }
-    }
-    cellValueToString(cellValue, field, references) {
-        let names = [];
-        if (cellValue?.length && references) {
-            for (let index = 0; index < cellValue.length; index++) {
-                const userInfo = references?.members[cellValue[index]];
-                if (!userInfo) {
-                    continue;
-                }
-                if (userInfo.display_name_pinyin) {
-                    names.push(userInfo.display_name_pinyin);
-                }
-            }
-        }
-        return names && names.length ? names.join(', ') : null;
-    }
-}
-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;
-}
-
-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 LinkField(),
-    [AITableFieldType.member]: new MemberField(),
-    [AITableFieldType.progress]: new NumberField(),
-    [AITableFieldType.createdBy]: new MemberField(),
-    [AITableFieldType.updatedBy]: new MemberField()
-};
-
-function getSortRecords(aiTable, records, activeView) {
+function getSortRecords(aiTable, records, activeView, sortKeysMap) {
     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 sortRecordsBySortInfo(aiTable, records, activeView, sortKeysMap);
     }
     return sortByViewPosition(records, activeView);
 }
-function sortRecordsBySortInfo(aiTable, records, activeView) {
+function sortRecordsBySortInfo(aiTable, records, activeView, sortKeysMap) {
     const shallowRows = [...records];
     if (activeView.settings?.sorts?.length) {
         shallowRows.sort((prev, current) => {
@@ -1125,10 +719,11 @@ function sortRecordsBySortInfo(aiTable, records, activeView) {
                     return acc;
                 }
                 const fieldMethod = ViewOperationMap[field.type];
+                const sortKey = sortKeysMap?.[field.type];
                 const cellValue1 = AITableQueries.getFieldValue(aiTable, [prev._id, field._id]);
                 const cellValue2 = AITableQueries.getFieldValue(aiTable, [current._id, field._id]);
                 const references = aiTable.references();
-                const res = fieldMethod.compare(cellValue1, cellValue2, field, references);
+                const res = fieldMethod.compare(cellValue1, cellValue2, field, references, sortKey);
                 return res * rule.direction;
             }, 0);
         });
@@ -1218,9 +813,9 @@ function getSortFields(aiTable, fields, activeView) {
     return sortByViewPosition(fields, activeView);
 }
 
-function buildRecordsByView(aiTable, records, fields, activeView) {
+function buildRecordsByView(aiTable, records, fields, activeView, sortKeysMap) {
     const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
-    return getSortRecords(aiTable, filteredRecords, activeView);
+    return getSortRecords(aiTable, filteredRecords, activeView, sortKeysMap);
 }
 function buildFieldsByView(aiTable, fields, activeView) {
     return getSortFields(aiTable, fields, activeView);
@@ -1792,11 +1387,7 @@ const RemoveRecordsItem = {
     name: '删除行',
     icon: 'trash',
     exec: (aiTable, targetName, position, aiTableGridSelectionService) => {
-        let selectedRecordIds = [...aiTable.selection().selectedRecords.keys()];
-        if (!selectedRecordIds.length) {
-            const recordId = getDetailByTargetName(targetName).recordId;
-            selectedRecordIds = [recordId];
-        }
+        let selectedRecordIds = AITable.getActiveRecordIds(aiTable);
         selectedRecordIds.forEach((id) => {
             Actions.removeRecord(aiTable, [id]);
         });
@@ -1810,5 +1401,5 @@ const VIEW_ACTIONS = [ActionName.SetView, ActionName.AddView, ActionName.RemoveV
  * Generated bundle index. Do not edit.
  */
 
-export { AITableFilterLogical, AITableFilterOperation, AI_TABLE_CONTENT_FIELD_NAME, ActionName, Actions, Direction, DividerMenuItem, EditFieldPropertyItem, ExecuteType, FLUSHING, Positions, RemovePositions, RemoveRecordsItem, SystemFieldIndex, VIEW_ACTIONS, ViewOperationMap, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyEvents, applyYjsEvents, buildFieldsByView, buildRecordsByView, buildRemoveFieldItem, createDefaultPositions, createSharedType, doFilter, getCustomFieldValues, getDataBySharedType, getDefaultRecordDataByFilter, getDefaultRecordValues, getFilteredRecords, getIdBySystemFieldValues, getIdBySystemFieldValuesType, getPosition, getPositionsByRecordSyncElement, getPositionsBySystemFieldValues, getRecordsBySharedJson, getShareTypeNumberPath, getSharedMapValueId, getSharedMapValueIndex, getSharedRecord, getSharedRecordId, getSharedRecordIndex, getSharedTypeByData, getShortIdBySystemFieldValues, getSortFields, getSortRecords, getSystemFieldValues, getTrackableEntityBySystemFieldValues, getValuesByCustomFieldValues, isEmpty, isPathEqual, removeView, setRecordPositions$1 as setRecordPositions, setRecordUpdatedInfo, sortByViewPosition, sortRecordsBySortInfo, toRecordSyncElement, toSharedType, toSyncElement, translatePositionToPath, translateYjsEvent, updateFieldValue, updateRecordsUpdatedInfo, withState };
+export { AITableFilterLogical, AI_TABLE_CONTENT_FIELD_NAME, ActionName, Actions, Direction, DividerMenuItem, EditFieldPropertyItem, ExecuteType, FLUSHING, Positions, RemovePositions, RemoveRecordsItem, SystemFieldIndex, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyEvents, applyYjsEvents, buildFieldsByView, buildRecordsByView, buildRemoveFieldItem, createDefaultPositions, createSharedType, doFilter, getCustomFieldValues, getDataBySharedType, getDefaultRecordDataByFilter, getDefaultRecordValues, getFilteredRecords, getIdBySystemFieldValues, getIdBySystemFieldValuesType, getPosition, getPositionsByRecordSyncElement, getPositionsBySystemFieldValues, getRecordsBySharedJson, getShareTypeNumberPath, getSharedMapValueId, getSharedMapValueIndex, getSharedRecord, getSharedRecordId, getSharedRecordIndex, getSharedTypeByData, getShortIdBySystemFieldValues, getSortFields, getSortRecords, getSystemFieldValues, getTrackableEntityBySystemFieldValues, getValuesByCustomFieldValues, isPathEqual, removeView, setRecordPositions$1 as setRecordPositions, setRecordUpdatedInfo, sortByViewPosition, sortRecordsBySortInfo, toRecordSyncElement, toSharedType, toSyncElement, translatePositionToPath, translateYjsEvent, updateFieldValue, updateRecordsUpdatedInfo, withState };
 //# sourceMappingURL=ai-table-state.mjs.map