ep-craft 0.1.32 → 0.1.34

package/dist/components/table/src/table-header/index.d.ts

@@ -0,0 +1,361 @@
+import type TableLayout from '../table-layout';
+import type { ComponentInternalInstance, PropType, Ref } from 'vue';
+import type { DefaultRow, Sort } from '../table/defaults';
+import type { Store } from '../store';
+export interface TableHeader extends ComponentInternalInstance {
+    state: {
+        onColumnsChange: (layout: TableLayout<any>) => void;
+        onScrollableChange: (layout: TableLayout<any>) => void;
+    };
+    filterPanels: Ref<DefaultRow>;
+}
+export interface TableHeaderProps<T extends DefaultRow> {
+    fixed: string;
+    store: Store<T>;
+    border: boolean;
+    defaultSort: Sort;
+    allowDragLastColumn: boolean;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    store: {
+        required: true;
+        type: PropType<TableHeaderProps<any>["store"]>;
+    };
+    border: BooleanConstructor;
+    defaultSort: {
+        type: PropType<TableHeaderProps<any>["defaultSort"]>;
+        default: () => {
+            prop: string;
+            order: string;
+        };
+    };
+    appendFilterPanelTo: {
+        type: StringConstructor;
+    };
+    allowDragLastColumn: {
+        type: BooleanConstructor;
+    };
+}>, {
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    t: import("@element-plus/hooks").Translator;
+    filterPanels: Ref<{}, {}>;
+    onColumnsChange: (layout: TableLayout<DefaultRow>) => void;
+    onScrollableChange: (layout: TableLayout<DefaultRow>) => void;
+    columnRows: import("vue").ComputedRef<import("../table-column/defaults.js").TableColumnCtx<any>[][]>;
+    getHeaderRowClass: (rowIndex: number) => string;
+    getHeaderRowStyle: (rowIndex: number) => any;
+    getHeaderCellClass: (rowIndex: number, columnIndex: number, row: any, column: import("../table-column/defaults.js").TableColumnCtx<any>) => string;
+    getHeaderCellStyle: (rowIndex: number, columnIndex: number, row: any, column: import("../table-column/defaults.js").TableColumnCtx<any>) => import("vue").CSSProperties;
+    handleHeaderClick: (event: PointerEvent, column: import("../table-column/defaults.js").TableColumnCtx<any>) => void;
+    handleHeaderContextMenu: (event: PointerEvent, column: import("../table-column/defaults.js").TableColumnCtx<any>) => void;
+    handleMouseDown: (event: MouseEvent, column: import("../table-column/defaults.js").TableColumnCtx<any>) => void;
+    handleMouseMove: (event: MouseEvent, column: import("../table-column/defaults.js").TableColumnCtx<any>) => void;
+    handleMouseOut: () => void;
+    handleSortClick: (event: Event, column: import("../table-column/defaults.js").TableColumnCtx<any>, givenOrder?: import("../table/defaults").TableSortOrder | boolean) => void;
+    handleFilterClick: (event: Event) => void;
+    isGroup: import("vue").ComputedRef<boolean>;
+    toggleAllSelection: (event: Event) => void;
+    saveIndexSelection: import("vue").Reactive<Map<any, any>>;
+    isTableLayoutAuto: boolean;
+    theadRef: Ref<any, any>;
+    updateFixedColumnStyle: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    store: {
+        required: true;
+        type: PropType<TableHeaderProps<any>["store"]>;
+    };
+    border: BooleanConstructor;
+    defaultSort: {
+        type: PropType<TableHeaderProps<any>["defaultSort"]>;
+        default: () => {
+            prop: string;
+            order: string;
+        };
+    };
+    appendFilterPanelTo: {
+        type: StringConstructor;
+    };
+    allowDragLastColumn: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    fixed: string;
+    border: boolean;
+    defaultSort: Sort;
+    allowDragLastColumn: boolean;
+}, {}, {
+    ElCheckbox: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: PropType<import("../../../../utils/index.js").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (NumberConstructor | StringConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            ariaLabel: StringConstructor;
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox").CheckboxValueType) => any) | undefined;
+            onChange?: ((val: import("@element-plus/components/checkbox").CheckboxValueType) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: import("@element-plus/components/checkbox").CheckboxValueType) => void;
+            change: (val: import("@element-plus/components/checkbox").CheckboxValueType) => void;
+        }, import("vue").PublicProps, {
+            name: string;
+            border: boolean;
+            disabled: boolean;
+            label: string | number | boolean | Record<string, any>;
+            value: string | number | boolean | Record<string, any>;
+            id: string;
+            modelValue: string | number | boolean;
+            validateEvent: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            trueValue: string | number;
+            falseValue: string | number;
+            trueLabel: string | number;
+            falseLabel: string | number;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: PropType<import("../../../../utils/index.js").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (NumberConstructor | StringConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            ariaLabel: StringConstructor;
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox").CheckboxValueType) => any) | undefined;
+            onChange?: ((val: import("@element-plus/components/checkbox").CheckboxValueType) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            name: string;
+            border: boolean;
+            disabled: boolean;
+            label: string | number | boolean | Record<string, any>;
+            value: string | number | boolean | Record<string, any>;
+            id: string;
+            modelValue: string | number | boolean;
+            validateEvent: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            trueValue: string | number;
+            falseValue: string | number;
+            trueLabel: string | number;
+            falseLabel: string | number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        ariaControls: StringConstructor;
+        modelValue: {
+            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        label: {
+            type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        value: {
+            type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        indeterminate: BooleanConstructor;
+        disabled: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        checked: BooleanConstructor;
+        name: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        trueValue: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        falseValue: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        trueLabel: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        falseLabel: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        id: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        border: BooleanConstructor;
+        size: {
+            readonly type: PropType<import("../../../../utils/index.js").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        tabindex: (NumberConstructor | StringConstructor)[];
+        validateEvent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        ariaLabel: StringConstructor;
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((val: import("@element-plus/components/checkbox").CheckboxValueType) => any) | undefined;
+        onChange?: ((val: import("@element-plus/components/checkbox").CheckboxValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (val: import("@element-plus/components/checkbox").CheckboxValueType) => void;
+        change: (val: import("@element-plus/components/checkbox").CheckboxValueType) => void;
+    }, string, {
+        name: string;
+        border: boolean;
+        disabled: boolean;
+        label: string | number | boolean | Record<string, any>;
+        value: string | number | boolean | Record<string, any>;
+        id: string;
+        modelValue: string | number | boolean;
+        validateEvent: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        trueValue: string | number;
+        falseValue: string | number;
+        trueLabel: string | number;
+        falseLabel: string | number;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) & import("vue").Plugin;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/table/src/table-header/index.js

@@ -0,0 +1,255 @@
+import { defineComponent as A, h as a, getCurrentInstance as D, inject as _, ref as O, reactive as j, watch as N, onBeforeUnmount as q, onMounted as G, nextTick as x } from "vue";
+import { EpCheckbox as I } from "../../../checkbox/index.js";
+import { useNamespace as U } from "../../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { useLocale as V } from "../../../../hooks/use-locale/index.js";
+import "../../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../../hooks/use-z-index/index.js";
+import "../../../../hooks/use-delayed-toggle/index.js";
+import "../../../../hooks/use-aria/index.js";
+import "../../../../hooks/use-model-toggle/index.js";
+import "../../../../hooks/use-empty-values/index.js";
+import z from "../filter-panel.vue.js";
+import J from "../layout-observer.js";
+import { TABLE_INJECTION_KEY as K } from "../tokens.js";
+import Y from "./event-helper.js";
+import $ from "./style.helper.js";
+import Q from "./utils-helper.js";
+const ye = A({
+  name: "ElTableHeader",
+  components: {
+    ElCheckbox: I
+  },
+  props: {
+    fixed: {
+      type: String,
+      default: ""
+    },
+    store: {
+      required: !0,
+      type: Object
+    },
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: () => ({
+        prop: "",
+        order: ""
+      })
+    },
+    appendFilterPanelTo: {
+      type: String
+    },
+    allowDragLastColumn: {
+      type: Boolean
+    }
+  },
+  setup(l, { emit: H }) {
+    const h = D(), r = _(K), k = U("table"), u = O({}), { onColumnsChange: C, onScrollableChange: g } = J(r), M = (r == null ? void 0 : r.props.tableLayout) === "auto", o = j(/* @__PURE__ */ new Map()), S = O();
+    let n;
+    const s = () => {
+      n = setTimeout(() => {
+        o.size > 0 && (o.forEach((m, R) => {
+          const E = S.value.querySelector(
+            `.${R.replace(/\s/g, ".")}`
+          );
+          if (E) {
+            const B = E.getBoundingClientRect().width;
+            m.width = B || m.width;
+          }
+        }), o.clear());
+      });
+    };
+    N(o, s), q(() => {
+      n && (clearTimeout(n), n = void 0);
+    }), G(async () => {
+      await x(), await x();
+      const { prop: m, order: R } = l.defaultSort;
+      r == null || r.store.commit("sort", { prop: m, order: R, init: !0 }), s();
+    });
+    const {
+      handleHeaderClick: T,
+      handleHeaderContextMenu: y,
+      handleMouseDown: d,
+      handleMouseMove: v,
+      handleMouseOut: L,
+      handleSortClick: b,
+      handleFilterClick: c
+    } = Y(l, H), {
+      getHeaderRowStyle: i,
+      getHeaderRowClass: e,
+      getHeaderCellStyle: f,
+      getHeaderCellClass: w
+    } = $(l), { isGroup: t, toggleAllSelection: p, columnRows: F } = Q(
+      l
+    ), { t: P } = V();
+    return h.state = {
+      onColumnsChange: C,
+      onScrollableChange: g
+    }, h.filterPanels = u, {
+      ns: k,
+      t: P,
+      filterPanels: u,
+      onColumnsChange: C,
+      onScrollableChange: g,
+      columnRows: F,
+      getHeaderRowClass: e,
+      getHeaderRowStyle: i,
+      getHeaderCellClass: w,
+      getHeaderCellStyle: f,
+      handleHeaderClick: T,
+      handleHeaderContextMenu: y,
+      handleMouseDown: d,
+      handleMouseMove: v,
+      handleMouseOut: L,
+      handleSortClick: b,
+      handleFilterClick: c,
+      isGroup: t,
+      toggleAllSelection: p,
+      saveIndexSelection: o,
+      isTableLayoutAuto: M,
+      theadRef: S,
+      updateFixedColumnStyle: s
+    };
+  },
+  render() {
+    const {
+      ns: l,
+      t: H,
+      isGroup: h,
+      columnRows: r,
+      getHeaderCellStyle: k,
+      getHeaderCellClass: u,
+      getHeaderRowClass: C,
+      getHeaderRowStyle: g,
+      handleHeaderClick: M,
+      handleHeaderContextMenu: o,
+      handleMouseDown: S,
+      handleMouseMove: n,
+      handleSortClick: s,
+      handleMouseOut: T,
+      store: y,
+      $parent: d,
+      saveIndexSelection: v,
+      isTableLayoutAuto: L
+    } = this;
+    let b = 1;
+    return a(
+      "thead",
+      {
+        ref: "theadRef",
+        class: l.is("group", h)
+      },
+      r.map(
+        (c, i) => a(
+          "tr",
+          {
+            class: C(i),
+            key: i,
+            style: g(i)
+          },
+          c.map((e, f) => {
+            e.rowSpan > b && (b = e.rowSpan);
+            const w = u(
+              i,
+              f,
+              c,
+              e
+            );
+            return L && e.fixed && v.set(w, e), a(
+              "th",
+              {
+                class: w,
+                colspan: e.colSpan,
+                key: `${e.id}-thead`,
+                rowspan: e.rowSpan,
+                scope: e.colSpan > 1 ? "colgroup" : "col",
+                ariaSort: e.sortable ? e.order : void 0,
+                style: k(
+                  i,
+                  f,
+                  c,
+                  e
+                ),
+                onClick: (t) => {
+                  var p;
+                  (p = t.currentTarget) != null && p.classList.contains(
+                    "noclick"
+                  ) || M(t, e);
+                },
+                onContextmenu: (t) => o(t, e),
+                onMousedown: (t) => S(t, e),
+                onMousemove: (t) => n(t, e),
+                onMouseout: T
+              },
+              [
+                a(
+                  "div",
+                  {
+                    class: [
+                      "cell",
+                      e.filteredValue && e.filteredValue.length > 0 ? "highlight" : ""
+                    ]
+                  },
+                  [
+                    e.renderHeader ? e.renderHeader({
+                      column: e,
+                      $index: f,
+                      store: y,
+                      _self: d
+                    }) : e.label,
+                    e.sortable && a(
+                      "button",
+                      {
+                        type: "button",
+                        class: "caret-wrapper",
+                        "aria-label": H("el.table.sortLabel", {
+                          column: e.label || ""
+                        }),
+                        onClick: (t) => s(t, e)
+                      },
+                      [
+                        a("i", {
+                          onClick: (t) => s(t, e, "ascending"),
+                          class: "sort-caret ascending"
+                        }),
+                        a("i", {
+                          onClick: (t) => s(t, e, "descending"),
+                          class: "sort-caret descending"
+                        })
+                      ]
+                    ),
+                    e.filterable && a(
+                      z,
+                      {
+                        store: y,
+                        placement: e.filterPlacement || "bottom-start",
+                        appendTo: d == null ? void 0 : d.appendFilterPanelTo,
+                        column: e,
+                        upDataColumn: (t, p) => {
+                          e[t] = p;
+                        }
+                      },
+                      {
+                        "filter-icon": () => e.renderFilterIcon ? e.renderFilterIcon({
+                          filterOpened: e.filterOpened
+                        }) : null
+                      }
+                    )
+                  ]
+                )
+              ]
+            );
+          })
+        )
+      )
+    );
+  }
+});
+export {
+  ye as default
+};

package/dist/components/table/src/table-header/style.helper.d.ts

@@ -0,0 +1,10 @@
+import type { TableColumnCtx } from '../table-column/defaults';
+import type { DefaultRow } from '../table/defaults';
+import type { TableHeaderProps } from '.';
+declare function useStyle<T extends DefaultRow>(props: TableHeaderProps<T>): {
+    getHeaderRowStyle: (rowIndex: number) => any;
+    getHeaderRowClass: (rowIndex: number) => string;
+    getHeaderCellStyle: (rowIndex: number, columnIndex: number, row: T, column: TableColumnCtx<T>) => import("vue").CSSProperties;
+    getHeaderCellClass: (rowIndex: number, columnIndex: number, row: T, column: TableColumnCtx<T>) => string;
+};
+export default useStyle;

package/dist/components/table/src/table-header/style.helper.js

@@ -0,0 +1,73 @@
+import { inject as m } from "vue";
+import { useNamespace as c } from "../../../../hooks/use-namespace/index.js";
+import { isString as C, isFunction as d } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "../../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../../hooks/use-z-index/index.js";
+import "../../../../hooks/use-delayed-toggle/index.js";
+import "../../../../hooks/use-aria/index.js";
+import "../../../../hooks/use-model-toggle/index.js";
+import "../../../../hooks/use-empty-values/index.js";
+import { getFixedColumnsClass as g, getFixedColumnOffset as u, ensurePosition as n } from "../util.js";
+import { TABLE_INJECTION_KEY as S } from "../tokens.js";
+function Y(f) {
+  const s = m(S), p = c("table");
+  return {
+    getHeaderRowStyle: (i) => {
+      const e = s == null ? void 0 : s.props.headerRowStyle;
+      return d(e) ? e.call(null, { rowIndex: i }) : e;
+    },
+    getHeaderRowClass: (i) => {
+      const e = [], l = s == null ? void 0 : s.props.headerRowClassName;
+      return C(l) ? e.push(l) : d(l) && e.push(l.call(null, { rowIndex: i })), e.join(" ");
+    },
+    getHeaderCellStyle: (i, e, l, t) => {
+      let o = (s == null ? void 0 : s.props.headerCellStyle) ?? {};
+      d(o) && (o = o.call(null, {
+        rowIndex: i,
+        columnIndex: e,
+        row: l,
+        column: t
+      }));
+      const r = u(
+        e,
+        t.fixed,
+        f.store,
+        l
+      );
+      return n(r, "left"), n(r, "right"), Object.assign({}, o, r);
+    },
+    getHeaderCellClass: (i, e, l, t) => {
+      const o = g(
+        p.b(),
+        e,
+        t.fixed,
+        f.store,
+        l
+      ), r = [
+        t.id,
+        t.order,
+        t.headerAlign,
+        t.className,
+        t.labelClassName,
+        ...o
+      ];
+      t.children || r.push("is-leaf"), t.sortable && r.push("is-sortable");
+      const a = s == null ? void 0 : s.props.headerCellClassName;
+      return C(a) ? r.push(a) : d(a) && r.push(
+        a.call(null, {
+          rowIndex: i,
+          columnIndex: e,
+          row: l,
+          column: t
+        })
+      ), r.push(p.e("cell")), r.filter((h) => !!h).join(" ");
+    }
+  };
+}
+export {
+  Y as default
+};