@aeroswarm/client 0.1.13 → 0.1.15

package/dist/react/index.js

@@ -318,6 +318,87 @@ function createAeroTrpcClient(endpoint, token) {
   });
 }
 
+// src/sdk/api/response.ts
+var ENVELOPE_HEADER = "x-aero-envelope";
+var STATUS_CODES = [
+  [401, "UNAUTHORIZED"],
+  [403, "FORBIDDEN"],
+  [404, "NOT_FOUND"],
+  [400, "BAD_REQUEST"],
+  [409, "CONFLICT"],
+  [429, "RATE_LIMITED"],
+  [503, "UNAVAILABLE"],
+  [500, "INTERNAL"]
+];
+function codeForStatus(status) {
+  const hit = STATUS_CODES.find(([s]) => s === status);
+  if (hit) return hit[1];
+  return status >= 500 ? "INTERNAL" : "BAD_REQUEST";
+}
+var AeroApiError = class extends Error {
+  status;
+  code;
+  /** Retrying later may succeed (rate limit, server busy or failing). */
+  recoverable;
+  details;
+  constructor(init) {
+    super(init.message);
+    this.name = "AeroApiError";
+    this.status = init.status;
+    this.code = init.code;
+    this.recoverable = init.recoverable;
+    this.details = init.details;
+  }
+};
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function isEnvelope(body) {
+  return isObject(body) && body.ok === true && "data" in body;
+}
+function isFailure(body) {
+  return isObject(body) && body.ok === false;
+}
+function errorFrom(res, body, text, label) {
+  const prefix = label ? `${label} \u2192 ${res.status}` : `HTTP ${res.status}`;
+  const failure = isFailure(body) ? body : void 0;
+  const e = failure?.error;
+  if (isObject(e)) {
+    const code = typeof e.code === "string" ? e.code : codeForStatus(res.status);
+    const message2 = typeof e.message === "string" ? e.message : res.statusText || prefix;
+    return new AeroApiError({
+      status: res.status,
+      code,
+      message: `${prefix}: ${message2}`,
+      recoverable: typeof e.recoverable === "boolean" ? e.recoverable : res.status >= 500,
+      details: e.details
+    });
+  }
+  const message = typeof e === "string" ? e : text.slice(0, 200) || res.statusText;
+  return new AeroApiError({
+    status: res.status,
+    code: codeForStatus(res.status),
+    message: message ? `${prefix}: ${message}` : prefix,
+    recoverable: res.status >= 500 || res.status === 429,
+    details: failure?.detail
+  });
+}
+async function readApiBody(res, label) {
+  const text = await res.text();
+  let body;
+  try {
+    body = text ? JSON.parse(text) : void 0;
+  } catch {
+    body = void 0;
+  }
+  if (!res.ok || isFailure(body)) throw errorFrom(res, body, text, label);
+  return body;
+}
+async function parseApiEnvelope(res, label) {
+  const body = await readApiBody(res, label);
+  if (!isEnvelope(body)) return { data: body };
+  const meta = body.meta;
+  return { data: body.data, ...isObject(meta) && { meta } };
+}
+
 // src/sdk/api/rest.ts
 var AeroRestClient = class {
   constructor(endpoint, token) {
@@ -335,8 +416,7 @@ var AeroRestClient = class {
       },
       body: body ? JSON.stringify(body) : void 0
     });
-    if (!res.ok) throw new Error(`${method} ${path} \u2192 ${res.status}`);
-    return res.json();
+    return await readApiBody(res, `${method} ${path}`);
   }
   createSource(body) {
     return this.req("POST", "/v1/sources", body);
@@ -555,12 +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}` } });
-    if (!res.ok) throw new Error(`Federated request failed: ${res.status} ${res.statusText} (${url.pathname})`);
-    return res.json();
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${this.opts.token}`, [ENVELOPE_HEADER]: "1" }
+    });
+    return parseApiEnvelope(res, `Federated request ${url.pathname}`);
+  }
+  async federatedFetch(base, path, query) {
+    return (await this.federatedRequest(base, path, query)).data;
   }
   tracks = {
     subscribe: (opts, callbacks) => {
@@ -651,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
@@ -821,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;
@@ -1131,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();
@@ -1145,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;
@@ -1165,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({
@@ -1343,7 +1590,7 @@ function useTrackHistory(options) {
     drState.current.delete(trackId);
     emitFrame();
   }, []);
-  useEffect2(() => {
+  useEffect3(() => {
     return () => {
       if (rafRef.current !== null) {
         cancelAnimationFrame(rafRef.current);
@@ -1358,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";
 
@@ -1458,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,
@@ -1472,7 +1719,7 @@ function useAeroTracks(opts = {}) {
       return result;
     }
   });
-  useEffect3(() => {
+  useEffect4(() => {
     if (opts.enabled === false) return;
     const actions = useTrackStore.getState();
     unsubRef.current = client.tracks.subscribe(
@@ -1609,6 +1856,7 @@ export {
   useTrackHistory,
   useTrackMotion,
   useTrackStore,
+  useTrackTrail,
   useTracks,
   useWebhooks
 };