'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
require('../../../utils/index.cjs');
require('../../../hooks/index.cjs');
var index$5 = require('../../vc-resize-observer/src/index.cjs');
var Header = require('./Header/Header.cjs');
var index$1 = require('./Body/index.cjs');
var useColumns = require('./hooks/useColumns.cjs');
var useFrame = require('./hooks/useFrame.cjs');
var valueUtil = require('./utils/valueUtil.cjs');
var useStickyOffsets = require('./hooks/useStickyOffsets.cjs');
var ColGroup = require('./ColGroup.cjs');
var index$4 = require('./Panel/index.cjs');
var index$2 = require('./Footer/index.cjs');
var expandUtil = require('./utils/expandUtil.cjs');
var fixUtil = require('./utils/fixUtil.cjs');
var stickyScrollBar = require('./stickyScrollBar.cjs');
var useSticky = require('./hooks/useSticky.cjs');
var index$3 = require('./FixedHolder/index.cjs');
var TableContext = require('./context/TableContext.cjs');
var BodyContext = require('./context/BodyContext.cjs');
var ResizeContext = require('./context/ResizeContext.cjs');
var StickyContext = require('./context/StickyContext.cjs');
var ExpandedRowContext = require('./context/ExpandedRowContext.cjs');
var log = require('../../../utils/log.cjs');
var index = require('../../../hooks/use-state/index.cjs');
var util = require('../../../utils/vue/util.cjs');
var is = require('../../../utils/is.cjs');
var getScrollBarSize = require('../../../utils/scroll/getScrollBarSize.cjs');
var reactivePick = require('../../../utils/vue/reactivePick.cjs');
var _class = require('../../../utils/dom/class.cjs');
var pickAttrs = require('../../../utils/lang/pickAttrs.cjs');

