aloha-vue 2.75.0 → 2.76.0

package/src/ATable/compositionAPI/InitAPI.js

@@ -1,53 +1,53 @@
-import {
-  ref,
-  toRef,
-} from "vue";
-
-import {
-  getModelColumnsVisibleDefault,
-} from "../utils/utils";
-
-import {
-  cloneDeep,
-  size,
-} from "lodash-es";
-
-export default function InitAPI(props, { emit }, {
-  checkColumnsOrdering = () => {},
-  checkVisibleColumns = () => {},
-  modelColumnsVisibleLocal = ref({}),
-}) {
-  const modelColumnsVisible = toRef(props, "modelColumnsVisible");
-  const columns = toRef(props, "columns");
-
-  const initTable = () => {
-    const {
-      shouldFixColumns: shouldFixOrderingColumns,
-      modelColumnsOrderingLocal,
-    } = checkColumnsOrdering();
-
-    let shouldFixVisibleColumns = false;
-    if (size(modelColumnsVisible.value)) {
-      modelColumnsVisibleLocal.value = cloneDeep(modelColumnsVisible.value);
-    } else {
-      shouldFixVisibleColumns = true;
-      modelColumnsVisibleLocal.value = getModelColumnsVisibleDefault(columns.value);
-      checkVisibleColumns();
-    }
-
-    emit("initTable", cloneDeep({
-      columnsOrdering: {
-        model: modelColumnsOrderingLocal,
-        shouldFix: shouldFixOrderingColumns,
-      },
-      columnsVisible: {
-        model: modelColumnsVisibleLocal.value,
-        shouldFix: shouldFixVisibleColumns,
-      },
-    }));
-  };
-
-  return {
-    initTable,
-  };
-}
+import {
+  ref,
+  toRef,
+} from "vue";
+
+import {
+  getModelColumnsVisibleDefault,
+} from "../utils/utils";
+
+import {
+  cloneDeep,
+  size,
+} from "lodash-es";
+
+export default function InitAPI(props, { emit }, {
+  checkColumnsOrdering = () => {},
+  checkVisibleColumns = () => {},
+  modelColumnsVisibleLocal = ref({}),
+}) {
+  const modelColumnsVisible = toRef(props, "modelColumnsVisible");
+  const columns = toRef(props, "columns");
+
+  const initTable = () => {
+    const {
+      shouldFixColumns: shouldFixOrderingColumns,
+      modelColumnsOrderingLocal,
+    } = checkColumnsOrdering();
+
+    let shouldFixVisibleColumns = false;
+    if (size(modelColumnsVisible.value)) {
+      modelColumnsVisibleLocal.value = cloneDeep(modelColumnsVisible.value);
+    } else {
+      shouldFixVisibleColumns = true;
+      modelColumnsVisibleLocal.value = getModelColumnsVisibleDefault(columns.value);
+      checkVisibleColumns();
+    }
+
+    emit("initTable", cloneDeep({
+      columnsOrdering: {
+        model: modelColumnsOrderingLocal,
+        shouldFix: shouldFixOrderingColumns,
+      },
+      columnsVisible: {
+        model: modelColumnsVisibleLocal.value,
+        shouldFix: shouldFixVisibleColumns,
+      },
+    }));
+  };
+
+  return {
+    initTable,
+  };
+}

package/src/ATable/compositionAPI/LimitOffsetAPI.js

