@hybridcore/ui 1.5.90 → 1.6.0

package/dist/components/charts/column-line-mix/logic.js

@@ -0,0 +1,162 @@
+import { R as O, A as R, T as p } from "../../../AnimatedTheme-jnasw6rT.js";
+import { useThemeProps as B, useTheme as I } from "@mui/material";
+import A from "lodash";
+import { useId as M, useRef as z, useEffect as P } from "react";
+import { colorSetFromPalette as E } from "../_common/utils.js";
+import { c as i, p as N, a as F } from "../../../ColorSet-C7vpNXhM.js";
+import { X as V, V as W } from "../../../AxisRenderer-DTyLLA6c.js";
+import { S as q } from "../../../Scrollbar-D86MJyr2.js";
+import { D as H } from "../../../DateAxis-YX3QNIB-.js";
+import { A as X, a as U } from "../../../AxisRendererY-C_ItLPNV.js";
+import { C as _ } from "../../../CategoryAxis-CwnfaGc8.js";
+import { C as $ } from "../../../ColumnSeries-CjgdJ2QL.js";
+import { D as k } from "../../../DataProcessor-CHDO51q4.js";
+import { L as j } from "../../../LineSeries-Uiv5o56b.js";
+import { B as G } from "../../../Bullet-DVczI2TD.js";
+import { C as J } from "../../../Circle-Cy5s-pVc.js";
+import { X as K } from "../../../XYCursor-C8WktvKM.js";
+import { L as Q } from "../../../Legend-Dp_MKfS4.js";
+const ve = (C) => {
+  const f = B({ props: C, name: "HCColumnLineMix" }), {
+    dimensions: t,
+    values: h,
+    data: n,
+    initDelay: b = 0,
+    baseInterval: L,
+    colors: g,
+    sx: T,
+    ...Y
+  } = f, a = I(), x = `hc-column-line-mix-${M().replace(/:/g, "")}`, d = z(null);
+  P(() => {
+    let c;
+    return c = setTimeout(() => {
+      var w, v, y;
+      if (t.length < 1) {
+        console.error("ColumnLineMix requires at least 1 dimension");
+        return;
+      }
+      const e = O.new(x);
+      d.current = e, e.setThemes([R.new(e)]), e.interfaceColors.setAll({
+        text: i(a.palette.text.primary),
+        grid: i(a.palette.divider),
+        stroke: i(a.palette.divider)
+      });
+      const r = e.container.children.push(
+        V.new(e, {
+          panX: !1,
+          panY: !1,
+          wheelX: "none",
+          wheelY: "none",
+          paddingLeft: 0,
+          layout: e.verticalLayout
+        })
+      );
+      r.set("colors", E(e, g)), r.get("colors", {}).set("step", 3), r.set(
+        "scrollbarX",
+        q.new(e, { orientation: "horizontal" })
+      );
+      let s, l = n;
+      t[0].type === "date" ? (l = A.orderBy(n, [t[0].value]), s = r.xAxes.push(
+        H.new(e, {
+          maxDeviation: 0.1,
+          groupData: !1,
+          baseInterval: L || { timeUnit: "day", count: 1 },
+          renderer: X.new(e, {}),
+          tooltip: p.new(e, {})
+        })
+      ), (w = s.get("renderer")) == null || w.grid.template.setAll({
+        stroke: i(a.palette.divider),
+        strokeOpacity: 1
+      })) : (s = r.xAxes.push(
+        _.new(e, {
+          categoryField: t[0].value,
+          renderer: X.new(e, {}),
+          tooltip: p.new(e, {})
+        })
+      ), (v = s.get("renderer")) == null || v.grid.template.setAll({
+        stroke: i(a.palette.divider),
+        strokeOpacity: 1
+      }), e.numberFormatter.setAll({
+        numberFormat: "#",
+        numericFields: ["valueX"]
+      }), l = A.orderBy(n, [t[0].value]), s.data.setAll(l));
+      const u = r.yAxes.push(
+        W.new(e, {
+          min: 0,
+          extraMax: 0.1,
+          renderer: U.new(e, { strokeOpacity: 0.1 })
+        })
+      );
+      (y = u.get("renderer")) == null || y.grid.template.setAll({
+        stroke: i(a.palette.divider),
+        strokeOpacity: 1
+      }), h.forEach((m, S) => {
+        if (S === 0) {
+          const o = r.series.push(
+            $.new(e, {
+              name: m.name,
+              xAxis: s,
+              yAxis: u,
+              valueYField: m.dataFieldName,
+              ...t[0].type === "date" ? { valueXField: t[0].value } : { categoryXField: t[0].value },
+              tooltip: p.new(e, {
+                pointerOrientation: "horizontal",
+                labelText: "{name} in {categoryX}: {valueY} {info}"
+              })
+            })
+          );
+          o.columns.template.setAll({
+            tooltipY: N(10),
+            templateField: "columnSettings"
+          }), t[0].type === "date" && (o.data.processor = k.new(e, {
+            dateFormat: "i",
+            dateFields: [t[0].value]
+          })), o.data.setAll(l), o.appear();
+        } else {
+          const o = r.series.push(
+            j.new(e, {
+              name: m.name,
+              xAxis: s,
+              yAxis: u,
+              valueYField: m.dataFieldName,
+              ...t[0].type === "date" ? { valueXField: t[0].value } : { categoryXField: t[0].value },
+              tooltip: p.new(e, {
+                pointerOrientation: "horizontal",
+                labelText: "{name} in {categoryX}: {valueY} {info}"
+              })
+            })
+          );
+          o.strokes.template.setAll({
+            strokeWidth: 3,
+            templateField: "strokeSettings"
+          }), t[0].type === "date" && (o.data.processor = k.new(e, {
+            dateFormat: "i",
+            dateFields: [t[0].value]
+          })), o.data.setAll(l), o.bullets.push(function() {
+            return G.new(e, {
+              sprite: J.new(e, {
+                strokeWidth: 3,
+                stroke: o.get("stroke"),
+                radius: 5,
+                fill: e.interfaceColors.get("background")
+              })
+            });
+          });
+        }
+      }), r.set("cursor", K.new(e, {})), r.children.push(
+        Q.new(e, {
+          centerX: F,
+          x: F
+        })
+      ).data.setAll(r.series.values), r.appear(1e3, 100);
+    }, b), () => {
+      var e;
+      c && clearTimeout(c), (e = d.current) == null || e.dispose(), d.current = null;
+    };
+  }, [n, t, h, a.palette.mode, g]);
+  const D = { ...f };
+  return { chartId: x, ownerState: D, sx: T, other: Y };
+};
+export {
+  ve as useColumnLineMixLogic
+};

