impact-nova 2.6.2 → 3.0.0-alpha.0

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

@@ -0,0 +1,21 @@
+import { HexGridTile } from './hex-world-grid';
+export declare const HEX_CELL_WIDTH = 12;
+export declare const HEX_CELL_HEIGHT = 10.72;
+export declare const HEX_COLUMN_STEP = 11.5;
+export declare const HEX_ROW_STEP = 13.28;
+export declare const HEX_ODD_COLUMN_OFFSET = 6.64;
+export interface HexPixelPoint {
+    pixelX: number;
+    pixelY: number;
+}
+export declare function hexTileToPixel(column: number, row: number): HexPixelPoint;
+export interface HexMapExtents {
+    originColumn: number;
+    originRow: number;
+    width: number;
+    height: number;
+}
+export declare function extentsFromTiles(tiles: readonly HexGridTile[]): HexMapExtents;
+export declare function buildLandPath(tiles: readonly HexGridTile[], originColumn: number, originRow: number): string;
+export declare function tileKey(tile: HexGridTile): string;
+export declare function hexNeighbors(column: number, row: number): HexGridTile[];

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

@@ -0,0 +1,82 @@
+const r = 12, _ = 10.72, s = 11.5, H = 13.28, C = 6.64, E = [
+  { command: "M", coordinates: [9.56148, 9.69087] },
+  { command: "C", coordinates: [9.20834, 10.3244, 8.53986, 10.7171, 7.81452, 10.7171] },
+  { command: "H", coordinates: [3.94774] },
+  { command: "C", coordinates: [3.23129, 10.7171, 2.56957, 10.3339, 2.21301, 9.71249] },
+  { command: "L", coordinates: [0.265298, 6.3179] },
+  { command: "C", coordinates: [-0.090937, 5.69704, -0.0882008, 4.93312, 0.272474, 4.31482] },
+  { command: "L", coordinates: [2.21064, 0.992257] },
+  { command: "C", coordinates: [2.56906, 0.377822, 3.22686, 0, 3.93819, 0] },
+  { command: "H", coordinates: [7.824] },
+  { command: "C", coordinates: [8.54428, 0, 9.20893, 0.387309, 9.56404, 1.01397] },
+  { command: "L", coordinates: [11.4467, 4.33636] },
+  { command: "C", coordinates: [11.7909, 4.94364, 11.7935, 5.6864, 11.4536, 6.2961] },
+  { command: "L", coordinates: [9.56148, 9.69087] },
+  { command: "Z", coordinates: [] }
+];
+function d(o, n) {
+  return {
+    pixelX: o * 11.5,
+    pixelY: n * 13.28 + (o % 2 === 1 ? 6.64 : 0)
+  };
+}
+function m(o, n) {
+  return E.map((t) => {
+    if (t.command === "Z") return "Z";
+    if (t.command === "H")
+      return `H${(t.coordinates[0] ?? 0) + o}`;
+    const i = [];
+    for (let c = 0; c < t.coordinates.length; c += 2) {
+      const e = (t.coordinates[c] ?? 0) + o, a = (t.coordinates[c + 1] ?? 0) + n;
+      i.push(`${e} ${a}`);
+    }
+    return `${t.command}${i.join(" ")}`;
+  }).join("");
+}
+function T(o) {
+  if (o.length === 0)
+    return { originColumn: 0, originRow: 0, width: 12, height: 10.72 };
+  let n = Number.POSITIVE_INFINITY, t = Number.NEGATIVE_INFINITY, i = Number.POSITIVE_INFINITY, c = Number.NEGATIVE_INFINITY;
+  for (const e of o)
+    e.x < n && (n = e.x), e.x > t && (t = e.x), e.y < i && (i = e.y), e.y > c && (c = e.y);
+  return {
+    originColumn: n,
+    originRow: i,
+    width: (t - n + 1) * 11.5 + 12 + 11.5,
+    height: (c - i + 1) * 13.28 + 10.72 + 6.64 + 13.28
+  };
+}
+function x(o, n, t) {
+  const i = [];
+  for (const c of o) {
+    const { pixelX: e, pixelY: a } = d(c.x - n, c.y - t);
+    i.push(m(e, a));
+  }
+  return i.join("");
+}
+function L(o) {
+  return `${o.x}:${o.y}`;
+}
+function I(o, n) {
+  const i = o % 2 !== 0 ? 1 : -1;
+  return [
+    { x: o - 1, y: n },
+    { x: o + 1, y: n },
+    { x: o, y: n - 1 },
+    { x: o, y: n + 1 },
+    { x: o - 1, y: n + i },
+    { x: o + 1, y: n + i }
+  ];
+}
+export {
+  _ as HEX_CELL_HEIGHT,
+  r as HEX_CELL_WIDTH,
+  s as HEX_COLUMN_STEP,
+  C as HEX_ODD_COLUMN_OFFSET,
+  H as HEX_ROW_STEP,
+  x as buildLandPath,
+  T as extentsFromTiles,
+  I as hexNeighbors,
+  d as hexTileToPixel,
+  L as tileKey
+};

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

