tempest-react-sdk 0.21.0 → 0.23.0

package/dist/geo/TrajectoryMap.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrajectoryMap.cjs","sources":["../../src/geo/TrajectoryMap.tsx"],"sourcesContent":["import { lazy, Suspense, useEffect, useMemo, useRef, useState, type HTMLAttributes } from \"react\";\nimport { cn } from \"@/utils/cn\";\nimport { boundingBox, expandBounds } from \"./bounds\";\nimport { haversineKm } from \"./distance\";\nimport { fitProjection, type PixelPoint } from \"./projection\";\nimport type { Coordinate, GeoMarker } from \"./types\";\nimport styles from \"./TrajectoryMap.module.css\";\n\n// Leaflet layer is loaded on demand — only when a `tileUrl` is supplied, so\n// apps that stick to the tile-free SVG never pull leaflet into their bundle.\nconst LeafletTrajectory = lazy(() =>\n    import(\"./leaflet-map\").then((m) => ({ default: m.LeafletTrajectory })),\n);\n\nexport interface TrajectoryMapProps extends Omit<HTMLAttributes<HTMLDivElement>, \"children\"> {\n    /** Ordered coordinates forming the trajectory. */\n    points: readonly Coordinate[];\n    /** Optional \"current position\" marker, drawn on top of the path. */\n    current?: Coordinate | null;\n    /** Viewport height in pixels. Default: `320`. */\n    height?: number;\n    /** Inner padding in pixels kept clear on every edge. Default: `24`. */\n    padding?: number;\n    /** Draw a light reference grid behind the path (SVG mode). Default: `true`. */\n    showGrid?: boolean;\n    /** Draw a distance scale bar (SVG mode). Default: `true`. */\n    showScale?: boolean;\n    /** Path stroke color. Default: the primary token. */\n    strokeColor?: string;\n    /**\n     * Tile URL template (`{z}/{x}/{y}`) of a map server **you host**. When set,\n     * the map upgrades to a real Leaflet tile layer (requires `leaflet` to be\n     * installed). Omit for the zero-dependency, zero-network SVG plot.\n     */\n    tileUrl?: string;\n    /** Attribution text shown over the tile layer. */\n    tileAttribution?: string;\n    /** Accessible label for the map region. Default: `\"Trajetória\"`. */\n    label?: string;\n    /** Point markers to overlay (e.g. stops, POIs). Included in the auto-fit. */\n    markers?: readonly GeoMarker[];\n    /** Fired when a marker is clicked. */\n    onMarkerClick?: (marker: GeoMarker, index: number) => void;\n}\n\nconst NICE_KM_STEPS = [0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000] as const;\n\n/** Pick the largest \"nice\" distance whose bar fits within `maxPixels`. */\nfunction pickScaleKm(kmPerPixel: number, maxPixels: number): { km: number; pixels: number } {\n    const maxKm = kmPerPixel * maxPixels;\n    let chosen: number = NICE_KM_STEPS[0];\n    for (const step of NICE_KM_STEPS) {\n        if (step <= maxKm) chosen = step;\n    }\n    return { km: chosen, pixels: chosen / kmPerPixel };\n}\n\n/** Format a distance in km for the scale bar (meters below 1 km). */\nfunction formatScale(km: number): string {\n    return km < 1 ? `${Math.round(km * 1000)} m` : `${km % 1 === 0 ? km : km.toFixed(1)} km`;\n}\n\n/**\n * Plot a GPS trajectory. By default it renders a **tile-free SVG** map (Web\n * Mercator projection, auto-fit to the points, optional grid + scale bar) —\n * 100% self-contained, no external tiles or paid API. Pass `tileUrl` pointing\n * at a map server **you host** to upgrade to a real Leaflet tile layer.\n *\n * @example\n * // Zero-dependency SVG plot\n * <TrajectoryMap points={points} current={lastPoint} height={360} />\n *\n * @example\n * // Real tiles from your own server (requires `leaflet` installed)\n * <TrajectoryMap points={points} tileUrl=\"https://tiles.internal/{z}/{x}/{y}.png\" />\n */\nexport function TrajectoryMap({\n    points,\n    current,\n    height = 320,\n    padding = 24,\n    showGrid = true,\n    showScale = true,\n    strokeColor,\n    tileUrl,\n    tileAttribution,\n    label = \"Trajetória\",\n    markers,\n    onMarkerClick,\n    className,\n    style,\n    ...rest\n}: TrajectoryMapProps) {\n    const containerRef = useRef<HTMLDivElement>(null);\n    const [width, setWidth] = useState<number>(600);\n\n    useEffect(() => {\n        const node = containerRef.current;\n        if (!node || typeof ResizeObserver === \"undefined\") return;\n        const observer = new ResizeObserver((entries) => {\n            const measured = entries[0]?.contentRect.width;\n            if (measured && measured > 0) setWidth(measured);\n        });\n        observer.observe(node);\n        return () => observer.disconnect();\n    }, []);\n\n    const allPoints = useMemo<Coordinate[]>(\n        () => [...points, ...(current ? [current] : []), ...(markers ?? [])],\n        [points, current, markers],\n    );\n\n    const svg = useMemo(() => {\n        const box = boundingBox(allPoints);\n        if (!box) return null;\n\n        const projection = fitProjection(expandBounds(box, 0.12), width, height, { padding });\n        const pixels: PixelPoint[] = points.map((p) => projection.project(p));\n        const polyline = pixels.map((p) => `${p.x.toFixed(1)},${p.y.toFixed(1)}`).join(\" \");\n\n        const startPixel = pixels[0] ?? null;\n        const endPixel = pixels.length > 0 ? pixels[pixels.length - 1] : null;\n        const currentPixel = current ? projection.project(current) : null;\n\n        // Distance-per-pixel at the map center, for the scale bar: measure the\n        // center → east-edge span in both km (haversine) and pixels (projected).\n        const centerCoord = {\n            latitude: (box.minLatitude + box.maxLatitude) / 2,\n            longitude: (box.minLongitude + box.maxLongitude) / 2,\n        };\n        const center = projection.project(centerCoord);\n        const eastRef = projection.project({ ...centerCoord, longitude: box.maxLongitude });\n        const edgeKm = haversineKm(centerCoord, { ...centerCoord, longitude: box.maxLongitude });\n        const edgePixels = Math.abs(eastRef.x - center.x) || 1;\n        const kmPerPixel = edgeKm / edgePixels || 0;\n\n        const markerPixels = (markers ?? []).map((m) => ({ marker: m, p: projection.project(m) }));\n\n        return { polyline, startPixel, endPixel, currentPixel, kmPerPixel, markerPixels };\n    }, [allPoints, points, current, markers, width, height, padding]);\n\n    // ── Leaflet tile mode ────────────────────────────────────────────────────\n    if (tileUrl) {\n        return (\n            <div\n                ref={containerRef}\n                className={cn(styles.map, className)}\n                style={{ height, ...style }}\n                role=\"img\"\n                aria-label={label}\n                {...rest}\n            >\n                <Suspense fallback={<div className={styles.loading}>Carregando mapa…</div>}>\n                    <LeafletTrajectory\n                        points={points}\n                        current={current}\n                        tileUrl={tileUrl}\n                        tileAttribution={tileAttribution}\n                        strokeColor={strokeColor}\n                    />\n                </Suspense>\n            </div>\n        );\n    }\n\n    // ── Tile-free SVG mode ─────────────────────────────────────────────────────\n    const scale =\n        showScale && svg && svg.kmPerPixel > 0\n            ? pickScaleKm(svg.kmPerPixel, Math.min(120, width * 0.35))\n            : null;\n\n    return (\n        <div\n            ref={containerRef}\n            className={cn(styles.map, className)}\n            style={{ height, ...style }}\n            role=\"img\"\n            aria-label={label}\n            {...rest}\n        >\n            {!svg ? (\n                <div className={styles.empty}>Sem pontos de trajetória ainda.</div>\n            ) : (\n                <svg\n                    className={styles.svg}\n                    width=\"100%\"\n                    height={height}\n                    viewBox={`0 0 ${width} ${height}`}\n                    preserveAspectRatio=\"xMidYMid meet\"\n                >\n                    {showGrid && (\n                        <g className={styles.grid}>\n                            {[0.25, 0.5, 0.75].map((f) => (\n                                <line\n                                    key={`h${f}`}\n                                    x1={0}\n                                    y1={height * f}\n                                    x2={width}\n                                    y2={height * f}\n                                />\n                            ))}\n                            {[0.25, 0.5, 0.75].map((f) => (\n                                <line\n                                    key={`v${f}`}\n                                    x1={width * f}\n                                    y1={0}\n                                    x2={width * f}\n                                    y2={height}\n                                />\n                            ))}\n                        </g>\n                    )}\n\n                    {svg.polyline && (\n                        <polyline\n                            className={styles.path}\n                            points={svg.polyline}\n                            fill=\"none\"\n                            stroke={strokeColor}\n                            data-testid=\"trajectory-path\"\n                        />\n                    )}\n\n                    {svg.startPixel && (\n                        <circle\n                            className={styles.start}\n                            cx={svg.startPixel.x}\n                            cy={svg.startPixel.y}\n                            r={5}\n                        />\n                    )}\n                    {svg.endPixel && !current && (\n                        <circle\n                            className={styles.end}\n                            cx={svg.endPixel.x}\n                            cy={svg.endPixel.y}\n                            r={5}\n                        />\n                    )}\n                    {svg.currentPixel && (\n                        <>\n                            <circle\n                                className={styles.pulse}\n                                cx={svg.currentPixel.x}\n                                cy={svg.currentPixel.y}\n                                r={10}\n                            />\n                            <circle\n                                className={styles.current}\n                                cx={svg.currentPixel.x}\n                                cy={svg.currentPixel.y}\n                                r={5}\n                            />\n                        </>\n                    )}\n\n                    {svg.markerPixels.map(({ marker, p }, i) => {\n                        const interactive = Boolean(onMarkerClick);\n                        return (\n                            <circle\n                                key={marker.id ?? i}\n                                className={styles.marker}\n                                cx={p.x}\n                                cy={p.y}\n                                r={marker.radius ?? 6}\n                                style={marker.color ? { fill: marker.color } : undefined}\n                                data-marker-id={marker.id ?? i}\n                                tabIndex={interactive ? 0 : undefined}\n                                role={interactive ? \"button\" : undefined}\n                                aria-label={marker.label}\n                                onClick={interactive ? () => onMarkerClick?.(marker, i) : undefined}\n                                onKeyDown={\n                                    interactive\n                                        ? (e) => {\n                                              if (e.key === \"Enter\" || e.key === \" \") {\n                                                  e.preventDefault();\n                                                  onMarkerClick?.(marker, i);\n                                              }\n                                          }\n                                        : undefined\n                                }\n                            >\n                                {marker.label ? <title>{marker.label}</title> : null}\n                            </circle>\n                        );\n                    })}\n\n                    {scale && (\n                        <g\n                            className={styles.scale}\n                            transform={`translate(${padding}, ${height - padding})`}\n                        >\n                            <line x1={0} y1={0} x2={scale.pixels} y2={0} />\n                            <line x1={0} y1={-4} x2={0} y2={4} />\n                            <line x1={scale.pixels} y1={-4} x2={scale.pixels} y2={4} />\n                            <text x={scale.pixels / 2} y={-8} textAnchor=\"middle\">\n                                {formatScale(scale.km)}\n                            </text>\n                        </g>\n                    )}\n                </svg>\n            )}\n        </div>\n    );\n}\n"],"names":["LeafletTrajectory","lazy","m","NICE_KM_STEPS","pickScaleKm","kmPerPixel","maxPixels","maxKm","chosen","step","formatScale","km","TrajectoryMap","points","current","height","padding","showGrid","showScale","strokeColor","tileUrl","tileAttribution","label","markers","onMarkerClick","className","style","rest","containerRef","useRef","width","setWidth","useState","useEffect","node","observer","entries","measured","allPoints","useMemo","svg","box","boundingBox","projection","fitProjection","expandBounds","pixels","p","polyline","startPixel","endPixel","currentPixel","centerCoord","center","eastRef","edgeKm","haversineKm","edgePixels","markerPixels","jsx","cn","styles","Suspense","scale","jsxs","f","Fragment","marker","interactive","e"],"mappings":"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"}

package/dist/geo/TrajectoryMap.js

