@squawk/adsbtop 0.2.0

package/dist/selection.d.ts

@@ -0,0 +1,25 @@
+import type { Aircraft } from '@squawk/types';
+/**
+ * Finds the index of the aircraft currently identified by `selectedIcaoHex`
+ * within `aircraft`.
+ *
+ * @param aircraft - The currently displayed aircraft, in display order.
+ * @param selectedIcaoHex - The selected aircraft's ICAO hex, or undefined if none is selected.
+ * @returns The index of the selected aircraft, or -1 if none is selected or it is no longer present.
+ */
+export declare function findSelectedIndex(aircraft: readonly Aircraft[], selectedIcaoHex: string | undefined): number;
+/**
+ * Computes the ICAO hex to select after moving the cursor by `delta` rows
+ * from the current selection. Clamped at the first/last row rather than
+ * wrapping, matching `htop`'s arrow-key behavior. If the current selection
+ * is unset or no longer present in `aircraft` (e.g. the aircraft was lost),
+ * resets to the first row regardless of `delta` - simpler and more
+ * predictable than trying to reconstruct "where it would have moved to".
+ *
+ * @param aircraft - The currently displayed aircraft, in display order.
+ * @param selectedIcaoHex - The currently selected aircraft's ICAO hex, or undefined if none is selected.
+ * @param delta - Rows to move: -1 for up, 1 for down.
+ * @returns The ICAO hex to select next, or undefined if `aircraft` is empty.
+ */
+export declare function moveSelection(aircraft: readonly Aircraft[], selectedIcaoHex: string | undefined, delta: -1 | 1): string | undefined;
+//# sourceMappingURL=selection.d.ts.map

package/dist/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../src/selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,QAAQ,EAAE,EAC7B,eAAe,EAAE,MAAM,GAAG,SAAS,GAClC,MAAM,CAKR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,QAAQ,EAAE,EAC7B,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,GACZ,MAAM,GAAG,SAAS,CAUpB"}

package/dist/selection.js

@@ -0,0 +1,38 @@
+/**
+ * Finds the index of the aircraft currently identified by `selectedIcaoHex`
+ * within `aircraft`.
+ *
+ * @param aircraft - The currently displayed aircraft, in display order.
+ * @param selectedIcaoHex - The selected aircraft's ICAO hex, or undefined if none is selected.
+ * @returns The index of the selected aircraft, or -1 if none is selected or it is no longer present.
+ */
+export function findSelectedIndex(aircraft, selectedIcaoHex) {
+    if (selectedIcaoHex === undefined) {
+        return -1;
+    }
+    return aircraft.findIndex((candidate) => candidate.icaoHex === selectedIcaoHex);
+}
+/**
+ * Computes the ICAO hex to select after moving the cursor by `delta` rows
+ * from the current selection. Clamped at the first/last row rather than
+ * wrapping, matching `htop`'s arrow-key behavior. If the current selection
+ * is unset or no longer present in `aircraft` (e.g. the aircraft was lost),
+ * resets to the first row regardless of `delta` - simpler and more
+ * predictable than trying to reconstruct "where it would have moved to".
+ *
+ * @param aircraft - The currently displayed aircraft, in display order.
+ * @param selectedIcaoHex - The currently selected aircraft's ICAO hex, or undefined if none is selected.
+ * @param delta - Rows to move: -1 for up, 1 for down.
+ * @returns The ICAO hex to select next, or undefined if `aircraft` is empty.
+ */
+export function moveSelection(aircraft, selectedIcaoHex, delta) {
+    if (aircraft.length === 0) {
+        return undefined;
+    }
+    const currentIndex = findSelectedIndex(aircraft, selectedIcaoHex);
+    if (currentIndex === -1) {
+        return aircraft[0]?.icaoHex;
+    }
+    const nextIndex = Math.min(Math.max(currentIndex + delta, 0), aircraft.length - 1);
+    return aircraft[nextIndex]?.icaoHex;
+}

package/dist/sparkline.d.ts