@@ -0,0 +1,18 @@
+import { HexGridTile } from './hex-world-grid';
+export interface HexRegionLattice {
+    columns: number;
+    rows: number;
+    minLongitude: number;
+    maxLongitude: number;
+    minLatitude: number;
+    maxLatitude: number;
+    land: readonly HexGridTile[];
+}
+export declare function expandHexRuns(runs: readonly number[]): HexGridTile[];
+export declare function latticeLandKeys(lattice: HexRegionLattice): ReadonlySet<string>;
+export declare function isWithinLattice(latitude: number, longitude: number, lattice: HexRegionLattice): boolean;
+export declare function projectOntoLattice(latitude: number, longitude: number, lattice: HexRegionLattice): HexGridTile;
+export declare function snapToLatticeLand(tile: HexGridTile, landKeys: ReadonlySet<string>, fallback: HexGridTile): {
+    tile: HexGridTile;
+    hops: number;
+};

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

@@ -0,0 +1,47 @@
+import { tileKey as h, hexNeighbors as c } from "./hex-geometry.js";
+function x(o) {
+  const t = [];
+  for (let n = 0; n + 2 < o.length; n += 3) {
+    const r = o[n] ?? 0, s = o[n + 1] ?? 0, u = o[n + 2] ?? s;
+    for (let e = s; e <= u; e += 1)
+      t.push({ x: r, y: e });
+  }
+  return t;
+}
+function p(o) {
+  return new Set(o.land.map(h));
+}
+function L(o, t, n) {
+  return o >= n.minLatitude && o <= n.maxLatitude && t >= n.minLongitude && t <= n.maxLongitude;
+}
+function f(o, t, n) {
+  const r = Math.max(1, n.columns - 1), s = Math.max(1, n.rows - 1), u = (t - n.minLongitude) / (n.maxLongitude - n.minLongitude) * r, e = (n.maxLatitude - o) / (n.maxLatitude - n.minLatitude) * s;
+  return {
+    x: Math.min(n.columns - 1, Math.max(0, Math.round(u))),
+    y: Math.min(n.rows - 1, Math.max(0, Math.round(e)))
+  };
+}
+function w(o, t, n) {
+  const r = h(o);
+  if (t.has(r)) return { tile: o, hops: 0 };
+  const s = [{ tile: o, hops: 0 }], u = /* @__PURE__ */ new Set([r]);
+  for (; s.length > 0; ) {
+    const e = s.shift();
+    for (const i of c(e.tile.x, e.tile.y)) {
+      const a = h(i);
+      if (u.has(a)) continue;
+      u.add(a);
+      const m = e.hops + 1;
+      if (t.has(a)) return { tile: i, hops: m };
+      s.push({ tile: i, hops: m });
+    }
+  }
+  return { tile: n, hops: Number.POSITIVE_INFINITY };
+}
+export {
+  x as expandHexRuns,
+  L as isWithinLattice,
+  p as latticeLandKeys,
+  f as projectOntoLattice,
+  w as snapToLatticeLand
+};

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

