ep-craft 0.1.32 → 0.1.34

package/dist/components/table/src/table-column/index2.vue.js

@@ -0,0 +1,4 @@
+import f from "./index.vue.js";
+export {
+  f as default
+};

package/dist/components/table/src/table-column/render-helper.d.ts

@@ -0,0 +1,17 @@
+import type { ComputedRef, RendererNode, Slots } from 'vue';
+import type { TableColumn, TableColumnCtx } from './defaults';
+import type { DefaultRow, Table } from '../table/defaults';
+declare function useRender<T extends DefaultRow>(props: TableColumnCtx<T>, slots: Slots, owner: ComputedRef<Table<T>>): {
+    columnId: import("vue").Ref<string, string>;
+    realAlign: import("vue").Ref<string | null | undefined, string | null | undefined>;
+    isSubColumn: import("vue").Ref<boolean, boolean>;
+    realHeaderAlign: import("vue").Ref<string | null | undefined, string | null | undefined>;
+    columnOrTableParent: ComputedRef<Table<T> | TableColumn<T>>;
+    setColumnWidth: (column: TableColumnCtx<T>) => TableColumnCtx<T>;
+    setColumnForcedProps: (column: TableColumnCtx<T>) => TableColumnCtx<T>;
+    setColumnRenders: (column: TableColumnCtx<T>) => TableColumnCtx<T>;
+    getPropsData: (...propsKey: string[][]) => Record<string, any>;
+    getColumnElIndex: (children: T[], child: RendererNode | null) => number;
+    updateColumnOrder: () => void;
+};
+export default useRender;

package/dist/components/table/src/table-column/render-helper.js

@@ -0,0 +1,116 @@
+import { getCurrentInstance as V, ref as o, watchEffect as x, computed as b, h as v, Fragment as k, createTextVNode as H, renderSlot as W, Comment as S, unref as y } from "vue";
+import { isUndefined as N } from "../../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { debugWarn as j } from "../../../../utils/error.js";
+import { isArray as E } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { useNamespace as M } from "../../../../hooks/use-namespace/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 { defaultRenderCell as U, treeCellPrefix as q, cellForced as z, getDefaultClassName as B } from "../config.js";
+import { parseWidth as G, parseMinWidth as J, ensureValidVNode as K } from "../util.js";
+function he(i, a, m) {
+  const s = V(), I = o(""), w = o(!1), d = o(), p = o(), g = M("table");
+  x(() => {
+    d.value = i.align ? `is-${i.align}` : null, d.value;
+  }), x(() => {
+    p.value = i.headerAlign ? `is-${i.headerAlign}` : d.value, p.value;
+  });
+  const P = b(() => {
+    let e = s.vnode.vParent || s.parent;
+    for (; e && !e.tableId && !e.columnId; )
+      e = e.vnode.vParent || e.parent;
+    return e;
+  }), $ = b(() => {
+    const { store: e } = s.parent;
+    if (!e) return !1;
+    const { treeData: r } = e.states, t = r.value;
+    return t && Object.keys(t).length > 0;
+  }), h = o(G(i.width)), C = o(J(i.minWidth)), O = (e) => (h.value && (e.width = h.value), C.value && (e.minWidth = C.value), !h.value && C.value && (e.width = void 0), e.minWidth || (e.minWidth = 80), e.realWidth = Number(
+    N(e.width) ? e.minWidth : e.width
+  ), e), T = (e) => {
+    const r = e.type, t = z[r] || {};
+    Object.keys(t).forEach((l) => {
+      const u = t[l];
+      l !== "className" && !N(u) && (e[l] = u);
+    });
+    const n = B(r);
+    if (n) {
+      const l = `${y(g.namespace)}-${n}`;
+      e.className = e.className ? `${e.className} ${l}` : l;
+    }
+    return e;
+  }, A = (e) => {
+    E(e) ? e.forEach((t) => r(t)) : r(e);
+    function r(t) {
+      var l;
+      const n = (l = t == null ? void 0 : t.type) == null ? void 0 : l.name;
+      (n === "EpTableColumn" || n === "ElTableColumn") && (t.vParent = s);
+    }
+  };
+  return {
+    columnId: I,
+    realAlign: d,
+    isSubColumn: w,
+    realHeaderAlign: p,
+    columnOrTableParent: P,
+    setColumnWidth: O,
+    setColumnForcedProps: T,
+    setColumnRenders: (e) => {
+      i.renderHeader ? j(
+        "TableColumn",
+        "Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header."
+      ) : e.type !== "selection" && (e.renderHeader = (t) => {
+        if (s.columnConfig.value.label, a.header) {
+          const n = a.header(t);
+          if (K(n))
+            return v(k, n);
+        }
+        return H(e.label);
+      }), a["filter-icon"] && (e.renderFilterIcon = (t) => W(a, "filter-icon", t)), a.expand && (e.renderExpand = (t) => W(a, "expand", t));
+      let r = e.renderCell;
+      return e.type === "expand" ? (e.renderCell = (t) => v(
+        "div",
+        {
+          class: "cell"
+        },
+        [r(t)]
+      ), m.value.renderExpanded = (t) => a.default ? a.default(t) : a.default) : (r = r || U, e.renderCell = (t) => {
+        let n = null;
+        if (a.default) {
+          const f = a.default(t);
+          n = f.some((F) => F.type !== S) ? f : r(t);
+        } else
+          n = r(t);
+        const { columns: l } = m.value.store.states, u = l.value.findIndex(
+          (f) => f.type === "default"
+        ), R = $.value && t.cellIndex === u, D = q(t, R), c = {
+          class: "cell",
+          style: {}
+        };
+        return e.showOverflowTooltip && (c.class = `${c.class} ${y(g.namespace)}-tooltip`, c.style = {
+          width: `${(t.column.realWidth || Number(t.column.width)) - 1}px`
+        }), A(n), v("div", c, [D, n]);
+      }), e;
+    },
+    getPropsData: (...e) => e.reduce(
+      (r, t) => (E(t) && t.forEach((n) => {
+        r[n] = i[n];
+      }), r),
+      {}
+    ),
+    getColumnElIndex: (e, r) => Array.prototype.indexOf.call(e, r),
+    updateColumnOrder: () => {
+      m.value.store.commit("updateColumnOrder", s.columnConfig.value);
+    }
+  };
+}
+export {
+  he as default
+};

