yanzhen-design-vue/es/components/vxe-table/src/hooks/use-vxe-table-virtual.mjs

import { ref, unref } from "vue";
import { isPlainObject, isBoolean, isElement, mergeWith, isString } from "lodash-es";
import { unrefTbodyRowElements, unrefTbodyRowRecord, isVirtualDom } from "../utils/index.mjs";
import { CELL_CLASS, VIRTUAL_CLASS } from "../constants.mjs";
import { useVxeTableColumnSlotRecord } from "./use-vxe-table-column-slot-record.mjs";
function useVxeTableVirtual(tableRef) {
  const { getRecordId, getElementRect, isFixedRecord } = useVxeTableColumnSlotRecord(tableRef);
  const virtualHiddenRecords = ref({});
  const virtualRectRecords = ref({});
  const virtualScroll = ref({
    enabled: true,
    isVirtualX: true,
    isVirtualY: true
  });
  function isVirtualHidden(record, name) {
    const { enabled, isVirtualY, isVirtualX } = unref(virtualScroll);
    if (enabled === false || isFixedRecord(record)) {
      return false;
    }
    const recordId = getRecordId(name, record);
    const ref2 = unref(virtualHiddenRecords)[recordId];
    switch (true) {
      case !ref2:
      case (isVirtualX && ref2.isVirtualX === true):
      case (isVirtualY && ref2.isVirtualY === true):
        return true;
    }
    return false;
  }
  function getNodeRect(record, name) {
    const recordId = getRecordId(record, name);
    return unref(virtualRectRecords)[recordId];
  }
  function handleVirtualRecord(bodyRect, ...args) {
    const record = args.find((value) => isPlainObject(value));
    const isUpdate = args.find((value) => isBoolean(value));
    const { parentWidth, parentHeight, scrollHeight, scrollWidth, tbody } = bodyRect;
    switch (true) {
      case parentWidth === 0:
      case (scrollWidth > 0 && scrollWidth <= parentWidth):
        unref(virtualScroll).isVirtualX = false;
        break;
      default:
        unref(virtualScroll).isVirtualX = true;
    }
    switch (true) {
      case parentHeight === 0:
      case (scrollHeight > 0 && scrollHeight <= parentHeight):
        unref(virtualScroll).isVirtualY = false;
        break;
      default:
        unref(virtualScroll).isVirtualY = true;
    }
    switch (true) {
      case (unref(virtualScroll).isVirtualY === false && unref(virtualScroll).isVirtualX === false):
        unref(virtualScroll).enabled = false;
        break;
      default:
        unref(virtualScroll).enabled = true;
    }
    if (!unref(virtualScroll).enabled) return;
    if (record) {
      updateNodeRect(record);
    } else if (isUpdate !== false) {
      const rows = unrefTbodyRowElements(tbody);
      if (rows && rows.length > 0) {
        unrefTbodyRowRecord(rows, tableRef, (record2) => {
          updateNodeRect(record2);
        });
      }
    }
  }
  function handleAsyncNodeRect(record, name, target) {
    var _a;
    const cellTarget = target == null ? void 0 : target.querySelector(`div.${CELL_CLASS}`);
    if (!isElement(cellTarget) || !isVirtualDom(target)) return;
    const recordId = getRecordId(name, record);
    const contentRect = (_a = getElementRect(cellTarget)) == null ? void 0 : _a.contentRect;
    mergeWith(unref(virtualRectRecords), {
      [recordId]: {
        width: (contentRect == null ? void 0 : contentRect.realWidth) ?? 0,
        height: (contentRect == null ? void 0 : contentRect.realHeight) ?? 0
      }
    });
  }
  function handleAsyncVirtualRecord(record, name, target) {
    var _a, _b;
    if (!isElement(target)) return;
    const scroll = (_b = (_a = unref(tableRef)) == null ? void 0 : _a.getScroll) == null ? void 0 : _b.call(_a);
    if (!scroll) return;
    const recordId = getRecordId(name, record);
    if (!unref(virtualHiddenRecords)[recordId]) {
      unref(virtualHiddenRecords)[recordId] = {
        isVirtualX: true,
        isVirtualY: true
      };
    }
    const virtual = {
      isVirtualX: false,
      isVirtualY: false
    };
    for (const [key, value] of Object.entries(virtual)) {
      const oldValue = unref(virtualHiddenRecords)[recordId][key];
      if (oldValue !== value) {
        unref(virtualHiddenRecords)[recordId][key] = value;
      }
    }
  }
  function updateNodeRect(...args) {
    const name = args.find((value) => isString(value)) ?? "default";
    const record = args.find((value) => isPlainObject(value));
    if (!record || !isElement(record == null ? void 0 : record.target)) return;
    handleAsyncVirtualRecord(record, name, record.target);
    handleAsyncNodeRect(record, name, record.target);
  }
  function virtualCellClassName(record) {
    const isVirtual = isVirtualHidden(record);
    return isVirtual ? VIRTUAL_CLASS : void 0;
  }
  const virtualNodeRect = {
    getNodeRect,
    updateNodeRect
  };
  return {
    virtualCellClassName,
    virtualNodeRect,
    virtualScroll,
    isVirtualHidden,
    onVirtualScroll: handleVirtualRecord
  };
}
export {
  useVxeTableVirtual
};