@aeroswarm/client 0.1.14 → 0.1.15

package/dist/react/index.js

@@ -392,9 +392,11 @@ async function readApiBody(res, label) {
   if (!res.ok || isFailure(body)) throw errorFrom(res, body, text, label);
   return body;
 }
-async function parseApiResponse(res, label) {
+async function parseApiEnvelope(res, label) {
   const body = await readApiBody(res, label);
-  return isEnvelope(body) ? body.data : body;
+  if (!isEnvelope(body)) return { data: body };
+  const meta = body.meta;
+  return { data: body.data, ...isObject(meta) && { meta } };
 }
 
 // src/sdk/api/rest.ts
@@ -633,13 +635,16 @@ var AeroSwarm = class _AeroSwarm {
       return null;
     }
   }
-  async federatedFetch(base, path, query) {
+  async federatedRequest(base, path, query) {
     const url = new URL(`${base}${path}`);
     for (const [k, v] of Object.entries(query ?? {})) if (v !== void 0) url.searchParams.set(k, v);
     const res = await fetch(url, {
       headers: { Authorization: `Bearer ${this.opts.token}`, [ENVELOPE_HEADER]: "1" }
     });
-    return parseApiResponse(res, `Federated request ${url.pathname}`);
+    return parseApiEnvelope(res, `Federated request ${url.pathname}`);
+  }
+  async federatedFetch(base, path, query) {
+    return (await this.federatedRequest(base, path, query)).data;
   }
   tracks = {
     subscribe: (opts, callbacks) => {
@@ -730,6 +735,42 @@ var AeroSwarm = class _AeroSwarm {
         });
       }
       return this.trpc.tracks.history.query(input);
+    },
+    /**
+     * The path an aircraft has flown, ready to draw: a GeoJSON line plus a point for every time
+     * mark, with the label already written in `tz`. By default the whole flight so far; `fromMs`
+     * and `toMs` choose a period, `sinceMs` fetches only what is new (see `createTrailPoller`),
+     * `stepM` asks for a coarser line. The airport's backend builds it (memory first, history
+     * as a fallback), so nothing is computed here. There is no AeroSwarm-side equivalent:
+     * pass `endpoint` or an `airportId` with a registered `historyEndpoint`.
+     */
+    trail: async (input) => {
+      const base = await this.resolveHistoryEndpoint(input.airportId, input.endpoint);
+      if (!base) {
+        throw new AeroApiError({
+          status: 400,
+          code: "BAD_REQUEST",
+          recoverable: false,
+          message: "tracks.trail needs the airport's backend: pass `endpoint`, or an `airportId` that has a historyEndpoint"
+        });
+      }
+      const num = (v) => v === void 0 ? void 0 : String(v);
+      const { data, meta } = await this.federatedRequest(
+        base,
+        `/tracks/${encodeURIComponent(input.trackId)}/trail`,
+        {
+          fromMs: num(input.fromMs),
+          toMs: num(input.toMs),
+          sinceMs: num(input.sinceMs),
+          stepM: num(input.stepM),
+          limit: num(input.limit),
+          labelEveryMs: num(input.labelEveryMs),
+          tz: input.tz,
+          labelFormat: input.labelFormat,
+          format: "geojson"
+        }
+      );
+      return { trail: data, ...meta && { meta } };
     }
   };
   /** Flight plans received from AFTN feeds. Live tracks that correlate with a
@@ -900,8 +941,135 @@ function AeroSwarmProvider({
   return /* @__PURE__ */ jsx(QueryClientProvider, { client: qc, children: /* @__PURE__ */ jsx(AeroSwarmContext.Provider, { value: { client }, children }) });
 }
 