package/dist/components/table/src/table-column/watcher-helper.d.ts

@@ -0,0 +1,8 @@
+import type { ComputedRef } from 'vue';
+import type { DefaultRow } from '../table/defaults';
+import type { TableColumnCtx } from './defaults';
+declare function useWatcher<T extends DefaultRow>(owner: ComputedRef<any>, props_: Partial<TableColumnCtx<T>>): {
+    registerComplexWatchers: () => void;
+    registerNormalWatchers: () => void;
+};
+export default useWatcher;

package/dist/components/table/src/table-column/watcher-helper.js

@@ -0,0 +1,85 @@
+import { getCurrentInstance as v, watch as f } from "vue";
+import { isUndefined as p } from "../../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { hasOwn as u } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { parseWidth as g, parseMinWidth as C } from "../util.js";
+import "../../../config-provider/index.js";
+import { useGlobalConfig as w } from "../../../config-provider/src/hooks/use-global-config.js";
+function d(r, i) {
+  return r.reduce((o, c) => (o[c] = c, o), i);
+}
+function K(r, i) {
+  const o = v();
+  return {
+    registerComplexWatchers: () => {
+      const m = ["fixed"], s = {
+        realWidth: "width",
+        realMinWidth: "minWidth"
+      }, n = d(m, s);
+      Object.keys(n).forEach((a) => {
+        const l = s[a];
+        u(i, l) && f(
+          () => i[l],
+          (e) => {
+            let t = e;
+            l === "width" && a === "realWidth" && (t = g(e)), l === "minWidth" && a === "realMinWidth" && (t = C(e)), o.columnConfig.value[l] = t, o.columnConfig.value[a] = t;
+            const h = l === "fixed";
+            r.value.store.scheduleLayout(h);
+          }
+        );
+      });
+    },
+    registerNormalWatchers: () => {
+      const m = [
+        "label",
+        "filters",
+        "filterMultiple",
+        "filteredValue",
+        "sortable",
+        "index",
+        "formatter",
+        "className",
+        "labelClassName",
+        "filterClassName",
+        "showOverflowTooltip",
+        "tooltipFormatter",
+        "resizable"
+      ], s = ["showOverflowTooltip"], n = {
+        property: "prop",
+        align: "realAlign",
+        headerAlign: "realHeaderAlign"
+      }, a = d(m, n);
+      Object.keys(a).forEach((e) => {
+        const t = n[e];
+        u(i, t) && f(
+          () => i[t],
+          (h) => {
+            o.columnConfig.value[e] = h, (e === "filters" || e === "filterMethod") && (o.columnConfig.value.filterable = !!(o.columnConfig.value.filters || o.columnConfig.value.filterMethod));
+          }
+        );
+      }), s.forEach((e) => {
+        u(r.value.props, e) && f(
+          () => r.value.props[e],
+          (t) => {
+            o.columnConfig.value.type !== "selection" && p(i[e]) && (o.columnConfig.value[e] = t);
+          }
+        );
+      });
+      const l = w("table");
+      l.value && u(l.value, "showOverflowTooltip") && f(
+        () => {
+          var e;
+          return (e = l.value) == null ? void 0 : e.showOverflowTooltip;
+        },
+        (e) => {
+          o.columnConfig.value.type !== "selection" && (!p(i.showOverflowTooltip) || !p(r.value.props.showOverflowTooltip) || (o.columnConfig.value.showOverflowTooltip = e));
+        }
+      );
+    }
+  };
+}
+export {
+  K as default
+};

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