@@ -0,0 +1,10 @@
+import { HexTilemapPoint, HexTilemapRegion } from '../hex-tilemap.types';
+import { HexGridTile } from './hex-world-grid';
+export interface PlacedHexPoint extends HexTilemapPoint {
+    tile: HexGridTile;
+}
+export interface HexTilemapLayout {
+    land: readonly HexGridTile[];
+    points: PlacedHexPoint[];
+}
+export declare function layoutHexTilemap(region: HexTilemapRegion, points: readonly HexTilemapPoint[]): HexTilemapLayout;

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

@@ -0,0 +1,35 @@
+import { tileKey as r, hexNeighbors as f } from "./hex-geometry.js";
+import { latticeLandKeys as p, isWithinLattice as h, projectOntoLattice as m, snapToLatticeLand as y } from "./hex-lattice.js";
+import { latticeForRegion as g } from "./hex-regions.js";
+function L(c, n, u) {
+  const o = [c], e = /* @__PURE__ */ new Set();
+  for (; o.length > 0; ) {
+    const i = o.shift(), s = r(i);
+    if (!e.has(s)) {
+      if (e.add(s), u.has(s) && !n.has(s))
+        return i;
+      for (const t of f(i.x, i.y))
+        e.has(r(t)) || o.push(t);
+    }
+  }
+  return null;
+}
+function x(c, n) {
+  const u = /* @__PURE__ */ new Set(), o = [], e = p(n), i = n.land[0] ?? { x: 0, y: 0 }, s = [...c].sort(
+    (t, l) => l.latitude - t.latitude || t.longitude - l.longitude
+  );
+  for (const t of s) {
+    if (!h(t.latitude, t.longitude, n)) continue;
+    const l = m(t.latitude, t.longitude, n), d = y(l, e, i);
+    if (!Number.isFinite(d.hops)) continue;
+    const a = L(d.tile, u, e);
+    a !== null && (u.add(r(a)), o.push({ ...t, tile: a }));
+  }
+  return { land: n.land, points: o };
+}
+function K(c, n) {
+  return x(n, g(c));
+}
+export {
+  K as layoutHexTilemap
+};

package/dist/components/data-display/hex-tilemap/internals/hex-new-zealand-grid.d.ts

@@ -0,0 +1,31 @@
+import { HexGridTile } from './hex-world-grid';
+/**
+ * New Zealand hex land mask.
+ *
+ * Source: Natural Earth 1:50m Cultural Vectors, country polygons, via the `world-atlas@2`
+ * package (`countries-50m.json`, ISO 3166-1 numeric id 554). The MultiPolygon (North Island,
+ * South Island, and small inshore islands) is rasterised onto a fixed equirectangular hex
+ * lattice with `d3.geoContains`. Ocean cells are omitted. This is not a hand-drawn silhouette.
+ *
+ * The same `lon/lat → (x, y)` mapping is used to project stores, so a store can only resolve
+ * to a cell that exists on this mask (after snapping to the nearest land cell).
+ */
+export declare const NZ_HEX_COLS = 24;
+export declare const NZ_HEX_ROWS = 32;
+export declare const NZ_LON_MIN = 166.2;
+export declare const NZ_LON_MAX = 178.9;
+export declare const NZ_LAT_MIN = -47.3;
+export declare const NZ_LAT_MAX = -34.1;
+export declare const NZ_HEX_LAND: readonly HexGridTile[];
+export declare const NZ_HEX_LAND_KEYS: ReadonlySet<string>;
+export declare function isWithinNzHexExtent(lat: number, lon: number): boolean;
+/** Same equirectangular mapping used to rasterise the Natural Earth polygons. */
+export declare function projectOntoNzHexGrid(lat: number, lon: number): HexGridTile;
+/**
+ * Walk from a projected cell to the nearest mask cell. Returns the hop count so callers can
+ * log stores that were not on land at the raw projection.
+ */
+export declare function snapToNzLand(tile: HexGridTile): {
+    tile: HexGridTile;
+    hops: number;
+};

package/dist/components/data-display/hex-tilemap/internals/hex-new-zealand-grid.js