@@ -1,99 +1,99 @@
-import {
-  computed,
-  ref,
-  toRef,
-} from "vue";
-
-import {
-  isPlainObject,
-} from "lodash-es";
-
-export default function LimitOffsetAPI(props, { emit }, {
-  closePreviewAll = () => {},
-  scrollToTable = () => {},
-  setFocusToTable = () => {},
-  viewCurrent = computed(() => ({})),
-}) {
-  const isTree = toRef(props, "isTree");
-  const offsetStart = toRef(props, "offsetStart");
-  const pagination = toRef(props, "pagination");
-
-  const limit = ref(undefined);
-  const offset = ref(undefined);
-
-  const initLocalVars = () => {
-    limit.value = pagination.value.limitStart || 10;
-    offset.value = offsetStart.value;
-  };
-
-  const usePaginationLocal = computed(() => {
-    if (isTree.value) {
-      return false;
-    }
-    if (pagination.value?.use) {
-      if (viewCurrent.value) {
-        return viewCurrent.value.usePagination || false;
-      }
-      return true;
-    }
-    return false;
-  });
-
-  const usePaginationTop = computed(() => {
-    return pagination.value.position === "top" ||
-      pagination.value.position === "y";
-  });
-
-  const usePaginationBottom = computed(() => {
-    return pagination.value.position === "bottom" ||
-      pagination.value.position === "y" ||
-      !usePaginationTop.value;
-  });
-
-  const changeOffset = _offset => {
-    let offsetLocal;
-    let reloadLocal;
-    if (isPlainObject(_offset)) {
-      offsetLocal = _offset.offset;
-      reloadLocal = _offset.reload;
-    } else {
-      offsetLocal = _offset;
-      reloadLocal = true;
-    }
-    if (reloadLocal) {
-      setFocusToTable();
-      scrollToTable();
-    }
-    offset.value = offsetLocal;
-    emit("changeOffset", {
-      offset: offsetLocal,
-      limit: limit.value,
-    });
-    if (reloadLocal) {
-      closePreviewAll();
-    }
-  };
-
-  const changeLimit = limitLocal => {
-    setFocusToTable();
-    scrollToTable();
-    limit.value = limitLocal;
-    offset.value = offsetStart.value;
-    emit("changeLimit", {
-      offset: offset.value,
-      limit: limitLocal,
-    });
-    closePreviewAll();
-  };
-
-  return {
-    changeLimit,
-    changeOffset,
-    initLocalVars,
-    limit,
-    offset,
-    usePaginationBottom,
-    usePaginationLocal,
-    usePaginationTop,
-  };
-}
+import {
+  computed,
+  ref,
+  toRef,
+} from "vue";
+
+import {
+  isPlainObject,
+} from "lodash-es";
+
+export default function LimitOffsetAPI(props, { emit }, {
+  closePreviewAll = () => {},
+  scrollToTable = () => {},
+  setFocusToTable = () => {},
+  viewCurrent = computed(() => ({})),
+}) {
+  const isTree = toRef(props, "isTree");
+  const offsetStart = toRef(props, "offsetStart");
+  const pagination = toRef(props, "pagination");
+
+  const limit = ref(undefined);
+  const offset = ref(undefined);
+
+  const initLocalVars = () => {
+    limit.value = pagination.value.limitStart || 10;
+    offset.value = offsetStart.value;
+  };
+
+  const usePaginationLocal = computed(() => {
+    if (isTree.value) {
+      return false;
+    }
+    if (pagination.value?.use) {
+      if (viewCurrent.value) {
+        return viewCurrent.value.usePagination || false;
+      }
+      return true;
+    }
+    return false;
+  });
+
+  const usePaginationTop = computed(() => {
+    return pagination.value.position === "top" ||
+      pagination.value.position === "y";
+  });
+
+  const usePaginationBottom = computed(() => {
+    return pagination.value.position === "bottom" ||
+      pagination.value.position === "y" ||
+      !usePaginationTop.value;
+  });
+
+  const changeOffset = _offset => {
+    let offsetLocal;
+    let reloadLocal;
+    if (isPlainObject(_offset)) {
+      offsetLocal = _offset.offset;
+      reloadLocal = _offset.reload;
+    } else {
+      offsetLocal = _offset;
+      reloadLocal = true;
+    }
+    if (reloadLocal) {
+      setFocusToTable();
+      scrollToTable();
+    }
+    offset.value = offsetLocal;
+    emit("changeOffset", {
+      offset: offsetLocal,
+      limit: limit.value,
+    });
+    if (reloadLocal) {
+      closePreviewAll();
+    }
+  };
+
+  const changeLimit = limitLocal => {
+    setFocusToTable();
+    scrollToTable();
+    limit.value = limitLocal;
+    offset.value = offsetStart.value;
+    emit("changeLimit", {
+      offset: offset.value,
+      limit: limitLocal,
+    });
+    closePreviewAll();
+  };
+
+  return {
+    changeLimit,
+    changeOffset,
+    initLocalVars,
+    limit,
+    offset,
+    usePaginationBottom,
+    usePaginationLocal,
+    usePaginationTop,
+  };
+}

