@ai-table/state 0.0.8

package/fesm2022/ai-table-state.mjs

@@ -0,0 +1,668 @@
+import * as Y from 'yjs';
+import { ActionName, AITableQueries, getDefaultFieldValue, Actions, FLUSHING } from '@ai-table/grid';
+import { isArray } from 'ngx-tethys/util';
+import { createDraft, finishDraft } from 'immer';
+
+class Positions {
+}
+var Direction;
+(function (Direction) {
+    Direction[Direction["default"] = 0] = "default";
+    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 ViewActionName;
+(function (ViewActionName) {
+    ViewActionName["SetView"] = "set_view";
+    ViewActionName["AddView"] = "add_view";
+    ViewActionName["RemoveView"] = "remove_view";
+})(ViewActionName || (ViewActionName = {}));
+
+const createSharedType = () => {
+    const doc = new Y.Doc();
+    const sharedType = doc.getMap('ai-table');
+    return sharedType;
+};
+const initSharedType = (doc, initializeValue) => {
+    const sharedType = doc.getMap('ai-table');
+    toSharedType(sharedType, initializeValue);
+    return sharedType;
+};
+function toSharedType(sharedType, data) {
+    sharedType.doc.transact(() => {
+        const fieldSharedType = new Y.Array();
+        fieldSharedType.insert(0, data.fields.map(toSyncElement));
+        sharedType.set('fields', fieldSharedType);
+        const recordSharedType = new Y.Array();
+        sharedType.set('records', recordSharedType);
+        recordSharedType.insert(0, data.records.map(toRecordSyncElement));
+        const viewsSharedType = new Y.Array();
+        sharedType.set('views', viewsSharedType);
+        viewsSharedType.insert(0, data.views.map(toSyncElement));
+    });
+}
+function toSyncElement(node) {
+    const element = new Y.Map();
+    for (const key in node) {
+        element.set(key, node[key]);
+    }
+    return element;
+}
+function toRecordSyncElement(record) {
+    const nonEditableArray = new Y.Array();
+    // 临时方案：为了解决删除时协同操作无法精准获取删除的 id 的问题，将原来的[idValue] 改为[{'_id': idValue}]
+    // 后续可能改为 YMap 或者通过在 views 中存储 positions 解决
+    nonEditableArray.insert(0, [{ _id: record['_id'] }]);
+    const editableArray = new Y.Array();
+    const editableFields = [];
+    for (const fieldId in record['values']) {
+        editableFields.push(record['values'][fieldId]);
+    }
+    editableArray.insert(0, [...editableFields, record['positions']]);
+    // To save memory, convert map to array.
+    const element = new Y.Array();
+    element.insert(0, [nonEditableArray, editableArray]);
+    return element;
+}
+
+const translateToRecordValues = (arrayRecord, fields) => {
+    const fieldIds = fields.map((item) => item._id);
+    const recordValue = {};
+    fieldIds.forEach((item, index) => {
+        recordValue[item] = arrayRecord[index] || '';
+    });
+    return recordValue;
+};
+const translateToRecords = (arrayRecords, fields) => {
+    return arrayRecords.map((record) => {
+        const [nonEditableArray, editableArray] = record;
+        return {
+            _id: nonEditableArray[0]['_id'],
+            positions: editableArray[editableArray.length - 1],
+            values: translateToRecordValues(editableArray.slice(0, editableArray.length - 1), fields)
+        };
+    });
+};
+function translatePositionToPath(data, position, activeViewId) {
+    let index = data.findIndex((value, index) => {
+        if (index === 0) {
+            return position < value.positions[activeViewId];
+        }
+        return position > data[index - 1].positions[activeViewId] && position < value.positions[activeViewId];
+    });
+    if (index === -1) {
+        index = data.length;
+    }
+    return [index];
+}
+function getShareTypeNumberPath(path) {
+    return path.filter((node) => typeof node === 'number');
+}
+function getSharedRecordId(records, recordIndex) {
+    return records && records.get(recordIndex).get(0).get(0)['_id'];
+}
+function getSharedMapValueId(values, index) {
+    return values && values.get(index).get('_id');
+}
+function getSharedRecordIndex(sharedRecords, recordId) {
+    let recordIndex = -1;
+    for (let index = 0; index < sharedRecords.length; index++) {
+        const sharedRecordId = getSharedRecordId(sharedRecords, index);
+        if (sharedRecordId === recordId) {
+            recordIndex = index;
+            break;
+        }
+    }
+    return recordIndex;
+}
+function getSharedMapValueIndex(sharedNodes, id) {
+    let nodeIndex = -1;
+    for (let index = 0; index < sharedNodes.length; index++) {
+        const sharedId = getSharedMapValueId(sharedNodes, index);
+        if (sharedId === id) {
+            nodeIndex = index;
+            break;
+        }
+    }
+    return nodeIndex;
+}
+
+const initTable = (sharedType) => {
+    const data = sharedType.toJSON();
+    const fields = data['fields'];
+    const records = translateToRecords(data['records'], fields);
+    const views = data['views'];
+    return {
+        records,
+        fields,
+        views
+    };
+};
+
+function translateArrayEvent(aiTable, activeViewId, 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 = [];
+    event.changes.delta.forEach((delta) => {
+        if ('retain' in delta) {
+            offset += delta.retain ?? 0;
+        }
+        if ('delete' in delta) {
+            if (isAddOrRemove(targetPath)) {
+                if (isViewsTranslate) {
+                    const removeView = aiTable.views()[offset];
+                    if (removeView) {
+                        actions.push({
+                            type: ViewActionName.RemoveView,
+                            path: [removeView._id]
+                        });
+                    }
+                }
+                else {
+                    const type = isRecordsTranslate ? ActionName.RemoveRecord : ActionName.RemoveField;
+                    const removeIds = getRemoveIds(event, type);
+                    if (removeIds.length) {
+                        removeIds.forEach((path) => {
+                            actions.push({
+                                type,
+                                path
+                            });
+                        });
+                    }
+                }
+            }
+        }
+        if ('insert' in delta) {
+            if (isArray(delta.insert)) {
+                if (isRecordsTranslate) {
+                    if (isAddOrRemove(targetPath)) {
+                        delta.insert?.map((item) => {
+                            const data = item.toJSON();
+                            const [fixedField, customField] = data;
+                            const position = customField[customField.length - 1][activeViewId];
+                            const path = translatePositionToPath(aiTable.records(), position, activeViewId);
+                            actions.push({
+                                type: ActionName.AddRecord,
+                                path: path,
+                                record: {
+                                    _id: fixedField[0]['_id'],
+                                    values: translateToRecordValues(customField, aiTable.fields())
+                                }
+                            });
+                        });
+                    }
+                    else {
+                        try {
+                            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
+                                    });
+                                }
+                            });
+                        }
+                        catch (error) { }
+                    }
+                }
+                if (isFieldsTranslate) {
+                    delta.insert?.map((item) => {
+                        const data = item.toJSON();
+                        const path = translatePositionToPath(aiTable.fields(), data['positions'][activeViewId], activeViewId);
+                        actions.push({
+                            type: ActionName.AddField,
+                            path,
+                            field: data
+                        });
+                    });
+                }
+                if (isViewsTranslate) {
+                    delta.insert?.map((item, index) => {
+                        const data = item.toJSON();
+                        actions.push({
+                            type: ViewActionName.AddView,
+                            path: [offset + index],
+                            view: data
+                        });
+                    });
+                }
+            }
+        }
+    });
+    return actions;
+}
+function isAddOrRemove(targetPath) {
+    return targetPath.length === 0;
+}
+function getRemoveIds(event, type) {
+    const ids = [];
+    if (!type) {
+        return ids;
+    }
+    Y.iterateDeletedStructs(event.transaction, event.transaction.deleteSet, 
+    // @param {Item|GC} item
+    (item) => {
+        if (item instanceof Y.Item && item.deleted) {
+            if (type === ActionName.RemoveField && item.parentSub === '_id') {
+                ids.push(item.content.getContent());
+            }
+            if (type === ActionName.RemoveRecord) {
+                const content = item.content.getContent();
+                if (content[0] && content[0]['_id']) {
+                    ids.push([content[0]['_id']]);
+                }
+            }
+        }
+    });
+    return ids;
+}
+
+function translateMapEvent(aiTable, sharedType, event) {
+    const isFieldsTranslate = event.path.includes('fields');
+    const isViewTranslate = event.path.includes('views');
+    if (isViewTranslate || isFieldsTranslate) {
+        let [targetPath] = getShareTypeNumberPath(event.path);
+        let targetElement;
+        const targetSyncElement = event.target;
+        if (isFieldsTranslate) {
+            const field = sharedType.get('fields')?.get(targetPath);
+            const fieldId = field && field.get('_id');
+            targetElement = fieldId && aiTable.fields().find((item) => item._id === field.get('_id'));
+        }
+        if (isViewTranslate) {
+            targetElement = aiTable.views()[targetPath];
+        }
+        if (targetElement) {
+            const keyChanges = Array.from(event.changes.keys.entries());
+            const newProperties = {};
+            const properties = {};
+            const entries = keyChanges.map(([key, info]) => {
+                const value = targetSyncElement.get(key);
+                return [key, info.action === 'delete' ? null : value instanceof Y.AbstractType ? value.toJSON() : value];
+            });
+            for (const [key, value] of entries) {
+                const k = key;
+                newProperties[k] = value;
+            }
+            const oldEntries = keyChanges.map(([key]) => [key, targetElement[key]]);
+            for (const [key, value] of oldEntries) {
+                const k = key;
+                properties[k] = value;
+            }
+            const type = isFieldsTranslate ? ActionName.SetField : ViewActionName.SetView;
+            return [
+                {
+                    type,
+                    properties: properties,
+                    newProperties: newProperties,
+                    path: [targetElement._id]
+                }
+            ];
+        }
+    }
+    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, activeViewId, sharedType, event) {
+    if (event instanceof Y.YArrayEvent) {
+        return translateArrayEvent(aiTable, activeViewId, 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) => {
+        aiTable.apply(item);
+    }));
+}
+function applyYjsEvents(aiTable, activeViewId, sharedType, events) {
+    if (YjsAITable.isUndo(aiTable)) {
+        applyEvents(aiTable, activeViewId, sharedType, events);
+    }
+    else {
+        YjsAITable.asRemote(aiTable, () => {
+            applyEvents(aiTable, activeViewId, sharedType, events);
+        });
+    }
+}
+
+function updateFieldValue(sharedType, action) {
+    const sharedRecords = sharedType.get('records');
+    const sharedFields = sharedType.get('fields');
+    if (sharedRecords && sharedFields) {
+        const recordIndex = getSharedRecordIndex(sharedRecords, action.path[0]);
+        const fieldIndex = getSharedMapValueIndex(sharedFields, action.path[1]);
+        if (recordIndex > -1 && fieldIndex > -1) {
+            const record = sharedRecords?.get(recordIndex);
+            const customField = record.get(1);
+            customField.delete(fieldIndex);
+            customField.insert(fieldIndex, [action.newFieldValue]);
+        }
+    }
+    return sharedType;
+}
+
+function setNode(sharedType, action) {
+    let sharedNodes;
+    if (action.type === ActionName.SetField) {
+        sharedNodes = sharedType.get('fields');
+    }
+    if (action.type === ViewActionName.SetView) {
+        sharedNodes = sharedType.get('views');
+    }
+    if (sharedNodes) {
+        let nodeIndex = getSharedMapValueIndex(sharedNodes, action.path[0]);
+        if (nodeIndex > -1) {
+            const node = sharedNodes.get(nodeIndex);
+            Object.entries(action.newProperties).forEach(([key, value]) => {
+                if (value == null) {
+                    node.delete(key);
+                }
+                else {
+                    node.set(key, value);
+                }
+            });
+            Object.entries(action.properties).forEach(([key]) => {
+                if (!action.newProperties.hasOwnProperty(key)) {
+                    node.delete(key);
+                }
+            });
+        }
+    }
+    return sharedType;
+}
+
+function addNode(sharedType, action) {
+    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 ActionName.AddField:
+            const sharedFields = sharedType.get('fields');
+            const sharedRecords = sharedType.get('records');
+            if (sharedFields && sharedRecords) {
+                sharedFields.push([toSyncElement(action.field)]);
+                const path = action.path[0];
+                for (let value of sharedRecords) {
+                    const newRecord = getDefaultFieldValue(action.field);
+                    const customField = value.get(1);
+                    customField.insert(path, [newRecord]);
+                }
+            }
+            break;
+    }
+    return sharedType;
+}
+
+function removeNode(sharedType, action) {
+    switch (action.type) {
+        case ActionName.RemoveRecord:
+            const records = sharedType.get('records');
+            if (records) {
+                const recordIndex = getSharedRecordIndex(records, action.path[0]);
+                if (recordIndex > -1) {
+                    records.delete(recordIndex);
+                }
+            }
+            break;
+        case ViewActionName.RemoveView:
+            const views = sharedType.get('views');
+            if (views) {
+                const viewIndex = getSharedMapValueIndex(views, action.path[0]);
+                if (viewIndex > -1) {
+                    views.delete(viewIndex);
+                }
+            }
+            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 (fieldIndex > -1) {
+                    sharedFields.delete(fieldIndex);
+                    for (let value of sharedRecords) {
+                        value.get(1).delete(fieldIndex);
+                    }
+                }
+            }
+            break;
+    }
+    return sharedType;
+}
+
+const actionMappers = {
+    add_record: addNode,
+    update_field_value: updateFieldValue,
+    remove_record: removeNode,
+    add_field: addNode,
+    set_field: setNode,
+    remove_field: removeNode,
+    set_view: setNode,
+    add_view: addNode,
+    remove_view: removeNode,
+};
+function applyActionOps(sharedType, actions, aiTable) {
+    if (actions.length > 0) {
+        sharedType.doc.transact(() => {
+            actions.forEach((action) => {
+                const apply = actionMappers[action.type];
+                if (apply) {
+                    return apply(sharedType, action);
+                }
+                return null;
+            });
+        }, aiTable);
+    }
+    return sharedType;
+}
+
+const GeneralViewActions = {
+    transform(aiTable, action) {
+        const views = createDraft(aiTable.views());
+        applyView(aiTable, views, action);
+        aiTable.views.update(() => {
+            return finishDraft(views);
+        });
+    }
+};
+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];
+                    }
+                }
+            }
+            break;
+        }
+        case ViewActionName.AddView: {
+            const [viewIndex] = action.path;
+            if (viewIndex > -1) {
+                views.splice(viewIndex, 0, action.view);
+            }
+            break;
+        }
+        case ViewActionName.RemoveView: {
+            const [viewId] = action.path;
+            const viewIndex = views.findIndex((item) => item._id === viewId);
+            if (viewIndex > -1) {
+                views.splice(viewIndex, 1);
+            }
+            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
+};
+
+const VIEW_ACTIONS = [ViewActionName.SetView, ViewActionName.AddView, ViewActionName.RemoveView];
+
+const withView = (aiTable) => {
+    const viewTable = aiTable;
+    viewTable.apply = (action) => {
+        aiTable.actions.push(action);
+        if (VIEW_ACTIONS.includes(action.type)) {
+            GeneralViewActions.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;
+};
+
+/**
+ * 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 };
+//# sourceMappingURL=ai-table-state.mjs.map