impact-nova 2.6.3 → 3.0.0-alpha.0

package/dist/components/data-display/globe-map/internals/use-globe-map-scene.js

@@ -0,0 +1,270 @@
+import * as e from "react";
+import { MeshBasicMaterial as T } from "three";
+import { createGlobeOceanTexture as N, resolveGlobeColor as F, applyGlobePinAppearance as H, createGlobePinElement as V, GLOBE_TRANSPARENT as _, globeLandColorForFeature as W, prefersGlobeReducedMotion as X, GLOBE_MAP_REGION_VIEWS as q, cameraDurationMs as A, GLOBE_MAP_SELECTED_ALTITUDE as U, readGlobeMapThemeColors as Y, GLOBE_MAP_MAX_PIXEL_RATIO as Z, globeControlDistances as j } from "../globe-map.utils.js";
+const J = [], se = {
+  antialias: !0,
+  alpha: !0,
+  powerPreference: "high-performance",
+  stencil: !1,
+  depth: !0
+};
+function K(o, n) {
+  o.renderer().setPixelRatio(Math.min(window.devicePixelRatio || 1, Z));
+  const t = o.controls();
+  t.enableDamping = !0, t.dampingFactor = 0.06, t.rotateSpeed = 0.45, t.zoomSpeed = 0.55, t.enablePan = !1, t.enableZoom = !0;
+  const r = j(o.getGlobeRadius());
+  t.minDistance = r.minDistance, t.maxDistance = r.maxDistance, t.autoRotate = n(), t.autoRotateSpeed = 0.28;
+  const i = () => {
+    t.autoRotate = !1;
+  }, c = () => {
+    t.autoRotate = n();
+  };
+  return t.addEventListener("start", i), t.addEventListener("end", c), () => {
+    t.removeEventListener("start", i), t.removeEventListener("end", c);
+  };
+}
+function B(o) {
+  if (typeof document > "u" || !document.body) return null;
+  try {
+    return Y(o);
+  } catch {
+    return null;
+  }
+}
+function Q(o) {
+  const [n, a] = e.useState(
+    () => B(o)
+  );
+  return e.useLayoutEffect(() => {
+    const t = () => a(B(o));
+    t();
+    const r = new MutationObserver(t);
+    return r.observe(document.documentElement, {
+      attributes: !0,
+      attributeFilter: ["class", "style"]
+    }), () => r.disconnect();
+  }, [o]), n;
+}
+function $(o) {
+  const [n, a] = e.useState({ width: 0, height: 0 });
+  return e.useLayoutEffect(() => {
+    const t = o.current;
+    if (!t) return;
+    const r = (c, u) => {
+      const l = Math.round(c), m = Math.round(u);
+      a(
+        (R) => Math.abs(R.width - l) < 1 && Math.abs(R.height - m) < 1 ? R : { width: l, height: m }
+      );
+    };
+    r(t.clientWidth, t.clientHeight);
+    const i = new ResizeObserver((c) => {
+      const u = c[0];
+      u && r(u.contentRect.width, u.contentRect.height);
+    });
+    return i.observe(t), () => i.disconnect();
+  }, [o]), n;
+}
+function ee(o) {
+  const { globeRef: n, region: a, selectedPoint: t, autoRotate: r } = o, i = e.useRef(r), c = e.useRef(!1), u = e.useRef(a), l = e.useRef(!0), m = e.useRef(null), R = e.useRef(null), [b, P] = e.useState(!1);
+  e.useLayoutEffect(() => {
+    i.current = r, u.current = a;
+  }, [r, a]);
+  const s = e.useCallback(
+    () => i.current && !c.current && !X(),
+    []
+  ), g = e.useCallback(() => {
+    const d = n.current;
+    d && (d.controls().autoRotate = s());
+  }, [s, n]), E = e.useCallback((d) => {
+    const L = n.current;
+    if (!L) return;
+    const M = q[u.current];
+    L.pointOfView(
+      { lat: M.latitude, lng: M.longitude, altitude: M.altitude },
+      d
+    );
+  }, [n]), w = e.useCallback(() => {
+    const d = n.current;
+    d && (R.current?.(), R.current = K(d, s), E(0), m.current = u.current, l.current = !0, P(!0));
+  }, [E, s, n]);
+  e.useEffect(() => () => R.current?.(), []), e.useEffect(() => {
+    b && g();
+  }, [g, r, b]), e.useEffect(() => {
+    !b || m.current === a || (m.current = a, E(A()));
+  }, [E, b, a]), e.useEffect(() => {
+    const d = n.current;
+    if (!(!d || !b)) {
+      if (l.current) {
+        l.current = !1;
+        return;
+      }
+      if (!t) {
+        E(A());
+        return;
+      }
+      d.pointOfView(
+        {
+          lat: t.latitude,
+          lng: t.longitude,
+          altitude: U
+        },
+        A()
+      );
+    }
+  }, [E, n, b, t]);
+  const O = e.useCallback(() => {
+    c.current = !0, g();
+  }, [g]), G = e.useCallback(() => {
+    c.current = !1, g();
+  }, [g]);
+  return { handleGlobeReady: w, handlePointerEnter: O, handlePointerLeave: G, isReady: b };
+}
+function te(o, n, a) {
+  e.useEffect(() => {
+    const t = o.current;
+    if (!t || !a) return;
+    const r = new IntersectionObserver(
+      ([c]) => {
+        const u = n.current;
+        u && (c?.isIntersecting && !document.hidden ? u.resumeAnimation() : u.pauseAnimation());
+      },
+      { threshold: 0.05 }
+    );
+    r.observe(t);
+    const i = () => {
+      const c = n.current;
+      c && (document.hidden ? c.pauseAnimation() : c.resumeAnimation());
+    };
+    return document.addEventListener("visibilitychange", i), () => {
+      r.disconnect(), document.removeEventListener("visibilitychange", i);
+    };
+  }, [n, a, o]);
+}
+function ne(o, n) {
+  o.style.opacity = n ? "1" : "0", o.style.pointerEvents = n ? "auto" : "none";
+}
+function ce(o) {
+  const {
+    region: n,
+    variant: a,
+    scenePoints: t,
+    selectedPoint: r,
+    autoRotate: i,
+    onPointClick: c,
+    onPointHover: u
+  } = o, l = e.useRef(null), m = e.useRef(void 0), R = e.useRef(c), b = e.useRef(u), P = e.useRef(r?.id ?? null), s = Q(a), g = $(l), { handleGlobeReady: E, handlePointerEnter: w, handlePointerLeave: O, isReady: G } = ee({
+    globeRef: m,
+    region: n,
+    selectedPoint: r,
+    autoRotate: i
+  });
+  te(l, m, G), e.useLayoutEffect(() => {
+    R.current = c, b.current = u, P.current = r?.id ?? null;
+  }, [c, u, r?.id]);
+  const d = e.useMemo(
+    () => s ? N(s.oceanMid) : "",
+    [s]
+  ), L = e.useMemo(() => {
+    if (s)
+      return new T({ color: s.oceanMid });
+  }, [s]), M = e.useMemo(() => s ? t.map((f) => ({
+    ...f,
+    color: F(f.color, s.brand)
+  })) : J, [t, s]);
+  e.useEffect(() => {
+    const f = l.current;
+    if (!f) return;
+    const p = r?.id ?? null;
+    f.querySelectorAll("[data-component='globe-map-pin']").forEach((h) => {
+      H(
+        h,
+        h.dataset.pointId === p,
+        h.dataset.pinColor ?? ""
+      );
+    });
+  }, [r?.id]);
+  const D = e.useCallback((f) => {
+    const p = f;
+    return V({
+      point: p,
+      selected: p.id === P.current,
+      onClick: (h, y, v) => {
+        const C = l.current?.getBoundingClientRect();
+        R.current(
+          h,
+          y - (C?.left ?? 0),
+          v - (C?.top ?? 0)
+        );
+      },
+      onHover: (h, y, v) => {
+        if (!h) {
+          b.current(null, 0, 0);
+          return;
+        }
+        const C = l.current?.getBoundingClientRect();
+        b.current(
+          h,
+          y - (C?.left ?? 0),
+          v - (C?.top ?? 0)
+        );
+      }
+    });
+  }, []), S = e.useRef(/* @__PURE__ */ new Map());
+  e.useEffect(
+    () => () => {
+      S.current.forEach((f) => f.dispose()), S.current.clear();
+    },
+    [s, a]
+  );
+  const k = e.useCallback(
+    (f) => s ? W(
+      f,
+      s,
+      a
+    ) : _,
+    [s, a]
+  ), I = e.useCallback(
+    (f) => {
+      const p = k(f), h = S.current.get(p);
+      if (h) return h;
+      const y = p.match(
+        /rgba\(\s*[\d.]+\s*,\s*[\d.]+\s*,\s*[\d.]+\s*,\s*([\d.]+)\s*\)/i
+      ), v = y ? Number(y[1]) : 1, C = new T({
+        color: p,
+        transparent: v < 1,
+        opacity: v,
+        depthWrite: !1
+      });
+      return S.current.set(p, C), C;
+    },
+    [k]
+  ), x = e.useCallback(
+    () => s?.border ?? _,
+    [s]
+  ), z = e.useCallback(() => "", []);
+  return {
+    stageRef: l,
+    globeRef: m,
+    stageSize: g,
+    oceanTexture: d,
+    globeSurfaceMaterial: L,
+    coloredPoints: M,
+    handleGlobeReady: E,
+    handlePointerEnter: w,
+    handlePointerLeave: O,
+    htmlElement: D,
+    hideBackFacingPin: ne,
+    landColor: k,
+    landMaterial: I,
+    borderColor: x,
+    emptyLabel: z,
+    isReady: G,
+    canRenderGlobe: !!(s && d && g.width > 0 && g.height > 0)
+  };
+}
+export {
+  J as EMPTY_GLOBE_POINTS,
+  se as GLOBE_RENDERER_CONFIG,
+  _ as GLOBE_TRANSPARENT,
+  ce as useGlobeMapScene
+};

