@ai-table/state 0.1.40 → 0.1.41

package/action/group.d.ts

@@ -0,0 +1,22 @@
+import { AITableGroups } from '@ai-table/utils';
+import { AIViewTable } from '../types/ai-table';
+declare function setViewGroup(aiTable: AIViewTable, groups: AITableGroups | null): void;
+declare function setCollapsedGroup(aiTable: AIViewTable, collapsedGroupIds: string[]): void;
+declare function toggleGroupCollapse(aiTable: AIViewTable, groupId: string): void;
+declare function addGroupField(aiTable: AIViewTable, fieldId: string, desc?: boolean): void;
+declare function removeGroupField(aiTable: AIViewTable, fieldId: string): void;
+declare function updateGroupFieldDirection(aiTable: AIViewTable, fieldId: string, desc: boolean): void;
+declare function reorderGroupFields(aiTable: AIViewTable, fromIndex: number, toIndex: number): void;
+declare function clearAllGroups(aiTable: AIViewTable): void;
+export declare const GroupActions: {
+    setViewGroup: typeof setViewGroup;
+    setCollapsedGroup: typeof setCollapsedGroup;
+    toggleGroupCollapse: typeof toggleGroupCollapse;
+    addGroupField: typeof addGroupField;
+    removeGroupField: typeof removeGroupField;
+    updateGroupFieldDirection: typeof updateGroupFieldDirection;
+    reorderGroupFields: typeof reorderGroupFields;
+    clearAllGroups: typeof clearAllGroups;
+};
+export {};
+//# sourceMappingURL=group.d.ts.map

package/action/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../packages/state/src/action/group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA0C,MAAM,iBAAiB,CAAC;AACxF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,iBAAS,YAAY,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,QAmBvE;AAED,iBAAS,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,EAAE,QAkB3E;AAGD,iBAAS,mBAAmB,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,QASjE;AAGD,iBAAS,aAAa,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,OAAe,QAkBlF;AAGD,iBAAS,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,QAQ9D;AAGD,iBAAS,yBAAyB,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,QAQtF;AAGD,iBAAS,kBAAkB,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,QAenF;AAGD,iBAAS,cAAc,CAAC,OAAO,EAAE,WAAW,QAE3C;AAED,eAAO,MAAM,YAAY;;;;;;;;;CASxB,CAAC"}

package/action/index.d.ts

