tav-ui/es/packages/components/table-pro/src/hooks/useExtendInstance2.mjs

Tav UI

import { unref, nextTick, reactive, watch } from 'vue';
import { ROW_KEY } from '../const2.mjs';

function createExendApis(tableRef, tablePropsRef, filterRef, isCheckboxCacheEnabled, checkboxCacheList, deleteCheckboxCache, deleteAllCheckboxCache, currentPage) {
  function getSelectRowKeys() {
    const {
      rowConfig: { keyField = ROW_KEY }
    } = unref(tablePropsRef);
    if (isCheckboxCacheEnabled.value) {
      return checkboxCacheList.value.map((cache) => `${cache[keyField]}`);
    } else {
      return unref(tableRef).getCheckboxRecords().map((record) => `${record[keyField]}`);
    }
  }
  async function clearSelectedRowByKey(keyField) {
    const rowKey = `${keyField}`;
    const {
      rowConfig: { keyField: _keyField = ROW_KEY }
    } = unref(tablePropsRef);
    const selectedRow = unref(tableRef).getCheckboxRecords().find((record) => {
      const recordRowKey = `${record[_keyField]}`;
      return recordRowKey === rowKey;
    });
    if (isCheckboxCacheEnabled.value) {
      await deleteCheckboxCache(selectedRow);
    } else {
      await unref(tableRef).toggleCheckboxRow(selectedRow);
    }
  }
  function getSelectRows() {
    if (isCheckboxCacheEnabled.value) {
      return checkboxCacheList.value;
    } else {
      return unref(tableRef).getCheckboxRecords();
    }
  }
  async function clearSelectedRows() {
    const { checkboxConfig = {}, radioConfig = {} } = unref(tablePropsRef);
    if (isCheckboxCacheEnabled.value) {
      await deleteAllCheckboxCache({
        deleteByPage: false
      });
    } else {
      const hasCheckbox = Object.keys(checkboxConfig).length > 0;
      const hasRadioConfig = Object.keys(radioConfig).length > 0;
      if (hasCheckbox)
        await unref(tableRef).clearCheckboxRow();
      if (hasRadioConfig)
        await unref(tableRef).clearRadioRow();
    }
  }
  function insertRow(records) {
    let _records = [];
    if (Array.isArray(records)) {
      _records = [...records];
    } else {
      _records = [records];
    }
    unref(tableRef).insertAt(_records, -1);
  }
  function updateRow(records) {
    const {
      rowConfig: { keyField = ROW_KEY }
    } = unref(tablePropsRef);
    const fullData = unref(tableRef).getTableData().fullData;
    let _records = [];
    if (Array.isArray(records)) {
      _records = [...records];
    } else {
      _records = [records];
    }
    const _data = fullData?.map((record) => {
      const matchedRecord = _records.find((_record) => _record[keyField] === record[keyField]);
      if (matchedRecord) {
        return { ...record, ...matchedRecord };
      } else {
        return record;
      }
    });
    unref(tableRef).loadData(_data);
  }
  function deleteRow(records) {
    let _records = [];
    if (Array.isArray(records)) {
      _records = [...records];
    } else {
      _records = [records];
    }
    unref(tableRef).remove(_records);
  }
  async function reload(options) {
    const tableFilterSearchParams = filterRef.value ? JSON.parse(filterRef.value.$el.dataset.filterParams) : {};
    const { checkboxConfig = {}, radioConfig = {} } = unref(tablePropsRef);
    const hasCheckbox = Object.keys(checkboxConfig).length > 0;
    const hasRadioConfig = Object.keys(radioConfig).length > 0;
    if (options?.clearSelect && hasCheckbox)
      unref(tableRef).clearCheckboxRow();
    if (options?.clearSelect && hasRadioConfig)
      unref(tableRef).clearRadioRow();
    const apiParams = {
      filter: tableFilterSearchParams,
      model: { page: currentPage.value }
    };
    if (options) {
      if (options.filter) {
        apiParams.filter = { ...apiParams.filter, ...options.filter ?? {} };
      }
      apiParams.model = {
        ...options.model ?? {},
        ...options.page && options.page > 0 ? { page: options.page } : {}
      };
    }
    if (isCheckboxCacheEnabled.value && options?.filter && Object.keys(options?.filter).length > 0 && JSON.stringify(options?.filter) !== JSON.stringify(tableFilterSearchParams)) {
      await deleteAllCheckboxCache({
        deleteByPage: false
      });
      await nextTick();
    }
    const { scrollTop: prevScrollTop, scrollLeft: prevScrollLeft } = unref(tableRef).getScroll();
    await unref(tableRef).commitProxy("reload", { ...apiParams });
    if (currentPage.value === apiParams?.model?.page) {
      nextTick(async () => {
        await unref(tableRef).refreshScroll();
        setTimeout(() => {
          unref(tableRef).scrollTo(prevScrollLeft, prevScrollTop);
        }, 16.7 * 2);
      });
    }
    const proxyInfo = unref(tableRef).getProxyInfo();
    if (apiParams?.model?.page && proxyInfo) {
      proxyInfo.pager.currentPage = apiParams.model.page;
    }
  }
  return {
    getSelectRowKeys,
    clearSelectedRowByKey,
    getSelectRows,
    clearSelectedRows,
    insertRow,
    updateRow,
    deleteRow,
    reload
  };
}
function useExtendInstance(tableRef, tablePropsRef, outerExtendApis, filterRef, isCheckboxCacheEnabled, checkboxCacheList, deleteCheckboxCache, deleteAllCheckboxCache, currentPage) {
  const state = reactive({
    instance: null
  });
  watch(() => tableRef.value, (curTableRef, preTableRef) => {
    if (curTableRef && curTableRef !== preTableRef) {
      state.instance = curTableRef;
      const extendApis = createExendApis(tableRef, tablePropsRef, filterRef, isCheckboxCacheEnabled, checkboxCacheList, deleteCheckboxCache, deleteAllCheckboxCache, currentPage);
      Object.keys(extendApis).forEach((name) => {
        state.instance[name] = extendApis[name];
      });
      Object.keys(outerExtendApis).forEach((name) => {
        state.instance[name] = outerExtendApis[name];
      });
      state.instance["filterRef"] = filterRef.value;
    }
  });
  return state;
}

export { useExtendInstance };
//# sourceMappingURL=useExtendInstance2.mjs.map