@@ -0,0 +1,216 @@
+import { jsx as t, jsxs as v, Fragment as W } from "react/jsx-runtime";
+import { useRef as Y, useState as q, useEffect as G, useMemo as w, Suspense as H, lazy as J } from "react";
+import { cn as K } from "../utils/cn.js";
+import { boundingBox as Q, expandBounds as V } from "./bounds.js";
+import { haversineKm as X } from "./distance.js";
+import { fitProjection as Z } from "./projection.js";
+import i from "./TrajectoryMap.module.css.js";
+const U = J(
+  () => import("./leaflet-map.js").then((n) => ({ default: n.LeafletTrajectory }))
+), M = [0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 25, 50, 100, 250, 500, 1e3];
+function k(n, s) {
+  const o = n * s;
+  let x = M[0];
+  for (const y of M)
+    y <= o && (x = y);
+  return { km: x, pixels: x / n };
+}
+function ee(n) {
+  return n < 1 ? `${Math.round(n * 1e3)} m` : `${n % 1 === 0 ? n : n.toFixed(1)} km`;
+}
+function se({
+  points: n,
+  current: s,
+  height: o = 320,
+  padding: x = 24,
+  showGrid: y = !0,
+  showScale: T = !0,
+  strokeColor: N,
+  tileUrl: g,
+  tileAttribution: B,
+  label: h = "Trajetória",
+  markers: f,
+  onMarkerClick: j,
+  className: $,
+  style: L,
+  ...R
+}) {
+  const b = Y(null), [d, E] = q(600);
+  G(() => {
+    const e = b.current;
+    if (!e || typeof ResizeObserver > "u") return;
+    const r = new ResizeObserver((c) => {
+      const a = c[0]?.contentRect.width;
+      a && a > 0 && E(a);
+    });
+    return r.observe(e), () => r.disconnect();
+  }, []);
+  const S = w(
+    () => [...n, ...s ? [s] : [], ...f ?? []],
+    [n, s, f]
+  ), l = w(() => {
+    const e = Q(S);
+    if (!e) return null;
+    const r = Z(V(e, 0.12), d, o, { padding: x }), c = n.map((m) => r.project(m)), a = c.map((m) => `${m.x.toFixed(1)},${m.y.toFixed(1)}`).join(" "), p = c[0] ?? null, F = c.length > 0 ? c[c.length - 1] : null, z = s ? r.project(s) : null, P = {
+      latitude: (e.minLatitude + e.maxLatitude) / 2,
+      longitude: (e.minLongitude + e.maxLongitude) / 2
+    }, A = r.project(P), D = r.project({ ...P, longitude: e.maxLongitude }), I = X(P, { ...P, longitude: e.maxLongitude }), O = Math.abs(D.x - A.x) || 1, _ = I / O || 0, C = (f ?? []).map((m) => ({ marker: m, p: r.project(m) }));
+    return { polyline: a, startPixel: p, endPixel: F, currentPixel: z, kmPerPixel: _, markerPixels: C };
+  }, [S, n, s, f, d, o, x]);
+  if (g)
+    return /* @__PURE__ */ t(
+      "div",
+      {
+        ref: b,
+        className: K(i.map, $),
+        style: { height: o, ...L },
+        role: "img",
+        "aria-label": h,
+        ...R,
+        children: /* @__PURE__ */ t(H, { fallback: /* @__PURE__ */ t("div", { className: i.loading, children: "Carregando mapa…" }), children: /* @__PURE__ */ t(
+          U,
+          {
+            points: n,
+            current: s,
+            tileUrl: g,
+            tileAttribution: B,
+            strokeColor: N
+          }
+        ) })
+      }
+    );
+  const u = T && l && l.kmPerPixel > 0 ? k(l.kmPerPixel, Math.min(120, d * 0.35)) : null;
+  return /* @__PURE__ */ t(
+    "div",
+    {
+      ref: b,
+      className: K(i.map, $),
+      style: { height: o, ...L },
+      role: "img",
+      "aria-label": h,
+      ...R,
+      children: l ? /* @__PURE__ */ v(
+        "svg",
+        {
+          className: i.svg,
+          width: "100%",
+          height: o,
+          viewBox: `0 0 ${d} ${o}`,
+          preserveAspectRatio: "xMidYMid meet",
+          children: [
+            y && /* @__PURE__ */ v("g", { className: i.grid, children: [
+              [0.25, 0.5, 0.75].map((e) => /* @__PURE__ */ t(
+                "line",
+                {
+                  x1: 0,
+                  y1: o * e,
+                  x2: d,
+                  y2: o * e
+                },
+                `h${e}`
+              )),
+              [0.25, 0.5, 0.75].map((e) => /* @__PURE__ */ t(
+                "line",
+                {
+                  x1: d * e,
+                  y1: 0,
+                  x2: d * e,
+                  y2: o
+                },
+                `v${e}`
+              ))
+            ] }),
+            l.polyline && /* @__PURE__ */ t(
+              "polyline",
+              {
+                className: i.path,
+                points: l.polyline,
+                fill: "none",
+                stroke: N,
+                "data-testid": "trajectory-path"
+              }
+            ),
+            l.startPixel && /* @__PURE__ */ t(
+              "circle",
+              {
+                className: i.start,
+                cx: l.startPixel.x,
+                cy: l.startPixel.y,
+                r: 5
+              }
+            ),
+            l.endPixel && !s && /* @__PURE__ */ t(
+              "circle",
+              {
+                className: i.end,
+                cx: l.endPixel.x,
+                cy: l.endPixel.y,
+                r: 5
+              }
+            ),
+            l.currentPixel && /* @__PURE__ */ v(W, { children: [
+              /* @__PURE__ */ t(
+                "circle",
+                {
+                  className: i.pulse,
+                  cx: l.currentPixel.x,
+                  cy: l.currentPixel.y,
+                  r: 10
+                }
+              ),
+              /* @__PURE__ */ t(
+                "circle",
+                {
+                  className: i.current,
+                  cx: l.currentPixel.x,
+                  cy: l.currentPixel.y,
+                  r: 5
+                }
+              )
+            ] }),
+            l.markerPixels.map(({ marker: e, p: r }, c) => {
+              const a = !!j;
+              return /* @__PURE__ */ t(
+                "circle",
+                {
+                  className: i.marker,
+                  cx: r.x,
+                  cy: r.y,
+                  r: e.radius ?? 6,
+                  style: e.color ? { fill: e.color } : void 0,
+                  "data-marker-id": e.id ?? c,
+                  tabIndex: a ? 0 : void 0,
+                  role: a ? "button" : void 0,
+                  "aria-label": e.label,
+                  onClick: a ? () => j?.(e, c) : void 0,
+                  onKeyDown: a ? (p) => {
+                    (p.key === "Enter" || p.key === " ") && (p.preventDefault(), j?.(e, c));
+                  } : void 0,
+                  children: e.label ? /* @__PURE__ */ t("title", { children: e.label }) : null
+                },
+                e.id ?? c
+              );
+            }),
+            u && /* @__PURE__ */ v(
+              "g",
+              {
+                className: i.scale,
+                transform: `translate(${x}, ${o - x})`,
+                children: [
+                  /* @__PURE__ */ t("line", { x1: 0, y1: 0, x2: u.pixels, y2: 0 }),
+                  /* @__PURE__ */ t("line", { x1: 0, y1: -4, x2: 0, y2: 4 }),
+                  /* @__PURE__ */ t("line", { x1: u.pixels, y1: -4, x2: u.pixels, y2: 4 }),
+                  /* @__PURE__ */ t("text", { x: u.pixels / 2, y: -8, textAnchor: "middle", children: ee(u.km) })
+                ]
+              }
+            )
+          ]
+        }
+      ) : /* @__PURE__ */ t("div", { className: i.empty, children: "Sem pontos de trajetória ainda." })
+    }
+  );
+}
+export {
+  se as TrajectoryMap
+};
+//# sourceMappingURL=TrajectoryMap.js.map