const EMPTY_DATA = [];
const EMPTY_SCROLL_TARGET = {};
const INTERNAL_HOOKS = "rc-table-internal-hook";
var VcTable = /* @__PURE__ */ vue.defineComponent({
  name: "VcTable",
  inheritAttrs: false,
  props: ["prefixCls", "data", "columns", "rowKey", "tableLayout", "scroll", "rowClassName", "title", "footer", "id", "showHeader", "components", "customRow", "customHeaderRow", "direction", "expandFixed", "expandColumnWidth", "expandedRowKeys", "defaultExpandedRowKeys", "expandedRowRender", "expandRowByClick", "expandIcon", "onExpand", "onExpandedRowsChange", "onUpdate:expandedRowKeys", "defaultExpandAllRows", "indentSize", "expandIconColumnIndex", "expandedRowClassName", "childrenColumnName", "rowExpandable", "sticky", "transformColumns", "internalHooks", "internalRefs", "canExpandable", "onUpdateInternalRefs", "transformCellText"],
  emits: ["expand", "expandedRowsChange", "updateInternalRefs", "update:expandedRowKeys"],
  setup(props, {
    attrs,
    slots,
    emit
  }) {
    const mergedData = vue.computed(() => props.data || EMPTY_DATA);
    const hasData = vue.computed(() => !!mergedData.value.length);
    const mergedComponents = vue.computed(() => valueUtil.mergeObject(props.components, {}));
    const getComponent = (path, defaultComponent) => valueUtil.getPathValue(mergedComponents.value, path) || defaultComponent;
    const getRowKey = vue.computed(() => {
      const rowKey = props.rowKey;
      if (typeof rowKey === "function")
        return rowKey;
      return (record) => {
        const key = record && record[rowKey];
        if (process.env.NODE_ENV !== "production") {
          log.warning(key !== void 0, "Each record in table should have a unique `key` prop, or set `rowKey` to an unique primary key.");
        }
        return key;
      };
    });
    const mergedExpandIcon = vue.computed(() => props.expandIcon || expandUtil.renderExpandIcon);
    const mergedChildrenColumnName = vue.computed(() => props.childrenColumnName || "children");
    const expandableType = vue.computed(() => {
      if (props.expandedRowRender)
        return "row";
      if (props.canExpandable || mergedData.value.some((record) => record && typeof record === "object" && record[mergedChildrenColumnName.value]))
        return "nest";
      return false;
    });
    const innerExpandedKeys = vue.shallowRef([]);
    const stop = vue.watchEffect(() => {
      if (props.defaultExpandedRowKeys)
        innerExpandedKeys.value = props.defaultExpandedRowKeys;
      if (props.defaultExpandAllRows) {
        innerExpandedKeys.value = expandUtil.findAllChildrenKeys(mergedData.value, getRowKey.value, mergedChildrenColumnName.value);
      }
    });
    stop();
    const mergedExpandedKeys = vue.computed(() => new Set(props.expandedRowKeys || innerExpandedKeys.value || []));
    const onTriggerExpand = (record) => {
      const key = getRowKey.value(record, mergedData.value.indexOf(record));
      let newExpandedKeys;
      const hasKey = mergedExpandedKeys.value.has(key);
      if (hasKey) {
        mergedExpandedKeys.value.delete(key);
        newExpandedKeys = [...mergedExpandedKeys.value];
      } else {
        newExpandedKeys = [...mergedExpandedKeys.value, key];
      }
      innerExpandedKeys.value = newExpandedKeys;
      emit("expand", !hasKey, record);
      emit("update:expandedRowKeys", newExpandedKeys);
      emit("expandedRowsChange", newExpandedKeys);
    };
    if (process.env.NODE_ENV !== "production" && props.expandedRowRender && mergedData.value.some((record) => {
      return Array.isArray(record == null ? void 0 : record[mergedChildrenColumnName.value]);
    }))
      log.warning(false, "`expandedRowRender` should not use with nested Table");
    const componentWidth = vue.ref(0);
    const [columns, flattenColumns] = useColumns.default({
      ...vue.toRefs(props),
      // children,
      expandable: vue.computed(() => !!props.expandedRowRender),
      expandedKeys: mergedExpandedKeys,
      getRowKey,
      onTriggerExpand,
      expandIcon: mergedExpandIcon
    }, vue.computed(() => props.internalHooks === INTERNAL_HOOKS ? props.transformColumns : null));
    const columnContext = vue.computed(() => ({
      columns: columns.value,
      flattenColumns: flattenColumns.value
    }));
    const fullTableRef = vue.ref();
    const scrollHeaderRef = vue.ref();
    const scrollBodyRef = vue.ref();
    const scrollBodySizeInfo = vue.ref({
      scrollWidth: 0,
      clientWidth: 0
    });
    const scrollSummaryRef = vue.ref();
    const [pingedLeft, setPingedLeft] = index.useState(false);
    const [pingedRight, setPingedRight] = index.useState(false);
    const [colsWidths, updateColsWidths] = useFrame.useLayoutState(/* @__PURE__ */ new Map());
    const colsKeys = vue.computed(() => valueUtil.getColumnsKey(flattenColumns.value));
    const colWidths = vue.computed(() => colsKeys.value.map((columnKey) => colsWidths.value.get(columnKey)));
    const columnCount = vue.computed(() => flattenColumns.value.length);
    const stickyOffsets = useStickyOffsets.default(colWidths, columnCount, vue.toRef(props, "direction"));
    const fixHeader = vue.computed(() => props.scroll && valueUtil.validateValue(props.scroll.y));
    const horizonScroll = vue.computed(() => props.scroll && valueUtil.validateValue(props.scroll.x) || Boolean(props.expandFixed));
    const fixColumn = vue.computed(() => horizonScroll.value && flattenColumns.value.some(({
      fixed
    }) => fixed));
    const stickyRef = vue.ref();
    const stickyState = useSticky.default(vue.toRef(props, "sticky"), vue.toRef(props, "prefixCls"));
    const summaryFixedInfos = vue.reactive({});
    const fixFooter = vue.computed(() => {
      const info = Object.values(summaryFixedInfos)[0];
      return (fixHeader.value || stickyState.value.isSticky) && info;
    });
    const summaryCollect = (uniKey, fixed) => {
      if (fixed)
        summaryFixedInfos[uniKey] = fixed;
      else
        delete summaryFixedInfos[uniKey];
    };
    const scrollXStyle = vue.ref({});
    const scrollYStyle = vue.ref({});
    const scrollTableStyle = vue.ref({});
    vue.watchEffect(() => {
      if (fixHeader.value) {
        scrollYStyle.value = {
          overflowY: "scroll",
          maxHeight: util.toPx(props.scroll.y)
        };
      }
      if (horizonScroll.value) {
        scrollXStyle.value = {
          overflowX: "auto"
        };
        if (!fixHeader.value)
          scrollYStyle.value = {
            overflowY: "hidden"
          };
        scrollTableStyle.value = {
          width: props.scroll.x === true ? "auto" : util.toPx(props.scroll.x),
          minWidth: "100%"
        };
      }
    });
    const onColumnResize = (columnKey, width) => {
      if (is.isVisible(fullTableRef.value)) {
        updateColsWidths((widths) => {
          if (widths.get(columnKey) !== width) {
            const newWidths = new Map(widths);
            newWidths.set(columnKey, width);
            return newWidths;
          }
          return widths;
        });
      }
    };
    const [setScrollTarget, getScrollTarget] = useFrame.useTimeoutLock(null);
    function forceScroll(scrollLeft, target) {
      if (!target)
        return;
      if (typeof target === "function") {
        target(scrollLeft);
        return;
      }
      const domTarget = target.$el || target;
      if (domTarget.scrollLeft !== scrollLeft)
        domTarget.scrollLeft = scrollLeft;
    }
    const onScroll = ({
      currentTarget,
      scrollLeft
    }) => {
      var _a;
      const isRTL = props.direction === "rtl";
      const mergedScrollLeft = typeof scrollLeft === "number" ? scrollLeft : currentTarget.scrollLeft;
      const compareTarget = currentTarget || EMPTY_SCROLL_TARGET;
      if (!getScrollTarget() || getScrollTarget() === compareTarget) {
        setScrollTarget(compareTarget);
        forceScroll(mergedScrollLeft, scrollHeaderRef.value);
        forceScroll(mergedScrollLeft, scrollBodyRef.value);
        forceScroll(mergedScrollLeft, scrollSummaryRef.value);
        forceScroll(mergedScrollLeft, (_a = stickyRef.value) == null ? void 0 : _a.setScrollLeft);
      }
      if (currentTarget) {
        const {
          scrollWidth,
          clientWidth
        } = currentTarget;
        if (isRTL) {
          setPingedLeft(-mergedScrollLeft < scrollWidth - clientWidth);
          setPingedRight(-mergedScrollLeft > 0);
        } else {
          setPingedLeft(mergedScrollLeft > 0);
          setPingedRight(mergedScrollLeft < scrollWidth - clientWidth);
        }
      }
    };
    const triggerOnScroll = () => {
      if (horizonScroll.value && scrollBodyRef.value) {
        onScroll({
          currentTarget: scrollBodyRef.value
        });
      } else {
        setPingedLeft(false);
        setPingedRight(false);
      }
    };
    let timtout;
    const updateWidth = (width) => {
      if (width !== componentWidth.value) {
        triggerOnScroll();
        componentWidth.value = fullTableRef.value ? fullTableRef.value.offsetWidth : width;
      }
    };
    const onFullTableResize = ({
      width
    }) => {
      clearTimeout(timtout);
      if (componentWidth.value === 0) {
        updateWidth(width);
        return;
      }
      timtout = setTimeout(() => {
        updateWidth(width);
      }, 100);
    };
    vue.watch([horizonScroll, () => props.data, () => props.columns], () => {
      if (horizonScroll.value)
        triggerOnScroll();
    }, {
      flush: "post"
    });
    const [scrollbarSize, setScrollbarSize] = index.useState(0);
    StickyContext.useProvideSticky();
    vue.onMounted(() => {
      vue.nextTick(() => {
        var _a, _b;
        triggerOnScroll();
        setScrollbarSize(getScrollBarSize.getTargetScrollBarSize(scrollBodyRef.value).width);
        scrollBodySizeInfo.value = {
          scrollWidth: ((_a = scrollBodyRef.value) == null ? void 0 : _a.scrollWidth) || 0,
          clientWidth: ((_b = scrollBodyRef.value) == null ? void 0 : _b.clientWidth) || 0
        };
      });
    });
    vue.onUpdated(() => {
      vue.nextTick(() => {
        var _a, _b;
        const scrollWidth = ((_a = scrollBodyRef.value) == null ? void 0 : _a.scrollWidth) || 0;
        const clientWidth = ((_b = scrollBodyRef.value) == null ? void 0 : _b.clientWidth) || 0;
        if (scrollBodySizeInfo.value.scrollWidth !== scrollWidth || scrollBodySizeInfo.value.clientWidth !== clientWidth) {
          scrollBodySizeInfo.value = {
            scrollWidth,
            clientWidth
          };
        }
      });
    });
    vue.watchEffect(() => {
      if (props.internalHooks === INTERNAL_HOOKS && props.internalRefs) {
        props.onUpdateInternalRefs({
          body: scrollBodyRef.value ? scrollBodyRef.value.$el || scrollBodyRef.value : null
        });
      }
    }, {
      flush: "post"
    });
    const mergedTableLayout = vue.computed(() => {
      if (props.tableLayout)
        return props.tableLayout;
      if (fixColumn.value)
        return props.scroll.x === "max-content" ? "auto" : "fixed";
      if (fixHeader.value || stickyState.value.isSticky || flattenColumns.value.some(({
        ellipsis
      }) => ellipsis))
        return "fixed";
      return "auto";
    });
    const emptyNode = () => {
      var _a;
      return hasData.value ? null : ((_a = slots.emptyText) == null ? void 0 : _a.call(slots)) || "No Data";
    };
    TableContext.useProvideTable(vue.reactive({
      ...vue.toRefs(reactivePick.reactivePick(props, "prefixCls", "direction", "transformCellText")),
      getComponent,
      scrollbarSize,
      fixedInfoList: vue.computed(() => flattenColumns.value.map((_, colIndex) => fixUtil.getCellFixedInfo(colIndex, colIndex, flattenColumns.value, stickyOffsets.value, props.direction))),
      isSticky: vue.computed(() => stickyState.value.isSticky),
      summaryCollect
    }));
    BodyContext.useProvideBody(vue.reactive({
      ...vue.toRefs(reactivePick.reactivePick(props, "rowClassName", "expandedRowClassName", "expandRowByClick", "expandedRowRender", "expandIconColumnIndex", "indentSize")),
      columns,
      flattenColumns,
      tableLayout: mergedTableLayout,
      expandIcon: mergedExpandIcon,
      expandableType,
      onTriggerExpand
    }));
    ResizeContext.useProvideResize({
      onColumnResize
    });
    ExpandedRowContext.useProvideExpandedRow({
      componentWidth,
      fixHeader,
      fixColumn,
      horizonScroll
    });
    const bodyTable = () => vue.createVNode(index$1.default, {
      "data": mergedData.value,
      "measureColumnWidth": fixHeader.value || horizonScroll.value || stickyState.value.isSticky,
      "expandedKeys": mergedExpandedKeys.value,
      "rowExpandable": props.rowExpandable,
      "getRowKey": getRowKey.value,
      "customRow": props.customRow,
      "childrenColumnName": mergedChildrenColumnName.value
    }, {
      emptyNode
    });
    const bodyColGroup = () => vue.createVNode(ColGroup.default, {
      "colWidths": flattenColumns.value.map(({
        width
      }) => width),
      "columns": flattenColumns.value
    }, null);
    return () => {
      var _a;
      const {
        prefixCls,
        scroll,
        tableLayout,
        direction,
        // Additional Part
        title = slots.title,
        footer = slots.footer,
        // Customize
        id,
        showHeader,
        customHeaderRow
      } = props;
      const {
        isSticky,
        offsetHeader,
        offsetSummary,
        offsetScroll,
        stickyClassName,
        container
      } = stickyState.value;
      const TableComponent = getComponent(["table"], "table");
      const customizeScrollBody = getComponent(["body"]);
      const summaryNode = (_a = slots.summary) == null ? void 0 : _a.call(slots, {
        pageData: mergedData.value
      });
      let groupTableNode = () => null;
      const headerProps = {
        colWidths: colWidths.value,
        columCount: flattenColumns.value.length,
        stickyOffsets: stickyOffsets.value,
        customHeaderRow,
        fixHeader: fixHeader.value,
        scroll
      };
      if (process.env.NODE_ENV !== "production" && typeof customizeScrollBody === "function" && hasData.value && !fixHeader.value)
        log.warning(false, "`components.body` with render props is only work on `scroll.y`.");
      if (fixHeader.value || isSticky) {
        let bodyContent = () => null;
        if (typeof customizeScrollBody === "function") {
          bodyContent = () => customizeScrollBody(mergedData.value, {
            scrollbarSize: scrollbarSize.value,
            ref: scrollBodyRef,
            onScroll
          });
          headerProps.colWidths = flattenColumns.value.map(({
            width
          }, index) => {
            const colWidth = index === columns.value.length - 1 ? width - scrollbarSize.value : width;
            if (typeof colWidth === "number" && !Number.isNaN(colWidth))
              return colWidth;
            log.warning(false, "When use `components.body` with render props. Each column should have a fixed `width` value.");
            return 0;
          });
        } else {
          bodyContent = () => vue.createVNode("div", {
            "style": {
              ...scrollXStyle.value,
              ...scrollYStyle.value
            },
            "onScroll": onScroll,
            "ref": scrollBodyRef,
            "class": _class.classNames(`${prefixCls}-body`)
          }, [vue.createVNode(TableComponent, {
            "style": {
              ...scrollTableStyle.value,
              tableLayout: mergedTableLayout.value
            }
          }, {
            default: () => [bodyColGroup(), bodyTable(), !fixFooter.value && summaryNode && vue.createVNode(index$2.default, {
              "stickyOffsets": stickyOffsets.value,
              "flattenColumns": flattenColumns.value
            }, {
              default: () => [summaryNode]
            })]
          })]);
        }
        const fixedHolderProps = {
          noData: !mergedData.value.length,
          maxContentScroll: horizonScroll.value && scroll.x === "max-content",
          ...headerProps,
          ...columnContext.value,
          direction,
          stickyClassName,
          onScroll
        };
        groupTableNode = () => vue.createVNode(vue.Fragment, null, [showHeader !== false && vue.createVNode(index$3.default, {
          ...fixedHolderProps,
          "stickyTopOffset": offsetHeader,
          "class": `${prefixCls}-header`,
          "ref": scrollHeaderRef
        }, {
          default: (fixedHolderPassProps) => vue.createVNode(vue.Fragment, null, [vue.createVNode(Header.default, fixedHolderPassProps, null), fixFooter.value === "top" && vue.createVNode(index$2.default, fixedHolderPassProps, {
            default: () => [summaryNode]
          })])
        }), bodyContent(), fixFooter.value && fixFooter.value !== "top" && vue.createVNode(index$3.default, {
          ...fixedHolderProps,
          "stickyBottomOffset": offsetSummary,
          "class": `${prefixCls}-summary`,
          "ref": scrollSummaryRef
        }, {
          default: (fixedHolderPassProps) => vue.createVNode(index$2.default, fixedHolderPassProps, {
            default: () => [summaryNode]
          })
        }), isSticky && scrollBodyRef.value && vue.createVNode(stickyScrollBar.default, {
          "ref": stickyRef,
          "offsetScroll": offsetScroll,
          "scrollBodyRef": scrollBodyRef,
          "onScroll": onScroll,
          "container": container,
          "scrollBodySizeInfo": scrollBodySizeInfo.value
        }, null)]);
      } else {
        groupTableNode = () => vue.createVNode("div", {
          "style": {
            ...scrollXStyle.value,
            ...scrollYStyle.value
          },
          "class": _class.classNames(`${prefixCls}-content`),
          "onScroll": onScroll,
          "ref": scrollBodyRef
        }, [vue.createVNode(TableComponent, {
          "style": {
            ...scrollTableStyle.value,
            tableLayout: mergedTableLayout.value
          }
        }, {
          default: () => [bodyColGroup(), showHeader !== false && vue.createVNode(Header.default, {
            ...headerProps,
            ...columnContext.value
          }, null), bodyTable(), summaryNode && vue.createVNode(index$2.default, {
            "stickyOffsets": stickyOffsets.value,
            "flattenColumns": flattenColumns.value
          }, {
            default: () => [summaryNode]
          })]
        })]);
      }
      const ariaProps = pickAttrs.pickAttrs(attrs, {
        aria: true,
        data: true
      });
      const fullTable = () => vue.createVNode("div", {
        ...ariaProps,
        "class": _class.classNames(prefixCls, {
          [`${prefixCls}-rtl`]: direction === "rtl",
          [`${prefixCls}-ping-left`]: pingedLeft.value,
          [`${prefixCls}-ping-right`]: pingedRight.value,
          [`${prefixCls}-layout-fixed`]: tableLayout === "fixed",
          [`${prefixCls}-fixed-header`]: fixHeader.value,
          /** No used but for compatible */
          [`${prefixCls}-fixed-column`]: fixColumn.value,
          [`${prefixCls}-scroll-horizontal`]: horizonScroll.value,
          [`${prefixCls}-has-fix-left`]: flattenColumns.value[0] && flattenColumns.value[0].fixed,
          [`${prefixCls}-has-fix-right`]: flattenColumns.value[columnCount.value - 1] && flattenColumns.value[columnCount.value - 1].fixed === "right",
          [attrs.class]: attrs.class
        }),
        "style": attrs.style,
        "id": id,
        "ref": fullTableRef
      }, [title && vue.createVNode(index$4.default, {
        "class": `${prefixCls}-title`
      }, {
        default: () => [title(mergedData.value)]
      }), vue.createVNode("div", {
        "class": `${prefixCls}-container`
      }, [groupTableNode()]), footer && vue.createVNode(index$4.default, {
        "class": `${prefixCls}-footer`
      }, {
        default: () => [footer(mergedData.value)]
      })]);
      if (horizonScroll.value) {
        return vue.createVNode(index$5.default, {
          "onResize": onFullTableResize
        }, {
          default: fullTable
        });
      }
      return fullTable();
    };
  }
});

exports.INTERNAL_HOOKS = INTERNAL_HOOKS;
exports.default = VcTable;
//# sourceMappingURL=Table.cjs.map