+// src/react/hooks/use-track-trail.ts
+import { useEffect, useRef, useState } from "react";
+
+// src/shared/trail/index.ts
+var lineOf = (fc) => fc.features.find((f) => f.properties.kind === "trail");
+var marksOf = (fc) => fc.features.filter((f) => f.properties.kind === "mark");
+function trailEnd(trail) {
+  const line = lineOf(trail);
+  return line && line.geometry.coordinates.length > 0 ? line.properties.to : void 0;
+}
+function mergeTrail(prev, delta) {
+  if (!prev) return delta;
+  const before = lineOf(prev);
+  const added = lineOf(delta);
+  if (!before || !added) return prev;
+  if (added.geometry.coordinates.length === 0) return prev;
+  const seen = new Set(marksOf(prev).map((m) => m.properties.t));
+  const newMarks = marksOf(delta).filter((m) => !seen.has(m.properties.t));
+  const line = {
+    ...before,
+    properties: { ...before.properties, to: added.properties.to, stepM: Math.max(before.properties.stepM, added.properties.stepM) },
+    geometry: { type: "LineString", coordinates: [...before.geometry.coordinates, ...added.geometry.coordinates] }
+  };
+  return { type: "FeatureCollection", features: [line, ...marksOf(prev), ...newMarks] };
+}
+var isGone = (err) => typeof err === "object" && err !== null && err.code === "NOT_FOUND";
+function createTrailPoller(fetchTrail, options) {
+  const pollMs = options.pollMs ?? 5e3;
+  const stopWhenGone = options.stopWhenGone ?? true;
+  let current;
+  let stopped = false;
+  let timer;
+  let running;
+  const schedule = () => {
+    if (stopped || pollMs <= 0) return;
+    timer = setTimeout(() => void tick(), pollMs);
+  };
+  async function once() {
+    try {
+      const since = current ? trailEnd(current) : void 0;
+      const { trail } = await fetchTrail(since);
+      if (stopped) return;
+      const next = mergeTrail(current, trail);
+      if (next !== current) {
+        current = next;
+        options.onUpdate(next);
+      }
+    } catch (err) {
+      if (stopped) return;
+      options.onError?.(err);
+      if (stopWhenGone && isGone(err)) stopped = true;
+    }
+  }
+  function tick() {
+    if (stopped) return Promise.resolve();
+    running ??= once().finally(() => {
+      running = void 0;
+      schedule();
+    });
+    return running;
+  }
+  void tick();
+  return {
+    stop() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    },
+    async refresh() {
+      if (timer) clearTimeout(timer);
+      await (running ?? tick());
+    },
+    current: () => current
+  };
+}
+
+// src/react/hooks/use-track-trail.ts
+function useTrackTrail(trackId, options = {}) {
+  const { client } = useAeroSwarmContext();
+  const [trail, setTrail] = useState(void 0);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(void 0);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const enabled = options.enabled !== false && !!trackId;
+  const key = JSON.stringify([
+    trackId,
+    options.endpoint,
+    options.airportId,
+    options.fromMs,
+    options.toMs,
+    options.stepM,
+    options.limit,
+    options.labelEveryMs,
+    options.tz,
+    options.labelFormat,
+    options.pollMs
+  ]);
+  useEffect(() => {
+    setTrail(void 0);
+    setError(void 0);
+    if (!enabled || !trackId) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    const { enabled: _enabled, pollMs, ...request } = optionsRef.current;
+    const poller = createTrailPoller(
+      (sinceMs) => client.tracks.trail({ ...request, trackId, sinceMs }),
+      {
+        // A fixed period in the past does not grow: ask once.
+        pollMs: request.toMs !== void 0 ? 0 : pollMs,
+        onUpdate: (t) => {
+          setTrail(t);
+          setLoading(false);
+          setError(void 0);
+        },
+        onError: (e) => {
+          setError(e);
+          setLoading(false);
+        }
+      }
+    );
+    return () => poller.stop();
+  }, [client, enabled, key]);
+  return { trail, loading, error };
+}
+
 // src/react/hooks/use-track-motion.ts
-import { useEffect, useMemo as useMemo2, useRef } from "react";
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2 } from "react";
 
 // src/shared/motion/index.ts
 var KT_TO_MS = 0.514444;