@@ -0,0 +1,138 @@
+const _ = 24, N = 32, t = 166.2, c = 178.9, n = -47.3, o = -34.1, y = Object.freeze([
+  { x: 12, y: 1 },
+  { x: 13, y: 2 },
+  { x: 13, y: 3 },
+  { x: 14, y: 3 },
+  { x: 14, y: 4 },
+  { x: 15, y: 5 },
+  { x: 15, y: 6 },
+  { x: 17, y: 6 },
+  { x: 16, y: 7 },
+  { x: 17, y: 7 },
+  { x: 16, y: 8 },
+  { x: 17, y: 8 },
+  { x: 16, y: 9 },
+  { x: 17, y: 9 },
+  { x: 18, y: 9 },
+  { x: 19, y: 9 },
+  { x: 21, y: 9 },
+  { x: 22, y: 9 },
+  { x: 16, y: 10 },
+  { x: 17, y: 10 },
+  { x: 18, y: 10 },
+  { x: 19, y: 10 },
+  { x: 20, y: 10 },
+  { x: 21, y: 10 },
+  { x: 16, y: 11 },
+  { x: 17, y: 11 },
+  { x: 18, y: 11 },
+  { x: 19, y: 11 },
+  { x: 20, y: 11 },
+  { x: 21, y: 11 },
+  { x: 14, y: 12 },
+  { x: 15, y: 12 },
+  { x: 16, y: 12 },
+  { x: 17, y: 12 },
+  { x: 18, y: 12 },
+  { x: 19, y: 12 },
+  { x: 15, y: 13 },
+  { x: 16, y: 13 },
+  { x: 17, y: 13 },
+  { x: 18, y: 13 },
+  { x: 19, y: 13 },
+  { x: 17, y: 14 },
+  { x: 18, y: 14 },
+  { x: 19, y: 14 },
+  { x: 17, y: 15 },
+  { x: 18, y: 15 },
+  { x: 11, y: 16 },
+  { x: 12, y: 16 },
+  { x: 16, y: 16 },
+  { x: 17, y: 16 },
+  { x: 18, y: 16 },
+  { x: 11, y: 17 },
+  { x: 12, y: 17 },
+  { x: 13, y: 17 },
+  { x: 14, y: 17 },
+  { x: 16, y: 17 },
+  { x: 17, y: 17 },
+  { x: 10, y: 18 },
+  { x: 11, y: 18 },
+  { x: 12, y: 18 },
+  { x: 13, y: 18 },
+  { x: 14, y: 18 },
+  { x: 10, y: 19 },
+  { x: 11, y: 19 },
+  { x: 12, y: 19 },
+  { x: 13, y: 19 },
+  { x: 9, y: 20 },
+  { x: 10, y: 20 },
+  { x: 11, y: 20 },
+  { x: 12, y: 20 },
+  { x: 13, y: 20 },
+  { x: 8, y: 21 },
+  { x: 9, y: 21 },
+  { x: 10, y: 21 },
+  { x: 11, y: 21 },
+  { x: 12, y: 21 },
+  { x: 7, y: 22 },
+  { x: 8, y: 22 },
+  { x: 9, y: 22 },
+  { x: 10, y: 22 },
+  { x: 11, y: 22 },
+  { x: 6, y: 23 },
+  { x: 7, y: 23 },
+  { x: 8, y: 23 },
+  { x: 9, y: 23 },
+  { x: 10, y: 23 },
+  { x: 4, y: 24 },
+  { x: 5, y: 24 },
+  { x: 6, y: 24 },
+  { x: 7, y: 24 },
+  { x: 8, y: 24 },
+  { x: 9, y: 24 },
+  { x: 3, y: 25 },
+  { x: 4, y: 25 },
+  { x: 5, y: 25 },
+  { x: 6, y: 25 },
+  { x: 7, y: 25 },
+  { x: 8, y: 25 },
+  { x: 9, y: 25 },
+  { x: 2, y: 26 },
+  { x: 3, y: 26 },
+  { x: 4, y: 26 },
+  { x: 5, y: 26 },
+  { x: 6, y: 26 },
+  { x: 7, y: 26 },
+  { x: 8, y: 26 },
+  { x: 2, y: 27 },
+  { x: 3, y: 27 },
+  { x: 4, y: 27 },
+  { x: 5, y: 27 },
+  { x: 6, y: 27 },
+  { x: 7, y: 27 },
+  { x: 8, y: 27 },
+  { x: 1, y: 28 },
+  { x: 2, y: 28 },
+  { x: 3, y: 28 },
+  { x: 4, y: 28 },
+  { x: 5, y: 28 },
+  { x: 6, y: 28 },
+  { x: 7, y: 28 },
+  { x: 4, y: 29 },
+  { x: 5, y: 29 },
+  { x: 6, y: 29 },
+  { x: 3, y: 30 }
+]);
+new Set(
+  y.map((x) => `${x.x}:${x.y}`)
+);
+export {
+  _ as NZ_HEX_COLS,
+  y as NZ_HEX_LAND,
+  N as NZ_HEX_ROWS,
+  o as NZ_LAT_MAX,
+  n as NZ_LAT_MIN,
+  c as NZ_LON_MAX,
+  t as NZ_LON_MIN
+};

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

