@progress/kendo-react-pivotgrid 6.1.1 → 7.0.0-develop.10

package/index.mjs

@@ -0,0 +1,1585 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as t from "react";
+import { useMouse as he, classNames as ee, useCustomComponent as I, IconWrap as ot, validatePackage as kt, setScrollbarWidth as Ye, noop as Mt, useDraggable as Tt, canUseRef as Fe, clone as Lt } from "@progress/kendo-react-common";
+import { useLocalization as xe } from "@progress/kendo-react-intl";
+import { headersReducer as Dt, toTree as pe, toRows as rt, toColumns as lt, toData as it, PivotGridNavigation as Ht, HEADERS_ACTION as We, PIVOT_CONFIGURATOR_ACTION as Gt, configuratorReducer as Ot, compareAxes as Qe, fetchData as qt, createDataState as Bt, fetchDiscover as de, addKPI as zt, buildKPIMeasures as Kt, rootFields as et, createDataTree as Ut, createFlatSchemaDimensions as Vt, createLocalDataState as $t } from "@progress/kendo-pivotgrid-common";
+import { averageAggregate as On, maxAggregate as qn, minAggregate as Bn, sumAggregate as zn } from "@progress/kendo-pivotgrid-common";
+import { chevronUpIcon as _t, chevronDownIcon as Xt, gridLayoutIcon as Zt, gearIcon as jt } from "@progress/kendo-svg-icons";
+import { Button as ye, Chip as Jt, ChipList as Yt } from "@progress/kendo-react-buttons";
+import { Field as se, Form as Wt, FormElement as Qt } from "@progress/kendo-react-form";
+import { Label as me } from "@progress/kendo-react-labels";
+import { ColumnMenuItem as en, ColumnMenuForm as tn, ColumnMenuTextFilter as nn, ColumnMenuTextColumn as an } from "@progress/kendo-react-data-tools";
+import { TreeView as st, TreeViewItemPropsContext as on } from "@progress/kendo-react-treeview";
+import { Skeleton as rn } from "@progress/kendo-react-indicators";
+const ln = {
+  name: "@progress/kendo-react-pivotgrid",
+  productName: "KendoReact",
+  productCodes: ["KENDOUIREACT", "KENDOUICOMPLETE"],
+  publishDate: 1701439804,
+  version: "",
+  licensingDocsUrl: "https://www.telerik.com/kendo-react-ui/components/my-license/"
+}, Re = "pivotgrid.emptyCellAriaLabel", Ne = "pivotgrid.fieldMenuReset", Se = "pivotgrid.fieldMenuApply", ke = "pivotgrid.configuratorTitle", Me = "pivotgrid.configuratorCancel", Te = "pivotgrid.configuratorApply", Le = "pivotgrid.configuratorColumnsTitle", De = "pivotgrid.configuratorRowsTitle", He = "pivotgrid.configuratorMeasuresTitle", Ge = "pivotgrid.configuratorEditorSearchTitle", sn = "pivotgrid.configuratorEditorSearchPlaceholder", ae = "pivotgrid.configuratorMissingFields", Oe = "pivotgrid.configuratorButtonLabel", Z = {
+  [Re]: "PivotGrid component. Use the arrow keys to navigate.",
+  [Ne]: "Reset",
+  [Se]: "Apply",
+  [Me]: "Cancel",
+  [Te]: "Apply",
+  [ke]: "Settings",
+  [Ge]: "Fields",
+  [sn]: "Search...",
+  [Le]: "Columns",
+  [De]: "Rows",
+  [He]: "Values",
+  [Oe]: "Change settings",
+  [ae]: "Select some fields to begin setup"
+}, ct = t.forwardRef((e, a) => {
+  const n = t.useRef(null), o = t.useRef(null);
+  t.useImperativeHandle(n, () => ({
+    element: o.current,
+    props: e
+  })), t.useImperativeHandle(a, () => n.current);
+  const l = he(
+    e,
+    n
+  );
+  return /* @__PURE__ */ t.createElement(
+    "tr",
+    {
+      ref: o,
+      ...l,
+      id: e.id,
+      style: e.style,
+      tabIndex: e.tabIndex,
+      children: e.children,
+      role: e.role,
+      "aria-owns": e.ariaOwns,
+      className: ee(
+        "k-pivotgrid-row",
+        e.className
+      )
+    }
+  );
+});
+ct.displayName = "KendoReactPivotGridRow";
+const dt = t.forwardRef((e, a) => {
+  const n = t.useRef(null), o = t.useRef(null);
+  t.useImperativeHandle(n, () => ({
+    element: o.current,
+    props: e
+  })), t.useImperativeHandle(a, () => n.current);
+  const l = he(
+    e,
+    n
+  );
+  return /* @__PURE__ */ t.createElement(
+    "td",
+    {
+      ref: o,
+      ...l,
+      id: e.id,
+      style: e.style,
+      tabIndex: e.tabIndex,
+      role: e.role,
+      "aria-describedby": e.ariaDescribedby,
+      className: ee(
+        "k-pivotgrid-cell",
+        {
+          "k-pivotgrid-header-total": e.total
+        },
+        e.className
+      )
+    },
+    e.children
+  );
+});
+dt.displayName = "KendoReactPivotGridCell";
+const tt = (e, a, n) => [e, (l, i) => {
+  const u = Dt(e, { ...l, tree: a });
+  n && n(u, i);
+}], Be = t.forwardRef((e, a) => {
+  const n = t.useRef(null), o = t.useRef(null);
+  t.useImperativeHandle(n, () => ({
+    element: o.current,
+    props: e
+  })), t.useImperativeHandle(a, () => n.current);
+  const [l, i] = I(e.icon || ut.icon), u = he(
+    e,
+    n
+  ), s = (E) => {
+    e.onIconClick && e.onIconClick.call(void 0, {
+      syntheticEvent: E.syntheticEvent,
+      target: n.current
+    });
+  };
+  return /* @__PURE__ */ t.createElement(
+    "th",
+    {
+      ref: o,
+      ...u,
+      colSpan: e.colSpan,
+      rowSpan: e.rowSpan,
+      id: e.id,
+      style: e.style,
+      tabIndex: e.tabIndex,
+      role: e.role,
+      ...e.expandable ? { "aria-expanded": e.expanded } : {},
+      className: ee(
+        "k-pivotgrid-cell",
+        {
+          "k-pivotgrid-header-total": e.total,
+          "k-pivotgrid-header-root": e.root,
+          "k-pivotgrid-expanded": e.expanded,
+          "k-first": e.first
+        },
+        e.className
+      )
+    },
+    e.expandable && /* @__PURE__ */ t.createElement(
+      l,
+      {
+        ...i,
+        onClick: s,
+        name: `chevron-${e.expanded ? "up" : "down"}`,
+        "aria-hidden": !0,
+        icon: e.expanded ? _t : Xt
+      }
+    ),
+    e.children
+  );
+}), ut = {
+  icon: ot
+};
+Be.defaultProps = ut;
+Be.displayName = "KendoReactPivotGridHeaderCell";
+const cn = (...e) => {
+  const a = t.useRef();
+  return (o) => {
+    a.current !== void 0 && window.cancelAnimationFrame(a.current);
+    const l = o.currentTarget, i = l.scrollLeft;
+    e.forEach((u) => {
+      const s = u.current;
+      s && s !== l && (a.current = window.requestAnimationFrame(() => {
+        s.scrollLeft = Math.round(i);
+      }));
+    });
+  };
+}, dn = (...e) => {
+  const a = t.useRef();
+  return (o) => {
+    a.current !== void 0 && window.cancelAnimationFrame(a.current);
+    const l = o.currentTarget, i = l.scrollTop;
+    e.forEach((u) => {
+      const s = u.current;
+      s && s !== l && (a.current = window.requestAnimationFrame(() => {
+        s.scrollTop = Math.round(i);
+      }));
+    });
+  };
+}, ze = t.forwardRef((e, a) => {
+  const n = t.useRef(null), o = t.useRef(null);
+  t.useImperativeHandle(n, () => ({
+    element: o.current,
+    props: e
+  })), t.useImperativeHandle(a, () => n.current);
+  const l = he(
+    e,
+    n
+  );
+  return /* @__PURE__ */ t.createElement(
+    "col",
+    {
+      ref: o,
+      ...l,
+      id: e.id,
+      style: e.style,
+      tabIndex: e.tabIndex,
+      children: e.children,
+      className: e.className
+    }
+  );
+}), un = {
+  path: []
+};
+ze.defaultProps = un;
+ze.displayName = "KendoReactPivotGridColumn";
+const Tn = (e, a, n) => {
+  const o = JSON.parse(JSON.stringify(e || [])), l = JSON.parse(JSON.stringify(a || [])), i = JSON.parse(JSON.stringify(n || [])), u = pe(o), [, s, E] = rt(u), m = pe(l), [, x, , y] = lt(m);
+  return it(
+    i,
+    x,
+    s,
+    y,
+    E
+  );
+}, we = (e = [], a = {}, n = null) => e.map((o) => {
+  const l = { dataItem: o };
+  return Object.keys(a).forEach((i) => {
+    l[i] = a[i](l, n);
+  }), l;
+}), Ke = (e = []) => {
+  let a = [...e];
+  return (e || []).forEach((n) => {
+    a = a.concat(Ke(n.children));
+  }), a;
+}, Pe = (e = []) => {
+  const a = /* @__PURE__ */ new Set();
+  return e.forEach((n) => {
+    a.add(String(n.name));
+  }), Array.from(a);
+}, oe = (e = []) => `${e.join(",")}`, mn = (e, a) => `${oe(e.map((n) => n.name))}|${oe(a.map((n) => n.name))}`, fn = (e, a, n) => {
+  if (!e)
+    return;
+  let o = 0, l, i = e.length, u;
+  for (; o < i; o++)
+    u = e[o].operator, (!n && u !== "in" || u === n) && e[o].field === a && (l = e[o]);
+  return l;
+}, nt = (e, a, n) => {
+  if (!e)
+    return [];
+  let o = 0, l = [], i = e.length, u;
+  for (; o < i; o++)
+    u = e[o].operator, (!n && u !== "in" || u === n) && e[o].field === a && l.push(e[o]);
+  return l;
+}, mt = (e, a) => e.uniqueName === a.uniqueName, gn = t.forwardRef((e, a) => {
+  kt(ln);
+  const {
+    rows: n,
+    rowAxes: o,
+    columns: l,
+    columnAxes: i,
+    data: u
+  } = { ...ue, ...e }, s = t.useRef(null), E = t.useRef(null), m = t.useRef(null), x = t.useRef(null), y = t.useRef(null), G = t.useRef(null), k = t.useRef(null), U = xe(), L = (h, R) => {
+    e.onRowAxesChange && e.onRowAxesChange({
+      value: h,
+      target: E.current,
+      syntheticEvent: R
+    });
+  }, V = (h, R) => {
+    e.onColumnAxesChange && e.onColumnAxesChange({
+      value: h,
+      target: E.current,
+      syntheticEvent: R
+    });
+  }, $ = pe((n || []).slice()), [, v] = tt((o || []).slice(), $, L), [N, f, z, K] = rt($), D = pe((l || []).slice()), [, c] = tt((i || []).slice(), D, V), [A, M, , P] = lt(D), p = it((u || []).slice(), M, f, P, z);
+  t.useImperativeHandle(E, () => ({
+    props: e,
+    element: s.current,
+    columnHeaderRows: A,
+    rowHeaderRows: N,
+    dataCells: p,
+    rowHeaderBreadth: K,
+    columnHeaderBreadth: P
+  })), t.useImperativeHandle(a, () => E.current);
+  const X = [], j = [], r = [], [g, C] = I(e.row || ue.row), [w, S] = I(e.column || ue.column), [O, _] = I(e.cell || ue.cell), [d, H] = I(e.headerCell || ue.headerCell), B = e.columnHeadersRow || g, T = e.columnHeadersColumn || w, W = e.columnHeadersCell || d, Y = e.rowHeadersRow || g, ne = e.rowHeadersColumn || w, pt = e.rowHeadersCell || d, yt = e.dataRow || g, wt = e.dataColumn || w;
+  for (let h = 0; h < M.length; h++)
+    X.push(/* @__PURE__ */ t.createElement(wt, { key: String(M[h].path), ...S, path: M[h].path })), r.push(/* @__PURE__ */ t.createElement(T, { key: String(M[h].path), ...S, path: M[h].path }));
+  for (let h = 0; h < K; h++)
+    j.push(/* @__PURE__ */ t.createElement(ne, { key: h, ...S }));
+  const Ft = (h) => {
+    h.target.props.expandable && c(
+      {
+        type: We.toggle,
+        payload: h.target.props.dataItem.path
+      },
+      h.syntheticEvent
+    );
+  }, bt = (h) => {
+    h.target.props.expandable && v(
+      {
+        type: We.toggle,
+        payload: h.target.props.dataItem.path
+      },
+      h.syntheticEvent
+    );
+  }, Ze = cn(k, G), It = dn(k, y), Pt = (h) => {
+    Ze(h), It(h);
+  }, je = t.useCallback(() => {
+    s.current && x.current && (s.current.style.gridTemplateRows = "", s.current.style.gridTemplateRows = `${x.current.offsetHeight}px 1fr`);
+  }, []), Je = t.useCallback(() => {
+    s.current && m.current && (s.current.style.gridTemplateColumns = "", s.current.style.gridTemplateColumns = `${m.current.offsetWidth}px 1fr`);
+  }, []), re = t.useRef(new Ht({ tabIndex: e.tabIndex || 0 }));
+  t.useEffect(() => {
+    if (s.current) {
+      const h = e.tabIndex || 0;
+      if (re.current.stop(), re.current.tabIndex = h, e.navigatable) {
+        re.current.start(s.current);
+        const R = re.current.first;
+        R && R.setAttribute("tabindex", String(h));
+      }
+    }
+    return () => {
+      re.current.stop();
+    };
+  }, [e.tabIndex, e.navigatable]), t.useEffect(() => {
+    re.current.update();
+  }), t.useEffect(() => {
+    if (x.current) {
+      const h = new window.ResizeObserver(je);
+      return h.observe(x.current), () => {
+        h.disconnect();
+      };
+    }
+  }, [je]), t.useEffect(() => {
+    if (m.current) {
+      const h = new window.ResizeObserver(Je);
+      return h.observe(m.current), () => {
+        h.disconnect();
+      };
+    }
+  }, [Je]), t.useLayoutEffect(() => {
+    if (Ye(), m.current) {
+      const h = new window.ResizeObserver(Ye);
+      return h.observe(m.current), () => {
+        h.disconnect();
+      };
+    }
+  }, []);
+  const le = new Array(A.length).fill([]).map(() => new Array(M.length));
+  A.forEach((h, R) => {
+    let F = 0;
+    Array.from(h.cells).forEach((b) => {
+      const J = !!(b && b.children && b.children.length), Ie = (b ? oe(b.normalizedPath) + (b.total ? "|[TOTAL]" : "") + (J ? "|[EXPANDED]" : "") : "").replace(/\s/g, "-");
+      if (b)
+        for (let Ce = 0; Ce < (b.colSpan || 1); Ce++) {
+          for (let ie = 0; ie < (b.rowSpan || 1); ie++) {
+            const Rt = le[R + ie].findIndex((Nt, St) => St >= F && !Nt);
+            le[R + ie][Rt] = Ie;
+          }
+          F++;
+        }
+    });
+  });
+  const ve = p.map((h) => h.cells.map((R) => mn(R.rowTuple.members, R.columnTuple.members).replace(/\s/g, "-")));
+  return /* @__PURE__ */ t.createElement(
+    "div",
+    {
+      ref: s,
+      id: e.id,
+      style: e.style,
+      tabIndex: e.navigatable ? void 0 : e.tabIndex,
+      className: ee("k-pivotgrid", e.className),
+      role: "grid"
+    },
+    /* @__PURE__ */ t.createElement("span", { className: "k-pivotgrid-empty-cell" }, /* @__PURE__ */ t.createElement("span", { className: "k-sr-only" }, U.toLanguageString(Re, Z[Re]))),
+    /* @__PURE__ */ t.createElement("div", { ref: G, className: "k-pivotgrid-column-headers", onScroll: Ze }, /* @__PURE__ */ t.createElement("table", { ref: x, className: "k-pivotgrid-table", role: "none" }, /* @__PURE__ */ t.createElement("colgroup", null, r), /* @__PURE__ */ t.createElement("tbody", { className: "k-pivotgrid-tbody", role: "rowgroup" }, A.map((h, R) => {
+      let F = !1;
+      return /* @__PURE__ */ t.createElement(
+        B,
+        {
+          key: h.name,
+          role: "row",
+          ...C
+        },
+        h.cells.map((b, J) => {
+          const Ie = J !== 0 && !F;
+          b && (F = !0);
+          const Ce = b && !!(b.children && b.children.length), ie = b && b.hasChildren && (!b.total || b.total && b.parent.total);
+          return b ? /* @__PURE__ */ t.createElement(
+            W,
+            {
+              ...H,
+              key: le[R][J],
+              "data-key": le[R][J],
+              id: le[R][J],
+              columnPath: b.normalizedPath,
+              rowSpan: b.rowSpan || void 0,
+              colSpan: b.colSpan || void 0,
+              onIconClick: Ft,
+              dataItem: b,
+              expanded: Ce,
+              expandable: ie,
+              total: b.total,
+              first: Ie,
+              root: b.levelNum === 0,
+              role: "columnheader"
+            },
+            b.caption
+          ) : null;
+        })
+      );
+    })))),
+    /* @__PURE__ */ t.createElement("div", { ref: y, className: "k-pivotgrid-row-headers" }, /* @__PURE__ */ t.createElement("table", { ref: m, className: "k-pivotgrid-table", role: "none" }, /* @__PURE__ */ t.createElement("colgroup", null, j), /* @__PURE__ */ t.createElement("tbody", { className: "k-pivotgrid-tbody", role: "rowgroup" }, N.map((h, R) => /* @__PURE__ */ t.createElement(
+      Y,
+      {
+        key: oe(f[R].path),
+        ...C,
+        path: f[R].path,
+        role: "row",
+        ariaOwns: ve[R].join(" ")
+      },
+      h.cells.filter(Boolean).map(
+        (F) => F ? /* @__PURE__ */ t.createElement(
+          pt,
+          {
+            ...H,
+            key: oe(F.normalizedPath) + (F.total ? "|[TOTAL]" : "") + (F.children && F.children.length ? "|[EXPANDED]" : ""),
+            "data-key": oe(F.normalizedPath) + (F.total ? "|[TOTAL]" : "") + (F.children && F.children.length ? "|[EXPANDED]" : ""),
+            rowPath: F.normalizedPath,
+            rowSpan: F.rowSpan || void 0,
+            colSpan: F.colSpan || void 0,
+            dataItem: F,
+            expanded: !!(F.children && F.children.length),
+            expandable: F.hasChildren && !F.total,
+            total: F.total,
+            onIconClick: bt,
+            root: F.levelNum === 0,
+            role: "rowheader"
+          },
+          F.caption
+        ) : null
+      )
+    ))))),
+    /* @__PURE__ */ t.createElement("div", { ref: k, className: "k-pivotgrid-values", onScroll: Pt }, /* @__PURE__ */ t.createElement("table", { className: "k-pivotgrid-table", role: "none" }, /* @__PURE__ */ t.createElement("colgroup", null, X), /* @__PURE__ */ t.createElement("tbody", { className: "k-pivotgrid-tbody", role: "none" }, p.map((h, R) => /* @__PURE__ */ t.createElement(
+      yt,
+      {
+        key: oe(f[R].path),
+        ...C,
+        path: f[R].path,
+        role: "none"
+      },
+      h.cells.map(
+        (F, b) => /* @__PURE__ */ t.createElement(
+          O,
+          {
+            key: ve[R][b],
+            "data-key": ve[R][b],
+            id: ve[R][b],
+            ..._,
+            rowPath: F.rowTuple.members.map((J) => J.name),
+            columnPath: F.columnTuple.members.map((J) => J.name),
+            dataItem: F,
+            total: f[R].total || M[b].total,
+            role: "gridcell",
+            ariaDescribedby: le.map((J) => J[b]).join(" ")
+          },
+          F && F.data && F.data.fmtValue ? F.data.fmtValue : " "
+        )
+      )
+    )))))
+  );
+}), ue = {
+  rowAxes: [],
+  columnAxes: [],
+  data: [],
+  row: ct,
+  column: ze,
+  cell: dt,
+  headerCell: Be
+};
+gn.displayName = "KendoReactPivotGrid";
+const ft = t.forwardRef((e, a) => {
+  const n = t.useRef(null), o = t.useRef(null);
+  return t.useImperativeHandle(o, () => ({ props: e, element: n.current })), t.useImperativeHandle(a, () => o.current), /* @__PURE__ */ t.createElement(
+    "div",
+    {
+      ref: n,
+      id: e.id,
+      style: e.style,
+      tabIndex: e.tabIndex,
+      className: ee(
+        "k-d-flex k-pos-relative",
+        {
+          "k-flex-row": e.configuratorPosition === "right",
+          "k-flex-row-reverse": e.configuratorPosition === "left",
+          "k-flex-column": e.configuratorPosition === "bottom",
+          "k-flex-column-reverse": e.configuratorPosition === "top"
+        },
+        e.className
+      )
+    },
+    e.children
+  );
+}), hn = {
+  configuratorPosition: "right"
+};
+ft.defaultProps = hn;
+ft.displayName = "KendoReactPivotGridContainer";
+const gt = t.createContext({ axes: null });
+var Ue = /* @__PURE__ */ ((e) => (e.toggle = "EXPAND_TOGGLE", e.expand = "EXPAND_EXPAND", e.collapse = "EXPAND_COLLAPSE", e))(Ue || {});
+const xn = (e, a, n) => {
+  switch (a.type) {
+    case "EXPAND_TOGGLE":
+      return Array.isArray(e) ? e.find((o) => n(o, a.payload)) ? [...e.filter((o) => !n(o, a.payload))] : [...e, a.payload] : n(e, a.payload) ? null : a.payload;
+    case "EXPAND_EXPAND":
+      if (Array.isArray(e)) {
+        if (!e.find((o) => n(o, a.payload)))
+          return [...e, a.payload];
+      } else if (!n(e, a.payload))
+        return a.payload;
+      break;
+    case "EXPAND_COLLAPSE":
+      if (Array.isArray(e)) {
+        if (e.find((o) => n(o, a.payload)))
+          return [...e.filter((o) => !n(o, a.payload))];
+      } else
+        n(e, a.payload);
+      break;
+    default:
+      return e;
+  }
+}, ht = (e = [], a, n, o = (l, i) => l === i) => {
+  const [l, i] = t.useState(e);
+  return [l, (s, E) => {
+    const m = xn(l, s, o);
+    a && a.call(void 0, {
+      value: m,
+      target: n.current,
+      syntheticEvent: E
+    }), i(m);
+  }];
+};
+var xt = /* @__PURE__ */ ((e) => (e.toggleExpansion = "PIVOT_CONFIGURATOR_ACTION_TOGGLE_EXPANSION", e))(xt || {});
+const q = {
+  ...Gt,
+  ...xt
+}, vn = (e, a) => {
+  const n = e.valueGetter("rowAxes"), o = e.valueGetter("columnAxes"), l = e.valueGetter("measureAxes"), i = e.valueGetter("sort"), u = e.valueGetter("filter"), [s, E] = ht(
+    [],
+    void 0,
+    a,
+    mt
+  ), [m, x] = t.useState(null), [y, G] = t.useState(null), [k, U] = t.useState(null), [L, V] = t.useState(null);
+  return [
+    {
+      dragItem: m,
+      dropTarget: k,
+      dropZone: y,
+      dropDirection: L,
+      columnAxes: o,
+      rowAxes: n,
+      measureAxes: l,
+      sort: i,
+      filter: u,
+      expanded: s
+    },
+    (v, N) => {
+      switch (v.type) {
+        case q.toggleExpansion: {
+          E({ type: Ue.toggle, payload: v.payload }, N);
+          break;
+        }
+        default:
+          const f = Ot(
+            {
+              filter: v.override && v.override.filter !== void 0 ? v.override.filter : u,
+              sort: v.override && v.override.sort !== void 0 ? v.override.sort : i,
+              rowAxes: v.override && v.override.rowAxes !== void 0 ? v.override.rowAxes : n,
+              columnAxes: v.override && v.override.columnAxes !== void 0 ? v.override.columnAxes : o,
+              measureAxes: v.override && v.override.measureAxes !== void 0 ? v.override.measureAxes : l,
+              dragItem: v.override && v.override.dragItem !== void 0 ? v.override.dragItem : m,
+              dropDirection: v.override && v.override.dropDirection !== void 0 ? v.override.dropDirection : L,
+              dropTarget: v.override && v.override.dropTarget !== void 0 ? v.override.dropTarget : k,
+              dropZone: v.override && v.override.dropZone !== void 0 ? v.override.dropZone : y
+            },
+            v
+          );
+          f.columnAxes !== void 0 && e.onChange("columnAxes", { value: f.columnAxes }), f.rowAxes !== void 0 && e.onChange("rowAxes", { value: f.rowAxes }), f.measureAxes !== void 0 && e.onChange("measureAxes", { value: f.measureAxes }), f.sort !== void 0 && e.onChange("sort", { value: f.sort }), f.filter !== void 0 && e.onChange("filter", { value: f.filter }), f.dropDirection !== void 0 && V(f.dropDirection), f.dropTarget !== void 0 && U(f.dropTarget), f.dropZone !== void 0 && G(f.dropZone), f.dragItem !== void 0 && x(f.dragItem);
+          break;
+      }
+    }
+  ];
+}, vt = t.createContext({}), be = t.createContext(
+  [
+    {
+      expanded: [],
+      rowAxes: [],
+      columnAxes: [],
+      measureAxes: [],
+      dragItem: null,
+      dropZone: null,
+      dropDirection: null,
+      dropTarget: null
+    },
+    Mt
+  ]
+), Ve = t.forwardRef(
+  (e, a) => {
+    const {
+      data: n,
+      dataItem: o,
+      defaultFilter: l
+    } = { ...te, ...e }, i = t.useRef(null), u = t.useRef(null), s = xe(), [E, m] = I(e.columnMenuItem || te.columnMenuItem), [x, y] = I(e.columnMenuForm || te.columnMenuForm), [G, k] = I(e.resetButton || te.resetButton), [U, L] = I(e.applyButton || te.applyButton), [V, $] = I(e.treeView || te.treeView), [v, N] = I(e.noData || te.noData);
+    t.useImperativeHandle(u, () => ({ props: e, element: i.current })), t.useImperativeHandle(a, () => u.current);
+    const [f, z] = t.useState(!1), {
+      onAxisFilterFieldsExpandChange: K,
+      onAxisFilterFieldExpand: D
+    } = t.useContext(vt), [, c] = t.useContext(be), [A, M] = t.useState(l), P = A ? A.value.split(",") : [], [p, X] = ht(
+      [],
+      void 0,
+      u,
+      mt
+    ), j = {
+      caption: (d) => d.dataItem.caption,
+      id: (d) => d.dataItem.uniqueName,
+      parent: (d, H) => H && H.value,
+      value: (d) => d.dataItem.defaultHierarchy || d.dataItem.uniqueName,
+      expanded: (d) => p.some((H) => H.uniqueName === d.id),
+      checked: (d) => !P.length || (P || []).some((H) => H === d.dataItem.uniqueName),
+      hasChildren: (d) => parseInt(d.dataItem.childrenCardinality, 10) > 0,
+      children: (d) => we(d.dataItem.children, j, d),
+      checkIndeterminate: (d) => {
+        const H = (d.children || []).length && d.children.every((B) => B.checked);
+        return H && (d.checked = !0), (d.children || []).some((B) => B.checked) && !H;
+      }
+    }, r = we(n, j), g = Ke(r), C = (d) => {
+      z(!f), K && K({
+        value: !f,
+        target: u.current,
+        syntheticEvent: d
+      });
+    }, w = (d) => {
+      X({ type: Ue.toggle, payload: d.item.dataItem }, d.syntheticEvent), D && D({
+        value: d.item.dataItem,
+        target: u.current,
+        syntheticEvent: d.syntheticEvent
+      });
+    }, S = (d) => {
+      let H;
+      d.item.checked ? H = {
+        field: String(o.name),
+        operator: "in",
+        value: g.filter((B) => B.checked).map((B) => String(B.value)).filter((B) => B !== d.item.value && B !== d.item.parent).join(",")
+      } : H = {
+        field: String(o.name),
+        operator: "in",
+        value: g.filter((B) => B.checked).map((B) => String(B.value)).concat([d.item.value]).join(",")
+      }, M(H);
+    }, O = (d) => {
+      z(!1), A && c({
+        type: q.removeFilter,
+        payload: A
+      }, d);
+    }, _ = (d) => {
+      z(!1), A && c({
+        type: l ? q.changeFilter : q.addFilter,
+        payload: A
+      }, d);
+    };
+    return /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        ref: i,
+        id: e.id,
+        tabIndex: e.tabIndex,
+        style: e.style,
+        className: ee("k-columnmenu-item-wrapper", e.className)
+      },
+      /* @__PURE__ */ t.createElement(
+        E,
+        {
+          ...m,
+          title: "Include Fields",
+          iconClass: "k-i-grid-layout",
+          svgIcon: Zt,
+          onClick: C
+        }
+      ),
+      /* @__PURE__ */ t.createElement(
+        x,
+        {
+          show: f,
+          actions: /* @__PURE__ */ t.createElement(t.Fragment, null, /* @__PURE__ */ t.createElement(
+            G,
+            {
+              type: "reset",
+              onClick: O,
+              ...k
+            },
+            s.toLanguageString(Ne, Z[Ne])
+          ), /* @__PURE__ */ t.createElement(
+            U,
+            {
+              themeColor: "primary",
+              onClick: _,
+              ...L
+            },
+            s.toLanguageString(Se, Z[Se])
+          )),
+          ...y
+        },
+        r && r.length ? /* @__PURE__ */ t.createElement(
+          V,
+          {
+            data: r,
+            checkboxes: !0,
+            onExpandChange: w,
+            onCheckChange: S,
+            textField: "caption",
+            expandIcons: !0,
+            hasChildrenField: "hasChildren",
+            checkIndeterminateField: "checkIndeterminate",
+            childrenField: "children",
+            ...$
+          }
+        ) : /* @__PURE__ */ t.createElement(v, { ...N })
+      )
+    );
+  }
+), te = {
+  data: [],
+  resetButton: ye,
+  applyButton: ye,
+  treeView: st,
+  noData: () => /* @__PURE__ */ t.createElement(rn, { shape: "rectangle", style: { height: "20px", width: "calc(100% - 16px)", margin: 8 } }),
+  columnMenuItem: en,
+  columnMenuForm: tn
+};
+Ve.defaultProps = te;
+Ve.displayName = "KendoReactPivotGridAxisFilterFieldsEditor";
+const $e = t.forwardRef((e, a) => {
+  const n = t.useRef(0), o = t.useRef(0), l = t.useRef(null), i = t.useRef(null), u = t.useRef(null), { axes: s } = t.useContext(gt), [E, m] = t.useState(!1), [x, y] = t.useContext(be);
+  t.useImperativeHandle(i, () => l.current && l.current.element), t.useImperativeHandle(u, () => ({ props: e, element: i.current })), t.useImperativeHandle(a, () => u.current);
+  const [G, k] = I(e.chip || fe.chip), [U, L] = I(e.dropClue || fe.dropClue), [V, $] = I(e.columnMenuTextColumn || fe.columnMenuTextColumn), [v, N] = I(e.filterFieldsEditor || fe.filterFieldsEditor), f = nt(x.filter, String(e.value), "in"), z = nt(x.filter, String(e.value)), K = (r, g) => {
+    y({ type: q.setSort, payload: g }, r);
+  }, D = (r, g) => {
+    g.length ? y({
+      type: q.setFilter,
+      payload: [
+        ...f || [],
+        ...g.reduce((C, w) => [
+          ...C,
+          ...w.filters.filter((S) => S.value)
+        ], [])
+      ]
+    }, r) : y({ type: q.setFilter, payload: f }, r);
+  }, c = (r) => {
+    y({ type: q.remove, payload: e.dataItem }, r.syntheticEvent);
+  }, A = (r) => {
+    const g = r.slice(), C = fn(x.filter, String(e.dataItem.name), "in");
+    return g.splice(1, 0, /* @__PURE__ */ t.createElement(
+      v,
+      {
+        key: "axis-filter-fields-editor",
+        defaultFilter: C,
+        dataItem: e.dataItem,
+        data: e.dataItem.fields,
+        axes: s,
+        ...N
+      }
+    )), g;
+  }, M = (r) => {
+    n.current = r.clientX, o.current = r.clientY;
+  }, P = (r) => {
+    Math.abs(n.current - r.clientX) < 10 && Math.abs(o.current - r.clientY) < 10 || (i.current && (i.current.style.transform = `translate(${r.clientX - n.current}px, ${r.clientY - o.current}px)`), m(!0), y({ type: q.setDragItem, payload: e.dataItem }));
+  }, p = () => {
+    m(!1), x.dragItem && (i.current && (i.current.style.transform = ""), y({ type: q.drop, payload: e.dataItem }));
+  }, X = (r) => {
+    x.dragItem && (y({ type: q.setDropTarget, payload: e.dataItem }, r.syntheticEvent), y({ type: q.setDropZone, payload: s }, r.syntheticEvent));
+  }, j = (r) => {
+    if (x.dragItem && !E && i.current) {
+      const g = i.current.getBoundingClientRect(), w = r.syntheticEvent.clientX - g.left < g.width / 2 ? "before" : "after";
+      y({ type: q.setDropDirection, payload: w }, r.syntheticEvent);
+    }
+  };
+  return Tt(i, {
+    onPress: M,
+    onDrag: P,
+    onRelease: p
+  }), /* @__PURE__ */ t.createElement(t.Fragment, null, x.dropTarget && Qe(x.dropTarget, e.dataItem) && x.dropDirection === "before" && /* @__PURE__ */ t.createElement(U, { ...L }), /* @__PURE__ */ t.createElement(
+    G,
+    {
+      ref: Fe(G) ? l : void 0,
+      ...e,
+      removable: !0,
+      onRemove: c,
+      onMouseEnter: X,
+      onMouseMove: j,
+      style: { pointerEvents: E ? "none" : void 0 },
+      rounded: "full",
+      ...k
+    },
+    e.text,
+    s !== "measureAxes" && /* @__PURE__ */ t.createElement(
+      V,
+      {
+        field: String(e.value),
+        itemsRender: A,
+        sort: x.sort,
+        onSortChange: K,
+        filter: z && z.length ? [{ logic: "and", filters: z }] : void 0,
+        onFilterChange: D,
+        filterContent: [
+          nn
+        ],
+        ...$
+      }
+    )
+  ), x.dropTarget && Qe(x.dropTarget, e.dataItem) && x.dropDirection === "after" && /* @__PURE__ */ t.createElement(U, { ...L }));
+}), fe = {
+  chip: Jt,
+  columnMenuTextColumn: an,
+  filterFieldsEditor: Ve,
+  dropClue: (e) => /* @__PURE__ */ t.createElement("div", { className: "k-grouping-dropclue", style: { position: "relative", zIndex: 1e4 }, ...e })
+};
+$e.defaultProps = fe;
+$e.displayName = "KendoReactPivotGridAxisEditor";
+const ce = t.forwardRef((e, a) => {
+  const {
+    value: n,
+    field: o
+  } = { ...qe, ...e }, l = t.useRef(null), i = t.useRef(null), u = t.useRef(null), [s, E] = I(e.chipList || qe.chipList);
+  t.useImperativeHandle(i, () => l.current && l.current.element), t.useImperativeHandle(u, () => ({ props: e, element: i.current })), t.useImperativeHandle(a, () => u.current);
+  const m = n.filter((x) => x.name.length === 1 && x.name.every((y) => y.indexOf("&") === -1)).map((x) => ({ ...x, text: String(x.name) }));
+  return /* @__PURE__ */ t.createElement(gt.Provider, { value: { axes: o } }, /* @__PURE__ */ t.createElement(
+    s,
+    {
+      ref: Fe(s) ? l : void 0,
+      textField: "text",
+      valueField: "name",
+      data: m,
+      chip: $e,
+      style: { position: "relative" },
+      className: e.className,
+      selection: "none",
+      ...E
+    }
+  ));
+}), qe = {
+  value: [],
+  chipList: Yt
+};
+ce.defaultProps = qe;
+ce.displayName = "KendoReactPivotGridAxesEditor";
+const _e = t.forwardRef((e, a) => {
+  const {
+    data: n,
+    rowAxes: o,
+    columnAxes: l,
+    measureAxes: i,
+    onExpand: u,
+    onCheck: s
+  } = { ...Ae, ...e }, E = t.useRef(null), m = t.useRef(null), [x, y] = I(e.treeView || Ae.treeView), [G, k] = I(e.noData || Ae.noData);
+  t.useImperativeHandle(m, () => ({ props: e, element: E.current && E.current.element })), t.useImperativeHandle(a, () => m.current);
+  const [U] = t.useContext(be), L = Pe(l), V = Pe(o), $ = Pe(i), N = Ke(n).filter((c) => [
+    ...L,
+    ...V,
+    ...$
+  ].some((A) => A === c.uniqueName || A === c.defaultHierarchy)), f = {
+    caption: (c) => c.dataItem.caption,
+    id: (c) => c.dataItem.uniqueName,
+    value: (c) => c.dataItem.defaultHierarchy || c.dataItem.uniqueName,
+    expanded: (c) => U.expanded.some((A) => A.uniqueName === c.dataItem.uniqueName),
+    hasChildren: (c) => !("hierarchyUniqueName" in c.dataItem) && !("aggregator" in c.dataItem),
+    selectable: (c) => !(!c.hasChildren && !c.dataItem.aggregator && !c.dataItem.measure || c.dataItem.type === 2 || c.dataItem.uniqueName === "[KPIs]"),
+    children: (c) => we(c.dataItem.children, f, c),
+    checked: (c) => N.some((A) => c.dataItem.defaultHierarchy ? A.defaultHierarchy === c.dataItem.defaultHierarchy : A.uniqueName === c.dataItem.uniqueName) || c.children.length && c.children.every((A) => A.checked)
+  }, z = (c) => {
+    u && u({
+      value: c.item.dataItem,
+      target: m.current,
+      syntheticEvent: c.syntheticEvent
+    });
+  }, K = (c) => {
+    s && s({
+      value: c.item.dataItem,
+      target: m.current,
+      syntheticEvent: c.syntheticEvent
+    });
+  }, D = we(e.data, f);
+  return /* @__PURE__ */ t.createElement(on.Provider, { value: (c) => ({ ...c, checkboxes: c.item.selectable }) }, D && D.length ? /* @__PURE__ */ t.createElement(
+    x,
+    {
+      ref: Fe(x) ? E : void 0,
+      data: D,
+      checkboxes: !0,
+      onExpandChange: z,
+      onCheckChange: K,
+      textField: "caption",
+      expandIcons: !0,
+      hasChildrenField: "hasChildren",
+      checkIndeterminateField: "checkIndeterminate",
+      childrenField: "children",
+      ...y
+    }
+  ) : /* @__PURE__ */ t.createElement(G, { ...k }));
+}), Ae = {
+  data: [],
+  rowAxes: [],
+  columnAxes: [],
+  measureAxes: [],
+  treeView: st,
+  noData: () => /* @__PURE__ */ t.createElement("div", null, "NO DATA")
+};
+_e.defaultProps = Ae;
+_e.displayName = "KendoReactPivotGridFieldsEditor";
+const Xe = t.forwardRef((e, a) => {
+  const {
+    onFieldsEditorFieldCheck: n,
+    onFieldsEditorFieldCheckAction: o,
+    onFieldsEditorFieldExpand: l,
+    onFieldsEditorFieldExpandAction: i,
+    onAxisFilterFieldExpand: u,
+    onAxisFilterFieldsExpandChange: s
+  } = e, [E, m] = I(e.fieldsLabel || Q.fieldsLabel), [x, y] = I(e.fieldsEditor || Q.fieldsEditor), [G, k] = I(e.columnAxesLabel || Q.columnAxesLabel), [U, L] = I(e.columnAxesEditor || Q.columnAxesEditor), [V, $] = I(e.rowAxesLabel || Q.rowAxesLabel), [v, N] = I(e.rowAxesEditor || Q.rowAxesEditor), [f, z] = I(e.measureAxesLabel || Q.measureAxesLabel), [K, D] = I(e.measureAxesEditor || Q.measureAxesEditor), c = t.useRef(null), A = t.useRef(null), M = xe(), [P, p] = vn(e, A);
+  t.useImperativeHandle(A, () => ({
+    element: c.current,
+    props: e,
+    state: P
+  })), t.useImperativeHandle(a, () => A.current);
+  const X = () => {
+    P.dragItem && p({ type: q.setDropZone, payload: "columnAxes" });
+  }, j = () => {
+    P.dragItem && p({ type: q.setDropZone, payload: null });
+  }, r = () => {
+    P.dragItem && p({ type: q.setDropZone, payload: "rowAxes" });
+  }, g = () => {
+    P.dragItem && p({ type: q.setDropZone, payload: null });
+  }, C = () => {
+    P.dragItem && p({ type: q.setDropZone, payload: "measureAxes" });
+  }, w = () => {
+    P.dragItem && p({ type: q.setDropZone, payload: null });
+  }, S = (T) => {
+    const W = {
+      target: T.target,
+      currentTarget: A.current,
+      value: T.value,
+      syntheticEvent: T.syntheticEvent
+    };
+    if (i) {
+      const Y = i(W, e, P);
+      Y && (Array.isArray(Y) ? Y.filter(Boolean).map((ne) => ne && p({ ...ne }, T.syntheticEvent)) : p({ ...Y }, T.syntheticEvent));
+    }
+    l && l({
+      target: T.target,
+      currentTarget: A.current,
+      value: T.value,
+      syntheticEvent: T.syntheticEvent
+    });
+  }, O = (T) => {
+    const W = {
+      target: T.target,
+      currentTarget: A.current,
+      value: T.value,
+      syntheticEvent: T.syntheticEvent
+    };
+    if (o) {
+      const Y = o(W, e, P);
+      Y && (Array.isArray(Y) ? Y.filter(Boolean).map((ne) => ne && p({ ...ne }, T.syntheticEvent)) : p({ ...Y }, T.syntheticEvent));
+    }
+    n && n(W);
+  }, _ = (T) => {
+    const W = {
+      target: T.target,
+      currentTarget: A.current,
+      value: T.value,
+      syntheticEvent: T.syntheticEvent
+    };
+    u && u(W);
+  }, d = (T) => {
+    const W = {
+      target: T.target,
+      currentTarget: A.current,
+      value: T.value,
+      syntheticEvent: T.syntheticEvent
+    };
+    s && s(W);
+  }, H = e.horizontal ? "div" : t.Fragment, B = e.horizontal ? { className: "k-form-field-wrapper" } : {};
+  return /* @__PURE__ */ t.createElement(
+    vt.Provider,
+    {
+      value: {
+        onAxisFilterFieldExpand: _,
+        onAxisFilterFieldsExpandChange: d
+      }
+    },
+    /* @__PURE__ */ t.createElement(be.Provider, { value: [P, p] }, /* @__PURE__ */ t.createElement(H, { ...B }, /* @__PURE__ */ t.createElement("div", { className: "k-form-field" }, /* @__PURE__ */ t.createElement(E, { name: "", component: me, ...m }, M.toLanguageString(Ge, Z[Ge]))), /* @__PURE__ */ t.createElement("div", { className: "k-form-field" }, /* @__PURE__ */ t.createElement("div", { className: "k-fields-list-wrapper" }, /* @__PURE__ */ t.createElement(
+      x,
+      {
+        data: e.data,
+        onExpand: S,
+        onCheck: O,
+        columnAxes: P.columnAxes,
+        rowAxes: P.rowAxes,
+        measureAxes: P.measureAxes,
+        ...y
+      }
+    )))), /* @__PURE__ */ t.createElement(H, { ...B }, /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-form-field",
+        onMouseEnter: X,
+        onMouseLeave: j
+      },
+      /* @__PURE__ */ t.createElement(
+        se,
+        {
+          name: "columnAxes",
+          field: "columnAxes",
+          component: G,
+          ...k
+        },
+        M.toLanguageString(Le, Z[Le])
+      )
+    ), e.valueGetter("columnAxes").length ? /* @__PURE__ */ t.createElement(
+      se,
+      {
+        name: "columnAxes",
+        field: "columnAxes",
+        component: U,
+        onMouseEnter: X,
+        onMouseLeave: j,
+        className: "k-column-fields",
+        ...L
+      }
+    ) : /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-settings-description",
+        onMouseEnter: X,
+        onMouseLeave: j
+      },
+      M.toLanguageString(ae, Z[ae])
+    ), /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-form-field",
+        onMouseEnter: r,
+        onMouseLeave: g
+      },
+      /* @__PURE__ */ t.createElement(
+        se,
+        {
+          name: "rowAxes",
+          field: "rowAxes",
+          component: V,
+          ...$
+        },
+        M.toLanguageString(De, Z[De])
+      )
+    ), e.valueGetter("rowAxes").length ? /* @__PURE__ */ t.createElement(
+      se,
+      {
+        name: "rowAxes",
+        field: "rowAxes",
+        component: v,
+        onMouseEnter: r,
+        onMouseLeave: g,
+        className: "k-column-fields",
+        ...N
+      }
+    ) : /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-settings-description",
+        onMouseEnter: r,
+        onMouseLeave: g
+      },
+      M.toLanguageString(ae, Z[ae])
+    )), /* @__PURE__ */ t.createElement(H, { ...B }, /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-form-field",
+        onMouseEnter: C,
+        onMouseLeave: w
+      },
+      /* @__PURE__ */ t.createElement(
+        se,
+        {
+          name: "measureAxes",
+          field: "measureAxes",
+          component: f,
+          ...z
+        },
+        M.toLanguageString(He, Z[He])
+      )
+    ), e.valueGetter("measureAxes").length ? /* @__PURE__ */ t.createElement(
+      se,
+      {
+        name: "measureAxes",
+        field: "measureAxes",
+        component: K,
+        onMouseEnter: C,
+        onMouseLeave: w,
+        className: "k-column-fields",
+        ...D
+      }
+    ) : /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: "k-settings-description",
+        onMouseEnter: C,
+        onMouseLeave: w
+      },
+      M.toLanguageString(ae, Z[ae])
+    )))
+  );
+}), Q = {
+  data: [],
+  horizontal: !1,
+  fieldsLabel: me,
+  fieldsEditor: _e,
+  columnAxesLabel: me,
+  columnAxesEditor: ce,
+  rowAxesLabel: me,
+  rowAxesEditor: ce,
+  measureAxesLabel: me,
+  measureAxesEditor: ce,
+  axesEditor: ce,
+  onFieldsEditorFieldCheckAction: (e) => ({ type: q.toggleSelection, payload: e.value }),
+  onFieldsEditorFieldExpandAction: (e) => ({ type: q.toggleExpansion, payload: e.value })
+};
+Xe.defaultProps = Q;
+Xe.displayName = "KendoReactPivotGridConfiguratorEditor";
+const Ct = t.forwardRef((e, a) => {
+  const {
+    horizontal: n,
+    data: o,
+    rowAxes: l,
+    columnAxes: i,
+    measureAxes: u
+  } = { ...ge, ...e }, s = t.useRef(null), E = t.useRef(null), m = t.useRef(null), x = xe(), [y, G] = I(e.editor || ge.editor), [k, U] = I(e.form || ge.form), [L, V] = I(e.formElement || ge.formElement);
+  t.useImperativeHandle(E, () => ({ props: e, element: s.current })), t.useImperativeHandle(a, () => E.current);
+  const $ = (N, f) => {
+    e.onRowAxesChange && e.onRowAxesChange({
+      target: E.current,
+      value: N.rowAxes,
+      syntheticEvent: f
+    }), e.onColumnAxesChange && e.onColumnAxesChange({
+      target: E.current,
+      value: N.columnAxes,
+      syntheticEvent: f
+    }), e.onMeasureAxesChange && e.onMeasureAxesChange({
+      target: E.current,
+      value: N.measureAxes,
+      syntheticEvent: f
+    }), e.onSortChange && e.onSortChange({
+      target: E.current,
+      value: N.sort,
+      syntheticEvent: f
+    }), e.onFilterChange && e.onFilterChange({
+      target: E.current,
+      value: N.filter,
+      syntheticEvent: f
+    });
+  }, v = {
+    rowAxes: l,
+    columnAxes: i,
+    measureAxes: u,
+    sort: e.sort,
+    filter: e.filter
+  };
+  return t.useEffect(() => {
+    m.current && m.current.onChange("rowAxes", { value: l });
+  }, [l]), t.useEffect(() => {
+    m.current && m.current.onChange("columnAxes", { value: i });
+  }, [i]), t.useEffect(() => {
+    m.current && m.current.onChange("measureAxes", { value: u });
+  }, [u]), t.useEffect(() => {
+    m.current && m.current.onChange("sort", { value: e.sort });
+  }, [e.sort]), t.useEffect(() => {
+    m.current && m.current.onChange("filter", { value: e.filter });
+  }, [e.filter]), /* @__PURE__ */ t.createElement(
+    "div",
+    {
+      ref: s,
+      id: e.id,
+      tabIndex: e.tabIndex,
+      style: e.style,
+      className: ee(
+        "k-pivotgrid-configurator",
+        e.className
+      )
+    },
+    /* @__PURE__ */ t.createElement(
+      "div",
+      {
+        className: ee(
+          "k-pivotgrid-configurator-panel",
+          "k-pivotgrid-configurator-push",
+          {
+            "k-pivotgrid-configurator-horizontal": n,
+            "k-pivotgrid-configurator-vertical": !n
+          }
+        )
+      },
+      /* @__PURE__ */ t.createElement("div", { className: "k-pivotgrid-configurator-header" }, /* @__PURE__ */ t.createElement("div", { className: "k-pivotgrid-configurator-header-text" }, x.toLanguageString(ke, Z[ke]))),
+      /* @__PURE__ */ t.createElement(
+        k,
+        {
+          ref: Fe(k) ? m : void 0,
+          initialValues: v,
+          onSubmit: $,
+          render: (N) => /* @__PURE__ */ t.createElement(t.Fragment, null, /* @__PURE__ */ t.createElement("div", { className: "k-pivotgrid-configurator-content" }, /* @__PURE__ */ t.createElement(
+            L,
+            {
+              horizontal: n,
+              ...V
+            },
+            /* @__PURE__ */ t.createElement(
+              y,
+              {
+                ...N,
+                horizontal: e.horizontal,
+                onFieldsEditorFieldExpand: e.onFieldsEditorFieldExpand,
+                onFieldsEditorFieldCheck: e.onFieldsEditorFieldCheck,
+                onAxisFilterFieldExpand: e.onAxisFilterFieldExpand,
+                onAxisFilterFieldsExpandChange: e.onAxisFilterFieldsExpandChange,
+                data: o,
+                ...G
+              }
+            )
+          )), /* @__PURE__ */ t.createElement("div", { className: "k-pivotgrid-configurator-actions k-actions k-hstack k-justify-content-end" }, /* @__PURE__ */ t.createElement(ye, { type: "submit", onClick: N.onFormReset }, x.toLanguageString(Me, Z[Me])), /* @__PURE__ */ t.createElement(ye, { themeColor: "primary", type: "submit", onClick: N.onSubmit }, x.toLanguageString(Te, Z[Te])))),
+          ...U
+        }
+      )
+    )
+  );
+}), ge = {
+  form: Wt,
+  formElement: Qt,
+  editor: Xe,
+  horizontal: !1,
+  data: [],
+  columnAxes: [],
+  rowAxes: [],
+  measureAxes: []
+};
+Ct.defaultProps = ge;
+Ct.displayName = "KendoReactPivotGridConfigurator";
+const Et = t.forwardRef((e, a) => {
+  const n = t.useRef(null), o = t.useRef(null), l = xe();
+  t.useImperativeHandle(n, () => ({ props: e, element: o.current })), t.useImperativeHandle(a, () => n.current);
+  const [i, u] = I(e.icon || At.icon), s = t.useMemo(
+    () => ee("k-pivotgrid-configurator-button", e.className),
+    [e.className]
+  ), E = he(
+    e,
+    n
+  );
+  return /* @__PURE__ */ t.createElement(
+    "div",
+    {
+      ref: o,
+      id: e.id,
+      className: s,
+      tabIndex: e.tabIndex,
+      ...E
+    },
+    /* @__PURE__ */ t.createElement("span", null, l.toLanguageString(Oe, Z[Oe]), /* @__PURE__ */ t.createElement(i, { name: "gear", icon: jt, ...u }))
+  );
+}), At = {
+  icon: ot
+};
+Et.defaultProps = At;
+Et.displayName = "KendoReactPivotGridConfiguratorButton";
+const Cn = (e) => {
+  const [a, n] = t.useState(!0), [o, l] = t.useState({ data: [], columns: [], rows: [] }), [i, u] = t.useState([]), [s, E] = t.useState(e.defaultColumnAxes || []), [m, x] = t.useState(e.defaultRowAxes || []), [y, G] = t.useState(e.defaultMeasureAxes || []), [k, U] = t.useState(e.defaultSort || []), [L, V] = t.useState(e.defaultFilter || []), $ = (r) => {
+    x(r.value);
+  }, v = (r) => {
+    E(r.value);
+  }, N = (r) => {
+    G(r.value);
+  }, f = (r) => {
+    U(r.value);
+  }, z = (r) => {
+    V(r.value);
+  };
+  t.useEffect(() => {
+    n(!0);
+    const r = {
+      connection: {
+        catalog: e.catalog,
+        cube: e.cube
+      },
+      columnAxes: s.slice(),
+      rowAxes: m.slice(),
+      measureAxes: y,
+      sort: k,
+      filter: L
+    };
+    setTimeout(() => {
+      qt({ url: e.url }, Lt(r)).then(Bt).then((g) => {
+        l(g), n(!1);
+      });
+    });
+  }, [s, m, y, L, k, e.cube, e.catalog, e.url]), t.useEffect(() => {
+    n(!0);
+    const r = {
+      connection: {
+        catalog: e.catalog,
+        cube: e.cube
+      },
+      restrictions: {
+        catalogName: e.catalog,
+        cubeName: e.cube
+      },
+      command: "schemaDimensions"
+    };
+    de({ url: e.url }, r).then((g) => {
+      zt(g), u(g), n(!1);
+    });
+  }, [e.catalog, e.cube, e.url]);
+  const K = (r = [], g) => {
+    for (let C = 0; C < r.length; C++) {
+      const w = r[C];
+      if (String(w.name) === String(g.name))
+        return w;
+    }
+    return null;
+  }, D = (r = [], g) => {
+    for (let C = 0; C < r.length; C++) {
+      const w = r[C];
+      if (w.uniqueName === g.uniqueName)
+        return w;
+      let S = D(w.children, g);
+      if (S !== null)
+        return S;
+    }
+    return null;
+  }, c = async (r) => {
+    let g, C, w, S, O, _;
+    r.name && (g = "schemaMembers", S = `${String(r.name)}.[(ALL)]`);
+    const d = {
+      connection: {
+        catalog: e.catalog,
+        cube: e.cube
+      },
+      restrictions: {
+        catalogName: e.catalog,
+        cubeName: e.cube,
+        hierarchyUniqueName: w,
+        dimensionUniqueName: C,
+        levelUniqueName: S,
+        memberUniqueName: O,
+        treeOp: _
+      },
+      command: g
+    };
+    return de({ url: e.url }, d);
+  }, A = async (r) => {
+    let g, C, w, S, O, _;
+    r.uniqueName && (g = "schemaMembers", O = r.uniqueName.replace(/\&/g, "&amp;"), _ = 1);
+    const d = {
+      connection: {
+        catalog: e.catalog,
+        cube: e.cube
+      },
+      restrictions: {
+        catalogName: e.catalog,
+        cubeName: e.cube,
+        hierarchyUniqueName: w,
+        dimensionUniqueName: C,
+        levelUniqueName: S,
+        memberUniqueName: O,
+        treeOp: _
+      },
+      command: g
+    };
+    return de({ url: e.url }, d);
+  }, M = async (r) => {
+    let g, C, w, S, O, _;
+    r.type === 2 ? g = "schemaMeasures" : r.dimensionUniqueName ? (g = "schemaLevels", w = r.uniqueName) : (g = "schemaHierarchies", C = r.uniqueName);
+    const d = {
+      connection: {
+        catalog: e.catalog,
+        cube: e.cube
+      },
+      restrictions: {
+        catalogName: e.catalog,
+        cubeName: e.cube,
+        hierarchyUniqueName: w,
+        dimensionUniqueName: C,
+        levelUniqueName: S,
+        memberUniqueName: O,
+        treeOp: _
+      },
+      command: g
+    };
+    return de({ url: e.url }, d);
+  }, P = async () => {
+    const r = {
+      connection: {
+        catalog: e.catalog,
+        cube: e.cube
+      },
+      restrictions: {
+        catalogName: e.catalog,
+        cubeName: e.cube
+      },
+      command: "schemaKPIs"
+    };
+    return de({ url: e.url }, r);
+  }, p = async (r) => {
+    const g = i.slice(), C = D(g, r.value);
+    if (C && C.uniqueName === "[KPIs]") {
+      const w = En(await P());
+      C.children = w;
+    } else if (C && C.type === "kpi")
+      C.children = Kt(C);
+    else if (C && !C.children) {
+      const w = await M(C);
+      C.children = w;
+    }
+    u(g);
+  }, X = async (r) => {
+    if (!r)
+      return;
+    const g = {
+      rowAxes: [m, x],
+      columnAxes: [s, E],
+      measureAxes: [y, G]
+    }, [C, w] = g[r.target.props.axes], S = C.slice(), O = K(S, r.target.props.dataItem);
+    if (O && !O.fields) {
+      const _ = await c(O);
+      O.fields = _, w(S);
+    }
+  }, j = async (r) => {
+    if (!r)
+      return;
+    const g = {
+      rowAxes: [m, x],
+      columnAxes: [s, E],
+      measureAxes: [y, G]
+    }, [C, w] = g[r.target.props.axes], S = C.slice(), O = K(S, r.target.props.dataItem);
+    if (O) {
+      const _ = (O.fields || []).slice(), d = D(_, r.value);
+      if (d && (!d.children || !d.children.length)) {
+        const H = await A(d);
+        d.children = H, O.fields = _, w(S);
+      }
+    }
+  };
+  return {
+    pivotProps: {
+      rowAxes: m,
+      columnAxes: s,
+      data: o.data,
+      rows: o.rows,
+      columns: o.columns,
+      onRowAxesChange: $,
+      onColumnAxesChange: v
+    },
+    configuratorProps: {
+      sort: k,
+      onSortChange: f,
+      filter: L,
+      onFilterChange: z,
+      data: i,
+      rowAxes: m,
+      columnAxes: s,
+      measureAxes: y,
+      onRowAxesChange: $,
+      onColumnAxesChange: v,
+      onMeasureAxesChange: N,
+      onFieldsEditorFieldExpand: p,
+      onAxisFilterFieldExpand: j,
+      onAxisFilterFieldsExpandChange: X
+    },
+    state: {
+      loading: a
+    }
+  };
+}, Ln = (e) => {
+  const a = Cn(e);
+  return e.children(a);
+}, En = (e) => {
+  for (let a = 0, n = e.length; a < n; a++)
+    e[a].uniqueName = e[a].name, e[a].type = "kpi";
+  return e;
+}, An = "aggregate", pn = "columns", at = { dataField: An, columnsData: pn }, Ee = "&", yn = (e) => {
+  const [a, n] = t.useState(!0), [o, l] = t.useState(e.defaultColumnAxes || []), [i, u] = t.useState(e.defaultRowAxes || []), [s, E] = t.useState(e.defaultMeasureAxes || []), [m, x] = t.useState(e.defaultSort || []), [y, G] = t.useState(e.defaultFilter || []), [k, U] = t.useState(/* @__PURE__ */ new Map()), L = t.useCallback((p) => {
+    u(p.value);
+  }, []), V = t.useCallback((p) => {
+    l(p.value);
+  }, []), $ = (p) => {
+    E(p.value);
+  }, v = (p) => {
+    x(p.value);
+  }, N = (p) => {
+    G(p.value);
+  }, f = t.useMemo(() => Array.from(et(o).keys()).join(Ee), [o]), z = t.useMemo(() => Array.from(et(i).keys()).join(Ee), [i]), K = t.useCallback(
+    (p) => ({ key: p, ...e.dimensions[p] }),
+    [e.dimensions]
+  ), D = t.useMemo(
+    () => f ? f.split(Ee).map(K) : [],
+    [f, K]
+  ), c = t.useMemo(
+    () => z ? z.split(Ee).map(K) : [],
+    [z, K]
+  ), A = t.useMemo(
+    () => s.map((p) => e.measures.find((X) => String(X.name) === String(p.name))).filter(Boolean),
+    [s, e.measures]
+  );
+  t.useEffect(
+    () => {
+      n(!0), setTimeout(() => {
+        const p = Ut(e.data, c, D, A, at, y);
+        U(p), n(!1);
+      }, 0);
+    },
+    [e.data, c, D, A, y]
+  );
+  const M = t.useMemo(
+    () => Vt(e.dimensions, e.measures),
+    [e.dimensions, e.measures]
+  ), P = t.useMemo(
+    () => $t({
+      dataTree: k,
+      rowSettings: c,
+      columnSettings: D,
+      rowAxes: i,
+      columnAxes: o,
+      measures: A,
+      sort: m,
+      fields: at
+    }),
+    [o, D, k, i, c, m]
+  );
+  return {
+    pivotProps: {
+      rowAxes: i,
+      columnAxes: o,
+      data: P.data,
+      rows: P.rows,
+      columns: P.columns,
+      onRowAxesChange: L,
+      onColumnAxesChange: V
+    },
+    configuratorProps: {
+      sort: m,
+      onSortChange: v,
+      filter: y,
+      onFilterChange: N,
+      data: M,
+      rowAxes: i,
+      columnAxes: o,
+      measureAxes: s,
+      onRowAxesChange: L,
+      onColumnAxesChange: V,
+      onMeasureAxesChange: $
+    },
+    state: {
+      loading: a
+    }
+  };
+}, Dn = (e) => {
+  const a = yn(e);
+  return e.children(a);
+};
+export {
+  gn as PivotGrid,
+  ce as PivotGridAxesEditor,
+  $e as PivotGridAxisEditor,
+  Ve as PivotGridAxisFilterFieldsEditor,
+  dt as PivotGridCell,
+  ze as PivotGridColumn,
+  Ct as PivotGridConfigurator,
+  Et as PivotGridConfiguratorButton,
+  Xe as PivotGridConfiguratorEditor,
+  ft as PivotGridContainer,
+  _e as PivotGridFieldsEditor,
+  Be as PivotGridHeaderCell,
+  ct as PivotGridRow,
+  Dn as PivotLocalDataService,
+  Ln as PivotOLAPService,
+  On as averageAggregate,
+  Tn as dataCells,
+  qn as maxAggregate,
+  Bn as minAggregate,
+  zn as sumAggregate,
+  yn as usePivotLocalDataService,
+  Cn as usePivotOLAPService
+};