vue-chrts 2.1.0-beta-2 → 2.1.0-beta-4

package/dist/components/Maps/DottedMap/mapUtils.js

@@ -0,0 +1,130 @@
+import y from "../../../node_modules/.pnpm/proj4@2.20.2/node_modules/proj4/lib/index.js";
+import Y from "../../../node_modules/.pnpm/@turf_boolean-point-in-polygon@7.3.1/node_modules/@turf/boolean-point-in-polygon/dist/esm/index.js";
+y.defs("GOOGLE") || y.defs("GOOGLE", "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs");
+const h = {
+  lat: { min: -56, max: 71 },
+  lng: { min: -179, max: 179 }
+}, P = (t) => ({ type: "Feature", geometry: { type: "MultiPolygon", coordinates: t.features.reduce(
+  (c, o) => c.concat(
+    o.geometry.type === "Polygon" ? [o.geometry.coordinates] : o.geometry.coordinates
+  ),
+  []
+) } }), M = (t) => {
+  const { type: n, features: c, geometry: o, coordinates: i } = t;
+  if (n === "FeatureCollection") {
+    const l = c.map(M);
+    return {
+      lat: {
+        min: Math.min(...l.map((e) => e.lat.min)),
+        max: Math.max(...l.map((e) => e.lat.max))
+      },
+      lng: {
+        min: Math.min(...l.map((e) => e.lng.min)),
+        max: Math.max(...l.map((e) => e.lng.max))
+      }
+    };
+  } else {
+    if (n === "Feature")
+      return M(o);
+    if (n === "MultiPolygon")
+      return M({
+        type: "Polygon",
+        coordinates: i.flat(1)
+      });
+    if (n === "Polygon") {
+      const l = i.flat(1), e = l.map(([u, r]) => r), a = l.map(([u, r]) => u);
+      return {
+        lat: {
+          min: Math.min(...e),
+          max: Math.max(...e)
+        },
+        lng: {
+          min: Math.min(...a),
+          max: Math.max(...a)
+        }
+      };
+    } else
+      throw new Error(`Unknown geojson type ${n}`);
+  }
+}, w = ({
+  height: t = 0,
+  width: n = 0,
+  countries: c = [],
+  region: o,
+  grid: i = "vertical",
+  geojsonWorld: l
+}) => {
+  if (t <= 0 && n <= 0)
+    throw new Error("height or width is required");
+  const e = l.features.reduce((s, m) => (s[m.id] = m, s), {});
+  let a = l;
+  c.length > 0 ? (a = {
+    type: "FeatureCollection",
+    features: c.map((s) => e[s]).filter(Boolean)
+  }, o || (o = M(a))) : o || (o = h), P(a);
+  const [u, r] = y("GOOGLE", [
+    o.lng.min,
+    o.lat.min
+  ]), [d, f] = y("GOOGLE", [
+    o.lng.max,
+    o.lat.max
+  ]), g = d - u, x = f - r;
+  n <= 0 ? n = Math.round(t * g / x) : t <= 0 && (t = Math.round(n * x / g));
+  const E = {}, G = i === "diagonal" ? Math.sqrt(3) / 2 : 1;
+  for (let s = 0; s * G < t; s += 1)
+    for (let m = 0; m < n; m += 1) {
+      const O = s % 2 === 0 && i === "diagonal" ? m + 0.5 : m, X = s * G, L = [
+        O / n * g + u,
+        f - X / t * x
+      ], p = y(
+        "GOOGLE",
+        "WGS84",
+        L
+      ), A = a.features.find((_) => Y(p, _));
+      if (A) {
+        const [_, N] = p;
+        E[[m, s].join(";")] = { x: O, y: X, lat: N, lng: _, countryId: A.id };
+      }
+    }
+  return {
+    points: E,
+    X_MIN: u,
+    Y_MIN: r,
+    X_MAX: d,
+    Y_MAX: f,
+    X_RANGE: g,
+    Y_RANGE: x,
+    region: o,
+    grid: i,
+    height: t,
+    width: n,
+    ystep: G
+  };
+}, F = (t, { lat: n, lng: c }) => {
+  const [o, i] = y("GOOGLE", [c, n]);
+  let [l, e] = [
+    t.width * (o - t.X_MIN) / t.X_RANGE,
+    t.height * (t.Y_MAX - i) / t.Y_RANGE
+  ];
+  const a = Math.round(e / t.ystep);
+  a % 2 === 0 && t.grid === "diagonal" && (l -= 0.5);
+  const u = Math.round(l);
+  let [r, d] = [u, Math.round(a) * t.ystep];
+  a % 2 === 0 && t.grid === "diagonal" && (r += 0.5);
+  const [f, g] = y(
+    "GOOGLE",
+    "WGS84",
+    [
+      r * t.X_RANGE / t.width + t.X_MIN,
+      t.Y_MAX - d * t.Y_RANGE / t.height
+    ]
+  );
+  return { x: r, y: d, lat: g, lng: f };
+};
+export {
+  h as DEFAULT_WORLD_REGION,
+  M as computeGeojsonBox,
+  P as geojsonToMultiPolygons,
+  w as getMap,
+  F as getPin
+};

