aloha-vue 1.2.136 → 1.2.137

package/package.json

@@ -14,7 +14,7 @@
     "Vue.js"
   ],
   "homepage": "https://github.com/ilia-brykin/aloha/#README.md",
-  "version": "1.2.136",
+  "version": "1.2.137",
   "author": {
     "name": "Ilia Brykin",
     "email": "brykin.ilia@gmail.com"

package/src/ATable/ATable.js

@@ -47,6 +47,7 @@ import {
   isPlainObject,
   uniqueId,
 } from "lodash-es";
+import ColumnsGroupedAPI from "./compositionAPI/ColumnsGroupedAPI";
 
 export default {
   name: "ATable",
@@ -439,7 +440,6 @@ export default {
 
     const {
       columnsScrollInvisible,
-      groupedHeaderRef,
       indexFirstScrollInvisibleColumn,
       isMultipleActionsActive,
       modelColumnsVisibleLocal,
@@ -464,6 +464,11 @@ export default {
       closePreviewAll,
     });
 
+    const {
+      columnsOrderedFromSimpleTable,
+      renderedGroupedColumns,
+    } = ColumnsGroupedAPI(props);
+
     const {
       columnIdsGroupByLocked,
       columnsFilteredForRender,
@@ -472,10 +477,10 @@ export default {
       countNotHiddenColumns,
     } = ColumnsAPI(props, {
       columnsScrollInvisible,
-      groupedHeaderRef,
       indexFirstScrollInvisibleColumn,
       modelColumnsVisibleLocal,
       modelIsTableWithoutScrollComputed,
+      columnsOrderedFromSimpleTable,
     });
 
     const {
@@ -537,7 +542,6 @@ export default {
       checkVisibleColumns,
       columnIdsGroupByLocked,
       columnsFilteredForRenderIndexesMapping,
-      groupedHeaderRef,
     });
 
     const {
@@ -687,7 +691,6 @@ export default {
       columnsOrdered,
       deleteRow,
       emptyText,
-      groupedHeaderRef,
       hasMultipleActions,
       hasRows,
       hasViews,
@@ -707,6 +710,7 @@ export default {
       onTogglePreview,
       previewDownRowIndexes,
       previewRightRowIndex,
+      renderedGroupedColumns,
       rowsLocal,
       rowsLocalAll,
       rowsLocalLength,
@@ -839,7 +843,6 @@ export default {
         }, [
           this.isSimpleTable ?
           h(ATableGroupedHeader, {
-            ref: "groupedHeaderRef",
             areAllRowsSelected: this.areAllRowsSelected,
             areAllVisibleRowsSelected: this.areAllVisibleRowsSelected,
             areSomeRowsSelected: this.areSomeRowsSelected,
@@ -853,6 +856,7 @@ export default {
             showFirstSortingSequenceNumber: this.showFirstSortingSequenceNumber,
             sortingSequenceNumberClass: this.sortingSequenceNumberClass,
             onSetSelectedRowsIndexes: this.setSelectedRowsIndexes,
+            columnsForRender: this.renderedGroupedColumns,
           }) :
           h(ATableHeader, {
             areAllRowsSelected: this.areAllRowsSelected,

package/src/ATable/ATableGroupedHeader/ATableGroupedHeader.js

@@ -4,7 +4,6 @@ import {
 
 import ATableHeaderTh from "../ATableHeaderTh/ATableHeaderTh";
 import ATableHeaderThAction from "../ATableHeaderThAction/ATableHeaderThAction";
-import ColumnsGroupedAPI from "./compositionAPI/ColumnsGroupedAPI";
 
 export default {
   name: "ATableGroupedHeader",
@@ -25,6 +24,10 @@ export default {
       type: Boolean,
       required: true,
     },
+    columnsForRender: {
+      type: Array,
+      required: true,
+    },
     disabledOptions: {
       type: Boolean,
       required: false,
@@ -72,17 +75,6 @@ export default {
     "isMobile",
     "isMultipleActionsActive",
   ],
-  setup(props) {
-    const {
-      columnsOrdered,
-      renderedGroupedColumns,
-    } = ColumnsGroupedAPI(props);
-
-    return {
-      columnsOrdered,
-      renderedGroupedColumns,
-    };
-  },
   render() {
     return h("div", {
       ref: "root",
@@ -93,7 +85,7 @@ export default {
         class: "a_table__row a_table__head__row",
         role: "row",
       }, [
-        this.renderedGroupedColumns,
+        this.columnsForRender,
         this.isActionColumnVisible && h(ATableHeaderThAction, {
           disabledOptions: this.disabledOptions,
           isRowActionsStickyLocal: this.isRowActionsStickyLocal,

package/src/ATable/ATableSortingAdditional/ATableSortingAdditional.js

@@ -1,6 +1,7 @@
 import {
   h,
   onBeforeUnmount,
+  ref,
 } from "vue";
 
 import ADropdown from "../../ADropdown/ADropdown";
@@ -32,17 +33,21 @@ export default {
     },
   },
   setup(props) {
+    const unappliedModelSort = ref([]);
+
     const {
       columnsAll,
+      columnsAllKeyBySortId,
       countColumnsAll,
     } = ColumnsAPI(props);
 
     const {
       dataForForm,
-      hasLastSelectOnlyOneColumn,
       initDataForForm,
     } = FormAPI(props, {
       columnsAll,
+      columnsAllKeyBySortId,
+      unappliedModelSort,
     });
 
     const {
@@ -62,13 +67,12 @@ export default {
       initUnappliedModelSort,
       removeUnappliedModelSort,
       textCountModelSort,
-      unappliedModelSort,
       updateUnappliedModelSort,
     } = ModelAPI(props, {
       closeDropdown,
       countColumnsAll,
-      hasLastSelectOnlyOneColumn,
       initDataForForm,
+      unappliedModelSort,
       wasOpenDropdown,
     });
 

package/src/ATable/ATableSortingAdditional/compositionAPI/ColumnsAPI.js

@@ -6,6 +6,7 @@ import {
 
 import {
   filter,
+  keyBy,
 } from "lodash-es";
 
 export default function ColumnsAPI(props) {
@@ -22,12 +23,17 @@ export default function ColumnsAPI(props) {
     ];
   });
 
+  const columnsAllKeyBySortId = computed(() => {
+    return keyBy(columnsAll.value, "sortId");
+  });
+
   const countColumnsAll = computed(() => {
     return columnsAll.value.length;
   });
 
   return {
     columnsAll,
+    columnsAllKeyBySortId,
     countColumnsAll,
   };
 }

package/src/ATable/ATableSortingAdditional/compositionAPI/FormAPI.js

@@ -4,38 +4,43 @@ import {
 } from "vue";
 
 import {
+  cloneDeep,
   filter,
+  find,
   forEach,
-  last,
 } from "lodash-es";
 
 export default function FormAPI(props, {
   columnsAll = computed(() => []),
+  columnsAllKeyBySortId = computed(() => ({})),
+  unappliedModelSort = ref([]),
 }) {
   const dataForForm = ref([]);
+  const DATA_MODES = [
+    {
+      label: "_A_TABLE_SORT_ADDITIONAL_DIRECTION_ASC_",
+      id: "asc",
+    },
+    {
+      label: "_A_TABLE_SORT_ADDITIONAL_DIRECTION_DESC_",
+      id: "desc",
+    },
+  ];
 
-  const initDataForForm = ({ unappliedModelSort = [] }) => {
+  const columnsAllNotSelected = computed(() => {
+    return filter(columnsAll.value, column => {
+      return !find(unappliedModelSort.value, ["sortId", column.sortId]);
+    });
+  });
+
+  const initDataForForm = () => {
     const DATA = [];
-    const DATA_MODES = [
-      {
-        label: "_A_TABLE_SORT_ADDITIONAL_DIRECTION_ASC_",
-        id: "asc",
-      },
-      {
-        label: "_A_TABLE_SORT_ADDITIONAL_DIRECTION_DESC_",
-        id: "desc",
-      },
-    ];
-    let columnsAllFiltered = columnsAll.value;
-    let lastSortId;
-    forEach(unappliedModelSort, ({ sortId }, index) => {
+    forEach(unappliedModelSort.value, ({ sortId }, index) => {
       const isFirst = index === 0;
-      if (lastSortId) {
-        columnsAllFiltered = filter(columnsAllFiltered, column => {
-          return column.sortId !== lastSortId;
-        });
+      const COLUMNS_FILTERED = cloneDeep(columnsAllNotSelected.value);
+      if (sortId && columnsAllKeyBySortId.value[sortId]) {
+        COLUMNS_FILTERED.unshift(columnsAllKeyBySortId.value[sortId]);
       }
-      lastSortId = sortId;
 
       DATA.push({
         type: "fieldset",
@@ -49,7 +54,7 @@ export default function FormAPI(props, {
             type: "select",
             classColumn: "a_column a_column_12_touch a_column_7_fullhd a_column_7_widescreen a_column_7_desktop",
             deselectable: false,
-            data: columnsAllFiltered,
+            data: COLUMNS_FILTERED,
             keyId: "sortId",
             keyLabel: "label",
             translateData: true,
@@ -80,13 +85,8 @@ export default function FormAPI(props, {
     dataForForm.value = DATA;
   };
 
-  const hasLastSelectOnlyOneColumn = computed(() => {
-    return last(dataForForm.value)?.children?.[0]?.data?.length === 1;
-  });
-
   return {
     dataForForm,
-    hasLastSelectOnlyOneColumn,
     initDataForForm,
   };
 }

package/src/ATable/ATableSortingAdditional/compositionAPI/ModelAPI.js

@@ -9,14 +9,15 @@ import EventBus from "../../../utils/EventBus";
 import {
   cloneDeep,
   forEach,
+  last,
   startsWith,
 } from "lodash-es";
 
 export default function ModelAPI(props, {
   closeDropdown = () => {},
   countColumnsAll = computed(() => 0),
-  hasLastSelectOnlyOneColumn = computed(() => false),
   initDataForForm = () => {},
+  unappliedModelSort = ref([]),
   wasOpenDropdown = ref(false),
 }) {
   const modelSort = toRef(props, "modelSort");
@@ -24,8 +25,6 @@ export default function ModelAPI(props, {
   const changeModelSort = inject("changeModelSort");
   const tableId = inject("tableId");
 
-  const unappliedModelSort = ref([]);
-
   const initUnappliedModelSort = ({ model } = {}) => {
     if (wasOpenDropdown.value && !model) {
       return;
@@ -53,8 +52,16 @@ export default function ModelAPI(props, {
     initDataForForm({ unappliedModelSort: UNAPPLIED_MODEL });
   };
 
+  const needAddModelUndefined = ({ model }) => {
+    if (model.length >= countColumnsAll.value) {
+      return false;
+    }
+    const MODEL_LAST_ITEM = last(model);
+    return !!MODEL_LAST_ITEM.sortId;
+  };
+
   const updateUnappliedModelSort = ({ model }) => {
-    if (model.length < countColumnsAll.value && !hasLastSelectOnlyOneColumn.value) {
+    if (needAddModelUndefined({ model })) {
       model.push({
         sortId: undefined,
         sortMode: "asc",
@@ -131,7 +138,6 @@ export default function ModelAPI(props, {
     initUnappliedModelSort,
     removeUnappliedModelSort,
     textCountModelSort,
-    unappliedModelSort,
     updateUnappliedModelSort,
   };
 }

package/src/ATable/compositionAPI/ColumnsAPI.js

@@ -10,16 +10,15 @@ import {
 import {
   cloneDeep,
   forEach,
-  get,
   keyBy,
 } from "lodash-es";
 
 export default function ColumnsAPI(props, {
   columnsScrollInvisible = ref([]),
-  groupedHeaderRef = ref({}),
   indexFirstScrollInvisibleColumn = ref(undefined),
   modelColumnsVisibleLocal = ref({}),
   modelIsTableWithoutScrollComputed = computed(() => false),
+  columnsOrderedFromSimpleTable = computed(() => []),
 }) {
   const columns = toRef(props, "columns");
   const isActionColumnVisible = toRef(props, "isActionColumnVisible");
@@ -30,10 +29,6 @@ export default function ColumnsAPI(props, {
     return keyBy(columns.value, "id");
   });
 
-  const columnsFromGroupedHeader = computed(() => {
-    return get(groupedHeaderRef, "value.columnsOrdered");
-  });
-
   const columnIdsGroupByLocked = computed(() => {
     const COLUMNS_GROUP_BY_LOCKED = {
       true: [],
@@ -59,8 +54,8 @@ export default function ColumnsAPI(props, {
   });
 
   const columnsOrdered = computed(() => {
-    if (columnsFromGroupedHeader.value && columnsFromGroupedHeader.value.length) {
-      return columnsFromGroupedHeader.value;
+    if (columnsOrderedFromSimpleTable.value && columnsOrderedFromSimpleTable.value.length) {
+      return columnsOrderedFromSimpleTable.value;
     }
     if (!modelColumnsOrdering.value.length) {
       return [...columnIdsGroupByLocked.value.trueColumns, ...columnIdsGroupByLocked.value.falseColumns];

package/src/ATable/{ATableGroupedHeader/compositionAPI → compositionAPI}/ColumnsGroupedAPI.js

@@ -1,171 +1,172 @@
-import {
-  computed,
-  h,
-  inject,
-  toRef,
-} from "vue";
-
-import ATableHeaderTh from "../../ATableHeaderTh/ATableHeaderTh";
-import ATranslation from "../../../ATranslation/ATranslation";
-
-import {
-  cloneDeep,
-  filter,
-  get,
-  includes,
-  isArray,
-  map,
-  min,
-  sortBy,
-  uniqBy,
-} from "lodash-es";
-
-export default function ColumnsGroupedAPI(props) {
-  const modelSort = toRef(props, "modelSort");
-  const showFirstSortingSequenceNumber = toRef(props, "showFirstSortingSequenceNumber");
-  const sortingSequenceNumberClass = toRef(props, "sortingSequenceNumberClass");
-
-  const columns = cloneDeep(map(inject("columnsFilteredForRender").value, (column, index) => {
-    return {
-      ...column,
-      _index: column.prio || index,
-    };
-  }));
-
-  const columnsWithIndexedGroups = computed(() => {
-    return map(columns, column => {
-      if (column.group && column.group.length) {
-        column.group = map(column.group, (_group, groupIndex) => {
-          return [
-            _group,
-            groupIndex,
-          ].join("%%%");
-        });
-      }
-
-      return column;
-    });
-  });
-
-  const getRecursiveChildrenForGroup = ({ groups, group, level, columnsOrderedFromGroups, firstLevelGroupObject }) => {
-    const foundGroupsForCurrentLevel = group ? filter(groups, _group => {
-      return includes(_group, group[level - 1]);
-    }) : groups;
-
-    const uniqGroupsForCurrentLevel = uniqBy(foundGroupsForCurrentLevel, _group => _group[level]);
-
-    const recursiveGroup = map(uniqGroupsForCurrentLevel, _group => {
-      const groupObjectToReturn = {
-        id: _group[level].split("%%%")[0],
-      };
-
-      let _firstLevelGroupObject;
-      if (level === 0) {
-        _firstLevelGroupObject = groupObjectToReturn;
-        _firstLevelGroupObject.columnIndexes = [];
-      } else {
-        _firstLevelGroupObject = firstLevelGroupObject;
-      }
-
-      if (_group.length > level + 1) {
-        groupObjectToReturn.children = get(
-          getRecursiveChildrenForGroup({
-            groups,
-            group: _group,
-            level: level + 1,
-            columnsOrderedFromGroups,
-            firstLevelGroupObject: _firstLevelGroupObject,
-          }),
-          "recursiveGroup"
-        );
-      } else if (_group.length === level + 1) {
-        groupObjectToReturn.columns = filter(columnsWithIndexedGroups.value, column => includes(column.group, _group[level]));
-        _firstLevelGroupObject.columnIndexes.push(...map(groupObjectToReturn.columns, "_index"));
-        columnsOrderedFromGroups.push(...groupObjectToReturn.columns);
-      }
-
-      return groupObjectToReturn;
-    });
-
-    return {
-      columnsOrderedFromGroups,
-      recursiveGroup,
-    };
-  };
-
-  const plainGroupsAndColumns = computed(() => {
-    return map(columnsWithIndexedGroups.value, column => {
-      return get(column, "group", column);
-    });
-  });
-  const onlyGroups = computed(() => {
-    return filter(plainGroupsAndColumns.value, group => isArray(group));
-  });
-  const onlyColumns = computed(() => {
-    return filter(plainGroupsAndColumns.value, group => !isArray(group));
-  });
-  const columnsGrouped = computed(() => {
-    const columnsOrderedFromGroupsLocal = [];
-
-    return getRecursiveChildrenForGroup({ groups: onlyGroups.value, group: null, level: 0, columnsOrderedFromGroups: columnsOrderedFromGroupsLocal });
-  });
-  const columnsOrdered = computed(() => {
-    return sortBy([
-      ...columnsGrouped.value.columnsOrderedFromGroups,
-      ...onlyColumns.value,
-    ], "_index");
-  });
-
-  const getColumnsForRender = col => {
-    return h(ATableHeaderTh, {
-      ref: "th",
-      class: "a_table__cell__child_group",
-      column: col,
-      columnGroupNames: col.group,
-      columnIndex: col._index,
-      hasMultipleActions: false,
-      modelSort: modelSort.value,
-      showFirstSortingSequenceNumber: showFirstSortingSequenceNumber.value,
-      sortingSequenceNumberClass: sortingSequenceNumberClass.value,
-    });
-  };
-  const getRecursiveGroupForRender = group => {
-    return h("div", {
-      class: "a_table__th_group",
-    }, [
-      h("div", {
-        class: "a_table__th_child_group",
-      }, [
-        h("div", {
-          class: "a_table__cell_group",
-        }, [
-          group.id && h(ATranslation, {
-            html: group.id,
-            tag: "span",
-            "aria-hidden": true,
-          }),
-        ]),
-        h("div", {
-          class: "a_table__th_group_container",
-        }, group.children ?
-          map(group.children, _gr => getRecursiveGroupForRender(_gr)) :
-          map(group.columns, _col => getColumnsForRender(_col))),
-      ]),
-    ]);
-  };
-  const renderedGroupedColumns = computed(() => {
-    const mixedColumnsAndGroups = sortBy([
-      ...columnsGrouped.value.recursiveGroup,
-      ...onlyColumns.value,
-    ], column => column.columnIndexes ? min(column.columnIndexes) : column._index);
-
-    return map(mixedColumnsAndGroups, column => {
-      return column.columnIndexes ? getRecursiveGroupForRender(column) : getColumnsForRender(column);
-    });
-  });
-
-  return {
-    columnsOrdered,
-    renderedGroupedColumns,
-  };
-}
+import {
+  computed,
+  h,
+  toRef,
+} from "vue";
+
+import ATableHeaderTh from "../ATableHeaderTh/ATableHeaderTh";
+import ATranslation from "../../ATranslation/ATranslation";
+
+import {
+  filter,
+  get,
+  includes,
+  isArray,
+  map,
+  min,
+  sortBy,
+  uniqBy,
+} from "lodash-es";
+
+export default function ColumnsGroupedAPI(props) {
+  const columns = toRef(props, "columns");
+  const modelSort = toRef(props, "modelSort");
+  const showFirstSortingSequenceNumber = toRef(props, "showFirstSortingSequenceNumber");
+  const sortingSequenceNumberClass = toRef(props, "sortingSequenceNumberClass");
+
+  const columnsLocal = computed(() => {
+    return map(columns.value, (column, index) => {
+      return {
+        ...column,
+        _index: column.prio || index,
+      };
+    });
+  });
+
+  const columnsWithIndexedGroups = computed(() => {
+    return map(columnsLocal.value, column => {
+      if (column.group && column.group.length) {
+        column.group = map(column.group, (_group, groupIndex) => {
+          return [
+            _group,
+            groupIndex,
+          ].join("%%%");
+        });
+      }
+
+      return column;
+    });
+  });
+
+  const getRecursiveChildrenForGroup = ({ groups, group, level, columnsOrderedFromGroups, firstLevelGroupObject }) => {
+    const foundGroupsForCurrentLevel = group ? filter(groups, _group => {
+      return includes(_group, group[level - 1]);
+    }) : groups;
+
+    const uniqGroupsForCurrentLevel = uniqBy(foundGroupsForCurrentLevel, _group => _group[level]);
+
+    const recursiveGroup = map(uniqGroupsForCurrentLevel, _group => {
+      const groupObjectToReturn = {
+        id: _group[level].split("%%%")[0],
+      };
+
+      let _firstLevelGroupObject;
+      if (level === 0) {
+        _firstLevelGroupObject = groupObjectToReturn;
+        _firstLevelGroupObject.columnIndexes = [];
+      } else {
+        _firstLevelGroupObject = firstLevelGroupObject;
+      }
+
+      if (_group.length > level + 1) {
+        groupObjectToReturn.children = get(
+          getRecursiveChildrenForGroup({
+            groups,
+            group: _group,
+            level: level + 1,
+            columnsOrderedFromGroups,
+            firstLevelGroupObject: _firstLevelGroupObject,
+          }),
+          "recursiveGroup"
+        );
+      } else if (_group.length === level + 1) {
+        groupObjectToReturn.columns = filter(columnsWithIndexedGroups.value, column => includes(column.group, _group[level]));
+        _firstLevelGroupObject.columnIndexes.push(...map(groupObjectToReturn.columns, "_index"));
+        columnsOrderedFromGroups.push(...groupObjectToReturn.columns);
+      }
+
+      return groupObjectToReturn;
+    });
+
+    return {
+      columnsOrderedFromGroups,
+      recursiveGroup,
+    };
+  };
+
+  const plainGroupsAndColumns = computed(() => {
+    return map(columnsWithIndexedGroups.value, column => {
+      return get(column, "group", column);
+    });
+  });
+  const onlyGroups = computed(() => {
+    return filter(plainGroupsAndColumns.value, group => isArray(group));
+  });
+  const onlyColumns = computed(() => {
+    return filter(plainGroupsAndColumns.value, group => !isArray(group));
+  });
+  const columnsGrouped = computed(() => {
+    const columnsOrderedFromGroupsLocal = [];
+
+    return getRecursiveChildrenForGroup({ groups: onlyGroups.value, group: null, level: 0, columnsOrderedFromGroups: columnsOrderedFromGroupsLocal });
+  });
+  const columnsOrderedFromSimpleTable = computed(() => {
+    return sortBy([
+      ...columnsGrouped.value.columnsOrderedFromGroups,
+      ...onlyColumns.value,
+    ], "_index");
+  });
+
+  const getColumnsForRender = col => {
+    return h(ATableHeaderTh, {
+      ref: "th",
+      class: "a_table__cell__child_group",
+      column: col,
+      columnGroupNames: map(col.group, group => group.split("%%%")[0]),
+      columnIndex: col._index,
+      hasMultipleActions: false,
+      modelSort: modelSort.value,
+      showFirstSortingSequenceNumber: showFirstSortingSequenceNumber.value,
+      sortingSequenceNumberClass: sortingSequenceNumberClass.value,
+    });
+  };
+  const getRecursiveGroupForRender = group => {
+    return h("div", {
+      class: "a_table__th_group",
+    }, [
+      h("div", {
+        class: "a_table__th_child_group",
+      }, [
+        h("div", {
+          class: "a_table__cell_group",
+        }, [
+          group.id && h(ATranslation, {
+            html: group.id,
+            tag: "span",
+            "aria-hidden": true,
+          }),
+        ]),
+        h("div", {
+          class: "a_table__th_group_container",
+        }, group.children ?
+          map(group.children, _gr => getRecursiveGroupForRender(_gr)) :
+          map(group.columns, _col => getColumnsForRender(_col))),
+      ]),
+    ]);
+  };
+  const renderedGroupedColumns = computed(() => {
+    const mixedColumnsAndGroups = sortBy([
+      ...columnsGrouped.value.recursiveGroup,
+      ...onlyColumns.value,
+    ], column => column.columnIndexes ? min(column.columnIndexes) : column._index);
+
+    return map(mixedColumnsAndGroups, column => {
+      return column.columnIndexes ? getRecursiveGroupForRender(column) : getColumnsForRender(column);
+    });
+  });
+
+  return {
+    columnsOrderedFromSimpleTable,
+    renderedGroupedColumns,
+  };
+}

package/src/ATable/compositionAPI/VariablesAPI.js

@@ -4,7 +4,6 @@ import {
 
 export default function VariablesAPI() {
   const columnsScrollInvisible = ref([]);
-  const groupedHeaderRef = ref(undefined);
   const indexFirstScrollInvisibleColumn = ref(undefined);
   const isMultipleActionsActive = ref(undefined);
   const modelColumnsVisibleLocal = ref({});
@@ -13,7 +12,6 @@ export default function VariablesAPI() {
 
   return {
     columnsScrollInvisible,
-    groupedHeaderRef,
     indexFirstScrollInvisibleColumn,
     isMultipleActionsActive,
     modelColumnsVisibleLocal,