@@ -1,4 +1,12 @@
 export declare const Actions: {
+    setViewGroup: (aiTable: import("@ai-table/state").AIViewTable, groups: import("@ai-table/utils").AITableGroups | null) => void;
+    setCollapsedGroup: (aiTable: import("@ai-table/state").AIViewTable, collapsedGroupIds: string[]) => void;
+    toggleGroupCollapse: (aiTable: import("@ai-table/state").AIViewTable, groupId: string) => void;
+    addGroupField: (aiTable: import("@ai-table/state").AIViewTable, fieldId: string, desc?: boolean) => void;
+    removeGroupField: (aiTable: import("@ai-table/state").AIViewTable, fieldId: string) => void;
+    updateGroupFieldDirection: (aiTable: import("@ai-table/state").AIViewTable, fieldId: string, desc: boolean) => void;
+    reorderGroupFields: (aiTable: import("@ai-table/state").AIViewTable, fromIndex: number, toIndex: number) => void;
+    clearAllGroups: (aiTable: import("@ai-table/state").AIViewTable) => void;
     setRecordPositions: typeof import("./position").setRecordPositions;
     setView: (aiTable: import("@ai-table/state").AIViewTable, value: Partial<import("@ai-table/utils").AITableView>, path: [string]) => void;
     addView: (aiTable: import("@ai-table/state").AIViewTable, originId: string, newView: import("@ai-table/utils").AITableView, isDuplicate?: boolean) => void;

package/action/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../packages/state/src/action/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;CAMnB,CAAC;AAEF,OAAO,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAE1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../packages/state/src/action/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;CAOnB,CAAC;AAEF,OAAO,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAE1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC"}

package/fesm2022/ai-table-state.mjs

@@ -3,7 +3,8 @@ import { UndoManager } from 'yjs';
 import { getShareTypeNumberPath, ActionName, translateArrayEvent, getSharedRecordIndex, getSharedMapValueIndex, toMapSyncElement, getIdBySystemFieldValuesType, setRecordUpdatedInfo, getPositionsByRecordSyncElement, setRecordPositions as setRecordPositions$1, toRecordSyncElement, AI_TABLE_CONTENT_FIELD_NAME, getValuesByCustomFieldValues, getPositionsBySystemFieldValues, getTrackableEntityBySystemFieldValues, getShortIdBySystemFieldValues, getIdBySystemFieldValues, sortByViewPosition, AITableFilterLogical, AITableFilterOperation, AITableFieldType, isEmpty, AI_TABLE_DEFAULT_MIN_UNFROZEN_WIDTH, AI_TABLE_MIN_FROZEN_COLUMN_COUNT, idCreator } from '@ai-table/utils';
 import * as i0 from '@angular/core';
 import { signal, Injectable } from '@angular/core';
-import { FieldModelMap, AITableQueries, isSystemField, AITable, getColumnIndicesSizeMap, shortIdCreator, generateNewName, getDefaultFieldValue, idsCreator, shortIdsCreator, setSelection, AI_TABLE_GRID_FIELD_SERVICE_MAP, clearSelection, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, isMac, writeToAITable } from '@ai-table/grid';
+import { FieldModelMap, AITableQueries, isSystemField, AITableRowType, AITable, getColumnIndicesSizeMap, shortIdCreator, generateNewName, getDefaultFieldValue, AI_TABLE_GROUP_MAX_LEVEL, idsCreator, shortIdsCreator, setSelection, AI_TABLE_GRID_FIELD_SERVICE_MAP, clearSelection, buildClipboardData, writeToClipboard, getI18nTextByKey, AITableGridI18nKey, isMac, writeToAITable } from '@ai-table/grid';
+import { nanoid } from 'nanoid';
 import * as _ from 'lodash';
 import ___default from 'lodash';
 import { createDraft, finishDraft } from 'immer';
@@ -591,6 +592,267 @@ function buildFieldStatType(data, activeView) {
     });
 }
 
