@aeroswarm/client 0.1.13 → 0.1.15

package/dist/index.js

@@ -314,6 +314,90 @@ 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 } };
+}
+async function parseApiResponse(res, label) {
+  return (await parseApiEnvelope(res, label)).data;
+}
+
 // src/sdk/api/rest.ts
 var AeroRestClient = class {
   constructor(endpoint, token) {
@@ -331,8 +415,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);
@@ -551,12 +634,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) => {
@@ -647,6 +734,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
@@ -1091,19 +1214,130 @@ var Motion = class {
 function createTrackMotion(options = {}) {
   return new Motion(options);
 }
+
+// src/shared/source/index.ts
+function sourceLabel(source) {
+  switch (source) {
+    case "ADSB":
+    case "ASTERIX_CAT021":
+      return "ADSB";
+    case "ASTERIX_CAT010":
+    case "ASTERIX_CAT011":
+      return "SURFACE";
+    case "ASTERIX_CAT020":
+      return "MLAT";
+    case "ASTERIX_CAT048":
+      return "RADAR";
+    case "ASTERIX_CAT062":
+      return "SYSTEM";
+    case "FUSED":
+      return "FUSED";
+    default: {
+      const unreachable = source;
+      return unreachable;
+    }
+  }
+}
+function formatDataSource(track) {
+  const kind = sourceLabel(track.source);
+  const ds = track.dataSource;
+  return ds ? `${kind} ${ds.sac}/${ds.sic}` : kind;
+}
+
+// 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
+  };
+}
 export {
+  AeroApiError,
   AeroReplayClient,
   AeroSwarm,
   AeroWsClient,
   LABEL_COLORS,
   TrackCache,
   clamp,
+  codeForStatus,
   createTrackMotion,
+  createTrailPoller,
+  formatDataSource,
   getLabelCategory,
   haversineKm,
   isInsideBbox,
   isRenderableTrack2 as isRenderableTrack,
+  mergeTrail,
+  parseApiEnvelope,
+  parseApiResponse,
+  readApiBody,
+  sourceLabel,
   toCurrentTrack,
+  trailEnd,
   withLabel
 };
 //# sourceMappingURL=index.js.map