package/dist/components/Maps/DottedMap/pins.d.ts

@@ -0,0 +1,9 @@
+import { MapPin } from './types';
+export declare const DEFAULT_PIN_OPTIONS: {
+    color: string;
+    radius: number;
+};
+export declare function createPin(lat: number, lng: number, data?: Record<string, unknown>, svgOptions?: MapPin['svgOptions']): MapPin;
+export declare const WORLD_PINS: MapPin[];
+export declare const USA_PINS: MapPin[];
+export declare function filterPinsByRegion(pins: MapPin[], region: string): MapPin[];

package/dist/components/Maps/DottedMap/pins.js

@@ -0,0 +1,58 @@
+const t = {
+  color: "var(--ui-text)",
+  radius: 0.15
+};
+function i(o, e, r = {}, c = {}) {
+  return {
+    lat: o,
+    lng: e,
+    svgOptions: { ...t, ...c },
+    data: r
+  };
+}
+const n = [
+  // North America (USA)
+  i(40.7128, -74.006, { city: "New York", region: "USA" }),
+  i(34.0522, -118.2437, { city: "Los Angeles", region: "USA" }),
+  i(41.8781, -87.6298, { city: "Chicago", region: "USA" }),
+  i(25.7617, -80.1918, { city: "Miami", region: "USA" }),
+  i(47.6062, -122.3321, { city: "Seattle", region: "USA" }),
+  // South America
+  i(-23.5505, -46.6333, { city: "São Paulo", region: "South America" }),
+  i(-34.6037, -58.3816, { city: "Buenos Aires", region: "South America" }),
+  i(-12.0464, -77.0428, { city: "Lima", region: "South America" }),
+  i(4.711, -74.0721, { city: "Bogotá", region: "South America" }),
+  i(-33.4489, -70.6693, { city: "Santiago", region: "South America" }),
+  // Europe
+  i(48.8566, 2.3522, { city: "Paris", region: "Europe" }),
+  i(51.5074, -0.1278, { city: "London", region: "Europe" }),
+  i(52.52, 13.405, { city: "Berlin", region: "Europe" }),
+  i(41.9028, 12.4964, { city: "Rome", region: "Europe" }),
+  i(59.3293, 18.0686, { city: "Stockholm", region: "Europe" }),
+  // Asia
+  i(35.6762, 139.6503, { city: "Tokyo", region: "Asia" }),
+  i(1.3521, 103.8198, { city: "Singapore", region: "Asia" }),
+  i(28.6139, 77.209, { city: "New Delhi", region: "Asia" }),
+  i(31.2304, 121.4737, { city: "Shanghai", region: "Asia" }),
+  i(25.2048, 55.2708, { city: "Dubai", region: "Asia" }),
+  // Oceania
+  i(-33.8688, 151.2093, { city: "Sydney", region: "Oceania" }),
+  i(-37.8136, 144.9631, { city: "Melbourne", region: "Oceania" }),
+  i(-36.8485, 174.7633, { city: "Auckland", region: "Oceania" }),
+  i(-27.4705, 153.026, { city: "Brisbane", region: "Oceania" }),
+  i(-31.9505, 115.8605, { city: "Perth", region: "Oceania" })
+], a = [
+  i(37.7749, -122.4194, { city: "San Francisco" }, { color: "#6366f1", radius: 0.3 }),
+  i(34.0522, -118.2437, { city: "Los Angeles" }, { color: "#6366f1", radius: 0.3 }),
+  i(47.6062, -122.3321, { city: "Seattle" }, { color: "#6366f1", radius: 0.3 }),
+  i(40.7128, -74.006, { city: "New York" }, { color: "#f59e0b", radius: 0.3 }),
+  i(42.3601, -71.0589, { city: "Boston" }, { color: "#f59e0b", radius: 0.3 }),
+  i(25.7617, -80.1918, { city: "Miami" }, { color: "#ec4899", radius: 0.3 }),
+  i(30.2672, -97.7431, { city: "Austin" }, { color: "#10b981", radius: 0.3 })
+];
+export {
+  t as DEFAULT_PIN_OPTIONS,
+  a as USA_PINS,
+  n as WORLD_PINS,
+  i as createPin
+};