@@ -0,0 +1,26 @@
+import type { PositionHistoryEntry } from '@squawk/adsb-feed';
+/**
+ * A two-row altitude sparkline. Stacking two block-character rows doubles
+ * the vertical resolution of a single row (16 distinguishable levels instead
+ * of 8) - a single row's eighth-block characters top out at 8 heights, not
+ * enough to show real definition once a flight settles into a shallow climb
+ * or a cruise segment with only minor wander.
+ */
+export interface AltitudeSparkline {
+    /** Top row: each column's fill above the row split (blank where the column doesn't reach it). */
+    topRow: string;
+    /** Bottom row: each column's fill up to the row split. */
+    bottomRow: string;
+}
+/**
+ * Builds a two-row altitude sparkline from a position history, oldest sample
+ * first. Barometric altitude is preferred per sample, geometric as a
+ * fallback - matching the table's altitude column precedence. Samples with
+ * neither field are skipped rather than breaking the line. Only the most
+ * recent {@link MAX_SPARKLINE_SAMPLES} are rendered.
+ *
+ * @param history - Position samples for one aircraft, oldest first (as returned by `AircraftFeed.getPositionHistory`).
+ * @returns The two rows, each scaled between the shown window's min and max altitude, or undefined if no sample carries an altitude.
+ */
+export declare function buildAltitudeSparkline(history: readonly PositionHistoryEntry[]): AltitudeSparkline | undefined;
+//# sourceMappingURL=sparkline.d.ts.map

package/dist/sparkline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkline.d.ts","sourceRoot":"","sources":["../src/sparkline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAiB9D;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,iGAAiG;IACjG,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;CACnB;AAYD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,oBAAoB,EAAE,GACvC,iBAAiB,GAAG,SAAS,CAmC/B"}

package/dist/sparkline.js

@@ -0,0 +1,62 @@
+/** Unicode block characters, one per eighth-row fill level (index 0 = 1/8 filled, index 7 = fully filled). */
+const SPARKLINE_LEVELS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+/** Combined vertical levels across both rows (8 per row) - double a single row's resolution. */
+const TOTAL_LEVELS = SPARKLINE_LEVELS.length * 2;
+/**
+ * Maximum samples rendered, most recent first truncated from the front of
+ * `history`. A sparkline is a fixed-size recent-trend glyph, not a full
+ * session dump - without this cap the line grows by one character per
+ * position update for as long as an aircraft stays tracked, eventually
+ * overflowing the terminal width and wrapping.
+ */
+const MAX_SPARKLINE_SAMPLES = 60;
+/**
+ * Renders `units` (0-8) as one row's block character, blank when 0.
+ *
+ * @param units - Eighths filled in this row, 0-8.
+ * @returns The block character for `units`, or a space when `units` is 0.
+ */
+function rowChar(units) {
+    return units <= 0 ? ' ' : (SPARKLINE_LEVELS[Math.min(units, SPARKLINE_LEVELS.length) - 1] ?? '');
+}
+/**
+ * Builds a two-row altitude sparkline from a position history, oldest sample
+ * first. Barometric altitude is preferred per sample, geometric as a
+ * fallback - matching the table's altitude column precedence. Samples with
+ * neither field are skipped rather than breaking the line. Only the most
+ * recent {@link MAX_SPARKLINE_SAMPLES} are rendered.
+ *
+ * @param history - Position samples for one aircraft, oldest first (as returned by `AircraftFeed.getPositionHistory`).
+ * @returns The two rows, each scaled between the shown window's min and max altitude, or undefined if no sample carries an altitude.
+ */
+export function buildAltitudeSparkline(history) {
+    const recent = history.slice(-MAX_SPARKLINE_SAMPLES);
+    const altitudes = recent
+        .map((entry) => entry.position.baroAltitudeFt ?? entry.position.geoAltitudeFt)
+        .filter((altitude) => altitude !== undefined);
+    if (altitudes.length === 0) {
+        return undefined;
+    }
+    const min = Math.min(...altitudes);
+    const max = Math.max(...altitudes);
+    if (min === max) {
+        // No range to scale against - render a flat mid-level bar on the bottom
+        // row only, leaving the top row blank. Matches the single-row version's
+        // convention for a value that never moved, and keeps "the top row is
+        // lit" meaning "real variation exists" rather than something a
+        // perfectly flat run can also trigger.
+        const flatBar = SPARKLINE_LEVELS[Math.floor(SPARKLINE_LEVELS.length / 2)] ?? '';
+        return { topRow: ' '.repeat(altitudes.length), bottomRow: flatBar.repeat(altitudes.length) };
+    }
+    const topChars = [];
+    const bottomChars = [];
+    for (const altitude of altitudes) {
+        const ratio = (altitude - min) / (max - min);
+        const level = Math.min(TOTAL_LEVELS - 1, Math.floor(ratio * TOTAL_LEVELS));
+        const bottomUnits = Math.min(level + 1, SPARKLINE_LEVELS.length);
+        const topUnits = level + 1 - bottomUnits;
+        bottomChars.push(rowChar(bottomUnits));
+        topChars.push(rowChar(topUnits));
+    }
+    return { topRow: topChars.join(''), bottomRow: bottomChars.join('') };
+}