@@ -0,0 +1,79 @@
+import type { Store } from '../store';
+import type { PropType } from 'vue';
+import type { DefaultRow, Sort, SummaryMethod } from '../table/defaults';
+export interface TableFooter<T extends DefaultRow> {
+    fixed: string;
+    store: Store<T>;
+    summaryMethod: SummaryMethod<T>;
+    sumText: string;
+    border: boolean;
+    defaultSort: Sort;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    store: {
+        required: true;
+        type: PropType<TableFooter<any>["store"]>;
+    };
+    summaryMethod: PropType<TableFooter<any>["summaryMethod"]>;
+    sumText: StringConstructor;
+    border: BooleanConstructor;
+    defaultSort: {
+        type: PropType<TableFooter<any>["defaultSort"]>;
+        default: () => {
+            prop: string;
+            order: string;
+        };
+    };
+}>, {
+    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;
+    };
+    onScrollableChange: (layout: import("../table-layout").default<any>) => void;
+    onColumnsChange: (layout: import("../table-layout").default<any>) => void;
+    getCellClasses: (columns: import("../..").TableColumnCtx<any>[], cellIndex: number) => string[];
+    getCellStyles: (column: import("../..").TableColumnCtx<any>, cellIndex: number) => import("vue").CSSProperties | undefined;
+    columns: import("vue").ComputedRef<import("../..").TableColumnCtx<DefaultRow>[]>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    store: {
+        required: true;
+        type: PropType<TableFooter<any>["store"]>;
+    };
+    summaryMethod: PropType<TableFooter<any>["summaryMethod"]>;
+    sumText: StringConstructor;
+    border: BooleanConstructor;
+    defaultSort: {
+        type: PropType<TableFooter<any>["defaultSort"]>;
+        default: () => {
+            prop: string;
+            order: string;
+        };
+    };
+}>> & Readonly<{}>, {
+    fixed: string;
+    border: boolean;
+    defaultSort: Sort;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,110 @@
+import { defineComponent as h, h as l, inject as y } from "vue";
+import { useNamespace as C } from "../../../../hooks/use-namespace/index.js";
+import "@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 g from "../layout-observer.js";
+import { TABLE_INJECTION_KEY as S } from "../tokens.js";
+import E from "./style-helper.js";
+const $ = h({
+  name: "ElTableFooter",
+  props: {
+    fixed: {
+      type: String,
+      default: ""
+    },
+    store: {
+      required: !0,
+      type: Object
+    },
+    summaryMethod: Function,
+    sumText: String,
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: () => ({
+        prop: "",
+        order: ""
+      })
+    }
+  },
+  setup(s) {
+    const n = y(S), i = C("table"), { getCellClasses: m, getCellStyles: u, columns: p } = E(
+      s
+    ), { onScrollableChange: r, onColumnsChange: e } = g(n);
+    return {
+      ns: i,
+      onScrollableChange: r,
+      onColumnsChange: e,
+      getCellClasses: m,
+      getCellStyles: u,
+      columns: p
+    };
+  },
+  render() {
+    const { columns: s, getCellStyles: n, getCellClasses: i, summaryMethod: m, sumText: u } = this, p = this.store.states.data.value;
+    let r = [];
+    return m ? r = m({
+      columns: s,
+      data: p
+    }) : s.forEach((e, t) => {
+      if (t === 0) {
+        r[t] = u;
+        return;
+      }
+      const c = p.map((o) => Number(o[e.property])), f = [];
+      let b = !0;
+      c.forEach((o) => {
+        if (!Number.isNaN(+o)) {
+          b = !1;
+          const a = `${o}`.split(".")[1];
+          f.push(a ? a.length : 0);
+        }
+      });
+      const N = Math.max.apply(null, f);
+      b ? r[t] = "" : r[t] = c.reduce((o, a) => {
+        const d = Number(a);
+        return Number.isNaN(+d) ? o : Number.parseFloat(
+          (o + a).toFixed(Math.min(N, 20))
+        );
+      }, 0);
+    }), l(
+      l("tfoot", [
+        l("tr", {}, [
+          ...s.map(
+            (e, t) => l(
+              "td",
+              {
+                key: t,
+                colspan: e.colSpan,
+                rowspan: e.rowSpan,
+                class: i(s, t),
+                style: n(e, t)
+              },
+              [
+                l(
+                  "div",
+                  {
+                    class: ["cell", e.labelClassName]
+                  },
+                  [r[t]]
+                )
+              ]
+            )
+          )
+        ])
+      ])
+    );
+  }
+});
+export {
+  $ as default
+};