package/dist/components/data-display/hex-tilemap/hex-tilemap.d.ts

@@ -0,0 +1,9 @@
+import { HexTilemapProps } from './hex-tilemap.types';
+import * as React from "react";
+export type { HexTilemapHoverPoint, HexTilemapPoint, HexTilemapProps, HexTilemapRegion, HexTilemapSeries, HexTilemapLegendProps, HexTilemapViewportProps, HexTilemapZoomProps, } from './hex-tilemap.types';
+export { HexTilemapLegend } from './internals/hex-tilemap-legend';
+export { HexTilemapViewport } from './internals/hex-tilemap-viewport';
+export { HexTilemapZoom } from './internals/hex-tilemap-zoom';
+export { HexTilemapTooltip } from './internals/hex-tilemap-tooltip';
+declare const HexTilemap: React.ForwardRefExoticComponent<HexTilemapProps & React.RefAttributes<HTMLDivElement>>;
+export { HexTilemap };

package/dist/components/data-display/hex-tilemap/hex-tilemap.js

@@ -0,0 +1,94 @@
+import { jsx as r, jsxs as N, Fragment as O } from "react/jsx-runtime";
+import * as t from "react";
+import { useControllableState as c } from "@radix-ui/react-use-controllable-state";
+import { createComponent as R } from "../../../lib/primitives/create-component.js";
+import { cn as _ } from "../../../lib/utils.js";
+import { useImpactNovaI18n as k } from "../../../i18n/use-impact-nova-i18n.js";
+import { hexTilemapRootVariants as A } from "./hex-tilemap.variants.js";
+import { HEX_ZOOM_DEFAULT as D } from "./internals/hex-camera.js";
+import { layoutHexTilemap as U } from "./internals/hex-layout.js";
+import { HexTilemapProvider as X } from "./internals/hex-tilemap-context.js";
+import { HexTilemapLegend as Z } from "./internals/hex-tilemap-legend.js";
+import { HexTilemapViewport as q } from "./internals/hex-tilemap-viewport.js";
+const re = R(
+  "HexTilemap",
+  ({
+    className: d,
+    children: u,
+    region: m = "world",
+    points: i = [],
+    series: f = [],
+    metricLabel: h = "Value",
+    formatValue: x = String,
+    zoom: S,
+    defaultZoom: s = D,
+    onZoomChange: H,
+    hiddenSeriesIds: T,
+    defaultHiddenSeriesIds: v = [],
+    onHiddenSeriesIdsChange: b,
+    height: P,
+    "aria-label": g,
+    ...C
+  }, I) => {
+    const { t: L } = k(), [M, w] = c({
+      prop: S,
+      defaultProp: s,
+      onChange: H
+    }), [e, l] = c({
+      prop: T,
+      defaultProp: v,
+      onChange: b
+    }), [z, V] = t.useState(null), a = t.useMemo(() => U(m, i), [i, m]), p = t.useMemo(
+      () => new Set(e ?? []),
+      [e]
+    ), j = t.useMemo(
+      () => a.points.filter((o) => !p.has(o.seriesId)),
+      [p, a.points]
+    ), y = t.useCallback(
+      (o) => {
+        const n = e ?? [], E = n.includes(o) ? n.filter((F) => F !== o) : [...n, o];
+        l(E);
+      },
+      [e, l]
+    );
+    return /* @__PURE__ */ r(
+      X,
+      {
+        value: {
+          region: m,
+          points: i,
+          series: f,
+          layout: a,
+          visiblePoints: j,
+          metricLabel: h,
+          formatValue: x,
+          zoom: M ?? s,
+          setZoom: w,
+          hiddenSeriesIds: e ?? [],
+          toggleSeries: y,
+          hoverPoint: z,
+          setHoverPoint: V,
+          mapLabel: g ?? L("hexTilemap.mapLabel")
+        },
+        children: /* @__PURE__ */ r(
+          "div",
+          {
+            ref: I,
+            "data-component": "hex-tilemap",
+            className: _(A(), d),
+            ...C,
+            children: u ?? /* @__PURE__ */ N(O, { children: [
+              /* @__PURE__ */ r(q, { height: P }),
+              /* @__PURE__ */ r(Z, {})
+            ] })
+          }
+        )
+      }
+    );
+  }
+);
+export {
+  re as HexTilemap,
+  Z as HexTilemapLegend,
+  q as HexTilemapViewport
+};

