impact-nova 2.6.3 → 3.0.0-alpha.1

package/dist/components/data-display/chart/resolve-highcharts-options.js

@@ -1,5 +1,5 @@
-import { resolveDesignTokenColor as l } from "../../../lib/resolve-design-token-color.js";
-const s = /* @__PURE__ */ new Set([
+import { resolveDesignTokenColor as e } from "../../../lib/resolve-design-token-color.js";
+const u = /* @__PURE__ */ new Set([
   "color",
   "fillColor",
   "lineColor",
@@ -12,24 +12,29 @@ const s = /* @__PURE__ */ new Set([
   "negativeColor",
   "medianColor"
 ]);
-function C(o) {
-  return o === "colors" || o !== void 0 && s.has(o);
+function c(o) {
+  return o === "colors" || o !== void 0 && u.has(o);
 }
-function t(o, r, i) {
+function n(o, t, i) {
   if (typeof o == "string")
-    return C(i) ? l(o, r) : o;
+    return c(i) ? e(o, t) : o;
   if (Array.isArray(o))
-    return o.map((n) => t(n, r, i));
+    return i === "stops" ? o.map((r) => {
+      if (!Array.isArray(r) || typeof r[1] != "string")
+        return n(r, t, i);
+      const [s, l, ...C] = r;
+      return [s, e(l, t), ...C];
+    }) : o.map((r) => n(r, t, i));
   if (!o || typeof o != "object")
     return o;
-  const e = {};
-  for (const [n, f] of Object.entries(o))
-    e[n] = t(f, r, n);
-  return e;
+  const f = {};
+  for (const [r, s] of Object.entries(o))
+    f[r] = n(s, t, r);
+  return f;
 }
-function d(o, r) {
-  return typeof document > "u" || !r ? o : t(o, r);
+function m(o, t) {
+  return typeof document > "u" || !t ? o : n(o, t);
 }
 export {
-  d as resolveHighchartsOptions
+  m as resolveHighchartsOptions
 };

package/dist/components/data-display/globe-map/globe-map.d.ts

@@ -0,0 +1,8 @@
+import { GlobeMapProps } from './globe-map.types';
+import * as React from "react";
+export type { GlobeMapContinent, GlobeMapCountryFeature, GlobeMapHoverPoint, GlobeMapPoint, GlobeMapPointAttribute, GlobeMapProps, GlobeMapRegion, GlobeMapSeries, GlobeMapVariant, } from './globe-map.types';
+export { GlobeMapLegend } from './internals/globe-map-legend';
+export { GlobeMapPointCard } from './internals/globe-map-point-card';
+export { GlobeMapTooltip } from './internals/globe-map-tooltip';
+declare const GlobeMap: React.ForwardRefExoticComponent<GlobeMapProps & React.RefAttributes<HTMLDivElement>>;
+export { GlobeMap };

package/dist/components/data-display/globe-map/globe-map.js

@@ -0,0 +1,161 @@
+import { jsx as d, jsxs as y } from "react/jsx-runtime";
+import * as t from "react";
+import { useControllableState as R } from "@radix-ui/react-use-controllable-state";
+import { createComponent as U } from "../../../lib/primitives/create-component.js";
+import { cn as W } from "../../../lib/utils.js";
+import { useImpactNovaI18n as X } from "../../../i18n/use-impact-nova-i18n.js";
+import { globeMapStageVariants as Y, globeMapViewportVariants as Z, globeMapRootVariants as _ } from "./globe-map.variants.js";
+import { visibleGlobePoints as ee, globeScenePoints as te, cameraDurationMs as oe } from "./globe-map.utils.js";
+import { GlobeMapProvider as ne } from "./internals/globe-map-context.js";
+import { GlobeMapLegend as le } from "./internals/globe-map-legend.js";
+import { GlobeMapPointCard as ie } from "./internals/globe-map-point-card.js";
+import { GlobeMapScene as re } from "./internals/globe-map-scene.js";
+import { GlobeMapTooltip as ae } from "./internals/globe-map-tooltip.js";
+function se(m, f, a) {
+  const n = m?.querySelector(`[data-point-id="${f}"]`), l = m?.getBoundingClientRect();
+  if (!n || !l || n.style.opacity === "0") return a;
+  const o = n.getBoundingClientRect();
+  return o.width === 0 && o.height === 0 ? a : {
+    x: o.left - l.left + o.width / 2,
+    y: o.top - l.top
+  };
+}
+const ve = U(
+  "GlobeMap",
+  ({
+    className: m,
+    children: f,
+    region: a = "world",
+    variant: n = "locations",
+    points: l = [],
+    series: o = [],
+    metricLabel: k = "Value",
+    formatValue: V = String,
+    selectedPointId: w,
+    defaultSelectedPointId: A = null,
+    onSelectedPointChange: B,
+    onPointClick: C,
+    hiddenSeriesIds: N,
+    defaultHiddenSeriesIds: L = [],
+    onHiddenSeriesIdsChange: j,
+    autoRotate: T = !0,
+    showPointCard: g = !0,
+    renderPointCard: q,
+    height: S = 560,
+    "aria-label": v,
+    ...D
+  }, $) => {
+    const { t: I } = X(), x = t.useRef(null), [h, G] = R({
+      prop: w,
+      defaultProp: A,
+      onChange: B
+    }), [c, H] = R({
+      prop: N,
+      defaultProp: L,
+      onChange: j
+    }), [M, P] = t.useState(null), [z, b] = t.useState(null), i = t.useMemo(
+      () => ee(l, c ?? []),
+      [c, l]
+    ), E = t.useMemo(
+      () => te(i, o),
+      [o, i]
+    ), F = t.useMemo(
+      () => i.find((e) => e.id === h) ?? null,
+      [h, i]
+    ), J = t.useCallback(
+      (e) => {
+        const r = c ?? [], u = r.includes(e) ? r.filter((s) => s !== e) : [...r, e];
+        H(u);
+      },
+      [c, H]
+    ), K = t.useCallback(() => {
+      P(null);
+    }, []), O = t.useCallback(
+      (e, r, u) => {
+        if (!e) {
+          b(null);
+          return;
+        }
+        b({
+          id: e.id,
+          label: e.label,
+          value: e.value,
+          seriesId: e.seriesId,
+          clientX: r,
+          clientY: u
+        });
+      },
+      []
+    ), Q = t.useCallback(
+      (e, r, u) => {
+        const s = i.find((p) => p.id === e.id);
+        if (!s || (b(null), G(s.id), C?.(s), !g)) return;
+        P({ x: r, y: u }), window.setTimeout(() => {
+          P((p) => p && se(x.current, s.id, p));
+        }, oe());
+      },
+      [C, G, g, i]
+    );
+    return /* @__PURE__ */ d(
+      ne,
+      {
+        value: {
+          region: a,
+          variant: n,
+          points: l,
+          series: o,
+          visiblePoints: i,
+          metricLabel: k,
+          formatValue: V,
+          hiddenSeriesIds: c ?? [],
+          toggleSeries: J,
+          hoverPoint: M ? null : z,
+          setHoverPoint: b,
+          selectedPointId: h ?? null,
+          pointCardAnchor: M,
+          closePointCard: K,
+          renderPointCard: q,
+          mapLabel: v ?? I("globeMap.mapLabel")
+        },
+        children: /* @__PURE__ */ y(
+          "div",
+          {
+            ref: $,
+            "data-component": "globe-map",
+            "data-region": a,
+            "data-variant": n,
+            "aria-label": v ?? I("globeMap.mapLabel"),
+            className: W(_(), m),
+            style: { minHeight: S },
+            ...D,
+            children: [
+              /* @__PURE__ */ d("div", { className: Z(), style: { height: S }, children: /* @__PURE__ */ y("div", { ref: x, className: Y(), children: [
+                /* @__PURE__ */ d(
+                  re,
+                  {
+                    region: a,
+                    variant: n,
+                    scenePoints: E,
+                    selectedPoint: F,
+                    autoRotate: T && !M,
+                    onPointClick: Q,
+                    onPointHover: O
+                  }
+                ),
+                /* @__PURE__ */ d(ae, {}),
+                g ? /* @__PURE__ */ d(ie, {}) : null
+              ] }) }),
+              f === void 0 ? /* @__PURE__ */ d(le, {}) : f
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+export {
+  ve as GlobeMap,
+  le as GlobeMapLegend,
+  ie as GlobeMapPointCard,
+  ae as GlobeMapTooltip
+};

package/dist/components/data-display/globe-map/globe-map.stories-data.d.ts

@@ -0,0 +1,12 @@
+import { GlobeMapPoint, GlobeMapSeries } from './globe-map.types';
+export declare const PERFORMANCE_SERIES: GlobeMapSeries[];
+export declare const LOCATION_SERIES: GlobeMapSeries[];
+export declare const STORE_LOCATOR_SERIES: GlobeMapSeries[];
+export declare const LOCATION_POINTS: GlobeMapPoint[];
+export declare const LONDON_STORE_POINTS: GlobeMapPoint[];
+export declare const WORLD_POINTS: GlobeMapPoint[];
+export declare const NEW_ZEALAND_POINTS: GlobeMapPoint[];
+export declare const UNITED_STATES_POINTS: GlobeMapPoint[];
+export declare const UNITED_STATES_AND_EUROPE_POINTS: GlobeMapPoint[];
+export declare const EXCEPTION_SERIES: GlobeMapSeries[];
+export declare const EXCEPTION_POINTS: GlobeMapPoint[];

package/dist/components/data-display/globe-map/globe-map.types.d.ts

@@ -0,0 +1,83 @@
+import type * as React from "react";
+export type GlobeMapRegion = "world" | "new-zealand" | "united-states" | "united-states-and-europe";
+export type GlobeMapVariant = "locations" | "exceptions";
+export type GlobeMapContinent = "eu" | "as" | "af" | "na" | "sa" | "oc" | "other";
+export interface GlobeMapCountryFeature {
+    type: "Feature";
+    id?: string | number;
+    continent?: GlobeMapContinent;
+    highlighted?: boolean;
+    geometry: {
+        type: string;
+        coordinates: unknown;
+    };
+}
+export interface GlobeMapPointAttribute {
+    label: string;
+    value: string;
+}
+export interface GlobeMapPoint {
+    id: string;
+    latitude: number;
+    longitude: number;
+    value: number;
+    label: string;
+    seriesId: string;
+    subtitle?: string;
+    attributes?: readonly GlobeMapPointAttribute[];
+    tags?: readonly string[];
+    images?: readonly string[];
+    initials?: string;
+}
+export interface GlobeMapSeries {
+    id: string;
+    label: string;
+    color: string;
+}
+export interface GlobeMapHoverPoint {
+    id: string;
+    label: string;
+    value: number;
+    seriesId: string;
+    clientX: number;
+    clientY: number;
+}
+export interface GlobeMapPointCardAnchor {
+    x: number;
+    y: number;
+}
+export interface GlobeMapCameraView {
+    latitude: number;
+    longitude: number;
+    altitude: number;
+}
+export interface GlobeMapProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    region?: GlobeMapRegion;
+    variant?: GlobeMapVariant;
+    points?: GlobeMapPoint[];
+    series?: GlobeMapSeries[];
+    metricLabel?: string;
+    formatValue?: (value: number) => string;
+    selectedPointId?: string | null;
+    defaultSelectedPointId?: string | null;
+    onSelectedPointChange?: (pointId: string | null) => void;
+    onPointClick?: (point: GlobeMapPoint) => void;
+    hiddenSeriesIds?: string[];
+    defaultHiddenSeriesIds?: string[];
+    onHiddenSeriesIdsChange?: (hiddenSeriesIds: string[]) => void;
+    autoRotate?: boolean;
+    showPointCard?: boolean;
+    renderPointCard?: (point: GlobeMapPoint) => React.ReactNode;
+    height?: number;
+    "aria-label"?: string;
+}
+export type GlobeMapLegendProps = React.HTMLAttributes<HTMLDivElement>;
+export interface GlobeMapScenePoint {
+    id: string;
+    lat: number;
+    lng: number;
+    color: string;
+    label: string;
+    value: number;
+    seriesId: string;
+}

package/dist/components/data-display/globe-map/globe-map.utils.d.ts

@@ -0,0 +1,115 @@
+import { GlobeMapCameraView, GlobeMapContinent, GlobeMapCountryFeature, GlobeMapPoint, GlobeMapRegion, GlobeMapScenePoint, GlobeMapSeries, GlobeMapVariant } from './globe-map.types';
+export declare const GLOBE_MAP_REGION_VIEWS: Record<GlobeMapRegion, GlobeMapCameraView>;
+export declare function prefersGlobeReducedMotion(): boolean;
+export declare function visibleGlobePoints(points: readonly GlobeMapPoint[], hiddenSeriesIds: readonly string[]): GlobeMapPoint[];
+export declare function globeScenePoints(points: readonly GlobeMapPoint[], series: readonly GlobeMapSeries[]): GlobeMapScenePoint[];
+export declare const GLOBE_TRANSPARENT = "rgba(0,0,0,0)";
+export declare const GLOBE_MAP_SELECTED_ALTITUDE = 1.35;
+/** Closest zoom: keeps the sphere limb inside the square canvas. */
+export declare const GLOBE_MAP_MIN_ALTITUDE = 1.35;
+/** Farthest zoom: slightly above the world framing view. */
+export declare const GLOBE_MAP_MAX_ALTITUDE = 2.5;
+export declare const GLOBE_MAP_CAMERA_DURATION_MS = 750;
+export declare const GLOBE_MAP_MAX_PIXEL_RATIO = 1.25;
+export declare function globeControlDistances(globeRadius: number): {
+    minDistance: number;
+    maxDistance: number;
+};
+export interface GlobeMapThemeColors {
+    ocean: string;
+    oceanMid: string;
+    oceanEdge: string;
+    land: string;
+    landHighlight: string;
+    landByContinent: Record<GlobeMapContinent, string>;
+    border: string;
+    atmosphere: string;
+    ring: string;
+    shine: string;
+    brand: string;
+    destructive: string;
+}
+export declare const GLOBE_MAP_VARIANT_MIXES: {
+    readonly locations: {
+        readonly ocean: "var(--color-globe-locations-ocean-highlight)";
+        readonly oceanMid: "var(--color-globe-locations-ocean-mid)";
+        readonly oceanEdge: "var(--color-globe-locations-ocean-edge)";
+        readonly land: string;
+        readonly landHighlight: string;
+        readonly landByContinent: Record<GlobeMapContinent, string>;
+        readonly border: string;
+        readonly atmosphere: "var(--color-globe-locations-ocean-edge)";
+        readonly ring: "color-mix(in srgb, var(--color-globe-locations-highlight-ink) 35%, transparent)";
+    };
+    readonly exceptions: {
+        readonly ocean: "var(--color-globe-exceptions-ocean)";
+        readonly oceanMid: "var(--color-globe-exceptions-ocean)";
+        readonly oceanEdge: "var(--color-globe-exceptions-ocean)";
+        readonly land: string;
+        readonly landHighlight: string;
+        readonly landByContinent: {
+            readonly eu: string;
+            readonly as: string;
+            readonly af: string;
+            readonly na: string;
+            readonly sa: string;
+            readonly oc: string;
+            readonly other: string;
+        };
+        readonly border: string;
+        readonly atmosphere: "var(--color-globe-exceptions-ocean)";
+        readonly ring: "color-mix(in srgb, var(--color-globe-exceptions-land-ink) 45%, transparent)";
+    };
+};
+export declare const GLOBE_MAP_GLOBE_INSET_PX = 8;
+export declare const GLOBE_MAP_GROUND_SHADOW_ROOM_PX = 56;
+export declare const GLOBE_MAP_GROUND_SHADOW_WIDTH_RATIO = 0.835;
+export declare const GLOBE_MAP_GROUND_SHADOW_HEIGHT_RATIO = 0.046;
+export declare const GLOBE_MAP_GROUND_SHADOW_BLUR_PX = 12.5;
+export declare const GLOBE_MAP_GROUND_SHADOW: {
+    readonly locations: "var(--color-border)";
+    readonly exceptions: "color-mix(in srgb, var(--color-globe-exceptions-border-ink) 18%, var(--color-border))";
+};
+export interface GlobeMapGroundShadowGlobe {
+    getGlobeRadius: () => number;
+    camera: () => {
+        fov?: number;
+        position: {
+            length: () => number;
+        };
+    };
+}
+export declare function syncGlobeMapGroundShadow(globe: GlobeMapGroundShadowGlobe, shadowElement: Element, canvasSize: number): void;
+export declare function toThreeJsColor(cssColor: string): string;
+export declare function resolveGlobeColor(cssColor: string, fallbackColor: string): string;
+export declare function globeLandColorForFeature(feature: Pick<GlobeMapCountryFeature, "continent" | "highlighted"> | undefined, themeColors: GlobeMapThemeColors, variant: GlobeMapVariant): string;
+export declare function readGlobeMapThemeColors(variant?: GlobeMapVariant): GlobeMapThemeColors;
+export declare function createSolidGlobeTexture(fillColor: string): string;
+export declare function createGlobeOceanTexture(oceanMidColor: string): string;
+export interface GlobeMapSurfaceMaterial {
+    color?: {
+        set: (color: string) => void;
+    };
+    emissive?: {
+        set: (color: string) => void;
+    };
+    emissiveIntensity?: number;
+    shininess?: number;
+    specular?: {
+        set: (color: string) => void;
+    };
+}
+export declare function applyGlobeIllustrationMaterial(globe: {
+    scene?: () => {
+        traverse: (visitor: (object: object) => void) => void;
+    };
+}): void;
+export declare function cameraDurationMs(): number;
+export declare function applyGlobePinAppearance(element: HTMLElement, selected: boolean, fillColor: string): void;
+export interface GlobePinElementOptions {
+    point: GlobeMapScenePoint;
+    selected: boolean;
+    onClick: (point: GlobeMapScenePoint, clientX: number, clientY: number) => void;
+    onHover: (point: GlobeMapScenePoint | null, clientX: number, clientY: number) => void;
+}
+export declare function createGlobePinElement(options: GlobePinElementOptions): HTMLElement;

package/dist/components/data-display/globe-map/globe-map.utils.js

@@ -0,0 +1,259 @@
+const U = {
+  world: { latitude: 18, longitude: 12, altitude: 2.15 },
+  "new-zealand": { latitude: -41.2, longitude: 174.8, altitude: 1.35 },
+  "united-states": { latitude: 39.5, longitude: -98.4, altitude: 1.55 },
+  "united-states-and-europe": { latitude: 42, longitude: -32, altitude: 1.95 }
+};
+function x() {
+  return typeof window > "u" || typeof window.matchMedia != "function" ? !1 : window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function k(e, t) {
+  return t.length === 0 ? [...e] : e.filter((n) => !t.includes(n.seriesId));
+}
+function W(e, t) {
+  const n = new Map(t.map((o) => [o.id, o.color]));
+  return e.map((o) => ({
+    id: o.id,
+    lat: o.latitude,
+    lng: o.longitude,
+    color: n.get(o.seriesId) ?? "var(--color-primary)",
+    label: o.label,
+    value: o.value,
+    seriesId: o.seriesId
+  }));
+}
+const X = "rgba(0,0,0,0)", v = 1.35, m = v, L = 2.5, I = 750, j = 1.25;
+function q(e) {
+  return {
+    minDistance: e * (1 + m),
+    maxDistance: e * (1 + L)
+  };
+}
+function s(e, t) {
+  return `color-mix(in srgb, ${e} ${t}%, transparent)`;
+}
+const E = "var(--color-globe-locations-ocean-highlight)", G = "var(--color-globe-locations-ocean-mid)", _ = "var(--color-globe-locations-ocean-edge)", p = s("var(--color-globe-locations-land-ink)", 18), T = {
+  eu: p,
+  as: p,
+  af: p,
+  na: p,
+  sa: p,
+  oc: p,
+  other: p
+}, f = "var(--color-globe-exceptions-ocean)", M = {
+  locations: {
+    ocean: E,
+    oceanMid: G,
+    oceanEdge: _,
+    land: p,
+    landHighlight: s("var(--color-globe-locations-highlight-ink)", 18),
+    landByContinent: T,
+    border: s("var(--color-globe-locations-border-ink)", 18),
+    atmosphere: _,
+    ring: "color-mix(in srgb, var(--color-globe-locations-highlight-ink) 35%, transparent)"
+  },
+  exceptions: {
+    ocean: f,
+    oceanMid: f,
+    oceanEdge: f,
+    land: s("var(--color-globe-exceptions-land-ink)", 10),
+    landHighlight: s("var(--color-globe-exceptions-land-ink)", 10),
+    landByContinent: {
+      eu: s("var(--color-globe-exceptions-eu)", 20),
+      as: s("var(--color-globe-exceptions-as)", 22),
+      af: s("var(--color-globe-exceptions-af)", 22),
+      na: s("var(--color-globe-exceptions-na)", 20),
+      sa: s("var(--color-globe-exceptions-sa)", 22),
+      oc: s("var(--color-globe-exceptions-oc)", 22),
+      other: s("var(--color-globe-exceptions-land-ink)", 10)
+    },
+    border: s("var(--color-globe-exceptions-border-ink)", 32),
+    atmosphere: f,
+    ring: "color-mix(in srgb, var(--color-globe-exceptions-land-ink) 45%, transparent)"
+  }
+}, F = 8, V = 56, P = 0.835, N = 0.046, S = 12.5, Y = {
+  locations: "var(--color-border)",
+  exceptions: "color-mix(in srgb, var(--color-globe-exceptions-border-ink) 18%, var(--color-border))"
+};
+function z(e, t, n) {
+  const o = e.getGlobeRadius(), a = e.camera().position.length(), r = e.camera().fov;
+  if (o <= 0 || a <= 0 || n <= 0 || r == null)
+    return;
+  const d = r * Math.PI / 180, c = o / a / Math.tan(d / 2) * (n / 2), l = n / 2, b = l + c, u = t.querySelector('[data-part="shadow-contact"]'), g = t.querySelector('[data-part="globe-ring"]'), h = t.querySelector('[data-part="globe-shine"]');
+  u && (u.setAttribute("cx", `${l}`), u.setAttribute("cy", `${b + S}`), u.setAttribute("rx", `${c * P}`), u.setAttribute("ry", `${c * N}`)), g && (g.setAttribute("cx", `${l}`), g.setAttribute("cy", `${l}`), g.setAttribute("r", `${c + 4}`)), h && (h.setAttribute("cx", `${l}`), h.setAttribute("cy", `${l}`), h.setAttribute("r", `${c}`));
+}
+const B = /color\(srgb\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)(?:\s*\/\s*([\d.]+))?\)/i;
+function y(e) {
+  return Math.max(0, Math.min(255, Math.round(Number(e) * 255)));
+}
+function D(e) {
+  const t = e.match(B);
+  if (t) {
+    const l = y(t[1] ?? "0"), b = y(t[2] ?? "0"), u = y(t[3] ?? "0"), g = t[4] == null ? 1 : Number(t[4]);
+    return g < 1 ? `rgba(${l}, ${b}, ${u}, ${g})` : `rgb(${l}, ${b}, ${u})`;
+  }
+  if (e.startsWith("rgb") || e.startsWith("#") || e.startsWith("hsl") || typeof document > "u") return e;
+  const n = document.createElement("canvas");
+  n.width = 1, n.height = 1;
+  const o = n.getContext("2d");
+  if (!o) return e;
+  o.fillStyle = e, o.fillRect(0, 0, 1, 1);
+  const [a, r, d, c] = o.getImageData(0, 0, 1, 1).data;
+  return c === 0 ? e : `rgb(${a}, ${r}, ${d})`;
+}
+function i(e, t) {
+  if (typeof document > "u" || !document.body) return t;
+  const n = document.createElement("span");
+  n.style.color = e || t, n.style.display = "none", document.body.appendChild(n);
+  const o = getComputedStyle(n).color;
+  return n.remove(), !o || o === "transparent" || o === "rgba(0, 0, 0, 0)" ? t : D(o);
+}
+function J(e, t, n) {
+  if (n === "locations")
+    return e?.highlighted ? t.landHighlight : t.land;
+  const o = e?.continent ?? "other";
+  return t.landByContinent[o] ?? t.land;
+}
+function K(e = "locations") {
+  const t = i("var(--color-surface-elevated)", "rgb(255, 255, 255)"), n = i("var(--color-primary)", t), o = i("var(--color-destructive)", t), a = M[e];
+  return {
+    ocean: i(a.ocean, t),
+    oceanMid: i(a.oceanMid, t),
+    oceanEdge: i(a.oceanEdge, t),
+    land: i(a.land, t),
+    landHighlight: i(a.landHighlight, t),
+    landByContinent: {
+      eu: i(a.landByContinent.eu, t),
+      as: i(a.landByContinent.as, t),
+      af: i(a.landByContinent.af, t),
+      na: i(a.landByContinent.na, t),
+      sa: i(a.landByContinent.sa, t),
+      oc: i(a.landByContinent.oc, t),
+      other: i(a.landByContinent.other, t)
+    },
+    border: i(a.border, t),
+    atmosphere: i(a.atmosphere, t),
+    ring: i(a.ring, t),
+    shine: i(E, t),
+    brand: n,
+    destructive: o
+  };
+}
+function R(e) {
+  const t = document.createElement("canvas");
+  t.width = 8, t.height = 4;
+  const n = t.getContext("2d");
+  return n ? (n.fillStyle = e, n.fillRect(0, 0, t.width, t.height), t.toDataURL("image/png")) : "";
+}
+function Q(e) {
+  return R(e);
+}
+function Z(e) {
+  e.scene?.().traverse((t) => {
+    const n = t;
+    n.isAmbientLight && n.intensity != null && (n.intensity = 1), n.isDirectionalLight && n.intensity != null && (n.intensity = 0);
+  });
+}
+function tt() {
+  return x() ? 0 : I;
+}
+const $ = [
+  "box-sizing:border-box",
+  "position:relative",
+  "border:0",
+  "padding:0",
+  "border-radius:9999px",
+  "cursor:pointer",
+  "appearance:none",
+  "pointer-events:auto"
+].join(";"), w = [
+  "position:absolute",
+  "left:50%",
+  "top:50%",
+  "width:100%",
+  "height:100%",
+  "border-radius:9999px",
+  "pointer-events:none",
+  "border:2px solid currentColor",
+  "opacity:0",
+  "transform:translate(-50%,-50%)"
+].join(";"), C = "globe-map-pin-pulse";
+function O(e) {
+  const t = e.querySelector("[data-part='pulse']");
+  t && (typeof t.getAnimations == "function" && t.getAnimations().forEach((n) => n.cancel()), t.style.opacity = "0");
+}
+function H(e) {
+  if (O(e), x()) return;
+  const t = e.querySelector("[data-part='pulse']");
+  if (!t || typeof t.animate != "function") return;
+  const n = t.animate(
+    [
+      { transform: "translate(-50%, -50%) scale(1)", opacity: 0.55 },
+      { transform: "translate(-50%, -50%) scale(2.6)", opacity: 0 }
+    ],
+    {
+      duration: 1400,
+      easing: "cubic-bezier(0.22, 1, 0.36, 1)",
+      iterations: 1 / 0
+    }
+  );
+  n.id = C;
+}
+function A(e, t, n) {
+  if (e.dataset.selected = t ? "true" : "false", e.dataset.pinColor = n, e.style.color = n, e.style.background = n, t) {
+    e.style.width = "16px", e.style.height = "16px", e.style.marginLeft = "-8px", e.style.marginTop = "-8px", e.style.boxShadow = [
+      "0 0 0 3px var(--color-surface-elevated)",
+      `0 0 0 10px color-mix(in srgb, ${n} 40%, transparent)`
+    ].join(","), e.style.zIndex = "2", H(e);
+    return;
+  }
+  e.style.width = "8px", e.style.height = "8px", e.style.marginLeft = "-4px", e.style.marginTop = "-4px", e.style.boxShadow = [
+    "0 0 0 1.5px var(--color-surface-elevated)",
+    `0 0 0 8px color-mix(in srgb, ${n} 18%, transparent)`
+  ].join(","), e.style.zIndex = "1", O(e);
+}
+function et(e) {
+  const { point: t, selected: n, onClick: o, onHover: a } = e, r = document.createElement("button");
+  r.type = "button", r.setAttribute("data-component", "globe-map-pin"), r.dataset.pointId = t.id, r.setAttribute("aria-label", t.label), r.style.cssText = $;
+  const d = document.createElement("span");
+  return d.setAttribute("data-part", "pulse"), d.setAttribute("aria-hidden", "true"), d.style.cssText = w, r.appendChild(d), A(r, n, t.color), r.addEventListener("pointerdown", (c) => {
+    c.stopPropagation();
+  }), r.addEventListener("click", (c) => {
+    c.preventDefault(), c.stopPropagation(), o(t, c.clientX, c.clientY);
+  }), r.addEventListener("pointerenter", (c) => {
+    r.dataset.selected !== "true" && (r.style.width = "12px", r.style.height = "12px", r.style.marginLeft = "-6px", r.style.marginTop = "-6px"), a(t, c.clientX, c.clientY);
+  }), r.addEventListener("pointerleave", () => {
+    A(r, r.dataset.selected === "true", t.color), a(null, 0, 0);
+  }), r;
+}
+export {
+  I as GLOBE_MAP_CAMERA_DURATION_MS,
+  F as GLOBE_MAP_GLOBE_INSET_PX,
+  Y as GLOBE_MAP_GROUND_SHADOW,
+  S as GLOBE_MAP_GROUND_SHADOW_BLUR_PX,
+  N as GLOBE_MAP_GROUND_SHADOW_HEIGHT_RATIO,
+  V as GLOBE_MAP_GROUND_SHADOW_ROOM_PX,
+  P as GLOBE_MAP_GROUND_SHADOW_WIDTH_RATIO,
+  L as GLOBE_MAP_MAX_ALTITUDE,
+  j as GLOBE_MAP_MAX_PIXEL_RATIO,
+  m as GLOBE_MAP_MIN_ALTITUDE,
+  U as GLOBE_MAP_REGION_VIEWS,
+  v as GLOBE_MAP_SELECTED_ALTITUDE,
+  M as GLOBE_MAP_VARIANT_MIXES,
+  X as GLOBE_TRANSPARENT,
+  Z as applyGlobeIllustrationMaterial,
+  A as applyGlobePinAppearance,
+  tt as cameraDurationMs,
+  Q as createGlobeOceanTexture,
+  et as createGlobePinElement,
+  R as createSolidGlobeTexture,
+  q as globeControlDistances,
+  J as globeLandColorForFeature,
+  W as globeScenePoints,
+  x as prefersGlobeReducedMotion,
+  K as readGlobeMapThemeColors,
+  i as resolveGlobeColor,
+  z as syncGlobeMapGroundShadow,
+  D as toThreeJsColor,
+  k as visibleGlobePoints
+};