@smartnet360/svelte-components 0.0.118 → 0.0.120

package/dist/apps/antenna-tools/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Antenna Tools Module
+ *
+ * A comprehensive antenna pattern visualization and management module.
+ *
+ * Two operating modes:
+ * 1. External Data Mode: Parent provides antenna specs, selection hidden
+ * 2. Standalone Mode: User selects from database, full UI
+ *
+ * Features:
+ * - MSI/PNT file parsing
+ * - Automatic frequency band purging on import
+ * - Polar chart visualization (line & area)
+ * - Electrical and mechanical tilt adjustment
+ * - Single and compare view modes
+ * - IndexedDB persistence with Dexie
+ */
+export { default as AntennaTools } from './components/AntennaTools.svelte';
+export { AntennaControls, AntennaSettingsModal, DatabaseViewer, DbNotification, JsonImporter, MSIConverter, } from './components/index';
+export { PolarLineChart, PolarAreaChart } from './components/chart-engines/index';
+export type { Antenna, RawAntenna, ExternalAntennaInput, BandDefinition, ViewMode, PatternType, ChartEngineType, PatternDisplayMode, AntennaSearchResult, } from './types';
+export { STANDARD_BANDS } from './types';
+export { db as antennaToolsDB } from './db';
+export { antennas, selectedAntenna, searchQuery, filteredAntennas, dbStatus, dataOperationStatus, updateDbStatus, trackDataOperation, } from './stores/index';
+export { loadAntennas, saveAntennasWithPurge, saveAntennas, importFromJson, exportAntennas, clearAllAntennas, hasImportedData, parseMSIFile, parseFolder, findAntennaByName, findAntennaBySpec, collectAvailableTilts, collectAvailableFrequencies, findTiltIndex, getTiltValue, findAntennaWithTilt, findAntennaExact, getUniqueAntennaModels, getUniqueAntennas, getRecentAntennas, addToRecentAntennas, clearRecentAntennas, sortAntennasWithRecent, } from './utils/index';
+export { purgeAntennas, getBandCenterFrequency, findBandForFrequency, isFrequencyInStandardBand, calculatePurgeStats, type PurgeStats, } from './band-config';

package/dist/apps/antenna-tools/index.js

@@ -0,0 +1,40 @@
+/**
+ * Antenna Tools Module
+ *
+ * A comprehensive antenna pattern visualization and management module.
+ *
+ * Two operating modes:
+ * 1. External Data Mode: Parent provides antenna specs, selection hidden
+ * 2. Standalone Mode: User selects from database, full UI
+ *
+ * Features:
+ * - MSI/PNT file parsing
+ * - Automatic frequency band purging on import
+ * - Polar chart visualization (line & area)
+ * - Electrical and mechanical tilt adjustment
+ * - Single and compare view modes
+ * - IndexedDB persistence with Dexie
+ */
+// === Main Component ===
+export { default as AntennaTools } from './components/AntennaTools.svelte';
+// === UI Components ===
+export { AntennaControls, AntennaSettingsModal, DatabaseViewer, DbNotification, JsonImporter, MSIConverter, } from './components/index';
+// === Chart Components ===
+export { PolarLineChart, PolarAreaChart } from './components/chart-engines/index';
+export { STANDARD_BANDS } from './types';
+// === Database ===
+export { db as antennaToolsDB } from './db';
+// === Stores ===
+export { antennas, selectedAntenna, searchQuery, filteredAntennas, dbStatus, dataOperationStatus, updateDbStatus, trackDataOperation, } from './stores/index';
+// === Utilities ===
+export { 
+// DB operations
+loadAntennas, saveAntennasWithPurge, saveAntennas, importFromJson, exportAntennas, clearAllAntennas, hasImportedData, 
+// MSI parsing
+parseMSIFile, parseFolder, 
+// Antenna helpers
+findAntennaByName, findAntennaBySpec, collectAvailableTilts, collectAvailableFrequencies, findTiltIndex, getTiltValue, findAntennaWithTilt, findAntennaExact, getUniqueAntennaModels, getUniqueAntennas, 
+// Recent antennas
+getRecentAntennas, addToRecentAntennas, clearRecentAntennas, sortAntennasWithRecent, } from './utils/index';
+// === Band Configuration ===
+export { purgeAntennas, getBandCenterFrequency, findBandForFrequency, isFrequencyInStandardBand, calculatePurgeStats, } from './band-config';