package/src/ATable/compositionAPI/MobileColumnsAPI.js

@@ -1,27 +1,27 @@
-import {
-  computed,
-  ref,
-} from "vue";
-
-import {
-  filter,
-} from "lodash-es";
-
-export default function MobileColumnsAPI({
-  columnsOrdered = ref([]),
-  isMobile = ref(false),
-  modelColumnsVisibleLocal = ref({}),
-}) {
-  const allVisibleMobileColumns = computed(() => {
-    if (!isMobile.value) {
-      return [];
-    }
-    return filter(columnsOrdered.value, column => {
-      return !!(column.isRender !== false && modelColumnsVisibleLocal.value[column.id] !== false);
-    });
-  });
-
-  return {
-    allVisibleMobileColumns,
-  };
-}
+import {
+  computed,
+  ref,
+} from "vue";
+
+import {
+  filter,
+} from "lodash-es";
+
+export default function MobileColumnsAPI({
+  columnsOrdered = ref([]),
+  isMobile = ref(false),
+  modelColumnsVisibleLocal = ref({}),
+}) {
+  const allVisibleMobileColumns = computed(() => {
+    if (!isMobile.value) {
+      return [];
+    }
+    return filter(columnsOrdered.value, column => {
+      return !!(column.isRender !== false && modelColumnsVisibleLocal.value[column.id] !== false);
+    });
+  });
+
+  return {
+    allVisibleMobileColumns,
+  };
+}

package/src/ATable/compositionAPI/MultipleActionAPI.js