+class GroupCalculator {
+    constructor(groups, aiTable, collapseState) {
+        this.groups = groups;
+        this.groupBreakpoints = new Map();
+        this.groupCollapseState = new Set(collapseState || []);
+        this.aiTable = aiTable;
+    }
+    calculateLinearRows(records, fields) {
+        const sortedRecords = this.sortRecordsByGroup(records, fields);
+        this.detectGroupBreakpoints(sortedRecords, fields);
+        return this.generateLinearRows(sortedRecords, fields);
+    }
+    sortRecordsByGroup(records, fields) {
+        const fieldsMap = new Map(fields.map((field) => [field._id, field]));
+        return [...records].sort((record1, record2) => {
+            return (this.groups.reduce((result, groupField) => {
+                if (result !== 0)
+                    return result;
+                const field = fieldsMap.get(groupField.fieldId);
+                if (!field)
+                    return 0;
+                const value1 = AITableQueries.getFieldValue(this.aiTable, [record1._id, field._id]);
+                const value2 = AITableQueries.getFieldValue(this.aiTable, [record2._id, field._id]);
+                const fieldModel = FieldModelMap[field.type];
+                if (!fieldModel)
+                    return 0;
+                const compareResult = fieldModel.compare(value1, value2, this.aiTable.context.references(), undefined, {
+                    aiTable: this.aiTable,
+                    field
+                });
+                return compareResult * (groupField.desc ? -1 : 1);
+            }, 0) || 1);
+        });
+    }
+    // 检测断点
+    detectGroupBreakpoints(records, fields) {
+        this.groupBreakpoints.clear();
+        if (records.length === 0)
+            return;
+        const fieldsMap = new Map(fields.map((field) => [field._id, field]));
+        let previousRecord = null;
+        records.forEach((record, index) => {
+            if (previousRecord === null) {
+                // 第一条记录，所有分组字段都是断点
+                this.groups.forEach((groupField) => {
+                    this.addBreakpoint(groupField.fieldId, index);
+                });
+            }
+            else {
+                // 检查每个分组字段是否发生变化
+                this.groups.forEach((groupField, groupIndex) => {
+                    const field = fieldsMap.get(groupField.fieldId);
+                    if (!field)
+                        return;
+                    const prevValue = AITableQueries.getFieldValue(this.aiTable, [previousRecord._id, field._id]);
+                    const currValue = AITableQueries.getFieldValue(this.aiTable, [record._id, field._id]);
+                    const fieldModel = FieldModelMap[field.type];
+                    if (!fieldModel)
+                        return;
+                    const compareResult = fieldModel.compare(prevValue, currValue, this.aiTable.context.references(), undefined, {
+                        aiTable: this.aiTable,
+                        field
+                    });
+                    if (compareResult !== 0) {
+                        // 值发生变化，从当前层级开始的所有层级都是断点
+                        for (let i = groupIndex; i < this.groups.length; i++) {
+                            this.addBreakpoint(this.groups[i].fieldId, index);
+                        }
+                        return;
+                    }
+                });
+            }
+            previousRecord = record;
+        });
+    }
+    // 添加断点
+    addBreakpoint(fieldId, recordIndex) {
+        if (!this.groupBreakpoints.has(fieldId)) {
+            this.groupBreakpoints.set(fieldId, []);
+        }
+        const breakpoints = this.groupBreakpoints.get(fieldId);
+        if (!breakpoints.includes(recordIndex)) {
+            breakpoints.push(recordIndex);
+        }
+    }
+    // 生成GroupLinearRows
+    generateLinearRows(records, fields) {
+        const linearRows = [];
+        const fieldsMap = new Map(fields.map((field) => [field._id, field]));
+        let lastGroupDepth = -1;
+        let currentGroupRecords = [];
+        let currentGroupIds = [];
+        let currentGroupRecordIndices = []; // 记录当前分组中每个记录的原始索引
+        // 开始添加一个空白行
+        linearRows.push({
+            type: AITableRowType.blank,
+            _id: nanoid(),
+            depth: 0
+        });
+        records.forEach((record, index) => {
+            // 生成分组标签
+            const groupTabRows = this.generateGroupTabRows(record, index, fieldsMap);
+            if (groupTabRows.length > 0) {
+                // 如果有新的分组标签，先处理上一个分组的结束
+                if (currentGroupRecords.length > 0) {
+                    this.handleGroupEnd(currentGroupRecords, linearRows, currentGroupIds, currentGroupRecordIndices);
+                    currentGroupRecords = [];
+                    currentGroupRecordIndices = [];
+                }
+                currentGroupIds = groupTabRows.map((row) => row.groupId);
+                const depths = groupTabRows.filter((d) => d.depth !== undefined).map((d) => d.depth);
+                const minDepth = depths.length > 0 ? Math.min(...depths) : 0;
+                // 如果当前分组的最小深度小于等于上一个分组的深度，说明是同级或上级分组，需添加空白行
+                if (lastGroupDepth >= 0 && minDepth <= lastGroupDepth) {
+                    linearRows.push({
+                        type: AITableRowType.blank,
+                        _id: nanoid(),
+                        depth: minDepth
+                    });
+                }
+                // 只添加未被父级折叠的分组
+                const visibleGroupTabRows = this.filterVisibleGroupTabs(groupTabRows);
+                linearRows.push(...visibleGroupTabRows);
+                lastGroupDepth = depths.length > 0 ? Math.max(...depths) : 0;
+            }
+            // 将记录添加到当前分组
+            currentGroupRecords.push(record);
+            currentGroupRecordIndices.push(index);
+        });
+        // 处理最后一个分组
+        if (currentGroupRecords.length > 0) {
+            this.handleGroupEnd(currentGroupRecords, linearRows, currentGroupIds, currentGroupRecordIndices);
+        }
+        // 添加分组结束的空白行
+        if (lastGroupDepth >= 0) {
+            linearRows.push({
+                type: AITableRowType.blank,
+                _id: nanoid(),
+                depth: 0
+            });
+        }
+        return linearRows;
+    }
+    handleGroupEnd(currentGroupRecords, linearRows, currentGroupIds, currentGroupRecordIndices) {
+        // 分组结束时添加该分组的记录和add行
+        let groupDisplayRowIndex = 0;
+        currentGroupRecords.forEach((record, i) => {
+            const recordIndex = currentGroupRecordIndices?.[i] ?? 0;
+            if (this.shouldShowRecord(record, recordIndex)) {
+                groupDisplayRowIndex++;
+                linearRows.push({
+                    type: AITableRowType.record,
+                    _id: record._id,
+                    displayIndex: groupDisplayRowIndex,
+                    depth: this.groups.length
+                });
+            }
+        });
+        // 分组未折叠，为每个分组添加add新增行
+        if (currentGroupRecords.length > 0 && this.shouldShowAddRow(currentGroupIds)) {
+            linearRows.push({
+                type: AITableRowType.add,
+                _id: '',
+                depth: this.groups.length
+            });
+        }
+    }
+    // 生成分组标签
+    generateGroupTabRows(record, recordIndex, fieldsMap) {
+        const groupTabRows = [];
+        this.groups.forEach((groupField, depth) => {
+            const breakpoints = this.groupBreakpoints.get(groupField.fieldId) || [];
+            if (breakpoints.includes(recordIndex)) {
+                const field = fieldsMap.get(groupField.fieldId);
+                if (!field)
+                    return;
+                const groupValue = AITableQueries.getFieldValue(this.aiTable, [record._id, field._id]);
+                const breakpointIndex = breakpoints.indexOf(recordIndex);
+                const groupId = this.generateGroupId(groupField.fieldId, depth, breakpointIndex);
+                const recordCount = this.calculateGroupRecordCount(record, recordIndex, depth);
+                groupTabRows.push({
+                    type: AITableRowType.group,
+                    _id: nanoid(),
+                    depth,
+                    fieldId: groupField.fieldId,
+                    groupValue,
+                    isCollapsed: this.groupCollapseState.has(groupId),
+                    recordCount,
+                    groupId
+                });
+            }
+        });
+        return groupTabRows;
+    }
+    // 生成分组ID
+    generateGroupId(fieldId, depth, breakpointIndex) {
+        // 通过字段ID、深度和断点索引确保唯一
+        return `${fieldId}_${depth}_${breakpointIndex}`;
+    }
+    calculateGroupRecordCount(_record, _recordIndex, _depth) {
+        // TODO: 实现精确的分组记录数计算
+        return 1;
+    }
+    shouldShowRecord(_record, recordIndex) {
+        for (let depth = 0; depth < this.groups.length; depth++) {
+            const groupField = this.groups[depth];
+            const breakpoints = this.groupBreakpoints.get(groupField.fieldId) || [];
+            // 找到当前记录所属的分组断点
+            let belongsToBreakpointIndex = -1;
+            for (let i = breakpoints.length - 1; i >= 0; i--) {
+                if (breakpoints[i] <= recordIndex) {
+                    belongsToBreakpointIndex = i;
+                    break;
+                }
+            }
+            if (belongsToBreakpointIndex >= 0) {
+                const groupId = this.generateGroupId(groupField.fieldId, depth, belongsToBreakpointIndex);
+                if (this.groupCollapseState.has(groupId)) {
+                    return false; // 父级分组被折叠，不显示记录
+                }
+            }
+        }
+        return true;
+    }
+    // 检查当前分组是否应该显示添加行
+    shouldShowAddRow(currentGroupIds) {
+        if (!currentGroupIds || currentGroupIds.length === 0) {
+            return true; // 默认显示
+        }
+        // 检查当前组的所有分组层级是否都展开
+        for (const groupId of currentGroupIds) {
+            if (this.groupCollapseState.has(groupId)) {
+                return false; // 有层级被折叠，不显示添加行
+            }
+        }
+        return true;
+    }
+    // 过滤可见的分组标签
+    filterVisibleGroupTabs(groupTabRows) {
+        const visibleRows = [];
+        for (let i = 0; i < groupTabRows.length; i++) {
+            const currentRow = groupTabRows[i];
+            let show = true;
+            // 检查当前分组标签的所有父级是否都展开
+            const currentDepth = currentRow.depth ?? 0;
+            for (let parentDepth = 0; parentDepth < currentDepth; parentDepth++) {
+                // 找到同一记录索引下的父级分组ID
+                const parentRow = groupTabRows.find((row) => row.depth === parentDepth);
+                if (parentRow && this.groupCollapseState.has(parentRow.groupId)) {
+                    show = false;
+                    break;
+                }
+            }
+            if (show) {
+                visibleRows.push(currentRow);
+            }
+        }
+        return visibleRows;
+    }
+}
+
 function buildRecordsByView(aiTable, records, fields, activeView, sortKeysMap) {
     const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
     return getSortRecords(aiTable, filteredRecords, activeView, sortKeysMap);
@@ -599,6 +861,21 @@ function buildFieldsByView(aiTable, fields, activeView) {
     const sortFields = getSortFields(aiTable, fields, activeView);
     return buildFieldStatType(sortFields, activeView);
 }
+function buildGroupLinearRows(aiTable, records, fields, activeView) {
+    if (activeView?.settings?.groups?.length && fields && aiTable) {
+        try {
+            const groups = activeView.settings?.groups;
+            const collapsedGroupIds = activeView.settings?.collapsedGroupIds;
+            const calculator = new GroupCalculator(groups, aiTable, collapsedGroupIds);
+            const filteredRecords = getFilteredRecords(aiTable, records, fields, activeView);
+            return calculator.calculateLinearRows(filteredRecords, fields);
+        }
+        catch (error) {
+            console.warn('Grouped build failed, using the default build method:', error);
+        }
+    }
+    return null;
+}
 
 function setView(aiTable, value, path) {
     const view = aiTable.views().find((item) => item._id === path[0]);
@@ -1419,12 +1696,124 @@ const RecordActions = {
     updateSystemFieldValues
 };
 
+function setViewGroup(aiTable, groups) {
+    const viewId = aiTable.activeViewId();
+    const view = aiTable.views().find((v) => v._id === viewId);
+    if (!view)
+        return;
+    const currentSettings = view.settings || {};
+    const newSettings = {
+        ...currentSettings,
+        groups: groups || [],
+        collapsedGroupIds: [] // 重置折叠
+    };
+    const operation = {
+        type: ActionName.SetView,
+        properties: { settings: currentSettings },
+        newProperties: { settings: newSettings },
+        path: [viewId]
+    };
+    aiTable.apply(operation);
+}
+function setCollapsedGroup(aiTable, collapsedGroupIds) {
+    const viewId = aiTable.activeViewId();
+    const view = aiTable.views().find((v) => v._id === viewId);
+    if (!view)
+        return;
+    const currentSettings = view.settings || {};
+    const newSettings = {
+        ...currentSettings,
+        collapsedGroupIds
+    };
+    const operation = {
+        type: ActionName.SetView,
+        properties: { settings: currentSettings },
+        newProperties: { settings: newSettings },
+        path: [viewId]
+    };
+    aiTable.apply(operation);
+}
+// 折叠
+function toggleGroupCollapse(aiTable, groupId) {
+    const viewId = aiTable.activeViewId();
+    const view = aiTable.views().find((v) => v._id === viewId);
+    if (!view)
+        return;
+    const currentCollapse = view.settings?.collapsedGroupIds || [];
+    const newCollapse = currentCollapse.includes(groupId) ? currentCollapse.filter((id) => id !== groupId) : [...currentCollapse, groupId];
+    setCollapsedGroup(aiTable, newCollapse);
+}
+// 添加分组
+function addGroupField(aiTable, fieldId, desc = false) {
+    const view = aiTable.views().find((v) => v._id === aiTable.activeViewId());
+    if (!view)
+        return;
+    const currentGroups = view.settings?.groups || [];
+    // 是否已存在
+    if (currentGroups.some((group) => group.fieldId === fieldId)) {
+        throw new Error('The field has been used for grouping.');
+    }
+    // 层级限制
+    if (currentGroups.length >= AI_TABLE_GROUP_MAX_LEVEL) {
+        throw new Error(`The maximum number of groups is ${AI_TABLE_GROUP_MAX_LEVEL}.`);
+    }
+    const newGroups = [...currentGroups, { fieldId, desc }];
+    setViewGroup(aiTable, newGroups);
+}
+// 删除分组
+function removeGroupField(aiTable, fieldId) {
+    const view = aiTable.views().find((v) => v._id === aiTable.activeViewId());
+    if (!view)
+        return;
+    const currentGroups = view.settings?.groups || [];
+    const newGroups = currentGroups.filter((group) => group.fieldId !== fieldId);
+    setViewGroup(aiTable, newGroups.length > 0 ? newGroups : null);
+}
+// 更新排序方向
+function updateGroupFieldDirection(aiTable, fieldId, desc) {
+    const view = aiTable.views().find((v) => v._id === aiTable.activeViewId());
+    if (!view)
+        return;
+    const currentGroups = view.settings?.groups || [];
+    const newGroups = currentGroups.map((group) => (group.fieldId === fieldId ? { ...group, desc } : group));
+    setViewGroup(aiTable, newGroups);
+}
+// 重新排序，拖拽顺序
+function reorderGroupFields(aiTable, fromIndex, toIndex) {
+    const view = aiTable.views().find((v) => v._id === aiTable.activeViewId());
+    if (!view)
+        return;
+    const currentGroups = view.settings?.groups || [];
+    if (fromIndex < 0 || fromIndex >= currentGroups.length || toIndex < 0 || toIndex >= currentGroups.length) {
+        return;
+    }
+    const newGroups = [...currentGroups];
+    const [movedItem] = newGroups.splice(fromIndex, 1);
+    newGroups.splice(toIndex, 0, movedItem);
+    setViewGroup(aiTable, newGroups);
+}
+// 清空分组
+function clearAllGroups(aiTable) {
+    setViewGroup(aiTable, null);
+}
+const GroupActions = {
+    setViewGroup,
+    setCollapsedGroup,
+    toggleGroupCollapse,
+    addGroupField,
+    removeGroupField,
+    updateGroupFieldDirection,
+    reorderGroupFields,
+    clearAllGroups
+};
+
 const Actions = {
     ...GeneralActions,
     ...RecordActions,
     ...FieldActions,
     ...ViewActions,
-    ...PositionsActions
+    ...PositionsActions,
+    ...GroupActions
 };
 
 function moveFields(aiTable, options) {
@@ -1833,5 +2222,5 @@ const VIEW_ACTIONS = [ActionName.SetView, ActionName.AddView, ActionName.RemoveV
  * Generated bundle index. Do not edit.
  */
 
-export { AITableStateI18nKey, AITableStateI18nText, Actions, CopyCellsItem, CopyFieldPropertyItem, DividerMenuItem, EditFieldPropertyItem, FLUSHING, InsertDownwardRecords, InsertUpwardRecords, PasteCellsItem, RemoveRecordsItem, UndoManagerService, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyActions, applyEvents, applyYjsEvents, buildFieldsByView, buildRecordsByView, buildRemoveFieldItem, buildSetFieldAction, buildSetRecordPositionsActon, calculateAdaptiveFrozenColumnCount, checkConditions, createMultiplePositions, createPositions, createSharedType, doFilter, freezeToThisColumn, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getFrozenFieldId, getMaxPosition, getPosition, getPositions, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getSortRecords, getStateI18nTextByKey, isPathEqual, moveFields, moveRecords, removeView, restoreDefaultFrozenColumn, sortRecordsBySortInfo, sortViews, toSharedType, translateYjsEvent, updateFieldAndValues, updateFieldValues, withState };
+export { AITableStateI18nKey, AITableStateI18nText, Actions, CopyCellsItem, CopyFieldPropertyItem, DividerMenuItem, EditFieldPropertyItem, FLUSHING, GroupCalculator, InsertDownwardRecords, InsertUpwardRecords, PasteCellsItem, RemoveRecordsItem, UndoManagerService, VIEW_ACTIONS, YjsAITable, actionMappers, addFields, addRecords, addView, applyActionOps, applyActions, applyEvents, applyYjsEvents, buildFieldsByView, buildGroupLinearRows, buildRecordsByView, buildRemoveFieldItem, buildSetFieldAction, buildSetRecordPositionsActon, calculateAdaptiveFrozenColumnCount, checkConditions, createMultiplePositions, createPositions, createSharedType, doFilter, freezeToThisColumn, generateCopyName, getDataBySharedType, getDefaultI18nTextByKey, getDefaultRecordDataByFilter, getDefaultRecordValues, getFieldPositionInView, getFieldsSizeMap, getFilteredRecords, getFrozenFieldId, getMaxPosition, getPosition, getPositions, getRecordsBySharedJson, getSharedTypeByData, getSortFields, getSortRecords, getStateI18nTextByKey, isPathEqual, moveFields, moveRecords, removeView, restoreDefaultFrozenColumn, sortRecordsBySortInfo, sortViews, toSharedType, translateYjsEvent, updateFieldAndValues, updateFieldValues, withState };
 //# sourceMappingURL=ai-table-state.mjs.map