package/dist/apps/antenna-tools/stores/antennas.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Antenna Tools - Stores
+ * Svelte stores for antenna data and UI state
+ */
+import type { Antenna } from '../types';
+/** All loaded antennas */
+export declare const antennas: import("svelte/store").Writable<Antenna[]>;
+/** Currently selected antenna (for single mode) */
+export declare const selectedAntenna: import("svelte/store").Writable<Antenna | null>;
+/** Search query for filtering antennas */
+export declare const searchQuery: import("svelte/store").Writable<string>;
+/** Filtered antennas based on search query */
+export declare const filteredAntennas: import("svelte/store").Readable<Antenna[]>;

package/dist/apps/antenna-tools/stores/antennas.js

@@ -0,0 +1,25 @@
+/**
+ * Antenna Tools - Stores
+ * Svelte stores for antenna data and UI state
+ */
+import { writable, derived } from 'svelte/store';
+// ─────────────────────────────────────────────────────────────────────────────
+// ANTENNA DATA STORES
+// ─────────────────────────────────────────────────────────────────────────────
+/** All loaded antennas */
+export const antennas = writable([]);
+/** Currently selected antenna (for single mode) */
+export const selectedAntenna = writable(null);
+/** Search query for filtering antennas */
+export const searchQuery = writable('');
+/** Filtered antennas based on search query */
+export const filteredAntennas = derived([antennas, searchQuery], ([$antennas, $searchQuery]) => {
+    if (!$searchQuery)
+        return $antennas;
+    const query = $searchQuery.toLowerCase();
+    return $antennas.filter(antenna => antenna.name?.toLowerCase().includes(query) ||
+        antenna.frequency?.toString().includes(query) ||
+        antenna.tilt?.toString().includes(query) ||
+        antenna.comment?.toLowerCase().includes(query) ||
+        antenna.polarization?.toLowerCase().includes(query));
+});

package/dist/apps/antenna-tools/stores/db-status.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Antenna Tools - Database Status Store
+ * Tracks database initialization and data operations
+ */
+export interface DbStatusState {
+    initialized: boolean;
+    antennaCount: number;
+    lastUpdated: Date | null;
+    loading: boolean;
+    error: string | null;
+}
+/** Database status store */
+export declare const dbStatus: import("svelte/store").Writable<DbStatusState>;
+/** Helper function to update database status */
+export declare function updateDbStatus(status: Partial<DbStatusState>): void;
+export interface DataOperationState {
+    operation: 'import' | 'export' | 'clear' | 'purge' | null;
+    inProgress: boolean;
+    success: boolean;
+    error: string | null;
+    message: string;
+    timestamp: Date | null;
+}
+/** Data operation status store */
+export declare const dataOperationStatus: import("svelte/store").Writable<DataOperationState>;
+/** Helper function to track data operations */
+export declare function trackDataOperation(operation: 'import' | 'export' | 'clear' | 'purge', status: {
+    inProgress: boolean;
+    success?: boolean;
+    error?: string | null;
+    message?: string;
+}): void;

package/dist/apps/antenna-tools/stores/db-status.js

@@ -0,0 +1,38 @@
+/**
+ * Antenna Tools - Database Status Store
+ * Tracks database initialization and data operations
+ */
+import { writable } from 'svelte/store';
+/** Database status store */
+export const dbStatus = writable({
+    initialized: false,
+    antennaCount: 0,
+    lastUpdated: null,
+    loading: false,
+    error: null
+});
+/** Helper function to update database status */
+export function updateDbStatus(status) {
+    dbStatus.update(current => ({ ...current, ...status }));
+}
+/** Data operation status store */
+export const dataOperationStatus = writable({
+    operation: null,
+    inProgress: false,
+    success: false,
+    error: null,
+    message: '',
+    timestamp: null
+});
+/** Helper function to track data operations */
+export function trackDataOperation(operation, status) {
+    dataOperationStatus.update(current => ({
+        ...current,
+        operation,
+        inProgress: status.inProgress,
+        success: status.success !== undefined ? status.success : current.success,
+        error: status.error !== undefined ? status.error : current.error,
+        message: status.message || current.message,
+        timestamp: new Date()
+    }));
+}

package/dist/apps/antenna-tools/stores/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Antenna Tools - Stores Index
+ */
+export { antennas, selectedAntenna, searchQuery, filteredAntennas } from './antennas';
+export { dbStatus, dataOperationStatus, updateDbStatus, trackDataOperation, type DbStatusState, type DataOperationState } from './db-status';