package/dist/components/data-display/hex-tilemap/hex-tilemap.stories-data.d.ts

@@ -0,0 +1,7 @@
+import { HexTilemapPoint, HexTilemapSeries } from './hex-tilemap.types';
+export declare const PERFORMANCE_SERIES: HexTilemapSeries[];
+export declare const WORLD_POINTS: HexTilemapPoint[];
+export declare const NEW_ZEALAND_POINTS: HexTilemapPoint[];
+export declare const UNITED_STATES_POINTS: HexTilemapPoint[];
+export declare const UNITED_STATES_AND_EUROPE_POINTS: HexTilemapPoint[];
+export declare const INSIGHT_TEXT = "Premium is the strongest cluster at 78% avg ST vs a 69% plan. Outlet is weakest at 56%. The 21pp spread between clusters is wide enough to act on.";

package/dist/components/data-display/hex-tilemap/hex-tilemap.types.d.ts

@@ -0,0 +1,43 @@
+import type * as React from "react";
+export type HexTilemapRegion = "world" | "new-zealand" | "united-states" | "united-states-and-europe";
+export interface HexTilemapPoint {
+    id: string;
+    latitude: number;
+    longitude: number;
+    value: number;
+    label: string;
+    seriesId: string;
+}
+export interface HexTilemapSeries {
+    id: string;
+    label: string;
+    color: string;
+}
+export interface HexTilemapHoverPoint {
+    id: string;
+    label: string;
+    value: number;
+    seriesId: string;
+    clientX: number;
+    clientY: number;
+}
+export interface HexTilemapProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    region?: HexTilemapRegion;
+    points?: HexTilemapPoint[];
+    series?: HexTilemapSeries[];
+    metricLabel?: string;
+    formatValue?: (value: number) => string;
+    zoom?: number;
+    defaultZoom?: number;
+    onZoomChange?: (zoom: number) => void;
+    hiddenSeriesIds?: string[];
+    defaultHiddenSeriesIds?: string[];
+    onHiddenSeriesIdsChange?: (hiddenSeriesIds: string[]) => void;
+    height?: number;
+    "aria-label"?: string;
+}
+export interface HexTilemapViewportProps extends React.HTMLAttributes<HTMLDivElement> {
+    height?: number;
+}
+export type HexTilemapLegendProps = React.HTMLAttributes<HTMLDivElement>;
+export type HexTilemapZoomProps = React.HTMLAttributes<HTMLDivElement>;