package/dist/geo/TrajectoryMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrajectoryMap.js","sources":["../../src/geo/TrajectoryMap.tsx"],"sourcesContent":["import { lazy, Suspense, useEffect, useMemo, useRef, useState, type HTMLAttributes } from \"react\";\nimport { cn } from \"@/utils/cn\";\nimport { boundingBox, expandBounds } from \"./bounds\";\nimport { haversineKm } from \"./distance\";\nimport { fitProjection, type PixelPoint } from \"./projection\";\nimport type { Coordinate, GeoMarker } from \"./types\";\nimport styles from \"./TrajectoryMap.module.css\";\n\n// Leaflet layer is loaded on demand — only when a `tileUrl` is supplied, so\n// apps that stick to the tile-free SVG never pull leaflet into their bundle.\nconst LeafletTrajectory = lazy(() =>\n    import(\"./leaflet-map\").then((m) => ({ default: m.LeafletTrajectory })),\n);\n\nexport interface TrajectoryMapProps extends Omit<HTMLAttributes<HTMLDivElement>, \"children\"> {\n    /** Ordered coordinates forming the trajectory. */\n    points: readonly Coordinate[];\n    /** Optional \"current position\" marker, drawn on top of the path. */\n    current?: Coordinate | null;\n    /** Viewport height in pixels. Default: `320`. */\n    height?: number;\n    /** Inner padding in pixels kept clear on every edge. Default: `24`. */\n    padding?: number;\n    /** Draw a light reference grid behind the path (SVG mode). Default: `true`. */\n    showGrid?: boolean;\n    /** Draw a distance scale bar (SVG mode). Default: `true`. */\n    showScale?: boolean;\n    /** Path stroke color. Default: the primary token. */\n    strokeColor?: string;\n    /**\n     * Tile URL template (`{z}/{x}/{y}`) of a map server **you host**. When set,\n     * the map upgrades to a real Leaflet tile layer (requires `leaflet` to be\n     * installed). Omit for the zero-dependency, zero-network SVG plot.\n     */\n    tileUrl?: string;\n    /** Attribution text shown over the tile layer. */\n    tileAttribution?: string;\n    /** Accessible label for the map region. Default: `\"Trajetória\"`. */\n    label?: string;\n    /** Point markers to overlay (e.g. stops, POIs). Included in the auto-fit. */\n    markers?: readonly GeoMarker[];\n    /** Fired when a marker is clicked. */\n    onMarkerClick?: (marker: GeoMarker, index: number) => void;\n}\n\nconst NICE_KM_STEPS = [0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000] as const;\n\n/** Pick the largest \"nice\" distance whose bar fits within `maxPixels`. */\nfunction pickScaleKm(kmPerPixel: number, maxPixels: number): { km: number; pixels: number } {\n    const maxKm = kmPerPixel * maxPixels;\n    let chosen: number = NICE_KM_STEPS[0];\n    for (const step of NICE_KM_STEPS) {\n        if (step <= maxKm) chosen = step;\n    }\n    return { km: chosen, pixels: chosen / kmPerPixel };\n}\n\n/** Format a distance in km for the scale bar (meters below 1 km). */\nfunction formatScale(km: number): string {\n    return km < 1 ? `${Math.round(km * 1000)} m` : `${km % 1 === 0 ? km : km.toFixed(1)} km`;\n}\n\n/**\n * Plot a GPS trajectory. By default it renders a **tile-free SVG** map (Web\n * Mercator projection, auto-fit to the points, optional grid + scale bar) —\n * 100% self-contained, no external tiles or paid API. Pass `tileUrl` pointing\n * at a map server **you host** to upgrade to a real Leaflet tile layer.\n *\n * @example\n * // Zero-dependency SVG plot\n * <TrajectoryMap points={points} current={lastPoint} height={360} />\n *\n * @example\n * // Real tiles from your own server (requires `leaflet` installed)\n * <TrajectoryMap points={points} tileUrl=\"https://tiles.internal/{z}/{x}/{y}.png\" />\n */\nexport function TrajectoryMap({\n    points,\n    current,\n    height = 320,\n    padding = 24,\n    showGrid = true,\n    showScale = true,\n    strokeColor,\n    tileUrl,\n    tileAttribution,\n    label = \"Trajetória\",\n    markers,\n    onMarkerClick,\n    className,\n    style,\n    ...rest\n}: TrajectoryMapProps) {\n    const containerRef = useRef<HTMLDivElement>(null);\n    const [width, setWidth] = useState<number>(600);\n\n    useEffect(() => {\n        const node = containerRef.current;\n        if (!node || typeof ResizeObserver === \"undefined\") return;\n        const observer = new ResizeObserver((entries) => {\n            const measured = entries[0]?.contentRect.width;\n            if (measured && measured > 0) setWidth(measured);\n        });\n        observer.observe(node);\n        return () => observer.disconnect();\n    }, []);\n\n    const allPoints = useMemo<Coordinate[]>(\n        () => [...points, ...(current ? [current] : []), ...(markers ?? [])],\n        [points, current, markers],\n    );\n\n    const svg = useMemo(() => {\n        const box = boundingBox(allPoints);\n        if (!box) return null;\n\n        const projection = fitProjection(expandBounds(box, 0.12), width, height, { padding });\n        const pixels: PixelPoint[] = points.map((p) => projection.project(p));\n        const polyline = pixels.map((p) => `${p.x.toFixed(1)},${p.y.toFixed(1)}`).join(\" \");\n\n        const startPixel = pixels[0] ?? null;\n        const endPixel = pixels.length > 0 ? pixels[pixels.length - 1] : null;\n        const currentPixel = current ? projection.project(current) : null;\n\n        // Distance-per-pixel at the map center, for the scale bar: measure the\n        // center → east-edge span in both km (haversine) and pixels (projected).\n        const centerCoord = {\n            latitude: (box.minLatitude + box.maxLatitude) / 2,\n            longitude: (box.minLongitude + box.maxLongitude) / 2,\n        };\n        const center = projection.project(centerCoord);\n        const eastRef = projection.project({ ...centerCoord, longitude: box.maxLongitude });\n        const edgeKm = haversineKm(centerCoord, { ...centerCoord, longitude: box.maxLongitude });\n        const edgePixels = Math.abs(eastRef.x - center.x) || 1;\n        const kmPerPixel = edgeKm / edgePixels || 0;\n\n        const markerPixels = (markers ?? []).map((m) => ({ marker: m, p: projection.project(m) }));\n\n        return { polyline, startPixel, endPixel, currentPixel, kmPerPixel, markerPixels };\n    }, [allPoints, points, current, markers, width, height, padding]);\n\n    // ── Leaflet tile mode ────────────────────────────────────────────────────\n    if (tileUrl) {\n        return (\n            <div\n                ref={containerRef}\n                className={cn(styles.map, className)}\n                style={{ height, ...style }}\n                role=\"img\"\n                aria-label={label}\n                {...rest}\n            >\n                <Suspense fallback={<div className={styles.loading}>Carregando mapa…</div>}>\n                    <LeafletTrajectory\n                        points={points}\n                        current={current}\n                        tileUrl={tileUrl}\n                        tileAttribution={tileAttribution}\n                        strokeColor={strokeColor}\n                    />\n                </Suspense>\n            </div>\n        );\n    }\n\n    // ── Tile-free SVG mode ─────────────────────────────────────────────────────\n    const scale =\n        showScale && svg && svg.kmPerPixel > 0\n            ? pickScaleKm(svg.kmPerPixel, Math.min(120, width * 0.35))\n            : null;\n\n    return (\n        <div\n            ref={containerRef}\n            className={cn(styles.map, className)}\n            style={{ height, ...style }}\n            role=\"img\"\n            aria-label={label}\n            {...rest}\n        >\n            {!svg ? (\n                <div className={styles.empty}>Sem pontos de trajetória ainda.</div>\n            ) : (\n                <svg\n                    className={styles.svg}\n                    width=\"100%\"\n                    height={height}\n                    viewBox={`0 0 ${width} ${height}`}\n                    preserveAspectRatio=\"xMidYMid meet\"\n                >\n                    {showGrid && (\n                        <g className={styles.grid}>\n                            {[0.25, 0.5, 0.75].map((f) => (\n                                <line\n                                    key={`h${f}`}\n                                    x1={0}\n                                    y1={height * f}\n                                    x2={width}\n                                    y2={height * f}\n                                />\n                            ))}\n                            {[0.25, 0.5, 0.75].map((f) => (\n                                <line\n                                    key={`v${f}`}\n                                    x1={width * f}\n                                    y1={0}\n                                    x2={width * f}\n                                    y2={height}\n                                />\n                            ))}\n                        </g>\n                    )}\n\n                    {svg.polyline && (\n                        <polyline\n                            className={styles.path}\n                            points={svg.polyline}\n                            fill=\"none\"\n                            stroke={strokeColor}\n                            data-testid=\"trajectory-path\"\n                        />\n                    )}\n\n                    {svg.startPixel && (\n                        <circle\n                            className={styles.start}\n                            cx={svg.startPixel.x}\n                            cy={svg.startPixel.y}\n                            r={5}\n                        />\n                    )}\n                    {svg.endPixel && !current && (\n                        <circle\n                            className={styles.end}\n                            cx={svg.endPixel.x}\n                            cy={svg.endPixel.y}\n                            r={5}\n                        />\n                    )}\n                    {svg.currentPixel && (\n                        <>\n                            <circle\n                                className={styles.pulse}\n                                cx={svg.currentPixel.x}\n                                cy={svg.currentPixel.y}\n                                r={10}\n                            />\n                            <circle\n                                className={styles.current}\n                                cx={svg.currentPixel.x}\n                                cy={svg.currentPixel.y}\n                                r={5}\n                            />\n                        </>\n                    )}\n\n                    {svg.markerPixels.map(({ marker, p }, i) => {\n                        const interactive = Boolean(onMarkerClick);\n                        return (\n                            <circle\n                                key={marker.id ?? i}\n                                className={styles.marker}\n                                cx={p.x}\n                                cy={p.y}\n                                r={marker.radius ?? 6}\n                                style={marker.color ? { fill: marker.color } : undefined}\n                                data-marker-id={marker.id ?? i}\n                                tabIndex={interactive ? 0 : undefined}\n                                role={interactive ? \"button\" : undefined}\n                                aria-label={marker.label}\n                                onClick={interactive ? () => onMarkerClick?.(marker, i) : undefined}\n                                onKeyDown={\n                                    interactive\n                                        ? (e) => {\n                                              if (e.key === \"Enter\" || e.key === \" \") {\n                                                  e.preventDefault();\n                                                  onMarkerClick?.(marker, i);\n                                              }\n                                          }\n                                        : undefined\n                                }\n                            >\n                                {marker.label ? <title>{marker.label}</title> : null}\n                            </circle>\n                        );\n                    })}\n\n                    {scale && (\n                        <g\n                            className={styles.scale}\n                            transform={`translate(${padding}, ${height - padding})`}\n                        >\n                            <line x1={0} y1={0} x2={scale.pixels} y2={0} />\n                            <line x1={0} y1={-4} x2={0} y2={4} />\n                            <line x1={scale.pixels} y1={-4} x2={scale.pixels} y2={4} />\n                            <text x={scale.pixels / 2} y={-8} textAnchor=\"middle\">\n                                {formatScale(scale.km)}\n                            </text>\n                        </g>\n                    )}\n                </svg>\n            )}\n        </div>\n    );\n}\n"],"names":["LeafletTrajectory","lazy","m","NICE_KM_STEPS","pickScaleKm","kmPerPixel","maxPixels","maxKm","chosen","step","formatScale","km","TrajectoryMap","points","current","height","padding","showGrid","showScale","strokeColor","tileUrl","tileAttribution","label","markers","onMarkerClick","className","style","rest","containerRef","useRef","width","setWidth","useState","useEffect","node","observer","entries","measured","allPoints","useMemo","svg","box","boundingBox","projection","fitProjection","expandBounds","pixels","p","polyline","startPixel","endPixel","currentPixel","centerCoord","center","eastRef","edgeKm","haversineKm","edgePixels","markerPixels","jsx","cn","styles","Suspense","scale","jsxs","f","Fragment","marker","i","interactive","e"],"mappings":";;;;;;;AAUA,MAAMA,IAAoBC;AAAA,EAAK,MAC3B,OAAO,kBAAe,EAAE,KAAK,CAACC,OAAO,EAAE,SAASA,EAAE,oBAAoB;AAC1E,GAiCMC,IAAgB,CAAC,MAAM,KAAK,MAAM,KAAK,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,GAAI;AAGrF,SAASC,EAAYC,GAAoBC,GAAmD;AACxF,QAAMC,IAAQF,IAAaC;AAC3B,MAAIE,IAAiBL,EAAc,CAAC;AACpC,aAAWM,KAAQN;AACf,IAAIM,KAAQF,MAAOC,IAASC;AAEhC,SAAO,EAAE,IAAID,GAAQ,QAAQA,IAASH,EAAA;AAC1C;AAGA,SAASK,GAAYC,GAAoB;AACrC,SAAOA,IAAK,IAAI,GAAG,KAAK,MAAMA,IAAK,GAAI,CAAC,OAAO,GAAGA,IAAK,MAAM,IAAIA,IAAKA,EAAG,QAAQ,CAAC,CAAC;AACvF;AAgBO,SAASC,GAAc;AAAA,EAC1B,QAAAC;AAAA,EACA,SAAAC;AAAA,EACA,QAAAC,IAAS;AAAA,EACT,SAAAC,IAAU;AAAA,EACV,UAAAC,IAAW;AAAA,EACX,WAAAC,IAAY;AAAA,EACZ,aAAAC;AAAA,EACA,SAAAC;AAAA,EACA,iBAAAC;AAAA,EACA,OAAAC,IAAQ;AAAA,EACR,SAAAC;AAAA,EACA,eAAAC;AAAA,EACA,WAAAC;AAAA,EACA,OAAAC;AAAA,EACA,GAAGC;AACP,GAAuB;AACnB,QAAMC,IAAeC,EAAuB,IAAI,GAC1C,CAACC,GAAOC,CAAQ,IAAIC,EAAiB,GAAG;AAE9C,EAAAC,EAAU,MAAM;AACZ,UAAMC,IAAON,EAAa;AAC1B,QAAI,CAACM,KAAQ,OAAO,iBAAmB,IAAa;AACpD,UAAMC,IAAW,IAAI,eAAe,CAACC,MAAY;AAC7C,YAAMC,IAAWD,EAAQ,CAAC,GAAG,YAAY;AACzC,MAAIC,KAAYA,IAAW,KAAGN,EAASM,CAAQ;AAAA,IACnD,CAAC;AACD,WAAAF,EAAS,QAAQD,CAAI,GACd,MAAMC,EAAS,WAAA;AAAA,EAC1B,GAAG,CAAA,CAAE;AAEL,QAAMG,IAAYC;AAAA,IACd,MAAM,CAAC,GAAG1B,GAAQ,GAAIC,IAAU,CAACA,CAAO,IAAI,CAAA,GAAK,GAAIS,KAAW,EAAG;AAAA,IACnE,CAACV,GAAQC,GAASS,CAAO;AAAA,EAAA,GAGvBiB,IAAMD,EAAQ,MAAM;AACtB,UAAME,IAAMC,EAAYJ,CAAS;AACjC,QAAI,CAACG,EAAK,QAAO;AAEjB,UAAME,IAAaC,EAAcC,EAAaJ,GAAK,IAAI,GAAGX,GAAOf,GAAQ,EAAE,SAAAC,GAAS,GAC9E8B,IAAuBjC,EAAO,IAAI,CAACkC,MAAMJ,EAAW,QAAQI,CAAC,CAAC,GAC9DC,IAAWF,EAAO,IAAI,CAACC,MAAM,GAAGA,EAAE,EAAE,QAAQ,CAAC,CAAC,IAAIA,EAAE,EAAE,QAAQ,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG,GAE5EE,IAAaH,EAAO,CAAC,KAAK,MAC1BI,IAAWJ,EAAO,SAAS,IAAIA,EAAOA,EAAO,SAAS,CAAC,IAAI,MAC3DK,IAAerC,IAAU6B,EAAW,QAAQ7B,CAAO,IAAI,MAIvDsC,IAAc;AAAA,MAChB,WAAWX,EAAI,cAAcA,EAAI,eAAe;AAAA,MAChD,YAAYA,EAAI,eAAeA,EAAI,gBAAgB;AAAA,IAAA,GAEjDY,IAASV,EAAW,QAAQS,CAAW,GACvCE,IAAUX,EAAW,QAAQ,EAAE,GAAGS,GAAa,WAAWX,EAAI,cAAc,GAC5Ec,IAASC,EAAYJ,GAAa,EAAE,GAAGA,GAAa,WAAWX,EAAI,cAAc,GACjFgB,IAAa,KAAK,IAAIH,EAAQ,IAAID,EAAO,CAAC,KAAK,GAC/ChD,IAAakD,IAASE,KAAc,GAEpCC,KAAgBnC,KAAW,CAAA,GAAI,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAGoB,EAAW,QAAQ,CAAC,IAAI;AAEzF,WAAO,EAAE,UAAAK,GAAU,YAAAC,GAAY,UAAAC,GAAU,cAAAC,GAAc,YAAA9C,GAAY,cAAAqD,EAAA;AAAA,EACvE,GAAG,CAACpB,GAAWzB,GAAQC,GAASS,GAASO,GAAOf,GAAQC,CAAO,CAAC;AAGhE,MAAII;AACA,WACI,gBAAAuC;AAAA,MAAC;AAAA,MAAA;AAAA,QACG,KAAK/B;AAAA,QACL,WAAWgC,EAAGC,EAAO,KAAKpC,CAAS;AAAA,QACnC,OAAO,EAAE,QAAAV,GAAQ,GAAGW,EAAA;AAAA,QACpB,MAAK;AAAA,QACL,cAAYJ;AAAA,QACX,GAAGK;AAAA,QAEJ,UAAA,gBAAAgC,EAACG,KAAS,UAAU,gBAAAH,EAAC,SAAI,WAAWE,EAAO,SAAS,UAAA,mBAAA,CAAgB,GAChE,UAAA,gBAAAF;AAAA,UAAC3D;AAAA,UAAA;AAAA,YACG,QAAAa;AAAA,YACA,SAAAC;AAAA,YACA,SAAAM;AAAA,YACA,iBAAAC;AAAA,YACA,aAAAF;AAAA,UAAA;AAAA,QAAA,EACJ,CACJ;AAAA,MAAA;AAAA,IAAA;AAMZ,QAAM4C,IACF7C,KAAasB,KAAOA,EAAI,aAAa,IAC/BpC,EAAYoC,EAAI,YAAY,KAAK,IAAI,KAAKV,IAAQ,IAAI,CAAC,IACvD;AAEV,SACI,gBAAA6B;AAAA,IAAC;AAAA,IAAA;AAAA,MACG,KAAK/B;AAAA,MACL,WAAWgC,EAAGC,EAAO,KAAKpC,CAAS;AAAA,MACnC,OAAO,EAAE,QAAAV,GAAQ,GAAGW,EAAA;AAAA,MACpB,MAAK;AAAA,MACL,cAAYJ;AAAA,MACX,GAAGK;AAAA,MAEH,UAACa,IAGE,gBAAAwB;AAAA,QAAC;AAAA,QAAA;AAAA,UACG,WAAWH,EAAO;AAAA,UAClB,OAAM;AAAA,UACN,QAAA9C;AAAA,UACA,SAAS,OAAOe,CAAK,IAAIf,CAAM;AAAA,UAC/B,qBAAoB;AAAA,UAEnB,UAAA;AAAA,YAAAE,KACG,gBAAA+C,EAAC,KAAA,EAAE,WAAWH,EAAO,MAChB,UAAA;AAAA,cAAA,CAAC,MAAM,KAAK,IAAI,EAAE,IAAI,CAACI,MACpB,gBAAAN;AAAA,gBAAC;AAAA,gBAAA;AAAA,kBAEG,IAAI;AAAA,kBACJ,IAAI5C,IAASkD;AAAA,kBACb,IAAInC;AAAA,kBACJ,IAAIf,IAASkD;AAAA,gBAAA;AAAA,gBAJR,IAAIA,CAAC;AAAA,cAAA,CAMjB;AAAA,cACA,CAAC,MAAM,KAAK,IAAI,EAAE,IAAI,CAACA,MACpB,gBAAAN;AAAA,gBAAC;AAAA,gBAAA;AAAA,kBAEG,IAAI7B,IAAQmC;AAAA,kBACZ,IAAI;AAAA,kBACJ,IAAInC,IAAQmC;AAAA,kBACZ,IAAIlD;AAAA,gBAAA;AAAA,gBAJC,IAAIkD,CAAC;AAAA,cAAA,CAMjB;AAAA,YAAA,GACL;AAAA,YAGHzB,EAAI,YACD,gBAAAmB;AAAA,cAAC;AAAA,cAAA;AAAA,gBACG,WAAWE,EAAO;AAAA,gBAClB,QAAQrB,EAAI;AAAA,gBACZ,MAAK;AAAA,gBACL,QAAQrB;AAAA,gBACR,eAAY;AAAA,cAAA;AAAA,YAAA;AAAA,YAInBqB,EAAI,cACD,gBAAAmB;AAAA,cAAC;AAAA,cAAA;AAAA,gBACG,WAAWE,EAAO;AAAA,gBAClB,IAAIrB,EAAI,WAAW;AAAA,gBACnB,IAAIA,EAAI,WAAW;AAAA,gBACnB,GAAG;AAAA,cAAA;AAAA,YAAA;AAAA,YAGVA,EAAI,YAAY,CAAC1B,KACd,gBAAA6C;AAAA,cAAC;AAAA,cAAA;AAAA,gBACG,WAAWE,EAAO;AAAA,gBAClB,IAAIrB,EAAI,SAAS;AAAA,gBACjB,IAAIA,EAAI,SAAS;AAAA,gBACjB,GAAG;AAAA,cAAA;AAAA,YAAA;AAAA,YAGVA,EAAI,gBACD,gBAAAwB,EAAAE,GAAA,EACI,UAAA;AAAA,cAAA,gBAAAP;AAAA,gBAAC;AAAA,gBAAA;AAAA,kBACG,WAAWE,EAAO;AAAA,kBAClB,IAAIrB,EAAI,aAAa;AAAA,kBACrB,IAAIA,EAAI,aAAa;AAAA,kBACrB,GAAG;AAAA,gBAAA;AAAA,cAAA;AAAA,cAEP,gBAAAmB;AAAA,gBAAC;AAAA,gBAAA;AAAA,kBACG,WAAWE,EAAO;AAAA,kBAClB,IAAIrB,EAAI,aAAa;AAAA,kBACrB,IAAIA,EAAI,aAAa;AAAA,kBACrB,GAAG;AAAA,gBAAA;AAAA,cAAA;AAAA,YACP,GACJ;AAAA,YAGHA,EAAI,aAAa,IAAI,CAAC,EAAE,QAAA2B,GAAQ,GAAApB,EAAA,GAAKqB,MAAM;AACxC,oBAAMC,IAAc,EAAQ7C;AAC5B,qBACI,gBAAAmC;AAAA,gBAAC;AAAA,gBAAA;AAAA,kBAEG,WAAWE,EAAO;AAAA,kBAClB,IAAId,EAAE;AAAA,kBACN,IAAIA,EAAE;AAAA,kBACN,GAAGoB,EAAO,UAAU;AAAA,kBACpB,OAAOA,EAAO,QAAQ,EAAE,MAAMA,EAAO,UAAU;AAAA,kBAC/C,kBAAgBA,EAAO,MAAMC;AAAA,kBAC7B,UAAUC,IAAc,IAAI;AAAA,kBAC5B,MAAMA,IAAc,WAAW;AAAA,kBAC/B,cAAYF,EAAO;AAAA,kBACnB,SAASE,IAAc,MAAM7C,IAAgB2C,GAAQC,CAAC,IAAI;AAAA,kBAC1D,WACIC,IACM,CAACC,MAAM;AACH,qBAAIA,EAAE,QAAQ,WAAWA,EAAE,QAAQ,SAC/BA,EAAE,eAAA,GACF9C,IAAgB2C,GAAQC,CAAC;AAAA,kBAEjC,IACA;AAAA,kBAGT,YAAO,QAAQ,gBAAAT,EAAC,SAAA,EAAO,UAAAQ,EAAO,OAAM,IAAW;AAAA,gBAAA;AAAA,gBAtB3CA,EAAO,MAAMC;AAAA,cAAA;AAAA,YAyB9B,CAAC;AAAA,YAEAL,KACG,gBAAAC;AAAA,cAAC;AAAA,cAAA;AAAA,gBACG,WAAWH,EAAO;AAAA,gBAClB,WAAW,aAAa7C,CAAO,KAAKD,IAASC,CAAO;AAAA,gBAEpD,UAAA;AAAA,kBAAA,gBAAA2C,EAAC,QAAA,EAAK,IAAI,GAAG,IAAI,GAAG,IAAII,EAAM,QAAQ,IAAI,EAAA,CAAG;AAAA,kBAC7C,gBAAAJ,EAAC,UAAK,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,EAAA,CAAG;AAAA,kBACnC,gBAAAA,EAAC,QAAA,EAAK,IAAII,EAAM,QAAQ,IAAI,IAAI,IAAIA,EAAM,QAAQ,IAAI,EAAA,CAAG;AAAA,kBACzD,gBAAAJ,EAAC,QAAA,EAAK,GAAGI,EAAM,SAAS,GAAG,GAAG,IAAI,YAAW,UACxC,UAAArD,GAAYqD,EAAM,EAAE,EAAA,CACzB;AAAA,gBAAA;AAAA,cAAA;AAAA,YAAA;AAAA,UACJ;AAAA,QAAA;AAAA,MAAA,IArHR,gBAAAJ,EAAC,OAAA,EAAI,WAAWE,EAAO,OAAO,6CAA+B;AAAA,IAuH7D;AAAA,EAAA;AAIhB;"}