package/dist/status-line.d.ts

@@ -0,0 +1,28 @@
+import type { FeedSource } from './cli-args.js';
+/** Inputs for {@link formatStatusLine}. */
+export interface StatusLineInfo {
+    /** Feed source currently in use. */
+    source: FeedSource;
+    /** Station host being connected to. */
+    host: string;
+    /** Station port being connected to. */
+    port: number;
+    /** Number of aircraft currently tracked. */
+    aircraftCount: number;
+    /** Update events observed in roughly the last second. */
+    messageRatePerSec: number;
+    /** Unix epoch ms of the most recent update, or undefined if none has arrived yet. */
+    lastMessageAt: number | undefined;
+    /** Current time, for the "last update" age. */
+    nowMs: number;
+}
+/**
+ * Builds the single-line connection/activity summary shown in the status
+ * header. A pure string builder, kept separate from the Ink component so it
+ * is directly unit-testable without a render harness.
+ *
+ * @param info - The connection and activity state to summarize.
+ * @returns The formatted status line, without any styling applied.
+ */
+export declare function formatStatusLine(info: StatusLineInfo): string;
+//# sourceMappingURL=status-line.d.ts.map

package/dist/status-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-line.d.ts","sourceRoot":"","sources":["../src/status-line.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,2CAA2C;AAC3C,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,MAAM,EAAE,UAAU,CAAC;IACnB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qFAAqF;IACrF,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAW7D"}

package/dist/status-line.js

@@ -0,0 +1,18 @@
+import { formatAge } from './format.js';
+/**
+ * Builds the single-line connection/activity summary shown in the status
+ * header. A pure string builder, kept separate from the Ink component so it
+ * is directly unit-testable without a render harness.
+ *
+ * @param info - The connection and activity state to summarize.
+ * @returns The formatted status line, without any styling applied.
+ */
+export function formatStatusLine(info) {
+    const lastUpdate = info.lastMessageAt === undefined
+        ? 'none yet'
+        : `${formatAge(info.lastMessageAt, info.nowMs)} ago`;
+    return (`source: ${info.source} ${info.host}:${info.port}  |  ` +
+        `aircraft: ${info.aircraftCount}  |  ` +
+        `msgs/s: ${info.messageRatePerSec}  |  ` +
+        `last update: ${lastUpdate}`);
+}

package/dist/test-utils.d.ts

@@ -0,0 +1,23 @@
+import type { AircraftFeed } from '@squawk/adsb-feed';
+import type { AircraftRegistration } from '@squawk/types';
+import type { RegistryDataLoader } from './use-icao-registry.js';
+/** A fake {@link AircraftFeed} for tests: a real `EventTarget` so production code can dispatch events on it normally, with `start`/`stop` call counts and stubbed query methods. */
+export interface FakeAircraftFeed extends AircraftFeed {
+    /** Number of times `start()` has been called. */
+    startCalls: number;
+    /** Number of times `stop()` has been called. */
+    stopCalls: number;
+}
+/**
+ * Creates a {@link FakeAircraftFeed} with no real socket/HTTP behavior, for
+ * tests that need to dispatch `aircraft:new`/`aircraft:update`/`aircraft:lost`
+ * events without a live dump1090-fa station.
+ */
+export declare function createFakeAircraftFeed(): FakeAircraftFeed;
+/**
+ * Creates a {@link RegistryDataLoader} resolving to `records` (empty by
+ * default), for tests that render `App` without pulling in the real
+ * `@squawk/icao-registry-data` package's ~40MB in-memory dataset.
+ */
+export declare function createFakeRegistryDataLoader(records?: AircraftRegistration[]): RegistryDataLoader;
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAwB,MAAM,mBAAmB,CAAC;AAC5E,OAAO,KAAK,EAAY,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAEpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,oLAAoL;AACpL,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAqBzD;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,GAAE,oBAAoB,EAAO,GACnC,kBAAkB,CAEpB"}