package/dist/components/Maps/DottedMap/regions.d.ts

@@ -0,0 +1,4 @@
+import { MapRegion } from './types';
+export declare const REGIONS: Record<string, MapRegion>;
+export declare const COUNTRIES: Record<string, string[]>;
+export declare const DEFAULT_ZOOM: Record<string, number>;

package/dist/components/Maps/DottedMap/regions.js

@@ -0,0 +1,66 @@
+const a = {
+  usa: {
+    lat: { min: 24, max: 50 },
+    lng: { min: -125, max: -66 }
+  },
+  europe: {
+    lat: { min: 20, max: 72 },
+    lng: { min: -75, max: 75 }
+  },
+  asia: {
+    lat: { min: -10, max: 55 },
+    lng: { min: 60, max: 150 }
+  },
+  oceania: {
+    lat: { min: -50, max: 0 },
+    lng: { min: 110, max: 180 }
+  }
+}, n = {
+  europe: [
+    "FRA",
+    "DEU",
+    "BEL",
+    "NLD",
+    "LUX",
+    "CHE",
+    "AUT",
+    "CZE",
+    "POL",
+    "SVK",
+    "HUN",
+    "SVN",
+    "ITA",
+    "ESP",
+    "PRT",
+    "GBR",
+    "IRL",
+    "DNK",
+    "SWE",
+    "FIN",
+    "ISL",
+    "EST",
+    "LVA",
+    "LTU",
+    "HRV",
+    "SRB",
+    "BIH",
+    "MNE",
+    "MKD",
+    "UKR",
+    "BLR"
+  ],
+  asia: ["CHN", "IND", "JPN", "KOR", "IDN", "PAK", "BGD", "SAU", "IRN"],
+  usa: ["USA"],
+  oceania: ["AUS", "NZL"]
+}, m = {
+  world: 1,
+  europe: 0.75,
+  asia: 0.5,
+  oceania: 0.5,
+  usa: 0.5
+};
+export {
+  n as COUNTRIES,
+  m as DEFAULT_ZOOM,
+  a as REGIONS
+};

package/dist/components/Maps/DottedMap/types.d.ts

@@ -0,0 +1,127 @@
+export type MapRegion = {
+    lat: {
+        min: number;
+        max: number;
+    };
+    lng: {
+        min: number;
+        max: number;
+    };
+};
+export type MapPin = {
+    lat: number;
+    lng: number;
+    svgOptions?: {
+        color?: string;
+        radius?: number;
+        strokeColor?: string;
+        strokeWidth?: number;
+        strokeOpacity?: number;
+    };
+    data?: Record<string, unknown>;
+};
+export interface DottedMapProps {
+    /**
+     * The height of the map in dots.
+     * If specified, width will be calculated automatically to preserve aspect ratio.
+     */
+    mapHeight?: number;
+    /**
+     * The width of the map in dots.
+     * If specified, height will be calculated automatically to preserve aspect ratio.
+     */
+    mapWidth?: number;
+    /**
+     * Array of ISO 3166-1 alpha-3 country codes to include in the map.
+     * If omitted, the whole world is used.
+     */
+    countries?: string[];
+    /**
+     * Specific region to display.
+     */
+    region?: MapRegion;
+    /**
+     * How points should be aligned.
+     * @default 'vertical'
+     */
+    grid?: 'vertical' | 'diagonal';
+    /**
+     * If true, prevent adding pins when they are outside of region/countries.
+     * @default false
+     */
+    avoidOuterPins?: boolean;
+    /**
+     * Array of pins to add to the map.
+     */
+    pins?: MapPin[];
+    /**
+     * Precomputed map data (JSON string or object).
+     * If provided, it will be used instead of computing the map from scratch.
+     */
+    precomputedMap?: string | object;
+    /**
+     * Default color of the dots.
+     * @default '#ffffff'
+     */
+    color?: string;
+    /**
+     * Default size (radius) of the dots.
+     * @default 0.5
+     */
+    dotSize?: number;
+    /**
+     * Stroke color of the dots.
+     */
+    strokeColor?: string;
+    /**
+     * Stroke width of the dots.
+     */
+    strokeWidth?: number;
+    /**
+     * Stroke opacity of the dots.
+     */
+    strokeOpacity?: number;
+    /**
+     * Shape of the dots.
+     * @default 'circle'
+     */
+    shape?: 'circle' | 'hexagon';
+    /**
+     * Custom colors for specific countries.
+     */
+    countryColors?: Record<string, string>;
+    /**
+     * Background color of the map container.
+     */
+    backgroundColor?: string;
+}
+export type DottedWorldMapProps = DottedMapProps;
+export interface MapVariant {
+    mapWidth?: number;
+    mapHeight?: number;
+    dotSize?: number;
+    grid?: 'vertical' | 'diagonal';
+    shape?: 'circle' | 'hexagon';
+    /**
+     * Custom colors for specific countries.
+     */
+    countryColors?: Record<string, string>;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    countries?: string[];
+    region?: MapRegion;
+    pins?: MapPin[];
+    color?: string;
+    defaultZoom?: number;
+}
+export type MapRegionName = 'world' | 'europe' | 'asia' | 'oceania' | 'usa';
+export interface MapLegendItem {
+    color: string;
+    label: string;
+}
+export interface ZoomConfig {
+    min: number;
+    max: number;
+    step: number;
+    default: number;
+}