package/dist/components/table/src/table-footer/mapState-helper.d.ts

@@ -0,0 +1,9 @@
+declare function useMapState(): {
+    leftFixedLeafCount: import("vue").ComputedRef<number>;
+    rightFixedLeafCount: import("vue").ComputedRef<number>;
+    columnsCount: import("vue").ComputedRef<number>;
+    leftFixedCount: import("vue").ComputedRef<number>;
+    rightFixedCount: import("vue").ComputedRef<number>;
+    columns: import("vue").ComputedRef<import("../..").TableColumnCtx<import("../..").DefaultRow>[]>;
+};
+export default useMapState;

package/dist/components/table/src/table-footer/mapState-helper.js

@@ -0,0 +1,16 @@
+import { inject as i, computed as n } from "vue";
+import { TABLE_INJECTION_KEY as c } from "../tokens.js";
+function r() {
+  const e = i(c), t = e == null ? void 0 : e.store, u = n(() => (t == null ? void 0 : t.states.fixedLeafColumnsLength.value) ?? 0), l = n(() => (t == null ? void 0 : t.states.rightFixedColumns.value.length) ?? 0), s = n(() => (t == null ? void 0 : t.states.columns.value.length) ?? 0), a = n(() => (t == null ? void 0 : t.states.fixedColumns.value.length) ?? 0), o = n(() => (t == null ? void 0 : t.states.rightFixedColumns.value.length) ?? 0);
+  return {
+    leftFixedLeafCount: u,
+    rightFixedLeafCount: l,
+    columnsCount: s,
+    leftFixedCount: a,
+    rightFixedCount: o,
+    columns: n(() => (t == null ? void 0 : t.states.columns.value) ?? [])
+  };
+}
+export {
+  r as default
+};

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