package/dist/apps/antenna-tools/stores/index.js

@@ -0,0 +1,5 @@
+/**
+ * Antenna Tools - Stores Index
+ */
+export { antennas, selectedAntenna, searchQuery, filteredAntennas } from './antennas';
+export { dbStatus, dataOperationStatus, updateDbStatus, trackDataOperation } from './db-status';

package/dist/apps/antenna-tools/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Antenna Tools - Type Definitions
+ * Clean, centralized type definitions for the antenna-tools module
+ */
+/**
+ * Frequency band definition for filtering antennas
+ */
+export interface BandDefinition {
+    /** Simple band name: "700", "800", "900", "1800", "2100", "2600" */
+    name: string;
+    /** Downlink minimum frequency (MHz) */
+    dlMin: number;
+    /** Downlink maximum frequency (MHz) */
+    dlMax: number;
+}
+/**
+ * Standard frequency bands - fixed preset
+ * Only downlink frequencies are considered
+ */
+export declare const STANDARD_BANDS: BandDefinition[];
+/**
+ * Antenna record stored in the database
+ * After purge: frequency = band name (700, 800, etc.), originalFrequency = actual MHz
+ */
+export interface Antenna {
+    /** Database ID (auto-generated) */
+    id?: number;
+    /** Antenna model name (e.g., "ADU4515R17v06") */
+    name: string;
+    /** Band name as number: 700, 800, 900, 1800, 2100, 2600 */
+    frequency: number;
+    /** Original frequency from MSI file in MHz (e.g., 763, 796) */
+    originalFrequency: number;
+    /** Antenna gain in dBd */
+    gain_dBd: number;
+    /** Electrical tilt value as string (e.g., "3", "4", "5") */
+    tilt: string;
+    /** Comment from MSI file */
+    comment?: string;
+    /** Number of horizontal pattern points (typically 360) */
+    horizontal: number;
+    /** Horizontal radiation pattern - 360 attenuation values */
+    pattern: number[];
+    /** Vertical radiation pattern - 360 attenuation values */
+    vertical_pattern: number[];
+    /** Polarization (e.g., "-45") */
+    polarization?: string;
+    /** Cross-polarization indicator */
+    x_pol?: string;
+    /** Co-polar indicator */
+    co?: string;
+    /** Tilt extracted from filename */
+    tilt_from_filename?: string;
+    /** Source file path */
+    sourcePath?: string;
+}
+/**
+ * Raw antenna data from MSI parsing (before purge)
+ * frequency = actual MHz value from file
+ */
+export interface RawAntenna {
+    id?: number;
+    name: string;
+    /** Actual frequency in MHz from MSI file */
+    frequency: number;
+    gain_dBd: number;
+    tilt: string;
+    comment?: string;
+    horizontal: number;
+    pattern: number[];
+    vertical_pattern: number[];
+    polarization?: string;
+    x_pol?: string;
+    co?: string;
+    tilt_from_filename?: string;
+    sourcePath?: string;
+}
+/**
+ * Input for external mode - when antenna data is provided by parent component
+ */
+export interface ExternalAntennaInput {
+    /** Antenna model name */
+    name: string;
+    /** Frequency band (700, 800, 900, 1800, 2100, 2600) */
+    frequency: number;
+    /** Electrical tilt in degrees */
+    electricalTilt: number;
+    /** Mechanical tilt in degrees */
+    mechanicalTilt: number;
+    /** Optional display label (e.g., "Cell A1", "Sector 2") */
+    label?: string;
+}
+/** View mode for antenna diagrams */
+export type ViewMode = 'single' | 'compare';
+/** Pattern type for radiation display */
+export type PatternType = 'horizontal' | 'vertical';
+/** Display mode for pattern visualization */
+export type PatternDisplayMode = 'normalized' | 'gain-adjusted';
+/** Chart engine type (polar-bar removed) */
+export type ChartEngineType = 'polar-line' | 'polar-area';
+/** Color theme for antenna controls */
+export type ColorTheme = 'primary' | 'warning' | 'success' | 'info' | 'secondary';
+/**
+ * Antenna selection state - tracks antenna, tilts, and available options
+ */
+export interface AntennaSelection {
+    /** The selected antenna record */
+    antenna: Antenna | null;
+    /** Index into availableTilts array for electrical tilt */
+    electricalTiltIndex: number;
+    /** Mechanical tilt value in degrees */
+    mechanicalTilt: number;
+    /** Available electrical tilt values for this antenna model */
+    availableTilts: string[];
+    /** Available frequencies (bands) for this antenna model */
+    availableFrequencies: number[];
+    /** Custom label for display (e.g., cell name) */
+    label?: string;
+}
+/**
+ * Result of finding an antenna by name
+ */
+export interface AntennaSearchResult {
+    antenna: Antenna | null;
+    matchType: 'exact' | 'case-insensitive' | 'partial' | 'not-found';
+}
+/**
+ * Props for initializing AntennaTools from external sources
+ */
+export interface AntennaToolsInit {
+    /** Antenna 1 specification (external mode) */
+    antenna1?: ExternalAntennaInput;
+    /** Antenna 2 specification (external mode) */
+    antenna2?: ExternalAntennaInput;
+    /** Initial view mode */
+    viewMode?: ViewMode;
+}