package/dist/components/Maps/DottedMap/useMapPanZoom.d.ts

@@ -0,0 +1,22 @@
+export interface PanZoomState {
+    x: number;
+    y: number;
+}
+export interface UseMapPanZoomOptions {
+    minScale?: number;
+    maxScale?: number;
+    scaleStep?: number;
+}
+export declare function useMapPanZoom(options?: UseMapPanZoomOptions): {
+    scale: import('vue').Ref<number, number>;
+    offset: {
+        x: number;
+        y: number;
+    };
+    zoomIn: () => void;
+    zoomOut: () => void;
+    resetView: (defaultZoom?: number) => void;
+    wasClick: () => boolean;
+    onWheel: (event: WheelEvent) => void;
+    onMouseDown: (event: MouseEvent) => void;
+};

package/dist/components/Maps/DottedMap/useMapPanZoom.js

@@ -0,0 +1,41 @@
+import { ref as X, reactive as y } from "vue";
+function b(x = {}) {
+  const {
+    minScale: w = 0.25,
+    maxScale: Y = 4,
+    scaleStep: a = 0.25
+  } = x, o = X(1), e = y({ x: 0, y: 0 });
+  let s = !1, l = 0, c = 0, u = 0, r = 0, n = !1;
+  const i = 5, m = () => {
+    o.value = Math.min(o.value + a, Y);
+  }, f = () => {
+    o.value = Math.max(o.value - a, w);
+  };
+  return {
+    scale: o,
+    offset: e,
+    zoomIn: m,
+    zoomOut: f,
+    resetView: (t = 1) => {
+      o.value = t, e.x = 0, e.y = 0;
+    },
+    wasClick: () => !n,
+    onWheel: (t) => {
+      t.preventDefault(), t.deltaY < 0 ? m() : f();
+    },
+    onMouseDown: (t) => {
+      s = !0, n = !1, l = t.clientX, c = t.clientY, u = e.x, r = e.y;
+      const v = (M) => {
+        if (!s) return;
+        const h = M.clientX - l, p = M.clientY - c;
+        (Math.abs(h) > i || Math.abs(p) > i) && (n = !0), e.x = u + h, e.y = r + p;
+      }, d = () => {
+        s = !1, document.removeEventListener("mousemove", v), document.removeEventListener("mouseup", d);
+      };
+      document.addEventListener("mousemove", v), document.addEventListener("mouseup", d);
+    }
+  };
+}
+export {
+  b as useMapPanZoom
+};

package/dist/components/Maps/TopoJSONMap/TopoJSONMap.js