@@ -0,0 +1,9 @@
+import type { TableColumnCtx } from '../table-column/defaults';
+import type { DefaultRow } from '../table/defaults';
+import type { TableFooter } from '.';
+declare function useStyle<T extends DefaultRow>(props: TableFooter<T>): {
+    getCellClasses: (columns: TableColumnCtx<T>[], cellIndex: number) => string[];
+    getCellStyles: (column: TableColumnCtx<T>, cellIndex: number) => import("vue").CSSProperties | undefined;
+    columns: import("vue").ComputedRef<TableColumnCtx<DefaultRow>[]>;
+};
+export default useStyle;

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

@@ -0,0 +1,42 @@
+import { useNamespace as a } from "../../../../hooks/use-namespace/index.js";
+import "vue";
+import "@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 { getFixedColumnOffset as n, ensurePosition as r, getFixedColumnsClass as p } from "../util.js";
+import c from "./mapState-helper.js";
+function q(i) {
+  const { columns: m } = c(), s = a("table");
+  return {
+    getCellClasses: (o, e) => {
+      const t = o[e], l = [
+        s.e("cell"),
+        t.id,
+        t.align,
+        t.labelClassName,
+        ...p(s.b(), e, t.fixed, i.store)
+      ];
+      return t.className && l.push(t.className), t.children || l.push(s.is("leaf")), l;
+    },
+    getCellStyles: (o, e) => {
+      const t = n(
+        e,
+        o.fixed,
+        i.store
+      );
+      return r(t, "left"), r(t, "right"), t;
+    },
+    columns: m
+  };
+}
+export {
+  q as default
+};

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

@@ -0,0 +1,14 @@
+import type { EmitFn } from '@element-plus/utils';
+import type { TableHeaderProps } from '.';
+import type { TableColumnCtx } from '../table-column/defaults';
+import type { DefaultRow, TableSortOrder } from '../table/defaults';
+declare function useEvent<T extends DefaultRow>(props: TableHeaderProps<T>, emit: EmitFn<string[]>): {
+    handleHeaderClick: (event: PointerEvent, column: TableColumnCtx<T>) => void;
+    handleHeaderContextMenu: (event: PointerEvent, column: TableColumnCtx<T>) => void;
+    handleMouseDown: (event: MouseEvent, column: TableColumnCtx<T>) => void;
+    handleMouseMove: (event: MouseEvent, column: TableColumnCtx<T>) => void;
+    handleMouseOut: () => void;
+    handleSortClick: (event: Event, column: TableColumnCtx<T>, givenOrder?: TableSortOrder | boolean) => void;
+    handleFilterClick: (event: Event) => void;
+};
+export default useEvent;

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