@@ -0,0 +1,6 @@
+import { HexTilemapRegion } from '../hex-tilemap.types';
+import { HexRegionLattice } from './hex-lattice';
+import { HexGridTile } from './hex-world-grid';
+export declare const NEW_ZEALAND_HEX_LATTICE: HexRegionLattice;
+export declare function latticeForRegion(region: HexTilemapRegion): HexRegionLattice;
+export declare function landTilesForRegion(region: HexTilemapRegion): readonly HexGridTile[];

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

@@ -0,0 +1,18 @@
+import { UNITED_STATES_HEX_LATTICE as t, UNITED_STATES_AND_EUROPE_HEX_LATTICE as E, WORLD_HEX_LATTICE as e } from "./hex-country-lattices.js";
+import { NZ_HEX_LAND as n, NZ_LAT_MAX as N, NZ_LAT_MIN as L, NZ_LON_MAX as T, NZ_LON_MIN as i, NZ_HEX_ROWS as r, NZ_HEX_COLS as A } from "./hex-new-zealand-grid.js";
+const u = {
+  columns: A,
+  rows: r,
+  minLongitude: i,
+  maxLongitude: T,
+  minLatitude: L,
+  maxLatitude: N,
+  land: n
+};
+function d(_) {
+  return _ === "new-zealand" ? u : _ === "united-states" ? t : _ === "united-states-and-europe" ? E : e;
+}
+export {
+  u as NEW_ZEALAND_HEX_LATTICE,
+  d as latticeForRegion
+};

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