package/dist/test-utils.js

@@ -0,0 +1,35 @@
+/**
+ * Creates a {@link FakeAircraftFeed} with no real socket/HTTP behavior, for
+ * tests that need to dispatch `aircraft:new`/`aircraft:update`/`aircraft:lost`
+ * events without a live dump1090-fa station.
+ */
+export function createFakeAircraftFeed() {
+    const feed = Object.assign(new EventTarget(), {
+        startCalls: 0,
+        stopCalls: 0,
+        start() {
+            feed.startCalls += 1;
+        },
+        stop() {
+            feed.stopCalls += 1;
+        },
+        getAircraft() {
+            return undefined;
+        },
+        getAllAircraft() {
+            return [];
+        },
+        getPositionHistory() {
+            return [];
+        },
+    });
+    return feed;
+}
+/**
+ * Creates a {@link RegistryDataLoader} resolving to `records` (empty by
+ * default), for tests that render `App` without pulling in the real
+ * `@squawk/icao-registry-data` package's ~40MB in-memory dataset.
+ */
+export function createFakeRegistryDataLoader(records = []) {
+    return () => Promise.resolve({ usBundledRegistry: { records } });
+}

package/dist/use-aircraft-feed.d.ts

@@ -0,0 +1,28 @@
+import type { AircraftFeed } from '@squawk/adsb-feed';
+import type { Aircraft } from '@squawk/types';
+import type { MessageLogEntry } from './aircraft-state.js';
+/** Live view of an `AircraftFeed`'s tracked aircraft and activity stats. */
+export interface AircraftFeedView {
+    /** Currently tracked aircraft, in no particular order - sort before display. */
+    aircraft: Aircraft[];
+    /** Total update events observed since the feed started. */
+    messageCount: number;
+    /** Unix epoch ms of the most recent update, or undefined if none has arrived yet. */
+    lastMessageAt: number | undefined;
+    /** Update events observed in roughly the last second. */
+    messageRatePerSec: number;
+    /** Every event type, oldest first, for the `[M]essages` panel's `all` verbosity. */
+    messageLog: MessageLogEntry[];
+    /** `aircraft:new`/`aircraft:lost` events only, oldest first, for the panel's default `newAndLost` verbosity - capped independently of `messageLog` so update volume can't evict a still-relevant entry. */
+    newAndLostLog: MessageLogEntry[];
+}
+/**
+ * Subscribes to `feed`'s aircraft events for the component's lifetime,
+ * starting it on mount and stopping it on unmount, and accumulates tracked
+ * aircraft plus activity stats via the pure `aircraftStateReducer`.
+ *
+ * @param feed - The feed to subscribe to. Changing the reference tears down the old subscription and starts a new one.
+ * @returns The current aircraft list and activity stats, updated as events arrive.
+ */
+export declare function useAircraftFeed(feed: AircraftFeed): AircraftFeedView;
+//# sourceMappingURL=use-aircraft-feed.d.ts.map

package/dist/use-aircraft-feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-aircraft-feed.d.ts","sourceRoot":"","sources":["../src/use-aircraft-feed.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAG9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAK3D,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,yDAAyD;IACzD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oFAAoF;IACpF,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,2MAA2M;IAC3M,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,CA8DpE"}

package/dist/use-aircraft-feed.js