package/dist/components/data-display/hex-tilemap/hex-tilemap.variants.d.ts

@@ -0,0 +1,11 @@
+export declare const hexTilemapRootVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const hexTilemapViewportVariants: (props?: ({
+    panning?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const hexTilemapLegendVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const hexTilemapLegendItemVariants: (props?: ({
+    hidden?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const hexTilemapZoomVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const hexTilemapZoomButtonVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const hexTilemapTooltipVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;

package/dist/components/data-display/hex-tilemap/hex-tilemap.variants.js

@@ -0,0 +1,47 @@
+import { cva as e } from "class-variance-authority";
+const o = e(
+  "flex w-full min-w-0 flex-col items-center gap-3"
+), t = e(
+  "relative w-full min-w-0 overflow-hidden rounded-lg bg-brand-tint overscroll-none touch-none select-none motion-reduce:scroll-auto",
+  {
+    variants: {
+      panning: {
+        true: "cursor-grabbing",
+        false: "cursor-grab"
+      }
+    },
+    defaultVariants: {
+      panning: !1
+    }
+  }
+), i = e(
+  "flex w-full flex-wrap items-center justify-center gap-6"
+), a = e(
+  "inline-flex items-center gap-1.5 rounded-sm text-xs font-medium leading-4 text-secondary-foreground capitalize focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring motion-reduce:transition-none",
+  {
+    variants: {
+      hidden: {
+        true: "opacity-40 line-through",
+        false: "opacity-100"
+      }
+    },
+    defaultVariants: {
+      hidden: !1
+    }
+  }
+), r = e(
+  "absolute bottom-2 end-2 z-[2] flex h-10 items-center gap-0.5 rounded-full border border-stroke bg-canvas-elevated py-1 ps-1 pe-4 shadow-elevation-floating"
+), s = e(
+  "inline-flex max-h-8 items-center justify-center rounded-lg p-2 text-secondary-foreground hover:bg-canvas-muted disabled:cursor-default disabled:opacity-40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-focus-ring motion-reduce:transition-none"
+), l = e(
+  "pointer-events-none absolute z-20 flex max-w-[220px] flex-col gap-0.5 rounded-lg border border-stroke bg-canvas-elevated px-3 py-2 shadow-elevation-card"
+);
+export {
+  a as hexTilemapLegendItemVariants,
+  i as hexTilemapLegendVariants,
+  o as hexTilemapRootVariants,
+  l as hexTilemapTooltipVariants,
+  t as hexTilemapViewportVariants,
+  s as hexTilemapZoomButtonVariants,
+  r as hexTilemapZoomVariants
+};

package/dist/components/data-display/hex-tilemap/index.d.ts

@@ -0,0 +1,2 @@
+export { HexTilemap, HexTilemapLegend, HexTilemapViewport, HexTilemapZoom, HexTilemapTooltip, } from './hex-tilemap';
+export type { HexTilemapHoverPoint, HexTilemapLegendProps, HexTilemapPoint, HexTilemapProps, HexTilemapRegion, HexTilemapSeries, HexTilemapViewportProps, HexTilemapZoomProps, } from './hex-tilemap.types';

package/dist/components/data-display/hex-tilemap/index.js

@@ -0,0 +1,12 @@
+import { HexTilemap as p } from "./hex-tilemap.js";
+import { HexTilemapLegend as r } from "./internals/hex-tilemap-legend.js";
+import { HexTilemapTooltip as i } from "./internals/hex-tilemap-tooltip.js";
+import { HexTilemapViewport as l } from "./internals/hex-tilemap-viewport.js";
+import { HexTilemapZoom as a } from "./internals/hex-tilemap-zoom.js";
+export {
+  p as HexTilemap,
+  r as HexTilemapLegend,
+  i as HexTilemapTooltip,
+  l as HexTilemapViewport,
+  a as HexTilemapZoom
+};

package/dist/components/data-display/hex-tilemap/internals/hex-camera.d.ts

@@ -0,0 +1,40 @@
+export declare const HEX_ZOOM_MIN = 50;
+export declare const HEX_ZOOM_MAX = 300;
+export declare const HEX_ZOOM_DEFAULT = 100;
+export declare const HEX_ZOOM_PRESETS: readonly [50, 100, 150, 200];
+export declare const HEX_WHEEL_ZOOM_STEP = 6;
+export declare const HEX_BUTTON_ZOOM_STEP = 25;
+export interface HexCamera {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface HexCameraExtents {
+    width: number;
+    height: number;
+}
+export declare function clampNumber(value: number, min: number, max: number): number;
+export declare function clampZoom(zoom: number): number;
+export declare function sizeForZoom(extents: HexCameraExtents, zoom: number): {
+    width: number;
+    height: number;
+};
+export declare function zoomFromCamera(camera: HexCamera, extents: HexCameraExtents): number;
+export declare function centeredCamera(extents: HexCameraExtents, zoom: number): HexCamera;
+/** Extra viewBox travel past the land frame so 100% zoom can still pan. */
+export declare const HEX_PAN_OVERSCROLL = 0.3;
+export declare function clampCamera(camera: HexCamera, extents: HexCameraExtents): HexCamera;
+export declare function zoomCameraAt(camera: HexCamera, extents: HexCameraExtents, nextZoom: number, focal?: {
+    x: number;
+    y: number;
+}): HexCamera;
+export declare function panCamera(camera: HexCamera, extents: HexCameraExtents, deltaX: number, deltaY: number): HexCamera;
+export declare function interpolateCamera(from: HexCamera, to: HexCamera, progress: number): HexCamera;
+export declare function easeOutCubic(progress: number): number;
+export declare function prefersReducedMotion(): boolean;
+export declare function clientToSvgPoint(svg: SVGSVGElement, clientX: number, clientY: number): {
+    x: number;
+    y: number;
+} | null;
+export declare function applyCameraViewBox(svg: SVGSVGElement, camera: HexCamera): void;

package/dist/components/data-display/hex-tilemap/internals/hex-camera.js

@@ -0,0 +1,103 @@
+const O = 50, _ = 300, E = 100, g = [50, 100, 150, 200], X = 6, f = 25;
+function c(t, n, i) {
+  return Math.min(i, Math.max(n, t));
+}
+function x(t) {
+  return c(Math.round(t), 50, 300);
+}
+function M(t, n) {
+  const i = 100 / x(n);
+  return {
+    width: t.width * i,
+    height: t.height * i
+  };
+}
+function p(t, n) {
+  const { width: i, height: h } = M(t, n);
+  return {
+    x: (t.width - i) / 2,
+    y: (t.height - h) / 2,
+    width: i,
+    height: h
+  };
+}
+const w = 0.3;
+function r(t, n) {
+  const i = t.width * w, h = t.height * w, o = Math.min(0, n.width - t.width) - i, e = Math.max(0, n.width - t.width) + i, u = Math.min(0, n.height - t.height) - h, d = Math.max(0, n.height - t.height) + h;
+  return {
+    ...t,
+    x: c(t.x, o, e),
+    y: c(t.y, u, d)
+  };
+}
+function l(t, n, i, h) {
+  const { width: o, height: e } = M(n, i);
+  if (h) {
+    const y = t.width === 0 ? 0.5 : (h.x - t.x) / t.width, s = t.height === 0 ? 0.5 : (h.y - t.y) / t.height;
+    return r(
+      { x: h.x - y * o, y: h.y - s * e, width: o, height: e },
+      n
+    );
+  }
+  const u = t.x + t.width / 2, d = t.y + t.height / 2;
+  return r(
+    { x: u - o / 2, y: d - e / 2, width: o, height: e },
+    n
+  );
+}
+function H(t, n, i, h) {
+  return r(
+    {
+      ...t,
+      x: t.x - i,
+      y: t.y - h
+    },
+    n
+  );
+}
+function T(t, n, i) {
+  return {
+    x: t.x + (n.x - t.x) * i,
+    y: t.y + (n.y - t.y) * i,
+    width: t.width + (n.width - t.width) * i,
+    height: t.height + (n.height - t.height) * i
+  };
+}
+function Z(t) {
+  return 1 - (1 - t) ** 3;
+}
+function C() {
+  return typeof window > "u" || typeof window.matchMedia != "function" ? !1 : window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function S(t, n, i) {
+  const h = t.getScreenCTM();
+  if (!h) return null;
+  const o = t.createSVGPoint();
+  o.x = n, o.y = i;
+  const e = o.matrixTransform(h.inverse());
+  return { x: e.x, y: e.y };
+}
+function A(t, n) {
+  t.setAttribute("viewBox", `${n.x} ${n.y} ${n.width} ${n.height}`);
+}
+export {
+  f as HEX_BUTTON_ZOOM_STEP,
+  w as HEX_PAN_OVERSCROLL,
+  X as HEX_WHEEL_ZOOM_STEP,
+  E as HEX_ZOOM_DEFAULT,
+  _ as HEX_ZOOM_MAX,
+  O as HEX_ZOOM_MIN,
+  g as HEX_ZOOM_PRESETS,
+  A as applyCameraViewBox,
+  p as centeredCamera,
+  r as clampCamera,
+  c as clampNumber,
+  x as clampZoom,
+  S as clientToSvgPoint,
+  Z as easeOutCubic,
+  T as interpolateCamera,
+  H as panCamera,
+  C as prefersReducedMotion,
+  M as sizeForZoom,
+  l as zoomCameraAt
+};

package/dist/components/data-display/hex-tilemap/internals/hex-country-lattices.d.ts

@@ -0,0 +1,9 @@
+import { HexRegionLattice } from './hex-lattice';
+/**
+ * Natural Earth 1:50m polygons (world-atlas land-50m / countries-50m) rasterised onto
+ * hex lattices. World uses the land layer so continents stay connected; regional
+ * frames use country polygons. Regenerated by scripts/generate-hex-country-masks.mjs.
+ */
+export declare const WORLD_HEX_LATTICE: HexRegionLattice;
+export declare const UNITED_STATES_HEX_LATTICE: HexRegionLattice;
+export declare const UNITED_STATES_AND_EUROPE_HEX_LATTICE: HexRegionLattice;