@@ -0,0 +1,113 @@
+import { getCurrentInstance as A, inject as D, ref as x } from "vue";
+import { isNull as H } from "lodash-unified";
+import { isElement as O } from "../../../../utils/types.js";
+import { isClient as P } from "@vueuse/core";
+import "@vue/shared";
+import { hasClass as M, removeClass as z, addClass as X } from "../../../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import { TABLE_INJECTION_KEY as $ } from "../tokens.js";
+function G(m, b) {
+  const y = A(), l = D($), E = (t) => {
+    t.stopPropagation();
+  }, S = (t, e) => {
+    !e.filters && e.sortable ? k(t, e, !1) : e.filterable && !e.sortable && E(t), l == null || l.emit("header-click", e, t);
+  }, T = (t, e) => {
+    l == null || l.emit("header-contextmenu", e, t);
+  }, v = x(null), g = x(!1), h = x(), N = (t, e) => {
+    var n, o;
+    if (P && !(e.children && e.children.length > 0) && v.value && m.border && v.value.id === e.id) {
+      g.value = !0;
+      const r = l;
+      b("set-drag-visible", !0);
+      const c = r == null ? void 0 : r.vnode.el, s = c == null ? void 0 : c.getBoundingClientRect().left, d = (o = (n = y == null ? void 0 : y.vnode) == null ? void 0 : n.el) == null ? void 0 : o.querySelector(`th.${e.id}`), i = d.getBoundingClientRect(), a = i.left - s + 30;
+      X(d, "noclick"), h.value = {
+        startMouseLeft: t.clientX,
+        startLeft: i.right - s,
+        startColumnLeft: i.left - s,
+        tableLeft: s
+      };
+      const u = r == null ? void 0 : r.refs.resizeProxy;
+      u.style.left = `${h.value.startLeft}px`, document.onselectstart = function() {
+        return !1;
+      }, document.ondragstart = function() {
+        return !1;
+      };
+      const f = (L) => {
+        const p = L.clientX - h.value.startMouseLeft, w = h.value.startLeft + p;
+        u.style.left = `${Math.max(a, w)}px`;
+      }, C = () => {
+        if (g.value) {
+          const { startColumnLeft: L, startLeft: p } = h.value, q = Number.parseInt(u.style.left, 10) - L;
+          e.width = e.realWidth = q, r == null || r.emit(
+            "header-dragend",
+            e.width,
+            p - L,
+            e,
+            t
+          ), requestAnimationFrame(() => {
+            m.store.scheduleLayout(!1, !0);
+          }), document.body.style.cursor = "", g.value = !1, v.value = null, h.value = void 0, b("set-drag-visible", !1);
+        }
+        document.removeEventListener("mousemove", f), document.removeEventListener("mouseup", C), document.onselectstart = null, document.ondragstart = null, setTimeout(() => {
+          z(d, "noclick");
+        }, 0);
+      };
+      document.addEventListener("mousemove", f), document.addEventListener("mouseup", C);
+    }
+  }, R = (t, e) => {
+    var u;
+    if (!m.border || e.children && e.children.length > 0) return;
+    const n = t.target, o = O(n) ? n.closest("th") : null;
+    if (!o)
+      return;
+    const r = M(o, "is-sortable");
+    if (r) {
+      const f = g.value ? "col-resize" : "";
+      o.style.cursor = f;
+      const C = o.querySelector(".caret-wrapper");
+      C && (C.style.cursor = f);
+    }
+    if (!e.resizable || g.value) {
+      v.value = null;
+      return;
+    }
+    const c = o.getBoundingClientRect(), s = ((u = o.parentNode) == null ? void 0 : u.lastElementChild) === o, d = m.allowDragLastColumn || !s, i = c.width > 12 && c.right - t.clientX < 8 && d, a = i ? "col-resize" : "";
+    document.body.style.cursor = a, v.value = i ? e : null, r && (o.style.cursor = a);
+  }, B = () => {
+    !P || g.value || (document.body.style.cursor = "");
+  }, I = ({ order: t, sortOrders: e }) => {
+    if (t === "") return e[0];
+    const n = e.indexOf(t || null);
+    return e[n > e.length - 2 ? 0 : n + 1];
+  }, k = (t, e, n) => {
+    var u;
+    t.stopPropagation();
+    const o = e.order === n ? null : n || I(e), r = (u = t.target) == null ? void 0 : u.closest("th");
+    if (r && M(r, "noclick")) {
+      z(r, "noclick");
+      return;
+    }
+    if (!e.sortable) return;
+    const c = t.currentTarget;
+    if (["ascending", "descending"].some(
+      (f) => M(c, f) && !e.sortOrders.includes(f)
+    ))
+      return;
+    const s = m.store.states;
+    let d = s.sortProp.value, i;
+    const a = s.sortingColumn.value;
+    (a !== e || a === e && H(a.order)) && (a && (a.order = null), s.sortingColumn.value = e, d = e.property ?? null), o ? i = e.order = o : i = e.order = null, s.sortProp.value = d, s.sortOrder.value = i, l == null || l.store.commit("changeSortCondition");
+  };
+  return {
+    handleHeaderClick: S,
+    handleHeaderContextMenu: T,
+    handleMouseDown: N,
+    handleMouseMove: R,
+    handleMouseOut: B,
+    handleSortClick: k,
+    handleFilterClick: E
+  };
+}
+export {
+  G as default
+};