package/dist/geo/TrajectoryMap.module.css.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const t="tempest_map_3qgBX",e="tempest_svg_Da-XM",s="tempest_empty_QQGkP",p="tempest_loading_R6YCf",a="tempest_grid_xFsTS",r="tempest_path_-A7Sl",n="tempest_start_OPmUL",m="tempest_end_7SX7p",_="tempest_current_WFLJk",c="tempest_pulse_DUzgL",o="tempest_marker_HB3Rb",l="tempest_scale_YuwqB",d={map:t,svg:e,empty:s,loading:p,grid:a,path:r,start:n,end:m,current:_,pulse:c,marker:o,scale:l};exports.current=_;exports.default=d;exports.empty=s;exports.end=m;exports.grid=a;exports.loading=p;exports.map=t;exports.marker=o;exports.path=r;exports.pulse=c;exports.scale=l;exports.start=n;exports.svg=e;
+//# sourceMappingURL=TrajectoryMap.module.css.cjs.map

package/dist/geo/TrajectoryMap.module.css.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrajectoryMap.module.css.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/geo/TrajectoryMap.module.css.js

@@ -0,0 +1,30 @@
+const t = "tempest_map_3qgBX", e = "tempest_svg_Da-XM", s = "tempest_empty_QQGkP", p = "tempest_loading_R6YCf", _ = "tempest_grid_xFsTS", m = "tempest_path_-A7Sl", n = "tempest_start_OPmUL", a = "tempest_end_7SX7p", c = "tempest_current_WFLJk", r = "tempest_pulse_DUzgL", o = "tempest_marker_HB3Rb", l = "tempest_scale_YuwqB", g = {
+  map: t,
+  svg: e,
+  empty: s,
+  loading: p,
+  grid: _,
+  path: m,
+  start: n,
+  end: a,
+  current: c,
+  pulse: r,
+  marker: o,
+  scale: l
+};
+export {
+  c as current,
+  g as default,
+  s as empty,
+  a as end,
+  _ as grid,
+  p as loading,
+  t as map,
+  o as marker,
+  m as path,
+  r as pulse,
+  l as scale,
+  n as start,
+  e as svg
+};
+//# sourceMappingURL=TrajectoryMap.module.css.js.map

package/dist/geo/TrajectoryMap.module.css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrajectoryMap.module.css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/dist/geo/bounds.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function d(t){if(t.length===0)return null;let i=t[0].latitude,u=t[0].latitude,a=t[0].longitude,n=t[0].longitude;for(const e of t)e.latitude<i&&(i=e.latitude),e.latitude>u&&(u=e.latitude),e.longitude<a&&(a=e.longitude),e.longitude>n&&(n=e.longitude);return{minLatitude:i,maxLatitude:u,minLongitude:a,maxLongitude:n}}function l(t){return{latitude:(t.minLatitude+t.maxLatitude)/2,longitude:(t.minLongitude+t.maxLongitude)/2}}function o(t,i=.1){const u=t.maxLatitude-t.minLatitude,a=t.maxLongitude-t.minLongitude,n=u*i||.001,e=a*i||.001;return{minLatitude:t.minLatitude-n,maxLatitude:t.maxLatitude+n,minLongitude:t.minLongitude-e,maxLongitude:t.maxLongitude+e}}exports.boundingBox=d;exports.boundsCenter=l;exports.expandBounds=o;
+//# sourceMappingURL=bounds.cjs.map

