@weng-lab/visualization 2.6.0-beta.1 → 2.6.0

package/dist/visualization.es549.js

@@ -1,31 +1,285 @@
-const e = [
-  "animate",
-  "circle",
-  "defs",
-  "desc",
-  "ellipse",
-  "g",
-  "image",
-  "line",
-  "filter",
-  "marker",
-  "mask",
-  "metadata",
-  "path",
-  "pattern",
-  "polygon",
-  "polyline",
-  "rect",
-  "stop",
-  "switch",
-  "symbol",
-  "svg",
-  "text",
-  "tspan",
-  "use",
-  "view"
-];
+import { addPointerEvent as k } from "./visualization.es181.js";
+import { extractEventInfo as B } from "./visualization.es182.js";
+import { getContextWindow as j } from "./visualization.es550.js";
+import { isRefObject as P } from "./visualization.es606.js";
+import { PanSession as T } from "./visualization.es551.js";
+import { applyConstraints as b, calcRelativeConstraints as I, resolveDragElastic as w, calcViewportConstraints as R, defaultElastic as O, rebaseAxisConstraints as W, calcOrigin as z } from "./visualization.es607.js";
+import { createBox as F } from "./visualization.es425.js";
+import { frame as C } from "./visualization.es326.js";
+import { eachAxis as p } from "./visualization.es448.js";
+import { invariant as U } from "./visualization.es306.js";
+import { measurePageBox as _ } from "./visualization.es420.js";
+import { convertBoxToBoundingBox as K, convertBoundingBoxToBox as N } from "./visualization.es441.js";
+import { addValueToWillChange as L } from "./visualization.es332.js";
+import { animateMotionValue as $ } from "./visualization.es325.js";
+import { addDomEvent as q } from "./visualization.es183.js";
+import { setDragLock as G } from "./visualization.es367.js";
+import { resize as V } from "./visualization.es379.js";
+import { percent as H } from "./visualization.es403.js";
+import { calcLength as J } from "./visualization.es445.js";
+import { mixNumber as M } from "./visualization.es352.js";
+import { isElementTextInput as Q } from "./visualization.es373.js";
+const X = /* @__PURE__ */ new WeakMap();
+class At {
+  constructor(t) {
+    this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = { x: 0, y: 0 }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = F(), this.latestPointerEvent = null, this.latestPanInfo = null, this.visualElement = t;
+  }
+  start(t, { snapToCursor: n = !1, distanceThreshold: s } = {}) {
+    const { presenceContext: i } = this.visualElement;
+    if (i && i.isPresent === !1)
+      return;
+    const e = (r) => {
+      n && this.snapToCursor(B(r).point), this.stopAnimation();
+    }, o = (r, l) => {
+      const { drag: g, dragPropagation: d, onDragStart: v } = this.getProps();
+      if (g && !d && (this.openDragLock && this.openDragLock(), this.openDragLock = G(g), !this.openDragLock))
+        return;
+      this.latestPointerEvent = r, this.latestPanInfo = l, this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), p((f) => {
+        let D = this.getAxisMotionValue(f).get() || 0;
+        if (H.test(D)) {
+          const { projection: y } = this.visualElement;
+          if (y && y.layout) {
+            const x = y.layout.layoutBox[f];
+            x && (D = J(x) * (parseFloat(D) / 100));
+          }
+        }
+        this.originPoint[f] = D;
+      }), v && C.update(() => v(r, l), !1, !0), L(this.visualElement, "transform");
+      const { animationState: E } = this.visualElement;
+      E && E.setActive("whileDrag", !0);
+    }, a = (r, l) => {
+      this.latestPointerEvent = r, this.latestPanInfo = l;
+      const { dragPropagation: g, dragDirectionLock: d, onDirectionLock: v, onDrag: E } = this.getProps();
+      if (!g && !this.openDragLock)
+        return;
+      const { offset: f } = l;
+      if (d && this.currentDirection === null) {
+        this.currentDirection = Z(f), this.currentDirection !== null && v && v(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", l.point, f), this.updateAxis("y", l.point, f), this.visualElement.render(), E && C.update(() => E(r, l), !1, !0);
+    }, u = (r, l) => {
+      this.latestPointerEvent = r, this.latestPanInfo = l, this.stop(r, l), this.latestPointerEvent = null, this.latestPanInfo = null;
+    }, c = () => {
+      const { dragSnapToOrigin: r } = this.getProps();
+      (r || this.constraints) && this.startAnimation({ x: 0, y: 0 });
+    }, { dragSnapToOrigin: h } = this.getProps();
+    this.panSession = new T(t, {
+      onSessionStart: e,
+      onStart: o,
+      onMove: a,
+      onSessionEnd: u,
+      resumeAnimation: c
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: h,
+      distanceThreshold: s,
+      contextWindow: j(this.visualElement),
+      element: this.visualElement.current
+    });
+  }
+  /**
+   * @internal
+   */
+  stop(t, n) {
+    const s = t || this.latestPointerEvent, i = n || this.latestPanInfo, e = this.isDragging;
+    if (this.cancel(), !e || !i || !s)
+      return;
+    const { velocity: o } = i;
+    this.startAnimation(o);
+    const { onDragEnd: a } = this.getProps();
+    a && C.postRender(() => a(s, i));
+  }
+  /**
+   * @internal
+   */
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: n } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.endPanSession();
+    const { dragPropagation: s } = this.getProps();
+    !s && this.openDragLock && (this.openDragLock(), this.openDragLock = null), n && n.setActive("whileDrag", !1);
+  }
+  /**
+   * Clean up the pan session without modifying other drag state.
+   * This is used during unmount to ensure event listeners are removed
+   * without affecting projection animations or drag locks.
+   * @internal
+   */
+  endPanSession() {
+    this.panSession && this.panSession.end(), this.panSession = void 0;
+  }
+  updateAxis(t, n, s) {
+    const { drag: i } = this.getProps();
+    if (!s || !A(t, i, this.currentDirection))
+      return;
+    const e = this.getAxisMotionValue(t);
+    let o = this.originPoint[t] + s[t];
+    this.constraints && this.constraints[t] && (o = b(o, this.constraints[t], this.elastic[t])), e.set(o);
+  }
+  resolveConstraints() {
+    const { dragConstraints: t, dragElastic: n } = this.getProps(), s = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : this.visualElement.projection?.layout, i = this.constraints;
+    t && P(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && s ? this.constraints = I(s.layoutBox, t) : this.constraints = !1, this.elastic = w(n), i !== this.constraints && !P(t) && s && this.constraints && !this.hasMutatedConstraints && p((e) => {
+      this.constraints !== !1 && this.getAxisMotionValue(e) && (this.constraints[e] = W(s.layoutBox[e], this.constraints[e]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: n } = this.getProps();
+    if (!t || !P(t))
+      return !1;
+    const s = t.current;
+    U(s !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
+    const { projection: i } = this.visualElement;
+    if (!i || !i.layout)
+      return !1;
+    const e = _(s, i.root, this.visualElement.getTransformPagePoint());
+    let o = R(i.layout.layoutBox, e);
+    if (n) {
+      const a = n(K(o));
+      this.hasMutatedConstraints = !!a, a && (o = N(a));
+    }
+    return o;
+  }
+  startAnimation(t) {
+    const { drag: n, dragMomentum: s, dragElastic: i, dragTransition: e, dragSnapToOrigin: o, onDragTransitionEnd: a } = this.getProps(), u = this.constraints || {}, c = p((h) => {
+      if (!A(h, n, this.currentDirection))
+        return;
+      let r = u && u[h] || {};
+      (o === !0 || o === h) && (r = { min: 0, max: 0 });
+      const l = i ? 200 : 1e6, g = i ? 40 : 1e7, d = {
+        type: "inertia",
+        velocity: s ? t[h] : 0,
+        bounceStiffness: l,
+        bounceDamping: g,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...e,
+        ...r
+      };
+      return this.startAxisValueAnimation(h, d);
+    });
+    return Promise.all(c).then(a);
+  }
+  startAxisValueAnimation(t, n) {
+    const s = this.getAxisMotionValue(t);
+    return L(this.visualElement, t), s.start($(t, s, 0, n, this.visualElement, !1));
+  }
+  stopAnimation() {
+    p((t) => this.getAxisMotionValue(t).stop());
+  }
+  /**
+   * Drag works differently depending on which props are provided.
+   *
+   * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+   * - Otherwise, we apply the delta to the x/y motion values.
+   */
+  getAxisMotionValue(t) {
+    const n = `_drag${t.toUpperCase()}`, s = this.visualElement.getProps(), i = s[n];
+    return i || this.visualElement.getValue(t, (s.initial ? s.initial[t] : void 0) || 0);
+  }
+  snapToCursor(t) {
+    p((n) => {
+      const { drag: s } = this.getProps();
+      if (!A(n, s, this.currentDirection))
+        return;
+      const { projection: i } = this.visualElement, e = this.getAxisMotionValue(n);
+      if (i && i.layout) {
+        const { min: o, max: a } = i.layout.layoutBox[n], u = e.get() || 0;
+        e.set(t[n] - M(o, a, 0.5) + u);
+      }
+    });
+  }
+  /**
+   * When the viewport resizes we want to check if the measured constraints
+   * have changed and, if so, reposition the element within those new constraints
+   * relative to where it was before the resize.
+   */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current)
+      return;
+    const { drag: t, dragConstraints: n } = this.getProps(), { projection: s } = this.visualElement;
+    if (!P(n) || !s || !this.constraints)
+      return;
+    this.stopAnimation();
+    const i = { x: 0, y: 0 };
+    p((o) => {
+      const a = this.getAxisMotionValue(o);
+      if (a && this.constraints !== !1) {
+        const u = a.get();
+        i[o] = z({ min: u, max: u }, this.constraints[o]);
+      }
+    });
+    const { transformTemplate: e } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = e ? e({}, "") : "none", s.root && s.root.updateScroll(), s.updateLayout(), this.constraints = !1, this.resolveConstraints(), p((o) => {
+      if (!A(o, t, null))
+        return;
+      const a = this.getAxisMotionValue(o), { min: u, max: c } = this.constraints[o];
+      a.set(M(u, c, i[o]));
+    }), this.visualElement.render();
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    X.set(this.visualElement, this);
+    const t = this.visualElement.current, n = k(t, "pointerdown", (c) => {
+      const { drag: h, dragListener: r = !0 } = this.getProps(), l = c.target, g = l !== t && Q(l);
+      h && r && !g && this.start(c);
+    });
+    let s;
+    const i = () => {
+      const { dragConstraints: c } = this.getProps();
+      P(c) && c.current && (this.constraints = this.resolveRefConstraints(), s || (s = Y(t, c.current, () => this.scalePositionWithinConstraints())));
+    }, { projection: e } = this.visualElement, o = e.addEventListener("measure", i);
+    e && !e.layout && (e.root && e.root.updateScroll(), e.updateLayout()), C.read(i);
+    const a = q(window, "resize", () => this.scalePositionWithinConstraints()), u = e.addEventListener("didUpdate", (({ delta: c, hasLayoutChanged: h }) => {
+      this.isDragging && h && (p((r) => {
+        const l = this.getAxisMotionValue(r);
+        l && (this.originPoint[r] += c[r].translate, l.set(l.get() + c[r].translate));
+      }), this.visualElement.render());
+    }));
+    return () => {
+      a(), n(), o(), u && u(), s && s();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: n = !1, dragDirectionLock: s = !1, dragPropagation: i = !1, dragConstraints: e = !1, dragElastic: o = O, dragMomentum: a = !0 } = t;
+    return {
+      ...t,
+      drag: n,
+      dragDirectionLock: s,
+      dragPropagation: i,
+      dragConstraints: e,
+      dragElastic: o,
+      dragMomentum: a
+    };
+  }
+}
+function S(m) {
+  let t = !0;
+  return () => {
+    if (t) {
+      t = !1;
+      return;
+    }
+    m();
+  };
+}
+function Y(m, t, n) {
+  const s = V(m, S(n)), i = V(t, S(n));
+  return () => {
+    s(), i();
+  };
+}
+function A(m, t, n) {
+  return (t === !0 || t === m) && (n === null || n === m);
+}
+function Z(m, t = 10) {
+  let n = null;
+  return Math.abs(m.y) > t ? n = "y" : Math.abs(m.x) > t && (n = "x"), n;
+}
 export {
-  e as lowercaseSVGElements
+  At as VisualElementDragControls,
+  X as elementDragControls
 };
 //# sourceMappingURL=visualization.es549.js.map

package/dist/visualization.es549.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es549.js","sources":["../../../node_modules/.pnpm/framer-motion@12.38.0_@emotion+is-prop-valid@1.4.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs"],"sourcesContent":["/**\n * We keep these listed separately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nconst lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"switch\",\n    \"symbol\",\n    \"svg\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nexport { lowercaseSVGElements };\n//# sourceMappingURL=lowercase-elements.mjs.map\n"],"names":["lowercaseSVGElements"],"mappings":"AAIK,MAACA,IAAuB;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es549.js","sources":["../../../node_modules/.pnpm/framer-motion@12.38.0_@emotion+is-prop-valid@1.4.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs"],"sourcesContent":["import { createBox, frame, eachAxis, measurePageBox, convertBoxToBoundingBox, convertBoundingBoxToBox, addValueToWillChange, animateMotionValue, mixNumber, addDomEvent, setDragLock, percent, calcLength, resize, isElementTextInput } from 'motion-dom';\nimport { invariant } from 'motion-utils';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { getContextWindow } from '../../utils/get-context-window.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { PanSession } from '../pan/PanSession.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\n\nconst elementDragControls = new WeakMap();\nclass VisualElementDragControls {\n    constructor(visualElement) {\n        this.openDragLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        /**\n         * The latest pointer event. Used as fallback when the `cancel` and `stop` functions are called without arguments.\n         */\n        this.latestPointerEvent = null;\n        /**\n         * The latest pan info. Used as fallback when the `cancel` and `stop` functions are called without arguments.\n         */\n        this.latestPanInfo = null;\n        this.visualElement = visualElement;\n    }\n    start(originEvent, { snapToCursor = false, distanceThreshold } = {}) {\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        const { presenceContext } = this.visualElement;\n        if (presenceContext && presenceContext.isPresent === false)\n            return;\n        const onSessionStart = (event) => {\n            if (snapToCursor) {\n                this.snapToCursor(extractEventInfo(event).point);\n            }\n            this.stopAnimation();\n        };\n        const onStart = (event, info) => {\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            const { drag, dragPropagation, onDragStart } = this.getProps();\n            if (drag && !dragPropagation) {\n                if (this.openDragLock)\n                    this.openDragLock();\n                this.openDragLock = setDragLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!this.openDragLock)\n                    return;\n            }\n            this.latestPointerEvent = event;\n            this.latestPanInfo = info;\n            this.isDragging = true;\n            this.currentDirection = null;\n            this.resolveConstraints();\n            if (this.visualElement.projection) {\n                this.visualElement.projection.isAnimationBlocked = true;\n                this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin and pointer offset\n             */\n            eachAxis((axis) => {\n                let current = this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    const { projection } = this.visualElement;\n                    if (projection && projection.layout) {\n                        const measuredAxis = projection.layout.layoutBox[axis];\n                        if (measuredAxis) {\n                            const length = calcLength(measuredAxis);\n                            current = length * (parseFloat(current) / 100);\n                        }\n                    }\n                }\n                this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            if (onDragStart) {\n                frame.update(() => onDragStart(event, info), false, true);\n            }\n            addValueToWillChange(this.visualElement, \"transform\");\n            const { animationState } = this.visualElement;\n            animationState && animationState.setActive(\"whileDrag\", true);\n        };\n        const onMove = (event, info) => {\n            this.latestPointerEvent = event;\n            this.latestPanInfo = info;\n            const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !this.openDragLock)\n                return;\n            const { offset } = info;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && this.currentDirection === null) {\n                this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (this.currentDirection !== null) {\n                    onDirectionLock && onDirectionLock(this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            this.updateAxis(\"x\", info.point, offset);\n            this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            this.visualElement.render();\n            /**\n             * This must fire after the render call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            if (onDrag) {\n                frame.update(() => onDrag(event, info), false, true);\n            }\n        };\n        const onSessionEnd = (event, info) => {\n            this.latestPointerEvent = event;\n            this.latestPanInfo = info;\n            this.stop(event, info);\n            this.latestPointerEvent = null;\n            this.latestPanInfo = null;\n        };\n        const resumeAnimation = () => {\n            const { dragSnapToOrigin: snap } = this.getProps();\n            if (snap || this.constraints) {\n                this.startAnimation({ x: 0, y: 0 });\n            }\n        };\n        const { dragSnapToOrigin } = this.getProps();\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart,\n            onStart,\n            onMove,\n            onSessionEnd,\n            resumeAnimation,\n        }, {\n            transformPagePoint: this.visualElement.getTransformPagePoint(),\n            dragSnapToOrigin,\n            distanceThreshold,\n            contextWindow: getContextWindow(this.visualElement),\n            element: this.visualElement.current,\n        });\n    }\n    /**\n     * @internal\n     */\n    stop(event, panInfo) {\n        const finalEvent = event || this.latestPointerEvent;\n        const finalPanInfo = panInfo || this.latestPanInfo;\n        const isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging || !finalPanInfo || !finalEvent)\n            return;\n        const { velocity } = finalPanInfo;\n        this.startAnimation(velocity);\n        const { onDragEnd } = this.getProps();\n        if (onDragEnd) {\n            frame.postRender(() => onDragEnd(finalEvent, finalPanInfo));\n        }\n    }\n    /**\n     * @internal\n     */\n    cancel() {\n        this.isDragging = false;\n        const { projection, animationState } = this.visualElement;\n        if (projection) {\n            projection.isAnimationBlocked = false;\n        }\n        this.endPanSession();\n        const { dragPropagation } = this.getProps();\n        if (!dragPropagation && this.openDragLock) {\n            this.openDragLock();\n            this.openDragLock = null;\n        }\n        animationState && animationState.setActive(\"whileDrag\", false);\n    }\n    /**\n     * Clean up the pan session without modifying other drag state.\n     * This is used during unmount to ensure event listeners are removed\n     * without affecting projection animations or drag locks.\n     * @internal\n     */\n    endPanSession() {\n        this.panSession && this.panSession.end();\n        this.panSession = undefined;\n    }\n    updateAxis(axis, _point, offset) {\n        const { drag } = this.getProps();\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        const axisValue = this.getAxisMotionValue(axis);\n        let next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    }\n    resolveConstraints() {\n        const { dragConstraints, dragElastic } = this.getProps();\n        const layout = this.visualElement.projection &&\n            !this.visualElement.projection.layout\n            ? this.visualElement.projection.measure(false)\n            : this.visualElement.projection?.layout;\n        const prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.layoutBox, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative. This only applies to relative (non-ref)\n         * constraints, as ref-based constraints from calcViewportConstraints are already in the\n         * correct coordinate space for the motion value transform offset.\n         */\n        if (prevConstraints !== this.constraints &&\n            !isRefObject(dragConstraints) &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis((axis) => {\n                if (this.constraints !== false &&\n                    this.getAxisMotionValue(axis)) {\n                    this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);\n                }\n            });\n        }\n    }\n    resolveRefConstraints() {\n        const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        const constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\", \"drag-constraints-ref\");\n        const { projection } = this.visualElement;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    }\n    startAnimation(velocity) {\n        const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();\n        const constraints = this.constraints || {};\n        const momentumAnimations = eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, this.currentDirection)) {\n                return;\n            }\n            let transition = (constraints && constraints[axis]) || {};\n            if (dragSnapToOrigin === true ||\n                dragSnapToOrigin === axis)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            const bounceStiffness = dragElastic ? 200 : 1000000;\n            const bounceDamping = dragElastic ? 40 : 10000000;\n            const inertia = {\n                type: \"inertia\",\n                velocity: dragMomentum ? velocity[axis] : 0,\n                bounceStiffness,\n                bounceDamping,\n                timeConstant: 750,\n                restDelta: 1,\n                restSpeed: 10,\n                ...dragTransition,\n                ...transition,\n            };\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    }\n    startAxisValueAnimation(axis, transition) {\n        const axisValue = this.getAxisMotionValue(axis);\n        addValueToWillChange(this.visualElement, axis);\n        return axisValue.start(animateMotionValue(axis, axisValue, 0, transition, this.visualElement, false));\n    }\n    stopAnimation() {\n        eachAxis((axis) => this.getAxisMotionValue(axis).stop());\n    }\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    getAxisMotionValue(axis) {\n        const dragKey = `_drag${axis.toUpperCase()}`;\n        const props = this.visualElement.getProps();\n        const externalMotionValue = props[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (props.initial\n                ? props.initial[axis]\n                : undefined) || 0);\n    }\n    snapToCursor(point) {\n        eachAxis((axis) => {\n            const { drag } = this.getProps();\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, this.currentDirection))\n                return;\n            const { projection } = this.visualElement;\n            const axisValue = this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                const { min, max } = projection.layout.layoutBox[axis];\n                /**\n                 * The layout measurement includes the current transform value,\n                 * so we need to add it back to get the correct snap position.\n                 * This fixes an issue where elements with initial coordinates\n                 * would snap to the wrong position on the first drag.\n                 */\n                const current = axisValue.get() || 0;\n                axisValue.set(point[axis] - mixNumber(min, max, 0.5) + current);\n            }\n        });\n    }\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    scalePositionWithinConstraints() {\n        if (!this.visualElement.current)\n            return;\n        const { drag, dragConstraints } = this.getProps();\n        const { projection } = this.visualElement;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        const boxProgress = { x: 0, y: 0 };\n        eachAxis((axis) => {\n            const axisValue = this.getAxisMotionValue(axis);\n            if (axisValue && this.constraints !== false) {\n                const latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        const { transformTemplate } = this.visualElement.getProps();\n        this.visualElement.current.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        projection.root && projection.root.updateScroll();\n        projection.updateLayout();\n        /**\n         * Reset constraints so resolveConstraints() will recalculate them\n         * with the freshly measured layout rather than returning the cached value.\n         */\n        this.constraints = false;\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            const axisValue = this.getAxisMotionValue(axis);\n            const { min, max } = this.constraints[axis];\n            axisValue.set(mixNumber(min, max, boxProgress[axis]));\n        });\n        /**\n         * Flush the updated transform to the DOM synchronously to prevent\n         * a visual flash at the element's CSS layout position (0,0) when\n         * the transform was stripped for measurement.\n         */\n        this.visualElement.render();\n    }\n    addListeners() {\n        if (!this.visualElement.current)\n            return;\n        elementDragControls.set(this.visualElement, this);\n        const element = this.visualElement.current;\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        const stopPointerListener = addPointerEvent(element, \"pointerdown\", (event) => {\n            const { drag, dragListener = true } = this.getProps();\n            const target = event.target;\n            /**\n             * Only block drag if clicking on a text input child element\n             * (input, textarea, select, contenteditable) where users might\n             * want to select text or interact with the control.\n             *\n             * Buttons and links don't block drag since they don't have\n             * click-and-move actions of their own.\n             */\n            const isClickingTextInputChild = target !== element && isElementTextInput(target);\n            if (drag && dragListener && !isClickingTextInputChild) {\n                this.start(event);\n            }\n        });\n        /**\n         * If using ref-based constraints, observe both the draggable element\n         * and the constraint container for size changes via ResizeObserver.\n         * Setup is deferred because dragConstraints.current is null when\n         * addListeners first runs (React hasn't committed the ref yet).\n         */\n        let stopResizeObservers;\n        const measureDragConstraints = () => {\n            const { dragConstraints } = this.getProps();\n            if (isRefObject(dragConstraints) && dragConstraints.current) {\n                this.constraints = this.resolveRefConstraints();\n                if (!stopResizeObservers) {\n                    stopResizeObservers = startResizeObservers(element, dragConstraints.current, () => this.scalePositionWithinConstraints());\n                }\n            }\n        };\n        const { projection } = this.visualElement;\n        const stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            projection.root && projection.root.updateScroll();\n            projection.updateLayout();\n        }\n        frame.read(measureDragConstraints);\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        const stopResizeListener = addDomEvent(window, \"resize\", () => this.scalePositionWithinConstraints());\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        const stopLayoutUpdateListener = projection.addEventListener(\"didUpdate\", (({ delta, hasLayoutChanged }) => {\n            if (this.isDragging && hasLayoutChanged) {\n                eachAxis((axis) => {\n                    const motionValue = this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                this.visualElement.render();\n            }\n        }));\n        return () => {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n            stopLayoutUpdateListener && stopLayoutUpdateListener();\n            stopResizeObservers && stopResizeObservers();\n        };\n    }\n    getProps() {\n        const props = this.visualElement.getProps();\n        const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;\n        return {\n            ...props,\n            drag,\n            dragDirectionLock,\n            dragPropagation,\n            dragConstraints,\n            dragElastic,\n            dragMomentum,\n        };\n    }\n}\nfunction skipFirstCall(callback) {\n    let isFirst = true;\n    return () => {\n        if (isFirst) {\n            isFirst = false;\n            return;\n        }\n        callback();\n    };\n}\nfunction startResizeObservers(element, constraintsElement, onResize) {\n    const stopElement = resize(element, skipFirstCall(onResize));\n    const stopContainer = resize(constraintsElement, skipFirstCall(onResize));\n    return () => {\n        stopElement();\n        stopContainer();\n    };\n}\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold = 10) {\n    let direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\n//# sourceMappingURL=VisualElementDragControls.mjs.map\n"],"names":["elementDragControls","VisualElementDragControls","visualElement","createBox","originEvent","snapToCursor","distanceThreshold","presenceContext","onSessionStart","event","extractEventInfo","onStart","info","drag","dragPropagation","onDragStart","setDragLock","eachAxis","axis","current","percent","projection","measuredAxis","calcLength","frame","addValueToWillChange","animationState","onMove","dragDirectionLock","onDirectionLock","onDrag","offset","getCurrentDirection","onSessionEnd","resumeAnimation","snap","dragSnapToOrigin","PanSession","getContextWindow","panInfo","finalEvent","finalPanInfo","isDragging","velocity","onDragEnd","_point","shouldDrag","axisValue","next","applyConstraints","dragConstraints","dragElastic","layout","prevConstraints","isRefObject","calcRelativeConstraints","resolveDragElastic","rebaseAxisConstraints","constraints","onMeasureDragConstraints","constraintsElement","invariant","constraintsBox","measurePageBox","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","convertBoundingBoxToBox","dragMomentum","dragTransition","onDragTransitionEnd","momentumAnimations","transition","bounceStiffness","bounceDamping","inertia","animateMotionValue","dragKey","props","externalMotionValue","point","min","max","mixNumber","boxProgress","latest","calcOrigin","transformTemplate","element","stopPointerListener","addPointerEvent","dragListener","target","isClickingTextInputChild","isElementTextInput","stopResizeObservers","measureDragConstraints","startResizeObservers","stopMeasureLayoutListener","stopResizeListener","addDomEvent","stopLayoutUpdateListener","delta","hasLayoutChanged","motionValue","defaultElastic","skipFirstCall","callback","isFirst","onResize","stopElement","resize","stopContainer","direction","currentDirection","lockThreshold"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/visualization.es55.js

@@ -1,47 +1,55 @@
-import { useState as w, useEffect as O, useMemo as S } from "react";
-import j from "./visualization.es187.js";
-import L from "./visualization.es50.js";
-import M from "./visualization.es52.js";
-import R from "./visualization.es51.js";
-import { jsx as l } from "react/jsx-runtime";
-function k() {
-  let {
-    detectBounds: e = !0,
-    zIndex: n,
-    ...c
-  } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-  const [p, o, i] = j(c), [t, u] = w(!1);
-  O(() => {
-    u(!1);
-  }, []);
-  const d = S(() => function(f) {
-    let {
-      left: a = 0,
-      top: m = 0,
-      detectBounds: r,
-      // allow override at component-level
-      zIndex: s,
-      // allow override at the component-level
-      ...I
-    } = f;
-    const x = r ?? e, B = s ?? n, T = x ? R : M, z = t ? 0 : window.scrollX, P = t ? 0 : window.scrollY, g = a + (o.left || 0) + z, h = m + (o.top || 0) + P;
-    return /* @__PURE__ */ l(L, {
-      zIndex: B,
-      children: /* @__PURE__ */ l(T, {
-        left: g,
-        top: h,
-        ...I
-      })
+import { jsxs as m, jsx as o } from "react/jsx-runtime";
+import Y from "./visualization.es119.js";
+import { truncateTextToWidth as j, getLabelPlacement as A } from "./visualization.es120.js";
+import D, { useCallback as R } from "react";
+import E from "./visualization.es35.js";
+import F from "./visualization.es22.js";
+import $ from "./visualization.es50.js";
+const Z = (t) => {
+  function i(e) {
+    return e.children && e.children.length > 0 ? e.children.reduce((d, X) => d + i(X), 0) : e.data.value ?? 0;
+  }
+  const c = t.node.children !== void 0 && t.node.children.length > 0, r = c ? t.node.data.displayValue ?? i(t.node) : t.node.data.value ?? 0, k = t.fontSize, n = t.node.data.style?.color || t.node.parent?.data.style?.color || "black", h = t.node.data.style?.labelColor || n, x = t.node.data.style?.strokeColor || n, u = t.node.data.style?.strokeWidth === 0 ? 0 : t.node.data.style?.strokeWidth || t.strokeWidth, v = t.isHovered ? u + 2 : u, l = t.node.x1 - t.node.x0, a = t.node.y1 - t.node.y0, b = t.node.data.label, C = j(b, l - 8, k, "sans-serif"), f = a > 55 && l > 50 && r > 0, g = a > 20, {
+    textX: T,
+    textY: S,
+    textAnchor: W,
+    valueAnchor: B,
+    baseline: L,
+    valueY: M,
+    valueX: w
+  } = A(t.node, t.labelPlacement, f, c), {
+    tooltipData: s,
+    tooltipLeft: N,
+    tooltipTop: z,
+    tooltipOpen: V,
+    showTooltip: y,
+    hideTooltip: H
+  } = E(), O = R((e) => {
+    if (!t.tooltipBody) return;
+    const d = t.tooltipBody(t.node.data);
+    y({
+      tooltipLeft: e.clientX + 10,
+      tooltipTop: e.clientY + 10,
+      tooltipData: d
     });
-  }, [e, n, o.left, o.top, t]);
-  return {
-    containerRef: p,
-    containerBounds: o,
-    forceRefreshBounds: i,
-    TooltipInPortal: d
+  }, [t.tooltipBody, t.node.data, y]), P = () => {
+    t.onNodeClicked && t.onNodeClicked(t.node.data);
   };
-}
+  return /* @__PURE__ */ m(D.Fragment, { children: [
+    /* @__PURE__ */ m("g", { onMouseEnter: () => t.onHover(!0), onMouseLeave: () => {
+      t.onHover(!1), H?.();
+    }, onMouseMove: O, onClick: P, style: {
+      cursor: "pointer",
+      transition: "stroke-width 0.2s"
+    }, children: [
+      /* @__PURE__ */ o("rect", { x: t.node.x0, y: t.node.y0, width: l, height: a, fill: n, fillOpacity: t.opacity, stroke: x, strokeWidth: v, rx: t.borderRadius }),
+      g && /* @__PURE__ */ o("text", { x: T, y: S, textAnchor: W, dominantBaseline: L, fill: h, fontSize: t.fontSize, fontWeight: 500, children: C }),
+      f && /* @__PURE__ */ o(Y, { cx: w, cy: M, color: h, value: r, align: B })
+    ] }),
+    t.tooltipBody && V && s && /* @__PURE__ */ o(F, { children: /* @__PURE__ */ o($, { left: (N ?? 0) + 10, top: z, children: s }) })
+  ] }, `frag-${t.node.data.label}`);
+};
 export {
-  k as default
+  Z as default
 };
 //# sourceMappingURL=visualization.es55.js.map

package/dist/visualization.es55.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es55.js","sources":["../../../node_modules/.pnpm/@visx+tooltip@4.0.0_@types+react-dom@19.2.3_@types+react@19.2.14__@types+react@19.2.14__1992a6888b9348459183e160bdb98c40/node_modules/@visx/tooltip/esm/hooks/useTooltipInPortal.js"],"sourcesContent":["import { useEffect, useMemo, useState } from 'react';\nimport useMeasure from 'react-use-measure';\nimport Portal from \"../Portal.js\";\nimport Tooltip from \"../tooltips/Tooltip.js\";\nimport TooltipWithBounds from \"../tooltips/TooltipWithBounds.js\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n/**\n * Hook that handles rendering of a Tooltip or TooltipWithBounds in a Portal.\n * Handles conversion of container coordinates to page coordinates using the container bounds.\n */\nexport default function useTooltipInPortal() {\n  let {\n    detectBounds: detectBoundsOption = true,\n    zIndex: zIndexOption,\n    ...useMeasureOptions\n  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  const [containerRef, containerBounds, forceRefreshBounds] = useMeasure(useMeasureOptions);\n  const [isSsr, setIsSsr] = useState(false);\n  useEffect(() => {\n    setIsSsr(false);\n  }, []);\n  const TooltipInPortal = useMemo(() => function (_ref) {\n    let {\n      left: containerLeft = 0,\n      top: containerTop = 0,\n      detectBounds: detectBoundsProp,\n      // allow override at component-level\n      zIndex: zIndexProp,\n      // allow override at the component-level\n      ...tooltipProps\n    } = _ref;\n    const detectBounds = detectBoundsProp == null ? detectBoundsOption : detectBoundsProp;\n    const zIndex = zIndexProp == null ? zIndexOption : zIndexProp;\n    const TooltipComponent = detectBounds ? TooltipWithBounds : Tooltip;\n    // convert container coordinates to page coordinates\n    const scrollX = isSsr ? 0 : window.scrollX;\n    const scrollY = isSsr ? 0 : window.scrollY;\n    const portalLeft = containerLeft + (containerBounds.left || 0) + scrollX;\n    const portalTop = containerTop + (containerBounds.top || 0) + scrollY;\n    return /*#__PURE__*/_jsx(Portal, {\n      zIndex: zIndex,\n      children: /*#__PURE__*/_jsx(TooltipComponent, {\n        left: portalLeft,\n        top: portalTop,\n        ...tooltipProps\n      })\n    });\n  }, [detectBoundsOption, zIndexOption, containerBounds.left, containerBounds.top, isSsr]);\n  return {\n    containerRef,\n    containerBounds,\n    forceRefreshBounds,\n    TooltipInPortal\n  };\n}"],"names":["useTooltipInPortal","detectBoundsOption","zIndexOption","useMeasureOptions","containerRef","containerBounds","forceRefreshBounds","useMeasure","isSsr","setIsSsr","useState","useEffect","TooltipInPortal","useMemo","_ref","containerLeft","containerTop","detectBoundsProp","zIndexProp","tooltipProps","detectBounds","zIndex","TooltipComponent","TooltipWithBounds","Tooltip","scrollX","scrollY","portalLeft","portalTop","_jsx","Portal"],"mappings":";;;;;;AAUe,SAASA,IAAqB;AAC3C,MAAI;AAAA,IACF,cAAcC,IAAqB;AAAA,IACnC,QAAQC;AAAA,IACR,GAAGC;AAAA,EACP,IAAM,UAAU,SAAS,KAAK,UAAU,CAAC,MAAM,SAAY,UAAU,CAAC,IAAI,CAAA;AACxE,QAAM,CAACC,GAAcC,GAAiBC,CAAkB,IAAIC,EAAWJ,CAAiB,GAClF,CAACK,GAAOC,CAAQ,IAAIC,EAAS,EAAK;AACxC,EAAAC,EAAU,MAAM;AACd,IAAAF,EAAS,EAAK;AAAA,EAChB,GAAG,CAAA,CAAE;AACL,QAAMG,IAAkBC,EAAQ,MAAM,SAAUC,GAAM;AACpD,QAAI;AAAA,MACF,MAAMC,IAAgB;AAAA,MACtB,KAAKC,IAAe;AAAA,MACpB,cAAcC;AAAA;AAAA,MAEd,QAAQC;AAAA;AAAA,MAER,GAAGC;AAAA,IACT,IAAQL;AACJ,UAAMM,IAAeH,KAA2BhB,GAC1CoB,IAASH,KAAqBhB,GAC9BoB,IAAmBF,IAAeG,IAAoBC,GAEtDC,IAAUjB,IAAQ,IAAI,OAAO,SAC7BkB,IAAUlB,IAAQ,IAAI,OAAO,SAC7BmB,IAAaZ,KAAiBV,EAAgB,QAAQ,KAAKoB,GAC3DG,IAAYZ,KAAgBX,EAAgB,OAAO,KAAKqB;AAC9D,WAAoBG,gBAAAA,EAAKC,GAAQ;AAAA,MAC/B,QAAQT;AAAA,MACR,UAAuBQ,gBAAAA,EAAKP,GAAkB;AAAA,QAC5C,MAAMK;AAAA,QACN,KAAKC;AAAA,QACL,GAAGT;AAAA,MACX,CAAO;AAAA,IACP,CAAK;AAAA,EACH,GAAG,CAAClB,GAAoBC,GAAcG,EAAgB,MAAMA,EAAgB,KAAKG,CAAK,CAAC;AACvF,SAAO;AAAA,IACL,cAAAJ;AAAA,IACA,iBAAAC;AAAA,IACA,oBAAAC;AAAA,IACA,iBAAAM;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es55.js","sources":["../src/components/TreeMap/SingleNode.tsx"],"sourcesContent":["import { SingleNodeProps, TreemapNode } from \"./types\";\nimport ValueOval from \"./ValueOval\";\nimport { getLabelPlacement, truncateTextToWidth } from \"./helpers\";\nimport { ReactNode, useCallback } from \"react\";\nimport { Portal, TooltipWithBounds, useTooltip } from \"@visx/tooltip\";\nimport React from \"react\";\nimport { HierarchyRectangularNode } from \"@visx/hierarchy\";\n\nconst SingleNode = <T,>(\n    props: SingleNodeProps<T>\n) => {\n    function getNodeValue(node: HierarchyRectangularNode<TreemapNode<T>>): number {\n        // If the node has children, sum their values\n        if (node.children && node.children.length > 0) {\n            return node.children.reduce((sum: number, child) => {\n                return sum + getNodeValue(child);\n            }, 0);\n        }\n\n        // Otherwise use the leaf's data value\n        return node.data.value ?? 0;\n    }\n\n    const hasChildren = props.node.children !== undefined && props.node.children.length > 0;\n    \n    const value = hasChildren ? props.node.data.displayValue ?? getNodeValue(props.node) : props.node.data.value ?? 0\n\n    const fontSize = props.fontSize\n    const nodeColor = props.node.data.style?.color ||  props.node.parent?.data.style?.color || \"black\"\n    const labelColor = props.node.data.style?.labelColor || nodeColor;\n    const nodeStrokeColor = props.node.data.style?.strokeColor || nodeColor;\n    const nodeStroke = props.node.data.style?.strokeWidth === 0 ? 0 : props.node.data.style?.strokeWidth || props.strokeWidth;\n    const stroke = props.isHovered ? nodeStroke + 2 : nodeStroke;\n\n    const width = props.node.x1 - props.node.x0;\n    const height = props.node.y1 - props.node.y0;\n\n    const fullLabel = props.node.data.label;\n    const truncatedLabel = truncateTextToWidth(fullLabel, width - 8, fontSize, \"sans-serif\");\n    const showValue = height > 55 && width > 50 && value > 0;\n    const showText = height > 20;\n\n    const { textX, textY, textAnchor, valueAnchor, baseline, valueY, valueX } = getLabelPlacement(\n        props.node,\n        props.labelPlacement,\n        showValue,\n        hasChildren\n    );\n\n    const {\n        tooltipData,\n        tooltipLeft,\n        tooltipTop,\n        tooltipOpen,\n        showTooltip,\n        hideTooltip,\n    } = useTooltip<ReactNode>();\n\n    const handleMouseMove = useCallback(\n        (event: React.MouseEvent<SVGElement>) => {\n            if (!props.tooltipBody) return;\n\n            const tooltipContent = props.tooltipBody(props.node.data);\n\n            showTooltip({\n                tooltipLeft: event.clientX + 10,\n                tooltipTop: event.clientY + 10,\n                tooltipData: tooltipContent,\n            });\n        },\n        [props.tooltipBody, props.node.data, showTooltip]\n    );\n\n    const handleNodeClick = () => {\n        if (!props.onNodeClicked) return;\n        props.onNodeClicked(props.node.data);\n    };\n\n    return (\n        <React.Fragment key={`frag-${props.node.data.label}`}>\n            <g\n                onMouseEnter={() => props.onHover(true)}\n                onMouseLeave={() => {\n                    props.onHover(false);\n                    hideTooltip?.();\n                }}\n                onMouseMove={handleMouseMove}\n                onClick={handleNodeClick}\n                style={{ cursor: \"pointer\", transition: \"stroke-width 0.2s\" }}\n            >\n                <rect\n                    x={props.node.x0}\n                    y={props.node.y0}\n                    width={width}\n                    height={height}\n                    fill={nodeColor}\n                    fillOpacity={props.opacity}\n                    stroke={nodeStrokeColor}\n                    strokeWidth={stroke}\n                    rx={props.borderRadius}\n                />\n                {showText && (\n                    <text\n                        x={textX}\n                        y={textY}\n                        textAnchor={textAnchor}\n                        dominantBaseline={baseline}\n                        fill={labelColor}\n                        fontSize={props.fontSize}\n                        fontWeight={500}\n                    >\n                        {truncatedLabel}\n                    </text>\n                )}\n                {showValue && (\n                    <ValueOval\n                        cx={valueX}\n                        cy={valueY}\n                        color={labelColor}\n                        value={value}\n                        align={valueAnchor}\n                    />\n                )}\n            </g>\n            {props.tooltipBody && tooltipOpen && tooltipData && (\n                <Portal>\n                    <TooltipWithBounds left={(tooltipLeft ?? 0) + 10} top={tooltipTop}>\n                        {tooltipData}\n                    </TooltipWithBounds>\n                </Portal>\n            )}\n        </React.Fragment>\n    );\n};\n\nexport default SingleNode;"],"names":["SingleNode","props","getNodeValue","node","children","length","reduce","sum","child","data","value","hasChildren","undefined","displayValue","fontSize","nodeColor","style","color","parent","labelColor","nodeStrokeColor","strokeColor","nodeStroke","strokeWidth","stroke","isHovered","width","x1","x0","height","y1","y0","fullLabel","label","truncatedLabel","truncateTextToWidth","showValue","showText","textX","textY","textAnchor","valueAnchor","baseline","valueY","valueX","getLabelPlacement","labelPlacement","tooltipData","tooltipLeft","tooltipTop","tooltipOpen","showTooltip","hideTooltip","useTooltip","handleMouseMove","useCallback","event","tooltipBody","tooltipContent","clientX","clientY","handleNodeClick","onNodeClicked","jsxs","React","onHover","cursor","transition","jsx","opacity","borderRadius","ValueOval","Portal","TooltipWithBounds"],"mappings":"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"}

package/dist/visualization.es550.js

@@ -1,8 +1,5 @@
-import { complex as e } from "./visualization.es397.js";
-const n = (r, t) => t === "zIndex" ? !1 : !!(typeof r == "number" || Array.isArray(r) || typeof r == "string" && // It's animatable if we have a string
-(e.test(r) || r === "0") && // And it contains numbers and/or colors
-!r.startsWith("url("));
+const t = ({ current: e }) => e ? e.ownerDocument.defaultView : null;
 export {
-  n as isAnimatable
+  t as getContextWindow
 };
 //# sourceMappingURL=visualization.es550.js.map

package/dist/visualization.es550.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es550.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/utils/is-animatable.mjs"],"sourcesContent":["import { complex } from '../../value/types/complex/index.mjs';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nconst isAnimatable = (value, name) => {\n    // If the list of keys that might be non-animatable grows, replace with Set\n    if (name === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        (complex.test(value) || value === \"0\") && // And it contains numbers and/or colors\n        !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n    ) {\n        return true;\n    }\n    return false;\n};\n\nexport { isAnimatable };\n//# sourceMappingURL=is-animatable.mjs.map\n"],"names":["isAnimatable","value","name","complex"],"mappings":";AAWK,MAACA,IAAe,CAACC,GAAOC,MAErBA,MAAS,WACF,KAIP,UAAOD,KAAU,YAAY,MAAM,QAAQA,CAAK,KAEhD,OAAOA,KAAU;AAAA,CAChBE,EAAQ,KAAKF,CAAK,KAAKA,MAAU;AAClC,CAACA,EAAM,WAAW,MAAM;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es550.js","sources":["../../../node_modules/.pnpm/framer-motion@12.38.0_@emotion+is-prop-valid@1.4.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/utils/get-context-window.mjs"],"sourcesContent":["// Fixes https://github.com/motiondivision/motion/issues/2270\nconst getContextWindow = ({ current }) => {\n    return current ? current.ownerDocument.defaultView : null;\n};\n\nexport { getContextWindow };\n//# sourceMappingURL=get-context-window.mjs.map\n"],"names":["getContextWindow","current"],"mappings":"AACK,MAACA,IAAmB,CAAC,EAAE,SAAAC,QACjBA,IAAUA,EAAQ,cAAc,cAAc;","x_google_ignoreList":[0]}