package/dist/components/charts/column-line-mix/styled.js

@@ -0,0 +1,12 @@
+import { styled as t, Box as e } from "@mui/material";
+const n = t(e, {
+  name: "HCColumnLineMix",
+  slot: "Root",
+  shouldForwardProp: (o) => o !== "ownerState"
+})(() => ({
+  width: "100%",
+  height: "100%"
+}));
+export {
+  n as ColumnLineMixRoot
+};

package/dist/components/charts/drill-down-treemap/index.js

@@ -0,0 +1,10 @@
+import { jsx as r } from "react/jsx-runtime";
+import { useDrillDownTreemapLogic as n } from "./logic.js";
+import { DrillDownTreemapRoot as l } from "./styled.js";
+function a(o) {
+  const { chartId: e, ownerState: t, sx: i, other: m } = n(o);
+  return /* @__PURE__ */ r(l, { ownerState: t, sx: i, ...m, children: /* @__PURE__ */ r("div", { id: e, style: { width: "100%", height: "100%" } }) });
+}
+export {
+  a as DrillDownTreemap
+};

package/dist/components/charts/drill-down-treemap/logic.js

@@ -0,0 +1,391 @@
+import { C as V, k as X, l as B, L as W, R as E, a as Z, A as $ } from "../../../AnimatedTheme-jnasw6rT.js";
+import { useThemeProps as G, useTheme as J } from "@mui/material";
+import K from "dayjs";
+import Q from "lodash";
+import { useId as U, useRef as ee, useEffect as te } from "react";
+import { colorSetFromPalette as ie } from "../_common/utils.js";
+import { m as I, f as N, e as j, p as C } from "../../../ColorSet-C7vpNXhM.js";
+import { a as ae, H as F } from "../../../Hierarchy-Bihj0S61.js";
+import { R as z } from "../../../RoundedRectangle-CWLi2PXn.js";
+import { r as ne, c as k, a as O } from "../../../constant-BiOGvlZc.js";
+class L extends V {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "labels", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new X(B.new({}), () => W._new(this._root, {
+        themeTags: I(this.labels.template.get("themeTags", []), ["label"]),
+        background: z.new(this._root, {
+          themeTags: ["background"]
+        })
+      }, [this.labels.template])))
+    }), Object.defineProperty(this, "_disposer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  /**
+   * @ignore
+   */
+  makeLabel(t) {
+    const i = this.labels.make();
+    return i._setDataItem(t), i.states.create("hover", {}), i.states.create("down", {}), i.events.on("click", () => {
+      const a = this.get("series");
+      a && a.selectDataItem(t);
+    }), this.labels.push(i), i;
+  }
+  _afterNew() {
+    this._defaultThemes.push(ae.new(this._root)), this._settings.themeTags = I(this._settings.themeTags, ["breadcrumb"]), super._afterNew();
+  }
+  _changed() {
+    if (super._changed(), this.isDirty("series")) {
+      const t = this.get("series"), i = this._prevSettings.series;
+      t != i ? this._disposer = t.events.on("dataitemselected", (a) => {
+        this._handleDataItem(a.dataItem);
+      }) : i && this._disposer && this._disposer.dispose(), this._handleDataItem(t.get("selectedDataItem"));
+    }
+  }
+  _handleDataItem(t) {
+    if (this.set("minHeight", this.height()), this.children.clear(), this.labels.clear(), t) {
+      let i = t;
+      for (; i; ) {
+        let a = this.makeLabel(i);
+        i == t && a.addTag("last"), this.children.moveValue(a, 0), i = i.get("parent");
+      }
+    }
+  }
+}
+Object.defineProperty(L, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "BreadcrumbBar"
+});
+Object.defineProperty(L, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: V.classNames.concat([L.className])
+});
+function se(h) {
+  h.x0 = Math.round(h.x0), h.y0 = Math.round(h.y0), h.x1 = Math.round(h.x1), h.y1 = Math.round(h.y1);
+}
+function x(h, t, i, a, s) {
+  for (var l = h.children, n, g = -1, b = l.length, m = h.value && (a - t) / h.value; ++g < b; )
+    n = l[g], n.y0 = i, n.y1 = s, n.x0 = t, n.x1 = t += n.value * m;
+}
+function A(h, t, i, a, s) {
+  for (var l = h.children, n, g = -1, b = l.length, m = h.value && (s - i) / h.value; ++g < b; )
+    n = l[g], n.x0 = t, n.x1 = a, n.y0 = i, n.y1 = i += n.value * m;
+}
+var re = (1 + Math.sqrt(5)) / 2;
+function oe(h, t, i, a, s, l) {
+  for (var n = [], g = t.children, b, m, r = 0, p = 0, e = g.length, c, u, o = t.value, d, f, v, P, D, y, w; r < e; ) {
+    c = s - i, u = l - a;
+    do
+      d = g[p++].value;
+    while (!d && p < e);
+    for (f = v = d, y = Math.max(u / c, c / u) / (o * h), w = d * d * y, D = Math.max(v / w, w / f); p < e; ++p) {
+      if (d += m = g[p].value, m < f && (f = m), m > v && (v = m), w = d * d * y, P = Math.max(v / w, w / f), P > D) {
+        d -= m;
+        break;
+      }
+      D = P;
+    }
+    n.push(b = { value: d, dice: c < u, children: g.slice(r, p) }), b.dice ? x(b, i, a, s, o ? a += u * d / o : l) : A(b, i, a, o ? i += c * d / o : s, l), o -= d, r = p;
+  }
+  return n;
+}
+const M = function h(t) {
+  function i(a, s, l, n, g) {
+    oe(t, a, s, l, n, g);
+  }
+  return i.ratio = function(a) {
+    return h((a = +a) > 1 ? a : 1);
+  }, i;
+}(re);
+function q() {
+  var h = M, t = !1, i = 1, a = 1, s = [0], l = k, n = k, g = k, b = k, m = k;
+  function r(e) {
+    return e.x0 = e.y0 = 0, e.x1 = i, e.y1 = a, e.eachBefore(p), s = [0], t && e.eachBefore(se), e;
+  }
+  function p(e) {
+    var c = s[e.depth], u = e.x0 + c, o = e.y0 + c, d = e.x1 - c, f = e.y1 - c;
+    d < u && (u = d = (u + d) / 2), f < o && (o = f = (o + f) / 2), e.x0 = u, e.y0 = o, e.x1 = d, e.y1 = f, e.children && (c = s[e.depth + 1] = l(e) / 2, u += m(e) - c, o += n(e) - c, d -= g(e) - c, f -= b(e) - c, d < u && (u = d = (u + d) / 2), f < o && (o = f = (o + f) / 2), h(e, u, o, d, f));
+  }
+  return r.round = function(e) {
+    return arguments.length ? (t = !!e, r) : t;
+  }, r.size = function(e) {
+    return arguments.length ? (i = +e[0], a = +e[1], r) : [i, a];
+  }, r.tile = function(e) {
+    return arguments.length ? (h = ne(e), r) : h;
+  }, r.padding = function(e) {
+    return arguments.length ? r.paddingInner(e).paddingOuter(e) : r.paddingInner();
+  }, r.paddingInner = function(e) {
+    return arguments.length ? (l = typeof e == "function" ? e : O(+e), r) : l;
+  }, r.paddingOuter = function(e) {
+    return arguments.length ? r.paddingTop(e).paddingRight(e).paddingBottom(e).paddingLeft(e) : r.paddingTop();
+  }, r.paddingTop = function(e) {
+    return arguments.length ? (n = typeof e == "function" ? e : O(+e), r) : n;
+  }, r.paddingRight = function(e) {
+    return arguments.length ? (g = typeof e == "function" ? e : O(+e), r) : g;
+  }, r.paddingBottom = function(e) {
+    return arguments.length ? (b = typeof e == "function" ? e : O(+e), r) : b;
+  }, r.paddingLeft = function(e) {
+    return arguments.length ? (m = typeof e == "function" ? e : O(+e), r) : m;
+  }, r;
+}
+function le(h, t, i, a, s) {
+  var l = h.children, n, g = l.length, b, m = new Array(g + 1);
+  for (m[0] = b = n = 0; n < g; ++n)
+    m[n + 1] = b += l[n].value;
+  r(0, g, h.value, t, i, a, s);
+  function r(p, e, c, u, o, d, f) {
+    if (p >= e - 1) {
+      var v = l[p];
+      v.x0 = u, v.y0 = o, v.x1 = d, v.y1 = f;
+      return;
+    }
+    for (var P = m[p], D = c / 2 + P, y = p + 1, w = e - 1; y < w; ) {
+      var T = y + w >>> 1;
+      m[T] < D ? y = T + 1 : w = T;
+    }
+    D - m[y - 1] < m[y] - D && p + 1 < y && --y;
+    var _ = m[y] - P, R = c - _;
+    if (d - u > f - o) {
+      var H = c ? (u * R + d * _) / c : d;
+      r(p, y, _, u, o, H, f), r(y, e, R, H, o, d, f);
+    } else {
+      var S = c ? (o * R + f * _) / c : f;
+      r(p, y, _, u, o, d, S), r(y, e, R, u, S, d, f);
+    }
+  }
+}
+function de(h, t, i, a, s) {
+  (h.depth & 1 ? A : x)(h, t, i, a, s);
+}
+class Y extends F {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_tag", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "treemap"
+    }), Object.defineProperty(this, "rectangleTemplate", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: B.new({})
+    }), Object.defineProperty(this, "_treemapLayout", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: q().tile(M)
+    }), Object.defineProperty(this, "rectangles", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new X(B.new({}), () => z._new(this._root, {
+        themeTags: I(this.rectangles.template.get("themeTags", []), [this._tag, "shape"])
+      }, [this.rectangles.template])))
+    });
+  }
+  _afterNew() {
+    super._afterNew(), this.setPrivate("scaleX", 1), this.setPrivate("scaleY", 1), this.nodes.template.setPrivate("trustBounds", !0);
+  }
+  _prepareChildren() {
+    if (super._prepareChildren(), this.isDirty("layoutAlgorithm")) {
+      let t;
+      switch (this.get("layoutAlgorithm")) {
+        case "squarify":
+          t = M;
+          break;
+        case "binary":
+          t = le;
+          break;
+        case "slice":
+          t = A;
+          break;
+        case "dice":
+          t = x;
+          break;
+        case "sliceDice":
+          t = de;
+          break;
+      }
+      if (t) {
+        this._treemapLayout = q().tile(t), this._updateVisuals();
+        const i = this.get("selectedDataItem");
+        i && this._zoom(i);
+      }
+    }
+    (this.isDirty("nodePaddingRight") || this.isDirty("nodePaddingLeft") || this.isDirty("nodePaddingTop") || this.isDirty("nodePaddingBottom") || this.isDirty("nodePaddingOuter") || this.isDirty("nodePaddingInner")) && this._rootNode && this._updateNodes(this._rootNode), (this.isPrivateDirty("scaleX") || this.isPrivateDirty("scaleY")) && this._rootNode && this._updateNodesScale(this._rootNode);
+  }
+  _updateVisuals() {
+    if (this._rootNode) {
+      const t = this._treemapLayout;
+      t.size([this.innerWidth(), this.innerHeight()]);
+      const i = this.get("nodePaddingLeft"), a = this.get("nodePaddingRight"), s = this.get("nodePaddingTop"), l = this.get("nodePaddingBottom"), n = this.get("nodePaddingInner"), g = this.get("nodePaddingOuter");
+      N(i) && t.paddingLeft(i), N(a) && t.paddingRight(a), N(s) && t.paddingTop(s), N(l) && t.paddingBottom(l), N(n) && t.paddingInner(n), N(g) && t.paddingOuter(g), t(this._rootNode), this._updateNodes(this._rootNode);
+    }
+  }
+  _updateNode(t) {
+    super._updateNode(t);
+    const i = t.get("node"), a = t.get("rectangle"), s = t.get("d3HierarchyNode"), l = this.getPrivate("scaleX", 1), n = this.getPrivate("scaleY", 1), g = s.x0 * l, b = s.x1 * l, m = s.y0 * n, r = s.y1 * n, p = b - g, e = r - m, c = this.get("animationDuration", 0), u = this.get("animationEasing");
+    if (i.animate({ key: "x", to: g, duration: c, easing: u }), i.animate({ key: "y", to: m, duration: c, easing: u }), i.animate({ key: "width", to: p, duration: c, easing: u }), i.animate({ key: "height", to: e, duration: c, easing: u }), a) {
+      const o = t.get("fill"), d = t.get("fillPattern");
+      a.animate({ key: "width", to: p, duration: c, easing: u }), a.animate({ key: "height", to: e, duration: c, easing: u }), a._setDefault("fill", o), a._setDefault("fillPattern", d), a._setDefault("stroke", o);
+    }
+  }
+  _updateNodesScale(t) {
+    const i = t.data.dataItem;
+    if (i) {
+      const a = i.get("node"), s = i.get("rectangle"), l = this.getPrivate("scaleX", 1), n = this.getPrivate("scaleY", 1), g = t.x0 * l, b = t.x1 * l, m = t.y0 * n, r = t.y1 * n, p = b - g, e = r - m;
+      a.setAll({ x: g, y: m, width: p, height: e }), s.setAll({ width: p, height: e });
+      const c = t.children;
+      c && j(c, (u) => {
+        this._updateNodesScale(u);
+      });
+    }
+  }
+  /**
+   * @ignore
+   */
+  makeNode(t) {
+    const i = super.makeNode(t), a = i.children.moveValue(this.rectangles.make(), 0);
+    i.setPrivate("tooltipTarget", a), t.setRaw("rectangle", a);
+    const s = t.get("label");
+    return a.on("width", () => {
+      s.setPrivate("maxWidth", a.width());
+    }), a.on("height", () => {
+      s.setPrivate("maxHeight", a.height());
+    }), i;
+  }
+  _zoom(t) {
+    if (this.width() > 0 && this.height() > 0) {
+      const i = t.get("d3HierarchyNode"), a = this.get("nodePaddingOuter", 0);
+      let s = i.x0 + a, l = i.x1 - a, n = i.y0 + a, g = i.y1 - a, b = (this.innerWidth() - a * 2) / (l - s), m = (this.innerHeight() - a * 2) / (g - n);
+      const r = this.get("animationEasing");
+      let p = this.get("animationDuration", 0);
+      this.inited || (p = 0), this.animatePrivate({ key: "scaleX", to: b, duration: p, easing: r }), this.animatePrivate({ key: "scaleY", to: m, duration: p, easing: r }), this.nodesContainer.animate({ key: "x", to: a - s * b, duration: p, easing: r }), this.nodesContainer.animate({ key: "y", to: a - n * m, duration: p, easing: r });
+    }
+  }
+  _selectDataItem(t, i, a) {
+    if (super._selectDataItem(t, i, a), t) {
+      let s = this.get("downDepth", 1) + t.get("depth");
+      this.inited || (s = this.get("initialDepth", 1));
+      const l = this._getVisibleNodes(t, s);
+      this.nodes.each((n) => {
+        l.indexOf(n.dataItem) == -1 ? n.setPrivate("focusable", !1) : n.removePrivate("focusable");
+      });
+    }
+    this._root._invalidateTabindexes();
+  }
+  _getVisibleNodes(t, i) {
+    const a = t.get("children");
+    let s = [];
+    return a && j(a, (l) => {
+      l.get("depth") == i || !l.get("children") ? s.push(l) : s = s.concat(this._getVisibleNodes(l, i));
+    }), s;
+  }
+}
+Object.defineProperty(Y, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Treemap"
+});
+Object.defineProperty(Y, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: F.classNames.concat([Y.className])
+});
+const we = (h) => {
+  const t = G({ props: h, name: "HCDrillDownTreemap" }), {
+    dimensions: i,
+    values: a,
+    data: s,
+    initDelay: l = 0,
+    colors: n,
+    sx: g,
+    ...b
+  } = t, m = J(), p = `hc-drill-down-treemap-${U().replace(/:/g, "")}`, e = ee(null);
+  te(() => {
+    let u;
+    return u = setTimeout(() => {
+      var D;
+      if (i.length < 2) {
+        console.error("DrillDownTreemap requires at least 2 dimensions");
+        return;
+      }
+      if (a.length < 1) {
+        console.error("DrillDownTreemap requires at least 1 value");
+        return;
+      }
+      const o = E.new(p);
+      e.current = o;
+      const d = Z.new(o);
+      d.rule("RoundedRectangle", ["hierarchy", "node", "shape", "depth1"]).setAll({ strokeWidth: 2 }), d.rule("RoundedRectangle", ["hierarchy", "node", "shape", "depth2"]).setAll({ strokeWidth: 1, strokeOpacity: 0.2 }), d.rule("Label", ["node", "depth1"]).setAll({ fontSize: 10 }), d.rule("Label", ["node", "depth2"]).setAll({ fontSize: 10 }), o.setThemes([$.new(o), d]);
+      const f = o.container.children.push(
+        V.new(o, {
+          width: C(100),
+          height: C(100),
+          layout: o.verticalLayout
+        })
+      ), v = f.children.push(
+        Y.new(o, {
+          sort: "descending",
+          singleBranchOnly: !1,
+          downDepth: 1,
+          upDepth: 0,
+          initialDepth: 1,
+          valueField: a[0].dataFieldName,
+          categoryField: "name",
+          childDataField: "children",
+          nodePaddingOuter: 0,
+          nodePaddingInner: 0
+        })
+      );
+      v.nodes.template.setPrivate("trustBounds", !0), v.set("colors", ie(o, n)), (D = v.get("colors")) == null || D.set("step", 1), f.children.moveValue(
+        L.new(o, { series: v }),
+        0
+      );
+      const P = (y, w, T) => {
+        if (y === "date") {
+          let _ = "YYYY";
+          return w.includes("month") ? _ = "MMM YYYY" : w.includes("day") && (_ = "DD MMM YYYY"), K(T).format(_);
+        }
+        return T;
+      };
+      if (i.length > 1) {
+        const y = Q.groupBy(s, i[0].value), w = [];
+        Object.keys(y).forEach((T) => {
+          w.push({
+            name: P(i[0].type, i[0].value, T),
+            children: y[T].map((_) => ({
+              name: P(
+                i[1].type,
+                i[1].value,
+                _[i[1].value]
+              ),
+              [a[0].dataFieldName]: _[a[0].dataFieldName]
+            }))
+          });
+        }), v.data.setAll([{ name: "Home", children: w }]);
+      }
+      v.set("selectedDataItem", v.dataItems[0]);
+    }, l), () => {
+      var o;
+      u && clearTimeout(u), (o = e.current) == null || o.dispose(), e.current = null;
+    };
+  }, [s, i, a, m.palette.mode, n]);
+  const c = { ...t };
+  return { chartId: p, ownerState: c, sx: g, other: b };
+};
+export {
+  we as useDrillDownTreemapLogic
+};

package/dist/components/charts/drill-down-treemap/styled.js

@@ -0,0 +1,12 @@
+import { styled as r, Box as t } from "@mui/material";
+const l = r(t, {
+  name: "HCDrillDownTreemap",
+  slot: "Root",
+  shouldForwardProp: (o) => o !== "ownerState"
+})(() => ({
+  width: "100%",
+  height: "100%"
+}));
+export {
+  l as DrillDownTreemapRoot
+};

package/dist/components/charts/drill-down-voronoi-treemap/index.js

@@ -0,0 +1,10 @@
+import { jsx as o } from "react/jsx-runtime";
+import { useDrillDownVoronoiTreemapLogic as m } from "./logic.js";
+import { DrillDownVoronoiTreemapRoot as l } from "./styled.js";
+function a(r) {
+  const { chartId: i, ownerState: e, sx: t, other: n } = m(r);
+  return /* @__PURE__ */ o(l, { ownerState: e, sx: t, ...n, children: /* @__PURE__ */ o("div", { id: i, style: { width: "100%", height: "100%" } }) });
+}
+export {
+  a as DrillDownVoronoiTreemap
+};