package/dist/geo/bounds.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounds.cjs","sources":["../../src/geo/bounds.ts"],"sourcesContent":["import type { Coordinate, GeoBounds } from \"./types\";\n\n/**\n * Compute the axis-aligned bounding box that contains every point. Returns\n * `null` for an empty list (there is nothing to bound).\n *\n * @param points - Coordinates to enclose.\n * @returns The bounds, or `null` when `points` is empty.\n */\nexport function boundingBox(points: readonly Coordinate[]): GeoBounds | null {\n    if (points.length === 0) return null;\n\n    let minLatitude = points[0].latitude;\n    let maxLatitude = points[0].latitude;\n    let minLongitude = points[0].longitude;\n    let maxLongitude = points[0].longitude;\n\n    for (const point of points) {\n        if (point.latitude < minLatitude) minLatitude = point.latitude;\n        if (point.latitude > maxLatitude) maxLatitude = point.latitude;\n        if (point.longitude < minLongitude) minLongitude = point.longitude;\n        if (point.longitude > maxLongitude) maxLongitude = point.longitude;\n    }\n\n    return { minLatitude, maxLatitude, minLongitude, maxLongitude };\n}\n\n/** Geometric center of a bounding box. */\nexport function boundsCenter(bounds: GeoBounds): Coordinate {\n    return {\n        latitude: (bounds.minLatitude + bounds.maxLatitude) / 2,\n        longitude: (bounds.minLongitude + bounds.maxLongitude) / 2,\n    };\n}\n\n/**\n * Grow a bounding box outward by `ratio` of its own span on every side, with a\n * small absolute floor so a single-point (zero-span) box still gets padding.\n * A `ratio` of `0.1` adds 10% margin — handy so a plotted trajectory does not\n * hug the edge of the viewport.\n *\n * @param bounds - The box to expand.\n * @param ratio - Fraction of the span to add per side. Default: `0.1`.\n * @returns A new, larger {@link GeoBounds}.\n */\nexport function expandBounds(bounds: GeoBounds, ratio = 0.1): GeoBounds {\n    const latSpan = bounds.maxLatitude - bounds.minLatitude;\n    const lonSpan = bounds.maxLongitude - bounds.minLongitude;\n    const latPad = latSpan * ratio || 0.001;\n    const lonPad = lonSpan * ratio || 0.001;\n\n    return {\n        minLatitude: bounds.minLatitude - latPad,\n        maxLatitude: bounds.maxLatitude + latPad,\n        minLongitude: bounds.minLongitude - lonPad,\n        maxLongitude: bounds.maxLongitude + lonPad,\n    };\n}\n"],"names":["boundingBox","points","minLatitude","maxLatitude","minLongitude","maxLongitude","point","boundsCenter","bounds","expandBounds","ratio","latSpan","lonSpan","latPad","lonPad"],"mappings":"gFASO,SAASA,EAAYC,EAAiD,CACzE,GAAIA,EAAO,SAAW,EAAG,OAAO,KAEhC,IAAIC,EAAcD,EAAO,CAAC,EAAE,SACxBE,EAAcF,EAAO,CAAC,EAAE,SACxBG,EAAeH,EAAO,CAAC,EAAE,UACzBI,EAAeJ,EAAO,CAAC,EAAE,UAE7B,UAAWK,KAASL,EACZK,EAAM,SAAWJ,IAAaA,EAAcI,EAAM,UAClDA,EAAM,SAAWH,IAAaA,EAAcG,EAAM,UAClDA,EAAM,UAAYF,IAAcA,EAAeE,EAAM,WACrDA,EAAM,UAAYD,IAAcA,EAAeC,EAAM,WAG7D,MAAO,CAAE,YAAAJ,EAAa,YAAAC,EAAa,aAAAC,EAAc,aAAAC,CAAA,CACrD,CAGO,SAASE,EAAaC,EAA+B,CACxD,MAAO,CACH,UAAWA,EAAO,YAAcA,EAAO,aAAe,EACtD,WAAYA,EAAO,aAAeA,EAAO,cAAgB,CAAA,CAEjE,CAYO,SAASC,EAAaD,EAAmBE,EAAQ,GAAgB,CACpE,MAAMC,EAAUH,EAAO,YAAcA,EAAO,YACtCI,EAAUJ,EAAO,aAAeA,EAAO,aACvCK,EAASF,EAAUD,GAAS,KAC5BI,EAASF,EAAUF,GAAS,KAElC,MAAO,CACH,YAAaF,EAAO,YAAcK,EAClC,YAAaL,EAAO,YAAcK,EAClC,aAAcL,EAAO,aAAeM,EACpC,aAAcN,EAAO,aAAeM,CAAA,CAE5C"}

package/dist/geo/bounds.js

@@ -0,0 +1,28 @@
+function d(t) {
+  if (t.length === 0) return null;
+  let i = t[0].latitude, u = t[0].latitude, a = t[0].longitude, n = t[0].longitude;
+  for (const e of t)
+    e.latitude < i && (i = e.latitude), e.latitude > u && (u = e.latitude), e.longitude < a && (a = e.longitude), e.longitude > n && (n = e.longitude);
+  return { minLatitude: i, maxLatitude: u, minLongitude: a, maxLongitude: n };
+}
+function l(t) {
+  return {
+    latitude: (t.minLatitude + t.maxLatitude) / 2,
+    longitude: (t.minLongitude + t.maxLongitude) / 2
+  };
+}
+function m(t, i = 0.1) {
+  const u = t.maxLatitude - t.minLatitude, a = t.maxLongitude - t.minLongitude, n = u * i || 1e-3, e = a * i || 1e-3;
+  return {
+    minLatitude: t.minLatitude - n,
+    maxLatitude: t.maxLatitude + n,
+    minLongitude: t.minLongitude - e,
+    maxLongitude: t.maxLongitude + e
+  };
+}
+export {
+  d as boundingBox,
+  l as boundsCenter,
+  m as expandBounds
+};
+//# sourceMappingURL=bounds.js.map

package/dist/geo/bounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounds.js","sources":["../../src/geo/bounds.ts"],"sourcesContent":["import type { Coordinate, GeoBounds } from \"./types\";\n\n/**\n * Compute the axis-aligned bounding box that contains every point. Returns\n * `null` for an empty list (there is nothing to bound).\n *\n * @param points - Coordinates to enclose.\n * @returns The bounds, or `null` when `points` is empty.\n */\nexport function boundingBox(points: readonly Coordinate[]): GeoBounds | null {\n    if (points.length === 0) return null;\n\n    let minLatitude = points[0].latitude;\n    let maxLatitude = points[0].latitude;\n    let minLongitude = points[0].longitude;\n    let maxLongitude = points[0].longitude;\n\n    for (const point of points) {\n        if (point.latitude < minLatitude) minLatitude = point.latitude;\n        if (point.latitude > maxLatitude) maxLatitude = point.latitude;\n        if (point.longitude < minLongitude) minLongitude = point.longitude;\n        if (point.longitude > maxLongitude) maxLongitude = point.longitude;\n    }\n\n    return { minLatitude, maxLatitude, minLongitude, maxLongitude };\n}\n\n/** Geometric center of a bounding box. */\nexport function boundsCenter(bounds: GeoBounds): Coordinate {\n    return {\n        latitude: (bounds.minLatitude + bounds.maxLatitude) / 2,\n        longitude: (bounds.minLongitude + bounds.maxLongitude) / 2,\n    };\n}\n\n/**\n * Grow a bounding box outward by `ratio` of its own span on every side, with a\n * small absolute floor so a single-point (zero-span) box still gets padding.\n * A `ratio` of `0.1` adds 10% margin — handy so a plotted trajectory does not\n * hug the edge of the viewport.\n *\n * @param bounds - The box to expand.\n * @param ratio - Fraction of the span to add per side. Default: `0.1`.\n * @returns A new, larger {@link GeoBounds}.\n */\nexport function expandBounds(bounds: GeoBounds, ratio = 0.1): GeoBounds {\n    const latSpan = bounds.maxLatitude - bounds.minLatitude;\n    const lonSpan = bounds.maxLongitude - bounds.minLongitude;\n    const latPad = latSpan * ratio || 0.001;\n    const lonPad = lonSpan * ratio || 0.001;\n\n    return {\n        minLatitude: bounds.minLatitude - latPad,\n        maxLatitude: bounds.maxLatitude + latPad,\n        minLongitude: bounds.minLongitude - lonPad,\n        maxLongitude: bounds.maxLongitude + lonPad,\n    };\n}\n"],"names":["boundingBox","points","minLatitude","maxLatitude","minLongitude","maxLongitude","point","boundsCenter","bounds","expandBounds","ratio","latSpan","lonSpan","latPad","lonPad"],"mappings":"AASO,SAASA,EAAYC,GAAiD;AACzE,MAAIA,EAAO,WAAW,EAAG,QAAO;AAEhC,MAAIC,IAAcD,EAAO,CAAC,EAAE,UACxBE,IAAcF,EAAO,CAAC,EAAE,UACxBG,IAAeH,EAAO,CAAC,EAAE,WACzBI,IAAeJ,EAAO,CAAC,EAAE;AAE7B,aAAWK,KAASL;AAChB,IAAIK,EAAM,WAAWJ,MAAaA,IAAcI,EAAM,WAClDA,EAAM,WAAWH,MAAaA,IAAcG,EAAM,WAClDA,EAAM,YAAYF,MAAcA,IAAeE,EAAM,YACrDA,EAAM,YAAYD,MAAcA,IAAeC,EAAM;AAG7D,SAAO,EAAE,aAAAJ,GAAa,aAAAC,GAAa,cAAAC,GAAc,cAAAC,EAAA;AACrD;AAGO,SAASE,EAAaC,GAA+B;AACxD,SAAO;AAAA,IACH,WAAWA,EAAO,cAAcA,EAAO,eAAe;AAAA,IACtD,YAAYA,EAAO,eAAeA,EAAO,gBAAgB;AAAA,EAAA;AAEjE;AAYO,SAASC,EAAaD,GAAmBE,IAAQ,KAAgB;AACpE,QAAMC,IAAUH,EAAO,cAAcA,EAAO,aACtCI,IAAUJ,EAAO,eAAeA,EAAO,cACvCK,IAASF,IAAUD,KAAS,MAC5BI,IAASF,IAAUF,KAAS;AAElC,SAAO;AAAA,IACH,aAAaF,EAAO,cAAcK;AAAA,IAClC,aAAaL,EAAO,cAAcK;AAAA,IAClC,cAAcL,EAAO,eAAeM;AAAA,IACpC,cAAcN,EAAO,eAAeM;AAAA,EAAA;AAE5C;"}

package/dist/geo/create-position-tracker.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const S=require("./distance.cjs");function k(g={}){const{minDistanceKm:f=.005,maxPoints:l=1/0,positionOptions:p,onUpdate:u,onError:m,onStatusChange:h}=g;let n=[],r=0,o=null,e=null,a="idle";function i(t){a!==t&&(a=t,h?.(t))}function v(t){const c={latitude:t.coords.latitude,longitude:t.coords.longitude,timestamp:t.timestamp,accuracy:t.coords.accuracy};if(o){const d=S.haversineKm(o,c);if(d<f)return;r+=d}o=c,n.push(c),n.length>l&&(n=n.slice(n.length-l)),u?.(n)}function y(t){i("error"),m?.(t)}function P(){if(e===null){if(typeof navigator>"u"||!navigator.geolocation){i("error");return}i("tracking"),e=navigator.geolocation.watchPosition(v,y,p)}}function s(){e!==null&&typeof navigator<"u"&&navigator.geolocation&&navigator.geolocation.clearWatch(e),e=null,i("idle")}function K(){s(),n=[],r=0,o=null,u?.(n)}return{start:P,stop:s,clear:K,get points(){return n},get distanceKm(){return r},get status(){return a}}}exports.createPositionTracker=k;
+//# sourceMappingURL=create-position-tracker.cjs.map