package/dist/apps/antenna-tools/types.js

@@ -0,0 +1,16 @@
+/**
+ * Antenna Tools - Type Definitions
+ * Clean, centralized type definitions for the antenna-tools module
+ */
+/**
+ * Standard frequency bands - fixed preset
+ * Only downlink frequencies are considered
+ */
+export const STANDARD_BANDS = [
+    { name: '700', dlMin: 758, dlMax: 768 }, // LTE B28
+    { name: '800', dlMin: 791, dlMax: 801 }, // LTE B20
+    { name: '900', dlMin: 935, dlMax: 960 }, // GSM 900
+    { name: '1800', dlMin: 1805, dlMax: 1880 }, // GSM 1800 / LTE B3
+    { name: '2100', dlMin: 2110, dlMax: 2170 }, // LTE B1
+    { name: '2600', dlMin: 2620, dlMax: 2690 }, // LTE B7
+];

package/dist/apps/antenna-tools/utils/antenna-helpers.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Antenna Tools - Antenna Helpers
+ * Utility functions for working with antenna data, tilts, and searches
+ */
+import type { Antenna, AntennaSearchResult, ExternalAntennaInput } from '../types';
+/**
+ * Find an antenna by name with fallback matching strategies
+ * @param antennas - Array of all antennas
+ * @param name - Name pattern to search for
+ * @returns Search result with antenna and match type
+ */
+export declare function findAntennaByName(antennas: Antenna[], name: string): AntennaSearchResult;
+/**
+ * Find antenna by external specification (name, frequency, tilt)
+ * Used for external mode when parent provides antenna specs
+ * @param antennas - Array of all antennas
+ * @param spec - External antenna specification
+ * @returns Matching antenna or null
+ */
+export declare function findAntennaBySpec(antennas: Antenna[], spec: Partial<ExternalAntennaInput> & {
+    name: string;
+}): Antenna | null;
+/**
+ * Collect all available electrical tilts for an antenna model
+ * Searches all antennas with the same name and extracts unique tilt values
+ * @param antennas - Array of all antennas
+ * @param antennaName - The antenna model name
+ * @param frequency - Optional frequency (band) to filter by
+ * @returns Sorted array of tilt values as strings
+ */
+export declare function collectAvailableTilts(antennas: Antenna[], antennaName: string, frequency?: number | null): string[];
+/**
+ * Collect all available frequencies (bands) for an antenna model
+ * @param antennas - Array of all antennas
+ * @param antennaName - The antenna model name
+ * @returns Sorted array of unique frequency bands (700, 800, 900, etc.)
+ */
+export declare function collectAvailableFrequencies(antennas: Antenna[], antennaName: string): number[];
+/**
+ * Find the index of a tilt value in the available tilts array
+ * @param availableTilts - Array of available tilt values
+ * @param tiltValue - The tilt value to find (as number)
+ * @returns Index in the array, or 0 if not found
+ */
+export declare function findTiltIndex(availableTilts: string[], tiltValue: number): number;
+/**
+ * Get the tilt value at a given index
+ * @param availableTilts - Array of available tilt values
+ * @param index - Index to retrieve
+ * @returns Tilt value as number
+ */
+export declare function getTiltValue(availableTilts: string[], index: number): number;
+/**
+ * Find an antenna with specific name, frequency (band), and tilt
+ * @param antennas - Array of all antennas
+ * @param name - Antenna model name
+ * @param frequency - Target frequency band (700, 800, etc.) - optional
+ * @param tiltValue - Target tilt value as string
+ * @returns Matching antenna or null
+ */
+export declare function findAntennaWithTilt(antennas: Antenna[], name: string, frequency: number | null, tiltValue: string): Antenna | null;
+/**
+ * Find antenna by exact match on name, frequency band, and electrical tilt
+ * Used for external mode lookup
+ * @param antennas - Array of all antennas
+ * @param name - Antenna model name
+ * @param frequency - Frequency band (700, 800, etc.)
+ * @param electricalTilt - Electrical tilt value
+ * @returns Matching antenna or null
+ */
+export declare function findAntennaExact(antennas: Antenna[], name: string, frequency: number, electricalTilt: number): Antenna | null;
+/**
+ * Get unique antenna models (by name)
+ * @param antennas - Array of all antennas
+ * @returns Array of unique antenna names
+ */
+export declare function getUniqueAntennaModels(antennas: Antenna[]): string[];
+/**
+ * Get a sample antenna for each unique model (for dropdown display)
+ * @param antennas - Array of all antennas
+ * @returns Array of unique antennas (one per model name)
+ */
+export declare function getUniqueAntennas(antennas: Antenna[]): Antenna[];