@@ -0,0 +1,24 @@
+import { HexTilemapHoverPoint, HexTilemapPoint, HexTilemapRegion, HexTilemapSeries } from '../hex-tilemap.types';
+import { HexTilemapLayout } from './hex-layout';
+import * as React from "react";
+export interface HexTilemapContextValue {
+    region: HexTilemapRegion;
+    points: HexTilemapPoint[];
+    series: HexTilemapSeries[];
+    layout: HexTilemapLayout;
+    visiblePoints: HexTilemapLayout["points"];
+    metricLabel: string;
+    formatValue: (value: number) => string;
+    zoom: number;
+    setZoom: (zoom: number) => void;
+    hiddenSeriesIds: string[];
+    toggleSeries: (seriesId: string) => void;
+    hoverPoint: HexTilemapHoverPoint | null;
+    setHoverPoint: (point: HexTilemapHoverPoint | null) => void;
+    mapLabel: string;
+}
+export declare function HexTilemapProvider({ value, children, }: {
+    value: HexTilemapContextValue;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useHexTilemapContext(): HexTilemapContextValue;

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

@@ -0,0 +1,19 @@
+import { jsx as r } from "react/jsx-runtime";
+import * as t from "react";
+const o = t.createContext(null);
+function x({
+  value: e,
+  children: n
+}) {
+  return /* @__PURE__ */ r(o.Provider, { value: e, children: n });
+}
+function m() {
+  const e = t.useContext(o);
+  if (!e)
+    throw new Error("HexTilemap components must be used within HexTilemap");
+  return e;
+}
+export {
+  x as HexTilemapProvider,
+  m as useHexTilemapContext
+};

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

@@ -0,0 +1,2 @@
+import { HexTilemapLegendProps } from '../hex-tilemap.types';
+export declare const HexTilemapLegend: import('react').ForwardRefExoticComponent<HexTilemapLegendProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,51 @@
+import { jsx as l, jsxs as p } from "react/jsx-runtime";
+import { createComponent as m } from "../../../../lib/primitives/create-component.js";
+import { cn as c } from "../../../../lib/utils.js";
+import { useImpactNovaI18n as h } from "../../../../i18n/use-impact-nova-i18n.js";
+import { hexTilemapLegendItemVariants as x, hexTilemapLegendVariants as u } from "../hex-tilemap.variants.js";
+import { useHexTilemapContext as b } from "./hex-tilemap-context.js";
+const N = m(
+  "HexTilemapLegend",
+  ({ className: n, ...o }, i) => {
+    const { t: a } = h(), { series: s, hiddenSeriesIds: d, toggleSeries: t } = b();
+    return /* @__PURE__ */ l(
+      "div",
+      {
+        ref: i,
+        "data-component": "hex-tilemap-legend",
+        role: "group",
+        "aria-label": a("hexTilemap.legend"),
+        className: c(u(), n),
+        ...o,
+        children: s.map((e) => {
+          const r = d.includes(e.id);
+          return /* @__PURE__ */ p(
+            "button",
+            {
+              type: "button",
+              "aria-pressed": !r,
+              "aria-label": r ? a("hexTilemap.showSeries", { label: e.label }) : a("hexTilemap.hideSeries", { label: e.label }),
+              className: x({ hidden: r }),
+              onClick: () => t(e.id),
+              children: [
+                /* @__PURE__ */ l(
+                  "span",
+                  {
+                    className: "size-2 shrink-0 rounded-sm",
+                    style: { backgroundColor: e.color },
+                    "aria-hidden": !0
+                  }
+                ),
+                /* @__PURE__ */ l("span", { children: e.label })
+              ]
+            },
+            e.id
+          );
+        })
+      }
+    );
+  }
+);
+export {
+  N as HexTilemapLegend
+};

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

@@ -0,0 +1,2 @@
+import type * as React from "react";
+export declare const HexTilemapTooltip: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,36 @@
+import { jsxs as e, jsx as m } from "react/jsx-runtime";
+import { createComponent as p } from "../../../../lib/primitives/create-component.js";
+import { cn as c } from "../../../../lib/utils.js";
+import { hexTilemapTooltipVariants as x } from "../hex-tilemap.variants.js";
+import { useHexTilemapContext as f } from "./hex-tilemap-context.js";
+const T = 12, d = 72, P = p("HexTilemapTooltip", ({ className: o, ...l }, n) => {
+  const { hoverPoint: t, metricLabel: a, formatValue: i } = f();
+  if (!t) return null;
+  const r = t.clientY < d, s = Math.max(T, t.clientX);
+  return /* @__PURE__ */ e(
+    "div",
+    {
+      ref: n,
+      "data-component": "hex-tilemap-tooltip",
+      role: "tooltip",
+      className: c(x(), o),
+      style: {
+        left: s,
+        top: t.clientY,
+        transform: r ? "translate(-50%, 12px)" : "translate(-50%, calc(-100% - 8px))"
+      },
+      ...l,
+      children: [
+        /* @__PURE__ */ m("span", { className: "text-xs font-semibold leading-4 text-content", children: t.label }),
+        /* @__PURE__ */ e("span", { className: "text-xs font-semibold leading-4 text-content", children: [
+          a,
+          " - ",
+          i(t.value)
+        ] })
+      ]
+    }
+  );
+});
+export {
+  P as HexTilemapTooltip
+};

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

@@ -0,0 +1,3 @@
+import { HexTilemapViewportProps } from '../hex-tilemap.types';
+import * as React from "react";
+export declare const HexTilemapViewport: React.ForwardRefExoticComponent<HexTilemapViewportProps & React.RefAttributes<HTMLDivElement>>;