package/dist/geo/create-position-tracker.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-position-tracker.cjs","sources":["../../src/geo/create-position-tracker.ts"],"sourcesContent":["import { haversineKm } from \"./distance\";\nimport type { TrackPoint } from \"./types\";\n\n/** Lifecycle status of a {@link PositionTracker}. */\nexport type TrackerStatus = \"idle\" | \"tracking\" | \"error\";\n\n/** Options for {@link createPositionTracker}. */\nexport interface CreatePositionTrackerOptions {\n    /**\n     * Discard a new sample when it is closer than this (in km) to the last\n     * kept point — filters GPS jitter while standing still. Default: `0.005`\n     * (5 meters). Pass `0` to keep every sample.\n     */\n    minDistanceKm?: number;\n    /**\n     * Cap the retained trajectory to the most recent N points (older points are\n     * dropped, but their distance stays counted). Default: `Infinity`.\n     */\n    maxPoints?: number;\n    /** Forwarded to `navigator.geolocation.watchPosition`. */\n    positionOptions?: PositionOptions;\n    /** Called with the full trajectory each time a point is added. */\n    onUpdate?: (points: readonly TrackPoint[]) => void;\n    /** Called on a `GeolocationPositionError`. */\n    onError?: (error: GeolocationPositionError) => void;\n    /** Called whenever the status changes. */\n    onStatusChange?: (status: TrackerStatus) => void;\n}\n\n/** Imperative controller returned by {@link createPositionTracker}. */\nexport interface PositionTracker {\n    /** Begin watching position. No-op if already tracking. */\n    start: () => void;\n    /** Stop watching. Retains the recorded trajectory. */\n    stop: () => void;\n    /** Stop and discard the recorded trajectory. */\n    clear: () => void;\n    /** Snapshot of the recorded trajectory (newest last). */\n    readonly points: readonly TrackPoint[];\n    /** Total distance of the recorded trajectory in kilometers. */\n    readonly distanceKm: number;\n    /** Current tracker status. */\n    readonly status: TrackerStatus;\n}\n\n/**\n * Record a live GPS trajectory from `navigator.geolocation.watchPosition`.\n * Framework-free — the {@link usePositionTracker} hook wraps this for React.\n *\n * Jitter while stationary is filtered by `minDistanceKm`; distance is\n * accumulated across the *full* run even when `maxPoints` trims the retained\n * array. 100% browser-side: no network, no external service.\n *\n * @param options - Filtering, retention and callbacks.\n * @returns A controller with `start`/`stop`/`clear` and live getters.\n *\n * @example\n * const tracker = createPositionTracker({\n *   minDistanceKm: 0.01,\n *   onUpdate: (pts) => console.log(pts.length, \"points\"),\n * });\n * tracker.start();\n * // …later\n * tracker.stop();\n * console.log(tracker.distanceKm);\n */\nexport function createPositionTracker(options: CreatePositionTrackerOptions = {}): PositionTracker {\n    const {\n        minDistanceKm = 0.005,\n        maxPoints = Infinity,\n        positionOptions,\n        onUpdate,\n        onError,\n        onStatusChange,\n    } = options;\n\n    let points: TrackPoint[] = [];\n    let distanceKm = 0;\n    let lastKept: TrackPoint | null = null;\n    let watchId: number | null = null;\n    let status: TrackerStatus = \"idle\";\n\n    function setStatus(next: TrackerStatus): void {\n        if (status === next) return;\n        status = next;\n        onStatusChange?.(next);\n    }\n\n    function handlePosition(position: GeolocationPosition): void {\n        const point: TrackPoint = {\n            latitude: position.coords.latitude,\n            longitude: position.coords.longitude,\n            timestamp: position.timestamp,\n            accuracy: position.coords.accuracy,\n        };\n\n        if (lastKept) {\n            const step = haversineKm(lastKept, point);\n            if (step < minDistanceKm) return;\n            distanceKm += step;\n        }\n\n        lastKept = point;\n        points.push(point);\n        if (points.length > maxPoints) {\n            points = points.slice(points.length - maxPoints);\n        }\n        onUpdate?.(points);\n    }\n\n    function handleError(error: GeolocationPositionError): void {\n        setStatus(\"error\");\n        onError?.(error);\n    }\n\n    function start(): void {\n        if (watchId !== null) return;\n        if (typeof navigator === \"undefined\" || !navigator.geolocation) {\n            setStatus(\"error\");\n            return;\n        }\n        setStatus(\"tracking\");\n        watchId = navigator.geolocation.watchPosition(handlePosition, handleError, positionOptions);\n    }\n\n    function stop(): void {\n        if (watchId !== null && typeof navigator !== \"undefined\" && navigator.geolocation) {\n            navigator.geolocation.clearWatch(watchId);\n        }\n        watchId = null;\n        setStatus(\"idle\");\n    }\n\n    function clear(): void {\n        stop();\n        points = [];\n        distanceKm = 0;\n        lastKept = null;\n        onUpdate?.(points);\n    }\n\n    return {\n        start,\n        stop,\n        clear,\n        get points() {\n            return points;\n        },\n        get distanceKm() {\n            return distanceKm;\n        },\n        get status() {\n            return status;\n        },\n    };\n}\n"],"names":["createPositionTracker","options","minDistanceKm","maxPoints","positionOptions","onUpdate","onError","onStatusChange","points","distanceKm","lastKept","watchId","status","setStatus","next","handlePosition","position","point","step","haversineKm","handleError","error","start","stop","clear"],"mappings":"kHAkEO,SAASA,EAAsBC,EAAwC,GAAqB,CAC/F,KAAM,CACF,cAAAC,EAAgB,KAChB,UAAAC,EAAY,IACZ,gBAAAC,EACA,SAAAC,EACA,QAAAC,EACA,eAAAC,CAAA,EACAN,EAEJ,IAAIO,EAAuB,CAAA,EACvBC,EAAa,EACbC,EAA8B,KAC9BC,EAAyB,KACzBC,EAAwB,OAE5B,SAASC,EAAUC,EAA2B,CACtCF,IAAWE,IACfF,EAASE,EACTP,IAAiBO,CAAI,EACzB,CAEA,SAASC,EAAeC,EAAqC,CACzD,MAAMC,EAAoB,CACtB,SAAUD,EAAS,OAAO,SAC1B,UAAWA,EAAS,OAAO,UAC3B,UAAWA,EAAS,UACpB,SAAUA,EAAS,OAAO,QAAA,EAG9B,GAAIN,EAAU,CACV,MAAMQ,EAAOC,EAAAA,YAAYT,EAAUO,CAAK,EACxC,GAAIC,EAAOhB,EAAe,OAC1BO,GAAcS,CAClB,CAEAR,EAAWO,EACXT,EAAO,KAAKS,CAAK,EACbT,EAAO,OAASL,IAChBK,EAASA,EAAO,MAAMA,EAAO,OAASL,CAAS,GAEnDE,IAAWG,CAAM,CACrB,CAEA,SAASY,EAAYC,EAAuC,CACxDR,EAAU,OAAO,EACjBP,IAAUe,CAAK,CACnB,CAEA,SAASC,GAAc,CACnB,GAAIX,IAAY,KAChB,IAAI,OAAO,UAAc,KAAe,CAAC,UAAU,YAAa,CAC5DE,EAAU,OAAO,EACjB,MACJ,CACAA,EAAU,UAAU,EACpBF,EAAU,UAAU,YAAY,cAAcI,EAAgBK,EAAahB,CAAe,EAC9F,CAEA,SAASmB,GAAa,CACdZ,IAAY,MAAQ,OAAO,UAAc,KAAe,UAAU,aAClE,UAAU,YAAY,WAAWA,CAAO,EAE5CA,EAAU,KACVE,EAAU,MAAM,CACpB,CAEA,SAASW,GAAc,CACnBD,EAAA,EACAf,EAAS,CAAA,EACTC,EAAa,EACbC,EAAW,KACXL,IAAWG,CAAM,CACrB,CAEA,MAAO,CACH,MAAAc,EACA,KAAAC,EACA,MAAAC,EACA,IAAI,QAAS,CACT,OAAOhB,CACX,EACA,IAAI,YAAa,CACb,OAAOC,CACX,EACA,IAAI,QAAS,CACT,OAAOG,CACX,CAAA,CAER"}

package/dist/geo/create-position-tracker.js

@@ -0,0 +1,65 @@
+import { haversineKm as k } from "./distance.js";
+function E(d = {}) {
+  const {
+    minDistanceKm: g = 5e-3,
+    maxPoints: l = 1 / 0,
+    positionOptions: p,
+    onUpdate: u,
+    onError: m,
+    onStatusChange: h
+  } = d;
+  let n = [], r = 0, o = null, e = null, a = "idle";
+  function i(t) {
+    a !== t && (a = t, h?.(t));
+  }
+  function v(t) {
+    const c = {
+      latitude: t.coords.latitude,
+      longitude: t.coords.longitude,
+      timestamp: t.timestamp,
+      accuracy: t.coords.accuracy
+    };
+    if (o) {
+      const f = k(o, c);
+      if (f < g) return;
+      r += f;
+    }
+    o = c, n.push(c), n.length > l && (n = n.slice(n.length - l)), u?.(n);
+  }
+  function y(t) {
+    i("error"), m?.(t);
+  }
+  function K() {
+    if (e === null) {
+      if (typeof navigator > "u" || !navigator.geolocation) {
+        i("error");
+        return;
+      }
+      i("tracking"), e = navigator.geolocation.watchPosition(v, y, p);
+    }
+  }
+  function s() {
+    e !== null && typeof navigator < "u" && navigator.geolocation && navigator.geolocation.clearWatch(e), e = null, i("idle");
+  }
+  function P() {
+    s(), n = [], r = 0, o = null, u?.(n);
+  }
+  return {
+    start: K,
+    stop: s,
+    clear: P,
+    get points() {
+      return n;
+    },
+    get distanceKm() {
+      return r;
+    },
+    get status() {
+      return a;
+    }
+  };
+}
+export {
+  E as createPositionTracker
+};
+//# sourceMappingURL=create-position-tracker.js.map

package/dist/geo/create-position-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-position-tracker.js","sources":["../../src/geo/create-position-tracker.ts"],"sourcesContent":["import { haversineKm } from \"./distance\";\nimport type { TrackPoint } from \"./types\";\n\n/** Lifecycle status of a {@link PositionTracker}. */\nexport type TrackerStatus = \"idle\" | \"tracking\" | \"error\";\n\n/** Options for {@link createPositionTracker}. */\nexport interface CreatePositionTrackerOptions {\n    /**\n     * Discard a new sample when it is closer than this (in km) to the last\n     * kept point — filters GPS jitter while standing still. Default: `0.005`\n     * (5 meters). Pass `0` to keep every sample.\n     */\n    minDistanceKm?: number;\n    /**\n     * Cap the retained trajectory to the most recent N points (older points are\n     * dropped, but their distance stays counted). Default: `Infinity`.\n     */\n    maxPoints?: number;\n    /** Forwarded to `navigator.geolocation.watchPosition`. */\n    positionOptions?: PositionOptions;\n    /** Called with the full trajectory each time a point is added. */\n    onUpdate?: (points: readonly TrackPoint[]) => void;\n    /** Called on a `GeolocationPositionError`. */\n    onError?: (error: GeolocationPositionError) => void;\n    /** Called whenever the status changes. */\n    onStatusChange?: (status: TrackerStatus) => void;\n}\n\n/** Imperative controller returned by {@link createPositionTracker}. */\nexport interface PositionTracker {\n    /** Begin watching position. No-op if already tracking. */\n    start: () => void;\n    /** Stop watching. Retains the recorded trajectory. */\n    stop: () => void;\n    /** Stop and discard the recorded trajectory. */\n    clear: () => void;\n    /** Snapshot of the recorded trajectory (newest last). */\n    readonly points: readonly TrackPoint[];\n    /** Total distance of the recorded trajectory in kilometers. */\n    readonly distanceKm: number;\n    /** Current tracker status. */\n    readonly status: TrackerStatus;\n}\n\n/**\n * Record a live GPS trajectory from `navigator.geolocation.watchPosition`.\n * Framework-free — the {@link usePositionTracker} hook wraps this for React.\n *\n * Jitter while stationary is filtered by `minDistanceKm`; distance is\n * accumulated across the *full* run even when `maxPoints` trims the retained\n * array. 100% browser-side: no network, no external service.\n *\n * @param options - Filtering, retention and callbacks.\n * @returns A controller with `start`/`stop`/`clear` and live getters.\n *\n * @example\n * const tracker = createPositionTracker({\n *   minDistanceKm: 0.01,\n *   onUpdate: (pts) => console.log(pts.length, \"points\"),\n * });\n * tracker.start();\n * // …later\n * tracker.stop();\n * console.log(tracker.distanceKm);\n */\nexport function createPositionTracker(options: CreatePositionTrackerOptions = {}): PositionTracker {\n    const {\n        minDistanceKm = 0.005,\n        maxPoints = Infinity,\n        positionOptions,\n        onUpdate,\n        onError,\n        onStatusChange,\n    } = options;\n\n    let points: TrackPoint[] = [];\n    let distanceKm = 0;\n    let lastKept: TrackPoint | null = null;\n    let watchId: number | null = null;\n    let status: TrackerStatus = \"idle\";\n\n    function setStatus(next: TrackerStatus): void {\n        if (status === next) return;\n        status = next;\n        onStatusChange?.(next);\n    }\n\n    function handlePosition(position: GeolocationPosition): void {\n        const point: TrackPoint = {\n            latitude: position.coords.latitude,\n            longitude: position.coords.longitude,\n            timestamp: position.timestamp,\n            accuracy: position.coords.accuracy,\n        };\n\n        if (lastKept) {\n            const step = haversineKm(lastKept, point);\n            if (step < minDistanceKm) return;\n            distanceKm += step;\n        }\n\n        lastKept = point;\n        points.push(point);\n        if (points.length > maxPoints) {\n            points = points.slice(points.length - maxPoints);\n        }\n        onUpdate?.(points);\n    }\n\n    function handleError(error: GeolocationPositionError): void {\n        setStatus(\"error\");\n        onError?.(error);\n    }\n\n    function start(): void {\n        if (watchId !== null) return;\n        if (typeof navigator === \"undefined\" || !navigator.geolocation) {\n            setStatus(\"error\");\n            return;\n        }\n        setStatus(\"tracking\");\n        watchId = navigator.geolocation.watchPosition(handlePosition, handleError, positionOptions);\n    }\n\n    function stop(): void {\n        if (watchId !== null && typeof navigator !== \"undefined\" && navigator.geolocation) {\n            navigator.geolocation.clearWatch(watchId);\n        }\n        watchId = null;\n        setStatus(\"idle\");\n    }\n\n    function clear(): void {\n        stop();\n        points = [];\n        distanceKm = 0;\n        lastKept = null;\n        onUpdate?.(points);\n    }\n\n    return {\n        start,\n        stop,\n        clear,\n        get points() {\n            return points;\n        },\n        get distanceKm() {\n            return distanceKm;\n        },\n        get status() {\n            return status;\n        },\n    };\n}\n"],"names":["createPositionTracker","options","minDistanceKm","maxPoints","positionOptions","onUpdate","onError","onStatusChange","points","distanceKm","lastKept","watchId","status","setStatus","next","handlePosition","position","point","step","haversineKm","handleError","error","start","stop","clear"],"mappings":";AAkEO,SAASA,EAAsBC,IAAwC,IAAqB;AAC/F,QAAM;AAAA,IACF,eAAAC,IAAgB;AAAA,IAChB,WAAAC,IAAY;AAAA,IACZ,iBAAAC;AAAA,IACA,UAAAC;AAAA,IACA,SAAAC;AAAA,IACA,gBAAAC;AAAA,EAAA,IACAN;AAEJ,MAAIO,IAAuB,CAAA,GACvBC,IAAa,GACbC,IAA8B,MAC9BC,IAAyB,MACzBC,IAAwB;AAE5B,WAASC,EAAUC,GAA2B;AAC1C,IAAIF,MAAWE,MACfF,IAASE,GACTP,IAAiBO,CAAI;AAAA,EACzB;AAEA,WAASC,EAAeC,GAAqC;AACzD,UAAMC,IAAoB;AAAA,MACtB,UAAUD,EAAS,OAAO;AAAA,MAC1B,WAAWA,EAAS,OAAO;AAAA,MAC3B,WAAWA,EAAS;AAAA,MACpB,UAAUA,EAAS,OAAO;AAAA,IAAA;AAG9B,QAAIN,GAAU;AACV,YAAMQ,IAAOC,EAAYT,GAAUO,CAAK;AACxC,UAAIC,IAAOhB,EAAe;AAC1B,MAAAO,KAAcS;AAAA,IAClB;AAEA,IAAAR,IAAWO,GACXT,EAAO,KAAKS,CAAK,GACbT,EAAO,SAASL,MAChBK,IAASA,EAAO,MAAMA,EAAO,SAASL,CAAS,IAEnDE,IAAWG,CAAM;AAAA,EACrB;AAEA,WAASY,EAAYC,GAAuC;AACxD,IAAAR,EAAU,OAAO,GACjBP,IAAUe,CAAK;AAAA,EACnB;AAEA,WAASC,IAAc;AACnB,QAAIX,MAAY,MAChB;AAAA,UAAI,OAAO,YAAc,OAAe,CAAC,UAAU,aAAa;AAC5D,QAAAE,EAAU,OAAO;AACjB;AAAA,MACJ;AACA,MAAAA,EAAU,UAAU,GACpBF,IAAU,UAAU,YAAY,cAAcI,GAAgBK,GAAahB,CAAe;AAAA;AAAA,EAC9F;AAEA,WAASmB,IAAa;AAClB,IAAIZ,MAAY,QAAQ,OAAO,YAAc,OAAe,UAAU,eAClE,UAAU,YAAY,WAAWA,CAAO,GAE5CA,IAAU,MACVE,EAAU,MAAM;AAAA,EACpB;AAEA,WAASW,IAAc;AACnB,IAAAD,EAAA,GACAf,IAAS,CAAA,GACTC,IAAa,GACbC,IAAW,MACXL,IAAWG,CAAM;AAAA,EACrB;AAEA,SAAO;AAAA,IACH,OAAAc;AAAA,IACA,MAAAC;AAAA,IACA,OAAAC;AAAA,IACA,IAAI,SAAS;AACT,aAAOhB;AAAA,IACX;AAAA,IACA,IAAI,aAAa;AACb,aAAOC;AAAA,IACX;AAAA,IACA,IAAI,SAAS;AACT,aAAOG;AAAA,IACX;AAAA,EAAA;AAER;"}