@@ -1,160 +1,160 @@
-import {
-  computed,
-  ref,
-  toRef,
-} from "vue";
-
-import {
-  getMultiplePanelId,
-} from "../utils/utils";
-
-import {
-  setFocusToElement,
-} from "../../utils/utilsDOM";
-import {
-  filter,
-  get,
-  isFunction,
-  size,
-  times,
-} from "lodash-es";
-
-export default function MultipleActionAPI(props, { emit }, {
-  checkVisibleColumns = () => {},
-  isMultipleActionsActive = ref(undefined),
-  rowsLocalAll = computed(() => []),
-  rowsLocalLength = computed(() => 0),
-}) {
-  const id = toRef(props, "id");
-  const multipleActions = toRef(props, "multipleActions");
-
-  const currentMultipleActions = ref(undefined);
-  const selectedRowsIndexes = ref({});
-  const areAllRowsSelected = ref(false);
-
-  const hasMultipleActions = computed(() => {
-    return multipleActions.value.length > 0;
-  });
-
-  const hasCurrentMultipleActionsIsHiddenCallback = computed(() => {
-    return isFunction(get(currentMultipleActions.value, "isHiddenCallback"));
-  });
-
-  const selectedRows = computed(() => {
-    return filter(rowsLocalAll.value, (row, index) => {
-      return selectedRowsIndexes.value[index];
-    });
-  });
-
-  const setEmptySelectedRowsIndexes = () => {
-    selectedRowsIndexes.value = {};
-  };
-
-  const closeMultipleActionsActive = () => {
-    isMultipleActionsActive.value = false;
-    currentMultipleActions.value = undefined;
-    areAllRowsSelected.value = false;
-    setEmptySelectedRowsIndexes();
-  };
-
-  const setFocusToMultiplePanel = () => {
-    if (window.isScrollDisabled) { // for autotests
-      return;
-    }
-
-    const PANEL_ID = getMultiplePanelId({ tableId: id.value });
-    setFocusToElement({
-      selector: `#${ PANEL_ID }`,
-    });
-  };
-
-  const toggleMultipleActionsActive = ({ isActive, action } = {}) => {
-    if (isActive) {
-      isMultipleActionsActive.value = true;
-      currentMultipleActions.value = action;
-      setTimeout(() => {
-        checkVisibleColumns();
-        setFocusToMultiplePanel();
-      });
-      emit("toggleMultipleActions", ({ isActive, action }));
-      return;
-    }
-
-    if (isMultipleActionsActive.value) {
-      closeMultipleActionsActive();
-    } else {
-      isMultipleActionsActive.value = true;
-    }
-    setTimeout(() => {
-      checkVisibleColumns();
-      setFocusToMultiplePanel();
-    });
-    emit("toggleMultipleActions", ({ isActive, action }));
-  };
-
-  const selectedRowsIndexesLength = computed(() => {
-    return size(selectedRowsIndexes.value);
-  });
-
-  const areAllVisibleRowsSelected = computed(() => {
-    return rowsLocalLength.value > 0 &&
-      rowsLocalLength.value === selectedRowsIndexesLength.value;
-  });
-
-  const areSomeRowsSelected = computed(() => {
-    return selectedRowsIndexesLength.value > 0;
-  });
-
-  const setSelectedRowsIndexes = ({ rowIndex, isAll }) => {
-    if (isAll) {
-      if (areSomeRowsSelected.value) {
-        setEmptySelectedRowsIndexes();
-      } else {
-        const SELECTED_ROWS_INDEXES = {};
-        if (hasCurrentMultipleActionsIsHiddenCallback.value) {
-          times(rowsLocalLength.value, index => {
-            if (!currentMultipleActions.value.isHiddenCallback({
-              row: rowsLocalAll.value[index],
-              rowIndex: index,
-            })) {
-              SELECTED_ROWS_INDEXES[index] = true;
-            }
-          });
-        } else {
-          times(rowsLocalLength.value, index => {
-            SELECTED_ROWS_INDEXES[index] = true;
-          });
-        }
-        selectedRowsIndexes.value = SELECTED_ROWS_INDEXES;
-      }
-      return;
-    }
-    if (selectedRowsIndexes.value[rowIndex]) {
-      delete selectedRowsIndexes.value[rowIndex];
-    } else {
-      selectedRowsIndexes.value[rowIndex] = true;
-    }
-  };
-
-  const toggleBtnAllRows = () => {
-    areAllRowsSelected.value = !areAllRowsSelected.value;
-    if (areAllRowsSelected.value) {
-      setEmptySelectedRowsIndexes();
-    }
-  };
-
-  return {
-    areAllRowsSelected,
-    areAllVisibleRowsSelected,
-    areSomeRowsSelected,
-    closeMultipleActionsActive,
-    currentMultipleActions,
-    hasMultipleActions,
-    selectedRows,
-    selectedRowsIndexes,
-    setEmptySelectedRowsIndexes,
-    setSelectedRowsIndexes,
-    toggleBtnAllRows,
-    toggleMultipleActionsActive,
-  };
-}
+import {
+  computed,
+  ref,
+  toRef,
+} from "vue";
+
+import {
+  getMultiplePanelId,
+} from "../utils/utils";
+
+import {
+  setFocusToElement,
+} from "../../utils/utilsDOM";
+import {
+  filter,
+  get,
+  isFunction,
+  size,
+  times,
+} from "lodash-es";
+
+export default function MultipleActionAPI(props, { emit }, {
+  checkVisibleColumns = () => {},
+  isMultipleActionsActive = ref(undefined),
+  rowsLocalAll = computed(() => []),
+  rowsLocalLength = computed(() => 0),
+}) {
+  const id = toRef(props, "id");
+  const multipleActions = toRef(props, "multipleActions");
+
+  const currentMultipleActions = ref(undefined);
+  const selectedRowsIndexes = ref({});
+  const areAllRowsSelected = ref(false);
+
+  const hasMultipleActions = computed(() => {
+    return multipleActions.value.length > 0;
+  });
+
+  const hasCurrentMultipleActionsIsHiddenCallback = computed(() => {
+    return isFunction(get(currentMultipleActions.value, "isHiddenCallback"));
+  });
+
+  const selectedRows = computed(() => {
+    return filter(rowsLocalAll.value, (row, index) => {
+      return selectedRowsIndexes.value[index];
+    });
+  });
+
+  const setEmptySelectedRowsIndexes = () => {
+    selectedRowsIndexes.value = {};
+  };
+
+  const closeMultipleActionsActive = () => {
+    isMultipleActionsActive.value = false;
+    currentMultipleActions.value = undefined;
+    areAllRowsSelected.value = false;
+    setEmptySelectedRowsIndexes();
+  };
+
+  const setFocusToMultiplePanel = () => {
+    if (window.isScrollDisabled) { // for autotests
+      return;
+    }
+
+    const PANEL_ID = getMultiplePanelId({ tableId: id.value });
+    setFocusToElement({
+      selector: `#${ PANEL_ID }`,
+    });
+  };
+
+  const toggleMultipleActionsActive = ({ isActive, action } = {}) => {
+    if (isActive) {
+      isMultipleActionsActive.value = true;
+      currentMultipleActions.value = action;
+      setTimeout(() => {
+        checkVisibleColumns();
+        setFocusToMultiplePanel();
+      });
+      emit("toggleMultipleActions", ({ isActive, action }));
+      return;
+    }
+
+    if (isMultipleActionsActive.value) {
+      closeMultipleActionsActive();
+    } else {
+      isMultipleActionsActive.value = true;
+    }
+    setTimeout(() => {
+      checkVisibleColumns();
+      setFocusToMultiplePanel();
+    });
+    emit("toggleMultipleActions", ({ isActive, action }));
+  };
+
+  const selectedRowsIndexesLength = computed(() => {
+    return size(selectedRowsIndexes.value);
+  });
+
+  const areAllVisibleRowsSelected = computed(() => {
+    return rowsLocalLength.value > 0 &&
+      rowsLocalLength.value === selectedRowsIndexesLength.value;
+  });
+
+  const areSomeRowsSelected = computed(() => {
+    return selectedRowsIndexesLength.value > 0;
+  });
+
+  const setSelectedRowsIndexes = ({ rowIndex, isAll }) => {
+    if (isAll) {
+      if (areSomeRowsSelected.value) {
+        setEmptySelectedRowsIndexes();
+      } else {
+        const SELECTED_ROWS_INDEXES = {};
+        if (hasCurrentMultipleActionsIsHiddenCallback.value) {
+          times(rowsLocalLength.value, index => {
+            if (!currentMultipleActions.value.isHiddenCallback({
+              row: rowsLocalAll.value[index],
+              rowIndex: index,
+            })) {
+              SELECTED_ROWS_INDEXES[index] = true;
+            }
+          });
+        } else {
+          times(rowsLocalLength.value, index => {
+            SELECTED_ROWS_INDEXES[index] = true;
+          });
+        }
+        selectedRowsIndexes.value = SELECTED_ROWS_INDEXES;
+      }
+      return;
+    }
+    if (selectedRowsIndexes.value[rowIndex]) {
+      delete selectedRowsIndexes.value[rowIndex];
+    } else {
+      selectedRowsIndexes.value[rowIndex] = true;
+    }
+  };
+
+  const toggleBtnAllRows = () => {
+    areAllRowsSelected.value = !areAllRowsSelected.value;
+    if (areAllRowsSelected.value) {
+      setEmptySelectedRowsIndexes();
+    }
+  };
+
+  return {
+    areAllRowsSelected,
+    areAllVisibleRowsSelected,
+    areSomeRowsSelected,
+    closeMultipleActionsActive,
+    currentMultipleActions,
+    hasMultipleActions,
+    selectedRows,
+    selectedRowsIndexes,
+    setEmptySelectedRowsIndexes,
+    setSelectedRowsIndexes,
+    toggleBtnAllRows,
+    toggleMultipleActionsActive,
+  };
+}