@@ -0,0 +1,170 @@
+import { defineComponent as O, useSlots as A, useTemplateRef as y, ref as C, computed as c, createElementBlock as h, openBlock as d, normalizeStyle as f, createVNode as s, createCommentVNode as m, createElementVNode as J, unref as r, withCtx as R, createBlock as $, renderSlot as v } from "vue";
+import { VisSingleContainer as D, VisTopoJSONMap as K, VisTooltip as H, VisBulletLegend as q } from "@unovis/vue";
+import { TopoJSONMap as p } from "@unovis/ts";
+import G from "../../Tooltip.js";
+import { LegendPosition as I } from "../../../types.js";
+const Q = {
+  ref: "slotWrapper",
+  style: { display: "none" }
+}, et = /* @__PURE__ */ O({
+  __name: "TopoJSONMap",
+  props: {
+    mapFeatureKey: {},
+    data: {},
+    topojson: {},
+    zoomFactor: { default: 1 },
+    zoomExtent: { default: () => [0.5, 6] },
+    projection: {},
+    areaColor: {},
+    areaCursor: {},
+    pointColor: {},
+    pointSize: { type: [Number, Function], default: 5 },
+    pointLabel: {},
+    pointCursor: {},
+    linkColor: {},
+    linkWidth: {},
+    linkCursor: {},
+    height: {},
+    width: {},
+    fitView: { type: Boolean },
+    fitViewPadding: {},
+    hideTooltip: { type: Boolean },
+    tooltipTitleFormatter: {},
+    yFormatter: {},
+    categories: {},
+    legendPosition: { default: I.BottomCenter },
+    legendStyle: {},
+    hideLegend: { type: Boolean, default: !1 },
+    duration: { default: 600 },
+    pointStrokeWidth: {},
+    mapFitToPoints: { type: Boolean, default: !1 },
+    padding: { default: () => ({
+      top: 5,
+      right: 5,
+      bottom: 5,
+      left: 5
+    }) }
+  },
+  emits: ["mouseenter", "mouseleave", "feature-click", "point-click"],
+  setup(T, { emit: S }) {
+    const e = T, a = S, w = A(), g = y("slotWrapper"), n = C(), F = c(() => {
+      var t;
+      return (t = e.legendPosition) == null ? void 0 : t.startsWith("top");
+    }), P = c(() => {
+      var t, i;
+      return (t = e.legendPosition) != null && t.includes("left") ? "flex-start" : (i = e.legendPosition) != null && i.includes("right") ? "flex-end" : "center";
+    });
+    function k(t) {
+      return typeof window > "u" ? "" : g.value ? g.value.innerHTML : "";
+    }
+    const V = {
+      [p.selectors.feature]: (t) => {
+        const i = t.data ?? t.datum ?? {}, o = t.properties ?? {};
+        return n.value = { ...o, ...i, ...t }, k();
+      },
+      [p.selectors.point]: (t) => (n.value = t, k())
+    }, u = y("map"), z = (t) => e.pointLabel ? e.pointLabel(t) : t.label, W = (t) => typeof e.pointSize == "function" ? e.pointSize(t) : e.pointSize ?? t.radius ?? 5, j = (t) => typeof e.pointColor == "function" ? e.pointColor(t) : e.pointColor ?? t.color, x = (t) => {
+      var o;
+      if (typeof e.linkColor == "function") return e.linkColor(t);
+      const i = typeof t.source == "object" ? t.source : (o = e.data.points) == null ? void 0 : o.find((M) => M.id === t.target);
+      return e.linkColor ?? t.color ?? (i == null ? void 0 : i.color);
+    }, _ = (t) => typeof e.areaColor == "function" ? e.areaColor(t) : e.areaColor ?? t.color, b = (t) => typeof e.linkWidth == "function" ? e.linkWidth(t) : e.linkWidth ?? t.width ?? 1, L = C(null), B = (t, i) => {
+      a("feature-click", t, i);
+    }, N = (t, i) => {
+      var o;
+      L.value = t, a("point-click", t, i), (o = u.value) != null && o.component && u.value.component._fitToPoints([t], 0.1);
+    }, E = (t) => e.tooltipTitleFormatter ? e.tooltipTitleFormatter(t) : t ? ((t == null ? void 0 : t.properties) ?? {}).name ?? "" : "", l = c(() => e.data);
+    return (t, i) => (d(), h("div", {
+      style: f({
+        display: "flex",
+        flexDirection: F.value ? "column-reverse" : "column",
+        gap: "var(--vis-legend-spacing)"
+      })
+    }, [
+      s(r(D), {
+        duration: e.duration,
+        data: l.value,
+        height: e.height,
+        width: e.width,
+        padding: e.padding
+      }, {
+        default: R(() => [
+          s(r(K), {
+            ref_key: "map",
+            ref: u,
+            data: l.value.areas,
+            "point-data": l.value.points,
+            "link-data": l.value.links,
+            topojson: e.topojson,
+            projection: e.projection,
+            "zoom-factor": e.zoomFactor,
+            "zoom-extent": e.zoomExtent,
+            fitView: e.fitView,
+            fitViewPadding: e.fitViewPadding,
+            pointLabel: z,
+            pointRadius: W,
+            pointColor: j,
+            pointCursor: e.pointCursor,
+            pointStrokeWidth: e.pointStrokeWidth,
+            linkColor: x,
+            linkWidth: b,
+            linkCursor: e.linkCursor,
+            mapFitToPoints: e.mapFitToPoints,
+            areaColor: _,
+            areaCursor: e.areaCursor,
+            "map-feature-name": e.mapFeatureKey,
+            events: {
+              [r(p).selectors.feature]: {
+                click: B,
+                mouseover: (o) => a("mouseenter", o),
+                mouseout: (o) => a("mouseleave", o)
+              },
+              [r(p).selectors.point]: {
+                click: N
+              }
+            }
+          }, null, 8, ["data", "point-data", "link-data", "topojson", "projection", "zoom-factor", "zoom-extent", "fitView", "fitViewPadding", "pointCursor", "pointStrokeWidth", "linkCursor", "mapFitToPoints", "areaCursor", "map-feature-name", "events"]),
+          e.hideTooltip ? m("", !0) : (d(), $(r(H), {
+            key: 0,
+            triggers: V
+          }))
+        ]),
+        _: 1
+      }, 8, ["duration", "data", "height", "width", "padding"]),
+      e.categories && !e.hideLegend ? (d(), h("div", {
+        key: 0,
+        style: f({
+          display: "flex",
+          justifyContent: P.value
+        })
+      }, [
+        s(r(q), {
+          style: f([
+            e.legendStyle,
+            "display: flex; gap: var(--vis-legend-spacing);"
+          ]),
+          items: Object.values(e.categories).map((o) => ({
+            ...o,
+            color: Array.isArray(o.color) ? o.color[0] : o.color
+          }))
+        }, null, 8, ["style", "items"])
+      ], 4)) : m("", !0),
+      J("div", Q, [
+        r(w).tooltip ? v(t.$slots, "tooltip", {
+          key: 0,
+          values: n.value
+        }) : n.value ? v(t.$slots, "fallback", { key: 1 }, () => [
+          s(G, {
+            data: n.value,
+            categories: e.categories ?? {},
+            "title-formatter": e.tooltipTitleFormatter ?? E,
+            "y-formatter": e.yFormatter
+          }, null, 8, ["data", "categories", "title-formatter", "y-formatter"])
+        ]) : m("", !0)
+      ], 512)
+    ], 4));
+  }
+});
+export {
+  et as default
+};