package/dist/geo/distance.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=6371.0088;function e(t){return t*Math.PI/180}function u(t,a){const n=e(t.latitude),o=e(a.latitude),s=e(a.latitude-t.latitude),c=e(a.longitude-t.longitude),l=Math.sin(s/2)**2+Math.cos(n)*Math.cos(o)*Math.sin(c/2)**2;return 2*h*Math.asin(Math.sqrt(l))}function M(t){let a=0;for(let n=1;n<t.length;n+=1)a+=u(t[n-1],t[n]);return a}function i(t,a){const n=e(t.latitude),o=e(a.latitude),s=e(a.longitude-t.longitude),c=Math.sin(s)*Math.cos(o),l=Math.cos(n)*Math.sin(o)-Math.sin(n)*Math.cos(o)*Math.cos(s);return(Math.atan2(c,l)*180/Math.PI+360)%360}exports.EARTH_RADIUS_KM=h;exports.bearingDeg=i;exports.haversineKm=u;exports.pathLengthKm=M;exports.toRadians=e;
+//# sourceMappingURL=distance.cjs.map

package/dist/geo/distance.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance.cjs","sources":["../../src/geo/distance.ts"],"sourcesContent":["import type { Coordinate } from \"./types\";\n\n/**\n * Mean Earth radius in kilometers. Same value used by `tempest-fastapi-sdk`\n * (`geo/distance.py`) so client and server distances agree.\n */\nexport const EARTH_RADIUS_KM = 6371.0088;\n\n/** Convert degrees to radians. */\nexport function toRadians(degrees: number): number {\n    return (degrees * Math.PI) / 180;\n}\n\n/**\n * Great-circle distance between two coordinates using the haversine formula\n * (spherical Earth). Mirrors `haversine_km` from `tempest-fastapi-sdk`.\n *\n * @param origin - Start coordinate.\n * @param destination - End coordinate.\n * @returns Distance in kilometers (`>= 0`).\n *\n * @example\n * haversineKm(\n *   { latitude: -23.5505, longitude: -46.6333 }, // São Paulo\n *   { latitude: -22.9068, longitude: -43.1729 }, // Rio de Janeiro\n * ); // ≈ 360.9\n */\nexport function haversineKm(origin: Coordinate, destination: Coordinate): number {\n    const lat1 = toRadians(origin.latitude);\n    const lat2 = toRadians(destination.latitude);\n    const deltaLat = toRadians(destination.latitude - origin.latitude);\n    const deltaLon = toRadians(destination.longitude - origin.longitude);\n\n    const a =\n        Math.sin(deltaLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(deltaLon / 2) ** 2;\n\n    return 2 * EARTH_RADIUS_KM * Math.asin(Math.sqrt(a));\n}\n\n/**\n * Total length of a trajectory: the sum of haversine distances between each\n * consecutive pair of points. Returns `0` for an empty or single-point path.\n *\n * @param points - Ordered coordinates along the path.\n * @returns Cumulative distance in kilometers.\n */\nexport function pathLengthKm(points: readonly Coordinate[]): number {\n    let total = 0;\n    for (let i = 1; i < points.length; i += 1) {\n        total += haversineKm(points[i - 1], points[i]);\n    }\n    return total;\n}\n\n/**\n * Initial bearing (forward azimuth) from `origin` to `destination`, in degrees\n * clockwise from true north, normalized to `[0, 360)`. Useful for orienting a\n * heading arrow on a trajectory.\n *\n * @param origin - Start coordinate.\n * @param destination - End coordinate.\n * @returns Bearing in degrees, `[0, 360)`.\n */\nexport function bearingDeg(origin: Coordinate, destination: Coordinate): number {\n    const lat1 = toRadians(origin.latitude);\n    const lat2 = toRadians(destination.latitude);\n    const deltaLon = toRadians(destination.longitude - origin.longitude);\n\n    const y = Math.sin(deltaLon) * Math.cos(lat2);\n    const x =\n        Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(deltaLon);\n\n    const bearing = (Math.atan2(y, x) * 180) / Math.PI;\n    return (bearing + 360) % 360;\n}\n"],"names":["EARTH_RADIUS_KM","toRadians","degrees","haversineKm","origin","destination","lat1","lat2","deltaLat","deltaLon","a","pathLengthKm","points","total","i","bearingDeg","y","x"],"mappings":"gFAMO,MAAMA,EAAkB,UAGxB,SAASC,EAAUC,EAAyB,CAC/C,OAAQA,EAAU,KAAK,GAAM,GACjC,CAgBO,SAASC,EAAYC,EAAoBC,EAAiC,CAC7E,MAAMC,EAAOL,EAAUG,EAAO,QAAQ,EAChCG,EAAON,EAAUI,EAAY,QAAQ,EACrCG,EAAWP,EAAUI,EAAY,SAAWD,EAAO,QAAQ,EAC3DK,EAAWR,EAAUI,EAAY,UAAYD,EAAO,SAAS,EAE7DM,EACF,KAAK,IAAIF,EAAW,CAAC,GAAK,EAAI,KAAK,IAAIF,CAAI,EAAI,KAAK,IAAIC,CAAI,EAAI,KAAK,IAAIE,EAAW,CAAC,GAAK,EAE9F,MAAO,GAAIT,EAAkB,KAAK,KAAK,KAAK,KAAKU,CAAC,CAAC,CACvD,CASO,SAASC,EAAaC,EAAuC,CAChE,IAAIC,EAAQ,EACZ,QAASC,EAAI,EAAGA,EAAIF,EAAO,OAAQE,GAAK,EACpCD,GAASV,EAAYS,EAAOE,EAAI,CAAC,EAAGF,EAAOE,CAAC,CAAC,EAEjD,OAAOD,CACX,CAWO,SAASE,EAAWX,EAAoBC,EAAiC,CAC5E,MAAMC,EAAOL,EAAUG,EAAO,QAAQ,EAChCG,EAAON,EAAUI,EAAY,QAAQ,EACrCI,EAAWR,EAAUI,EAAY,UAAYD,EAAO,SAAS,EAE7DY,EAAI,KAAK,IAAIP,CAAQ,EAAI,KAAK,IAAIF,CAAI,EACtCU,EACF,KAAK,IAAIX,CAAI,EAAI,KAAK,IAAIC,CAAI,EAAI,KAAK,IAAID,CAAI,EAAI,KAAK,IAAIC,CAAI,EAAI,KAAK,IAAIE,CAAQ,EAGzF,OADiB,KAAK,MAAMO,EAAGC,CAAC,EAAI,IAAO,KAAK,GAC9B,KAAO,GAC7B"}

package/dist/geo/distance.js

@@ -0,0 +1,26 @@
+const h = 6371.0088;
+function e(t) {
+  return t * Math.PI / 180;
+}
+function u(t, a) {
+  const n = e(t.latitude), o = e(a.latitude), c = e(a.latitude - t.latitude), s = e(a.longitude - t.longitude), l = Math.sin(c / 2) ** 2 + Math.cos(n) * Math.cos(o) * Math.sin(s / 2) ** 2;
+  return 2 * h * Math.asin(Math.sqrt(l));
+}
+function i(t) {
+  let a = 0;
+  for (let n = 1; n < t.length; n += 1)
+    a += u(t[n - 1], t[n]);
+  return a;
+}
+function r(t, a) {
+  const n = e(t.latitude), o = e(a.latitude), c = e(a.longitude - t.longitude), s = Math.sin(c) * Math.cos(o), l = Math.cos(n) * Math.sin(o) - Math.sin(n) * Math.cos(o) * Math.cos(c);
+  return (Math.atan2(s, l) * 180 / Math.PI + 360) % 360;
+}
+export {
+  h as EARTH_RADIUS_KM,
+  r as bearingDeg,
+  u as haversineKm,
+  i as pathLengthKm,
+  e as toRadians
+};
+//# sourceMappingURL=distance.js.map