@@ -0,0 +1,68 @@
+import { useEffect, useMemo, useReducer, useRef, useState } from 'react';
+import { aircraftStateReducer, initialAircraftState } from './aircraft-state.js';
+/** How often {@link useAircraftFeed} recomputes `messageRatePerSec`. */
+const RATE_SAMPLE_INTERVAL_MS = 1000;
+/**
+ * Subscribes to `feed`'s aircraft events for the component's lifetime,
+ * starting it on mount and stopping it on unmount, and accumulates tracked
+ * aircraft plus activity stats via the pure `aircraftStateReducer`.
+ *
+ * @param feed - The feed to subscribe to. Changing the reference tears down the old subscription and starts a new one.
+ * @returns The current aircraft list and activity stats, updated as events arrive.
+ */
+export function useAircraftFeed(feed) {
+    const [state, dispatch] = useReducer(aircraftStateReducer, initialAircraftState);
+    const [messageRatePerSec, setMessageRatePerSec] = useState(0);
+    const messageCountRef = useRef(state.messageCount);
+    useEffect(() => {
+        messageCountRef.current = state.messageCount;
+    }, [state.messageCount]);
+    useEffect(() => {
+        function handleNew(event) {
+            const { aircraft } = event.detail;
+            dispatch({ type: 'message', kind: 'new', aircraft, at: Date.now() });
+        }
+        function handleUpdate(event) {
+            const { aircraft } = event.detail;
+            dispatch({ type: 'message', kind: 'update', aircraft, at: Date.now() });
+        }
+        function handleLost(event) {
+            const { icaoHex, lastAircraft } = event.detail;
+            dispatch({ type: 'lost', icaoHex, callsign: lastAircraft.callsign, at: Date.now() });
+        }
+        feed.addEventListener('aircraft:new', handleNew);
+        feed.addEventListener('aircraft:update', handleUpdate);
+        feed.addEventListener('aircraft:lost', handleLost);
+        feed.start();
+        return () => {
+            feed.removeEventListener('aircraft:new', handleNew);
+            feed.removeEventListener('aircraft:update', handleUpdate);
+            feed.removeEventListener('aircraft:lost', handleLost);
+            feed.stop();
+        };
+    }, [feed]);
+    useEffect(() => {
+        let lastCount = messageCountRef.current;
+        const handle = setInterval(() => {
+            setMessageRatePerSec(messageCountRef.current - lastCount);
+            lastCount = messageCountRef.current;
+        }, RATE_SAMPLE_INTERVAL_MS);
+        return () => {
+            clearInterval(handle);
+        };
+    }, []);
+    // Memoized against the Map reference (which the reducer only replaces on a
+    // real message/lost action) rather than recomputed on every render - a
+    // fresh array on every render would make `aircraft` look "changed" to any
+    // consumer's effect/memo dependency array even when nothing happened, e.g.
+    // on the clock-tick re-renders the app's age column relies on.
+    const aircraft = useMemo(() => Array.from(state.aircraftByHex.values()), [state.aircraftByHex]);
+    return {
+        aircraft,
+        messageCount: state.messageCount,
+        lastMessageAt: state.lastMessageAt,
+        messageRatePerSec,
+        messageLog: state.messageLog,
+        newAndLostLog: state.newAndLostLog,
+    };
+}

package/dist/use-icao-registry.d.ts

@@ -0,0 +1,27 @@
+import type { IcaoRegistry } from '@squawk/icao-registry';
+import type { AircraftRegistration } from '@squawk/types';
+/** The subset of `@squawk/icao-registry-data`'s module exports this hook needs. */
+export interface RegistryDataModule {
+    /** The bundled US aircraft registry dataset. */
+    usBundledRegistry: {
+        /** Raw registration records, keyed by `icaoHex` once loaded into a resolver. */
+        records: AircraftRegistration[];
+    };
+}
+/** Loads the bundled registry dataset module - overridable so tests don't import the real ~40MB dataset. */
+export type RegistryDataLoader = () => Promise<RegistryDataModule>;
+/**
+ * Lazily loads `@squawk/icao-registry-data` and builds an `IcaoRegistry`
+ * after mount, so the dataset's decompress-and-parse cost doesn't block
+ * adsbtop's first paint. `@squawk/icao-registry-data` is a hard dependency
+ * (registration lookup is adsbtop's headline enrichment feature, unlike
+ * `@squawk/mcp`'s optional-peer treatment of the same dataset, where it's
+ * one tool among many) - a load failure is unexpected, and degrades to
+ * leaving registration columns/fields at `-` rather than crashing the live
+ * dashboard over a non-core enhancement.
+ *
+ * @param loadData - Loader for the bundled dataset module. Defaults to a real dynamic import of `@squawk/icao-registry-data`; overridable in tests.
+ * @returns The ready-to-query registry, or undefined while loading (or if loading failed).
+ */
+export declare function useIcaoRegistry(loadData?: RegistryDataLoader): IcaoRegistry | undefined;
+//# sourceMappingURL=use-icao-registry.d.ts.map