package/dist/components/Maps/TopoJSONMap/TopoJSONMap.vue.d.ts

@@ -0,0 +1,30 @@
+import { MapsData } from './types';
+import { MapPoint } from '../types';
+declare const _default: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onMouseenter?: ((d: any) => any) | undefined;
+        readonly onMouseleave?: ((d: any) => any) | undefined;
+        readonly "onFeature-click"?: ((d: any, event: MouseEvent) => any) | undefined;
+        readonly "onPoint-click"?: ((d: MapPoint, event: MouseEvent) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onMouseenter" | "onMouseleave" | "onFeature-click" | "onPoint-click"> & MapsData<T> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        tooltip?(_: {
+            values: T | undefined;
+        }): any;
+        fallback?(_: {}): any;
+    };
+    emit: {
+        (e: "mouseenter", d: any): void;
+        (e: "mouseleave", d: any): void;
+        (e: "feature-click", d: any, event: MouseEvent): void;
+        (e: "point-click", d: MapPoint, event: MouseEvent): void;
+    };
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/Maps/TopoJSONMap/TopoJSONMap2.js

@@ -0,0 +1,4 @@
+import f from "./TopoJSONMap.js";
+export {
+  f as default
+};

package/dist/components/Maps/TopoJSONMap/data.d.ts

@@ -0,0 +1,13 @@
+import { MapLibreStyleSpecs } from '@unovis/ts';
+export type MapPointDataRecord = {
+    name: string;
+    longitude: number;
+    latitude: number;
+    normal: number;
+    blocked: number;
+};
+export declare const data: MapPointDataRecord[];
+export declare const totalEvents: number;
+export declare const generateStyle: (backgroundColor: string, countryFillColor: string, countryBoundaryColor: string, coastlineColor: string) => MapLibreStyleSpecs;
+export declare const mapStyleLight: MapLibreStyleSpecs;
+export declare const mapStyleDark: MapLibreStyleSpecs;