package/dist/apps/antenna-tools/utils/antenna-helpers.js

@@ -0,0 +1,198 @@
+/**
+ * Antenna Tools - Antenna Helpers
+ * Utility functions for working with antenna data, tilts, and searches
+ */
+/**
+ * Find an antenna by name with fallback matching strategies
+ * @param antennas - Array of all antennas
+ * @param name - Name pattern to search for
+ * @returns Search result with antenna and match type
+ */
+export function findAntennaByName(antennas, name) {
+    if (!name || antennas.length === 0) {
+        return { antenna: null, matchType: 'not-found' };
+    }
+    // Strategy 1: Exact match
+    let found = antennas.find(a => a.name === name);
+    if (found) {
+        return { antenna: found, matchType: 'exact' };
+    }
+    // Strategy 2: Case-insensitive match
+    const lowerName = name.toLowerCase();
+    found = antennas.find(a => a.name.toLowerCase() === lowerName);
+    if (found) {
+        return { antenna: found, matchType: 'case-insensitive' };
+    }
+    // Strategy 3: Partial match (name contains search term)
+    found = antennas.find(a => a.name.toLowerCase().includes(lowerName));
+    if (found) {
+        return { antenna: found, matchType: 'partial' };
+    }
+    return { antenna: null, matchType: 'not-found' };
+}
+/**
+ * Find antenna by external specification (name, frequency, tilt)
+ * Used for external mode when parent provides antenna specs
+ * @param antennas - Array of all antennas
+ * @param spec - External antenna specification
+ * @returns Matching antenna or null
+ */
+export function findAntennaBySpec(antennas, spec) {
+    if (!spec.name || antennas.length === 0) {
+        return null;
+    }
+    // Strategy 1: Exact match with all criteria
+    if (spec.frequency !== undefined && spec.electricalTilt !== undefined) {
+        const exact = antennas.find(a => a.name === spec.name &&
+            a.frequency === spec.frequency &&
+            a.tilt === String(spec.electricalTilt));
+        if (exact)
+            return exact;
+    }
+    // Strategy 2: Match name and frequency (any tilt)
+    if (spec.frequency !== undefined) {
+        const byFreq = antennas.find(a => a.name === spec.name &&
+            a.frequency === spec.frequency);
+        if (byFreq)
+            return byFreq;
+    }
+    // Strategy 3: Match by name only with fallback strategies
+    const { antenna } = findAntennaByName(antennas, spec.name);
+    return antenna;
+}
+/**
+ * Collect all available electrical tilts for an antenna model
+ * Searches all antennas with the same name and extracts unique tilt values
+ * @param antennas - Array of all antennas
+ * @param antennaName - The antenna model name
+ * @param frequency - Optional frequency (band) to filter by
+ * @returns Sorted array of tilt values as strings
+ */
+export function collectAvailableTilts(antennas, antennaName, frequency) {
+    if (!antennaName)
+        return ['0'];
+    // Find all antennas with the same name
+    let sameModel = antennas.filter(a => a.name === antennaName);
+    // Optionally filter by frequency (band)
+    if (frequency) {
+        sameModel = sameModel.filter(a => a.frequency === frequency);
+    }
+    // Collect all unique tilts
+    const allTilts = new Set();
+    for (const antenna of sameModel) {
+        if (antenna.tilt) {
+            const tiltStr = antenna.tilt.toString();
+            if (tiltStr.includes(',')) {
+                tiltStr.split(',').forEach(t => allTilts.add(t.trim()));
+            }
+            else {
+                allTilts.add(tiltStr.trim());
+            }
+        }
+    }
+    // Return sorted array (numerically)
+    const sorted = Array.from(allTilts).sort((a, b) => parseFloat(a) - parseFloat(b));
+    return sorted.length > 0 ? sorted : ['0'];
+}
+/**
+ * Collect all available frequencies (bands) for an antenna model
+ * @param antennas - Array of all antennas
+ * @param antennaName - The antenna model name
+ * @returns Sorted array of unique frequency bands (700, 800, 900, etc.)
+ */
+export function collectAvailableFrequencies(antennas, antennaName) {
+    if (!antennaName)
+        return [];
+    const sameModel = antennas.filter(a => a.name === antennaName);
+    const frequencies = new Set();
+    for (const antenna of sameModel) {
+        if (antenna.frequency) {
+            frequencies.add(antenna.frequency);
+        }
+    }
+    return Array.from(frequencies).sort((a, b) => a - b);
+}
+/**
+ * Find the index of a tilt value in the available tilts array
+ * @param availableTilts - Array of available tilt values
+ * @param tiltValue - The tilt value to find (as number)
+ * @returns Index in the array, or 0 if not found
+ */
+export function findTiltIndex(availableTilts, tiltValue) {
+    const index = availableTilts.findIndex(t => parseInt(t, 10) === tiltValue);
+    return index >= 0 ? index : 0;
+}
+/**
+ * Get the tilt value at a given index
+ * @param availableTilts - Array of available tilt values
+ * @param index - Index to retrieve
+ * @returns Tilt value as number
+ */
+export function getTiltValue(availableTilts, index) {
+    const tilt = availableTilts[index];
+    return tilt ? parseInt(tilt, 10) : 0;
+}
+/**
+ * Find an antenna with specific name, frequency (band), and tilt
+ * @param antennas - Array of all antennas
+ * @param name - Antenna model name
+ * @param frequency - Target frequency band (700, 800, etc.) - optional
+ * @param tiltValue - Target tilt value as string
+ * @returns Matching antenna or null
+ */
+export function findAntennaWithTilt(antennas, name, frequency, tiltValue) {
+    return antennas.find(antenna => {
+        if (antenna.name !== name)
+            return false;
+        if (frequency && antenna.frequency !== frequency)
+            return false;
+        if (antenna.tilt) {
+            const tiltStr = antenna.tilt.toString();
+            const antennaTilts = tiltStr.includes(',')
+                ? tiltStr.split(',').map(t => t.trim())
+                : [tiltStr.trim()];
+            return antennaTilts.includes(tiltValue);
+        }
+        return tiltValue === '0';
+    }) || null;
+}
+/**
+ * Find antenna by exact match on name, frequency band, and electrical tilt
+ * Used for external mode lookup
+ * @param antennas - Array of all antennas
+ * @param name - Antenna model name
+ * @param frequency - Frequency band (700, 800, etc.)
+ * @param electricalTilt - Electrical tilt value
+ * @returns Matching antenna or null
+ */
+export function findAntennaExact(antennas, name, frequency, electricalTilt) {
+    return antennas.find(a => a.name === name &&
+        a.frequency === frequency &&
+        a.tilt === String(electricalTilt)) || null;
+}
+/**
+ * Get unique antenna models (by name)
+ * @param antennas - Array of all antennas
+ * @returns Array of unique antenna names
+ */
+export function getUniqueAntennaModels(antennas) {
+    const names = new Set();
+    for (const antenna of antennas) {
+        names.add(antenna.name);
+    }
+    return Array.from(names).sort();
+}
+/**
+ * Get a sample antenna for each unique model (for dropdown display)
+ * @param antennas - Array of all antennas
+ * @returns Array of unique antennas (one per model name)
+ */
+export function getUniqueAntennas(antennas) {
+    const seen = new Map();
+    for (const antenna of antennas) {
+        if (!seen.has(antenna.name)) {
+            seen.set(antenna.name, antenna);
+        }
+    }
+    return Array.from(seen.values()).sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/apps/antenna-tools/utils/chart-engines/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Antenna Tools - Chart Engine Utils Index
+ */
+export * from './polar-line-utils';
+export * from './polar-area-utils';

package/dist/apps/antenna-tools/utils/chart-engines/index.js

@@ -0,0 +1,5 @@
+/**
+ * Antenna Tools - Chart Engine Utils Index
+ */
+export * from './polar-line-utils';
+export * from './polar-area-utils';