package/dist/use-icao-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-icao-registry.d.ts","sourceRoot":"","sources":["../src/use-icao-registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,mFAAmF;AACnF,MAAM,WAAW,kBAAkB;IACjC,gDAAgD;IAChD,iBAAiB,EAAE;QACjB,gFAAgF;QAChF,OAAO,EAAE,oBAAoB,EAAE,CAAC;KACjC,CAAC;CACH;AAED,4GAA4G;AAC5G,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAInE;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,GAAE,kBAAkC,GAC3C,YAAY,GAAG,SAAS,CAsB1B"}

package/dist/use-icao-registry.js

@@ -0,0 +1,37 @@
+import { useEffect, useState } from 'react';
+import { createIcaoRegistry } from '@squawk/icao-registry';
+const defaultLoader = () => import('@squawk/icao-registry-data');
+/**
+ * Lazily loads `@squawk/icao-registry-data` and builds an `IcaoRegistry`
+ * after mount, so the dataset's decompress-and-parse cost doesn't block
+ * adsbtop's first paint. `@squawk/icao-registry-data` is a hard dependency
+ * (registration lookup is adsbtop's headline enrichment feature, unlike
+ * `@squawk/mcp`'s optional-peer treatment of the same dataset, where it's
+ * one tool among many) - a load failure is unexpected, and degrades to
+ * leaving registration columns/fields at `-` rather than crashing the live
+ * dashboard over a non-core enhancement.
+ *
+ * @param loadData - Loader for the bundled dataset module. Defaults to a real dynamic import of `@squawk/icao-registry-data`; overridable in tests.
+ * @returns The ready-to-query registry, or undefined while loading (or if loading failed).
+ */
+export function useIcaoRegistry(loadData = defaultLoader) {
+    const [registry, setRegistry] = useState(undefined);
+    useEffect(() => {
+        let cancelled = false;
+        loadData()
+            .then(({ usBundledRegistry }) => {
+            if (!cancelled) {
+                setRegistry(createIcaoRegistry({ data: usBundledRegistry.records }));
+            }
+        })
+            .catch(() => {
+            // Registration enrichment is a display enhancement, not core
+            // tracking functionality - leave the registry unset rather than
+            // crash the dashboard over a failed load.
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [loadData]);
+    return registry;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@squawk/adsbtop",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "Terminal dashboard for live ADS-B aircraft tracking, built on @squawk/adsb-feed",
+  "license": "MIT",
+  "author": "Neil Cochran",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/neilcochran/squawk.git",
+    "directory": "apps/adsbtop"
+  },
+  "homepage": "https://github.com/neilcochran/squawk",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "adsbtop": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.spec.*"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').chmodSync('dist/cli.js', 0o755)\"",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "tsc --noEmit && eslint src"
+  },
+  "dependencies": {
+    "@squawk/adsb-feed": "^0.2.0",
+    "@squawk/geo": "^0.4.9",
+    "@squawk/icao-registry": "^0.5.7",
+    "@squawk/icao-registry-data": "^0.8.11",
+    "@squawk/types": "^0.8.6",
+    "ink": "^7.1.1",
+    "ink-text-input": "^6.0.0",
+    "react": "^19.2.8"
+  },
+  "keywords": [
+    "aviation",
+    "adsb",
+    "ads-b",
+    "aircraft-tracking",
+    "terminal",
+    "tui",
+    "cli"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "@types/react": "^19.2.18",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "ink-testing-library": "^4.0.0"
+  }
+}