package/dist/geo/distance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance.js","sources":["../../src/geo/distance.ts"],"sourcesContent":["import type { Coordinate } from \"./types\";\n\n/**\n * Mean Earth radius in kilometers. Same value used by `tempest-fastapi-sdk`\n * (`geo/distance.py`) so client and server distances agree.\n */\nexport const EARTH_RADIUS_KM = 6371.0088;\n\n/** Convert degrees to radians. */\nexport function toRadians(degrees: number): number {\n    return (degrees * Math.PI) / 180;\n}\n\n/**\n * Great-circle distance between two coordinates using the haversine formula\n * (spherical Earth). Mirrors `haversine_km` from `tempest-fastapi-sdk`.\n *\n * @param origin - Start coordinate.\n * @param destination - End coordinate.\n * @returns Distance in kilometers (`>= 0`).\n *\n * @example\n * haversineKm(\n *   { latitude: -23.5505, longitude: -46.6333 }, // São Paulo\n *   { latitude: -22.9068, longitude: -43.1729 }, // Rio de Janeiro\n * ); // ≈ 360.9\n */\nexport function haversineKm(origin: Coordinate, destination: Coordinate): number {\n    const lat1 = toRadians(origin.latitude);\n    const lat2 = toRadians(destination.latitude);\n    const deltaLat = toRadians(destination.latitude - origin.latitude);\n    const deltaLon = toRadians(destination.longitude - origin.longitude);\n\n    const a =\n        Math.sin(deltaLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(deltaLon / 2) ** 2;\n\n    return 2 * EARTH_RADIUS_KM * Math.asin(Math.sqrt(a));\n}\n\n/**\n * Total length of a trajectory: the sum of haversine distances between each\n * consecutive pair of points. Returns `0` for an empty or single-point path.\n *\n * @param points - Ordered coordinates along the path.\n * @returns Cumulative distance in kilometers.\n */\nexport function pathLengthKm(points: readonly Coordinate[]): number {\n    let total = 0;\n    for (let i = 1; i < points.length; i += 1) {\n        total += haversineKm(points[i - 1], points[i]);\n    }\n    return total;\n}\n\n/**\n * Initial bearing (forward azimuth) from `origin` to `destination`, in degrees\n * clockwise from true north, normalized to `[0, 360)`. Useful for orienting a\n * heading arrow on a trajectory.\n *\n * @param origin - Start coordinate.\n * @param destination - End coordinate.\n * @returns Bearing in degrees, `[0, 360)`.\n */\nexport function bearingDeg(origin: Coordinate, destination: Coordinate): number {\n    const lat1 = toRadians(origin.latitude);\n    const lat2 = toRadians(destination.latitude);\n    const deltaLon = toRadians(destination.longitude - origin.longitude);\n\n    const y = Math.sin(deltaLon) * Math.cos(lat2);\n    const x =\n        Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(deltaLon);\n\n    const bearing = (Math.atan2(y, x) * 180) / Math.PI;\n    return (bearing + 360) % 360;\n}\n"],"names":["EARTH_RADIUS_KM","toRadians","degrees","haversineKm","origin","destination","lat1","lat2","deltaLat","deltaLon","a","pathLengthKm","points","total","i","bearingDeg","y","x"],"mappings":"AAMO,MAAMA,IAAkB;AAGxB,SAASC,EAAUC,GAAyB;AAC/C,SAAQA,IAAU,KAAK,KAAM;AACjC;AAgBO,SAASC,EAAYC,GAAoBC,GAAiC;AAC7E,QAAMC,IAAOL,EAAUG,EAAO,QAAQ,GAChCG,IAAON,EAAUI,EAAY,QAAQ,GACrCG,IAAWP,EAAUI,EAAY,WAAWD,EAAO,QAAQ,GAC3DK,IAAWR,EAAUI,EAAY,YAAYD,EAAO,SAAS,GAE7DM,IACF,KAAK,IAAIF,IAAW,CAAC,KAAK,IAAI,KAAK,IAAIF,CAAI,IAAI,KAAK,IAAIC,CAAI,IAAI,KAAK,IAAIE,IAAW,CAAC,KAAK;AAE9F,SAAO,IAAIT,IAAkB,KAAK,KAAK,KAAK,KAAKU,CAAC,CAAC;AACvD;AASO,SAASC,EAAaC,GAAuC;AAChE,MAAIC,IAAQ;AACZ,WAASC,IAAI,GAAGA,IAAIF,EAAO,QAAQE,KAAK;AACpC,IAAAD,KAASV,EAAYS,EAAOE,IAAI,CAAC,GAAGF,EAAOE,CAAC,CAAC;AAEjD,SAAOD;AACX;AAWO,SAASE,EAAWX,GAAoBC,GAAiC;AAC5E,QAAMC,IAAOL,EAAUG,EAAO,QAAQ,GAChCG,IAAON,EAAUI,EAAY,QAAQ,GACrCI,IAAWR,EAAUI,EAAY,YAAYD,EAAO,SAAS,GAE7DY,IAAI,KAAK,IAAIP,CAAQ,IAAI,KAAK,IAAIF,CAAI,GACtCU,IACF,KAAK,IAAIX,CAAI,IAAI,KAAK,IAAIC,CAAI,IAAI,KAAK,IAAID,CAAI,IAAI,KAAK,IAAIC,CAAI,IAAI,KAAK,IAAIE,CAAQ;AAGzF,UADiB,KAAK,MAAMO,GAAGC,CAAC,IAAI,MAAO,KAAK,KAC9B,OAAO;AAC7B;"}

package/dist/geo/estimate.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const A=require("./distance.cjs"),o=1.3,i=50,s={car:1,motorcycle:.95,bus:1.6};function u(t,r){return r?.[t]??s[t]??1}function E(t,r,e="car",_={}){const{circuityFactor:n=o,carSpeedKmh:c=i,modeDurationFactors:T}=_;if(c<=0)throw new RangeError("carSpeedKmh must be greater than 0");if(n<=0)throw new RangeError("circuityFactor must be greater than 0");const a=A.haversineKm(t,r)*n,F=a/c*60*u(e,T);return{mode:e,distance_km:a,duration_minutes:F,source:"heuristic"}}exports.DEFAULT_CAR_SPEED_KMH=i;exports.DEFAULT_CIRCUITY_FACTOR=o;exports.DEFAULT_MODE_DURATION_FACTORS=s;exports.durationFactor=u;exports.estimateTravel=E;
+//# sourceMappingURL=estimate.cjs.map

package/dist/geo/estimate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate.cjs","sources":["../../src/geo/estimate.ts"],"sourcesContent":["import { haversineKm } from \"./distance\";\nimport type { Coordinate, TravelEstimate, TravelMode } from \"./types\";\n\n/**\n * Multiplier applied to the great-circle distance to approximate real road\n * distance. Mirrors `DEFAULT_CIRCUITY_FACTOR` from `tempest-fastapi-sdk`.\n */\nexport const DEFAULT_CIRCUITY_FACTOR = 1.3;\n\n/**\n * Default average car speed in km/h used to derive duration from distance.\n * Mirrors `DEFAULT_CAR_SPEED_KMH` from `tempest-fastapi-sdk`.\n */\nexport const DEFAULT_CAR_SPEED_KMH = 50.0;\n\n/**\n * Per-mode multipliers applied to the car duration. Mirrors\n * `DEFAULT_MODE_DURATION_FACTORS` from `tempest-fastapi-sdk` — motorcycles are\n * a touch faster, buses considerably slower (stops + dedicated lanes).\n */\nexport const DEFAULT_MODE_DURATION_FACTORS: Record<TravelMode, number> = {\n    car: 1.0,\n    motorcycle: 0.95,\n    bus: 1.6,\n};\n\n/**\n * Look up the duration multiplier for a travel mode, falling back to `1.0`\n * for unknown modes. Mirrors `duration_factor` from `tempest-fastapi-sdk`.\n *\n * @param mode - Travel mode.\n * @param factors - Optional override map (partial merges over the defaults).\n * @returns The multiplier for `mode`.\n */\nexport function durationFactor(\n    mode: TravelMode,\n    factors?: Partial<Record<TravelMode, number>>,\n): number {\n    return factors?.[mode] ?? DEFAULT_MODE_DURATION_FACTORS[mode] ?? 1.0;\n}\n\n/** Options for {@link estimateTravel}. */\nexport interface EstimateTravelOptions {\n    /** Distance multiplier over the great-circle line. Default: `1.3`. */\n    circuityFactor?: number;\n    /** Average car speed in km/h. Default: `50`. */\n    carSpeedKmh?: number;\n    /** Per-mode duration multipliers (merged over the defaults). */\n    modeDurationFactors?: Partial<Record<TravelMode, number>>;\n}\n\n/**\n * Offline travel estimate between two coordinates. No network — distance comes\n * from {@link haversineKm} scaled by circuity, duration from a mode-adjusted\n * average speed. Mirrors `estimate_travel` from `tempest-fastapi-sdk`.\n *\n * @param origin - Start coordinate.\n * @param destination - End coordinate.\n * @param mode - Travel mode. Default: `\"car\"`.\n * @param options - Tuning knobs (circuity, speed, per-mode factors).\n * @returns A `\"heuristic\"` {@link TravelEstimate}.\n * @throws {RangeError} If `carSpeedKmh <= 0` or `circuityFactor <= 0`.\n *\n * @example\n * estimateTravel(\n *   { latitude: -23.5505, longitude: -46.6333 },\n *   { latitude: -23.5629, longitude: -46.6544 },\n *   \"car\",\n * ); // { mode: \"car\", distance_km: …, duration_minutes: …, source: \"heuristic\" }\n */\nexport function estimateTravel(\n    origin: Coordinate,\n    destination: Coordinate,\n    mode: TravelMode = \"car\",\n    options: EstimateTravelOptions = {},\n): TravelEstimate {\n    const {\n        circuityFactor = DEFAULT_CIRCUITY_FACTOR,\n        carSpeedKmh = DEFAULT_CAR_SPEED_KMH,\n        modeDurationFactors,\n    } = options;\n\n    if (carSpeedKmh <= 0) {\n        throw new RangeError(\"carSpeedKmh must be greater than 0\");\n    }\n    if (circuityFactor <= 0) {\n        throw new RangeError(\"circuityFactor must be greater than 0\");\n    }\n\n    const distanceKm = haversineKm(origin, destination) * circuityFactor;\n    const carMinutes = (distanceKm / carSpeedKmh) * 60.0;\n    const durationMinutes = carMinutes * durationFactor(mode, modeDurationFactors);\n\n    return {\n        mode,\n        distance_km: distanceKm,\n        duration_minutes: durationMinutes,\n        source: \"heuristic\",\n    };\n}\n"],"names":["DEFAULT_CIRCUITY_FACTOR","DEFAULT_CAR_SPEED_KMH","DEFAULT_MODE_DURATION_FACTORS","durationFactor","mode","factors","estimateTravel","origin","destination","options","circuityFactor","carSpeedKmh","modeDurationFactors","distanceKm","haversineKm","durationMinutes"],"mappings":"kHAOaA,EAA0B,IAM1BC,EAAwB,GAOxBC,EAA4D,CACrE,IAAK,EACL,WAAY,IACZ,IAAK,GACT,EAUO,SAASC,EACZC,EACAC,EACM,CACN,OAAOA,IAAUD,CAAI,GAAKF,EAA8BE,CAAI,GAAK,CACrE,CA+BO,SAASE,EACZC,EACAC,EACAJ,EAAmB,MACnBK,EAAiC,GACnB,CACd,KAAM,CACF,eAAAC,EAAiBV,EACjB,YAAAW,EAAcV,EACd,oBAAAW,CAAA,EACAH,EAEJ,GAAIE,GAAe,EACf,MAAM,IAAI,WAAW,oCAAoC,EAE7D,GAAID,GAAkB,EAClB,MAAM,IAAI,WAAW,uCAAuC,EAGhE,MAAMG,EAAaC,EAAAA,YAAYP,EAAQC,CAAW,EAAIE,EAEhDK,EADcF,EAAaF,EAAe,GACXR,EAAeC,EAAMQ,CAAmB,EAE7E,MAAO,CACH,KAAAR,EACA,YAAaS,EACb,iBAAkBE,EAClB,OAAQ,WAAA,CAEhB"}

package/dist/geo/estimate.js

@@ -0,0 +1,35 @@
+import { haversineKm as u } from "./distance.js";
+const m = 1.3, _ = 50, F = {
+  car: 1,
+  motorcycle: 0.95,
+  bus: 1.6
+};
+function h(t, r) {
+  return r?.[t] ?? F[t] ?? 1;
+}
+function A(t, r, e = "car", a = {}) {
+  const {
+    circuityFactor: n = m,
+    carSpeedKmh: c = _,
+    modeDurationFactors: i
+  } = a;
+  if (c <= 0)
+    throw new RangeError("carSpeedKmh must be greater than 0");
+  if (n <= 0)
+    throw new RangeError("circuityFactor must be greater than 0");
+  const o = u(t, r) * n, s = o / c * 60 * h(e, i);
+  return {
+    mode: e,
+    distance_km: o,
+    duration_minutes: s,
+    source: "heuristic"
+  };
+}
+export {
+  _ as DEFAULT_CAR_SPEED_KMH,
+  m as DEFAULT_CIRCUITY_FACTOR,
+  F as DEFAULT_MODE_DURATION_FACTORS,
+  h as durationFactor,
+  A as estimateTravel
+};
+//# sourceMappingURL=estimate.js.map