@@ -1210,10 +1378,10 @@ function createTrackMotion(options = {}) {
 // src/react/hooks/use-track-motion.ts
 function useTrackMotion(options) {
   const { onFrame, ...motionOptions } = options;
-  const onFrameRef = useRef(onFrame);
+  const onFrameRef = useRef2(onFrame);
   onFrameRef.current = onFrame;
   const motion = useMemo2(() => createTrackMotion(motionOptions), []);
-  useEffect(() => {
+  useEffect2(() => {
     const stop = motion.start((frame) => onFrameRef.current(frame));
     return () => {
       stop();
@@ -1224,7 +1392,7 @@ function useTrackMotion(options) {
 }
 
 // src/react/hooks/use-track-history.ts
-import { useCallback, useEffect as useEffect2, useRef as useRef2 } from "react";
+import { useCallback, useEffect as useEffect3, useRef as useRef3 } from "react";
 var DR_MIN_SPEED_KT = 10;
 var MAX_SPEED_KT = 1200;
 var GAP_RESET_MS = 3e4;
@@ -1244,22 +1412,22 @@ function useTrackHistory(options) {
     maxJumpDeg = 5,
     onFrame
   } = options;
-  const currentPositions = useRef2(/* @__PURE__ */ new Map());
-  const lastActualPos = useRef2(/* @__PURE__ */ new Map());
-  const history = useRef2(/* @__PURE__ */ new Map());
-  const lastSeen = useRef2(/* @__PURE__ */ new Map());
-  const lastUpdPerf = useRef2(/* @__PURE__ */ new Map());
-  const interp = useRef2(/* @__PURE__ */ new Map());
-  const velocity = useRef2(/* @__PURE__ */ new Map());
-  const drState = useRef2(/* @__PURE__ */ new Map());
-  const rafRef = useRef2(null);
-  const onFrameRef = useRef2(onFrame);
+  const currentPositions = useRef3(/* @__PURE__ */ new Map());
+  const lastActualPos = useRef3(/* @__PURE__ */ new Map());
+  const history = useRef3(/* @__PURE__ */ new Map());
+  const lastSeen = useRef3(/* @__PURE__ */ new Map());
+  const lastUpdPerf = useRef3(/* @__PURE__ */ new Map());
+  const interp = useRef3(/* @__PURE__ */ new Map());
+  const velocity = useRef3(/* @__PURE__ */ new Map());
+  const drState = useRef3(/* @__PURE__ */ new Map());
+  const rafRef = useRef3(null);
+  const onFrameRef = useRef3(onFrame);
   onFrameRef.current = onFrame;
-  const maxHistoryPointsRef = useRef2(maxHistoryPoints);
+  const maxHistoryPointsRef = useRef3(maxHistoryPoints);
   maxHistoryPointsRef.current = maxHistoryPoints;
-  const minDeltaDegRef = useRef2(minDeltaDeg);
+  const minDeltaDegRef = useRef3(minDeltaDeg);
   minDeltaDegRef.current = minDeltaDeg;
-  const maxJumpDegRef = useRef2(maxJumpDeg);
+  const maxJumpDegRef = useRef3(maxJumpDeg);
   maxJumpDegRef.current = maxJumpDeg;
   function emitFrame() {
     onFrameRef.current({
@@ -1422,7 +1590,7 @@ function useTrackHistory(options) {
     drState.current.delete(trackId);
     emitFrame();
   }, []);
-  useEffect2(() => {
+  useEffect3(() => {
     return () => {
       if (rafRef.current !== null) {
         cancelAnimationFrame(rafRef.current);
@@ -1437,7 +1605,7 @@ function useTrackHistory(options) {
 }
 
 // src/react/hooks/index.ts
-import { useCallback as useCallback2, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef3 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef4 } from "react";
 import { useQuery } from "@tanstack/react-query";
 import { useShallow } from "zustand/react/shallow";
 
@@ -1537,7 +1705,7 @@ function useAeroTracks(opts = {}) {
   const isDegraded = useTrackStore(selectIsDegraded);
   const lastUpdateAt = useTrackStore(selectLastUpdateAt);
   const error = useTrackStore(selectError);
-  const unsubRef = useRef3(null);
+  const unsubRef = useRef4(null);
   const { isLoading } = useQuery({
     queryKey: ["aero-snapshot", opts.bbox?.join(","), opts.source, opts.minConfidence],
     enabled: opts.enabled !== false,
@@ -1551,7 +1719,7 @@ function useAeroTracks(opts = {}) {
       return result;
     }
   });
-  useEffect3(() => {
+  useEffect4(() => {
     if (opts.enabled === false) return;
     const actions = useTrackStore.getState();
     unsubRef.current = client.tracks.subscribe(
@@ -1688,6 +1856,7 @@ export {
   useTrackHistory,
   useTrackMotion,
   useTrackStore,
+  useTrackTrail,
   useTracks,
   useWebhooks
 };