@smartnet360/svelte-components 0.0.13 → 0.0.15

package/dist/apps/antenna-pattern/utils/chart-engines/polar-line-utils.d.ts

@@ -0,0 +1,88 @@
+import type { Antenna } from '../../db';
+export interface PolarLineTraceData {
+    r: number[];
+    theta: number[];
+    type: 'scatterpolar';
+    mode: 'lines';
+    name: string;
+    line: {
+        color: string;
+        width: number;
+        dash: string;
+    };
+}
+/**
+ * Convert antenna pattern to Plotly polar line trace data
+ */
+export declare function convertAntennaPatternToLine(pattern: number[], name: string, color: string, width?: number, mechanicalTilt?: number, gainOffset?: number): PolarLineTraceData;
+/**
+ * Get fixed line color (no dynamic changes)
+ */
+export declare function getLineColor(electricalTilt: number, mechanicalTilt: number, baseColor: string): string;
+/**
+ * Get fixed line width (no dynamic changes)
+ */
+export declare function getLineWidth(electricalTilt: number, mechanicalTilt: number): number;
+/**
+ * Create polar line chart data for antenna patterns
+ */
+export declare function createPolarLineChartData(selectedAntenna: Antenna | null, selectedAntenna2: Antenna | null, viewMode: 'single' | 'compare', showHorizontalPatterns: boolean, showVerticalPatterns: boolean, ant1ElectricalTilt: number, ant1MechanicalTilt: number, ant2ElectricalTilt: number, ant2MechanicalTilt: number, patternDisplayMode?: 'normalized' | 'gain-adjusted'): PolarLineTraceData[];
+/**
+ * Create Plotly layout for polar line charts
+ */
+export declare function createPolarLineLayout(title: string): {
+    title: {
+        text: string;
+        font: {
+            size: number;
+            color: string;
+        };
+        x: number;
+        xanchor: string;
+    };
+    polar: {
+        radialaxis: {
+            visible: boolean;
+            range: number[];
+            tickfont: {
+                size: number;
+                color: string;
+            };
+            gridcolor: string;
+            linecolor: string;
+            tickmode: string;
+            tick0: number;
+            dtick: number;
+            ticksuffix: string;
+        };
+        angularaxis: {
+            visible: boolean;
+            tickfont: {
+                size: number;
+                color: string;
+            };
+            gridcolor: string;
+            linecolor: string;
+            direction: string;
+            period: number;
+            rotation: number;
+            ticksuffix: string;
+        };
+        bgcolor: string;
+    };
+    margin: {
+        t: number;
+        r: number;
+        b: number;
+        l: number;
+    };
+    height: number;
+    paper_bgcolor: string;
+    plot_bgcolor: string;
+    legend: {
+        orientation: string;
+        x: number;
+        y: number;
+        xanchor: string;
+    };
+};

package/dist/apps/antenna-pattern/utils/chart-engines/polar-line-utils.js

@@ -0,0 +1,134 @@
+/**
+ * Convert antenna pattern to Plotly polar line trace data
+ */
+export function convertAntennaPatternToLine(pattern, name, color, width = 2, mechanicalTilt = 0, gainOffset = 0) {
+    // Convert attenuation to dB (negate values) and apply gain offset
+    let processedPattern = pattern.map(value => -value + gainOffset);
+    // Apply mechanical tilt by shifting the pattern
+    if (mechanicalTilt !== 0) {
+        const shiftedPattern = new Array(360).fill(0);
+        for (let i = 0; i < 360; i++) {
+            const sourceIndex = (i - mechanicalTilt + 360) % 360;
+            shiftedPattern[i] = processedPattern[sourceIndex] || 0;
+        }
+        processedPattern = shiftedPattern;
+    }
+    // Generate theta values (0-359 degrees) with proper rotation to point to 0 degrees
+    const theta = Array.from({ length: pattern.length }, (_, i) => {
+        if (name.includes('Vertical')) {
+            return (i + 0) % 360; // Vertical patterns point to 0° (North/up)
+        }
+        return (i + 270) % 360; // Rotate horizontal patterns 270° (or -90°) to point North
+    });
+    return {
+        r: processedPattern,
+        theta,
+        type: 'scatterpolar',
+        mode: 'lines',
+        name,
+        line: {
+            color,
+            width,
+            dash: 'solid' // Always solid lines
+        }
+    };
+}
+/**
+ * Get fixed line color (no dynamic changes)
+ */
+export function getLineColor(electricalTilt, mechanicalTilt, baseColor) {
+    return baseColor; // Always return base color
+}
+/**
+ * Get fixed line width (no dynamic changes)
+ */
+export function getLineWidth(electricalTilt, mechanicalTilt) {
+    return 2; // Always return fixed width
+}
+/**
+ * Create polar line chart data for antenna patterns
+ */
+export function createPolarLineChartData(selectedAntenna, selectedAntenna2, viewMode, showHorizontalPatterns, showVerticalPatterns, ant1ElectricalTilt, ant1MechanicalTilt, ant2ElectricalTilt, ant2MechanicalTilt, patternDisplayMode = 'normalized') {
+    const data = [];
+    // Calculate gain offsets for gain-adjusted display mode
+    let ant1GainOffset = 0;
+    let ant2GainOffset = 0;
+    if (patternDisplayMode === 'gain-adjusted' && viewMode === 'compare') {
+        const ant1Gain = selectedAntenna?.gain_dBd || 0;
+        const ant2Gain = selectedAntenna2?.gain_dBd || 0;
+        const maxGain = Math.max(ant1Gain, ant2Gain);
+        // Offset both antennas relative to the highest gain antenna
+        ant1GainOffset = ant1Gain - maxGain;
+        ant2GainOffset = ant2Gain - maxGain;
+    }
+    // Create antenna 1 pattern data based on visibility settings
+    if (selectedAntenna) {
+        if (showHorizontalPatterns) {
+            const horizontalData1 = convertAntennaPatternToLine(selectedAntenna.pattern || [], 'Antenna 1 - Horizontal', getLineColor(ant1ElectricalTilt, ant1MechanicalTilt, '#0066cc'), getLineWidth(ant1ElectricalTilt, ant1MechanicalTilt), ant1MechanicalTilt, ant1GainOffset);
+            data.push(horizontalData1);
+        }
+        if (showVerticalPatterns) {
+            const verticalData1 = convertAntennaPatternToLine(selectedAntenna.vertical_pattern || [], 'Antenna 1 - Vertical', getLineColor(ant1ElectricalTilt, ant1MechanicalTilt, '#003d7a'), getLineWidth(ant1ElectricalTilt, ant1MechanicalTilt), ant1MechanicalTilt, ant1GainOffset);
+            data.push(verticalData1);
+        }
+    }
+    // Add second antenna if in compare mode and antenna 2 is selected
+    if (viewMode === 'compare' && selectedAntenna2) {
+        if (showHorizontalPatterns) {
+            const horizontalData2 = convertAntennaPatternToLine(selectedAntenna2.pattern || [], 'Antenna 2 - Horizontal', getLineColor(ant2ElectricalTilt, ant2MechanicalTilt, '#ffd700'), getLineWidth(ant2ElectricalTilt, ant2MechanicalTilt), ant2MechanicalTilt, ant2GainOffset);
+            data.push(horizontalData2);
+        }
+        if (showVerticalPatterns) {
+            const verticalData2 = convertAntennaPatternToLine(selectedAntenna2.vertical_pattern || [], 'Antenna 2 - Vertical', getLineColor(ant2ElectricalTilt, ant2MechanicalTilt, '#e6c200'), getLineWidth(ant2ElectricalTilt, ant2MechanicalTilt), ant2MechanicalTilt, ant2GainOffset);
+            data.push(verticalData2);
+        }
+    }
+    return data;
+}
+/**
+ * Create Plotly layout for polar line charts
+ */
+export function createPolarLineLayout(title) {
+    return {
+        title: {
+            text: title,
+            font: { size: 16, color: '#212529' },
+            x: 0.5,
+            xanchor: 'center'
+        },
+        polar: {
+            radialaxis: {
+                visible: true,
+                range: [-70, 0],
+                tickfont: { size: 10, color: '#6c757d' },
+                gridcolor: 'rgba(108, 117, 125, 0.3)',
+                linecolor: 'rgba(108, 117, 125, 0.5)',
+                tickmode: 'linear',
+                tick0: -70,
+                dtick: 10,
+                ticksuffix: ' dB'
+            },
+            angularaxis: {
+                visible: true,
+                tickfont: { size: 11, color: '#495057' },
+                gridcolor: 'rgba(108, 117, 125, 0.2)',
+                linecolor: 'rgba(108, 117, 125, 0.4)',
+                direction: 'clockwise',
+                period: 360,
+                rotation: 0,
+                ticksuffix: '°'
+            },
+            bgcolor: 'rgba(248, 249, 250, 0.5)'
+        },
+        margin: { t: 60, r: 40, b: 60, l: 40 },
+        height: 600,
+        paper_bgcolor: 'rgba(255, 255, 255, 0.95)',
+        plot_bgcolor: 'rgba(248, 249, 250, 0.3)',
+        legend: {
+            orientation: 'h',
+            x: 0.5,
+            y: -0.1,
+            xanchor: 'center'
+        }
+    };
+}

package/dist/apps/antenna-pattern/utils/recent-antennas.d.ts

@@ -0,0 +1,20 @@
+import type { Antenna } from '../db';
+/**
+ * Get recently selected antennas from localStorage
+ */
+export declare function getRecentAntennas(): Antenna[];
+/**
+ * Add an antenna to the recent list
+ */
+export declare function addToRecentAntennas(antenna: Antenna): void;
+/**
+ * Clear recent antennas list
+ */
+export declare function clearRecentAntennas(): void;
+/**
+ * Sort antennas to show recent ones first, then alphabetical
+ */
+export declare function sortAntennasWithRecent(antennas: Antenna[]): {
+    recent: Antenna[];
+    others: Antenna[];
+};

package/dist/apps/antenna-pattern/utils/recent-antennas.js

@@ -0,0 +1,60 @@
+const RECENT_ANTENNAS_KEY = 'recentAntennas';
+const MAX_RECENT_ANTENNAS = 10;
+/**
+ * Get recently selected antennas from localStorage
+ */
+export function getRecentAntennas() {
+    try {
+        const stored = localStorage.getItem(RECENT_ANTENNAS_KEY);
+        if (!stored)
+            return [];
+        const recent = JSON.parse(stored);
+        return Array.isArray(recent) ? recent : [];
+    }
+    catch (error) {
+        console.warn('Failed to load recent antennas:', error);
+        return [];
+    }
+}
+/**
+ * Add an antenna to the recent list
+ */
+export function addToRecentAntennas(antenna) {
+    try {
+        let recent = getRecentAntennas();
+        // Remove if already exists (to move to top)
+        recent = recent.filter(a => a.id !== antenna.id);
+        // Add to beginning
+        recent.unshift(antenna);
+        // Keep only the max number
+        recent = recent.slice(0, MAX_RECENT_ANTENNAS);
+        // Save to localStorage
+        localStorage.setItem(RECENT_ANTENNAS_KEY, JSON.stringify(recent));
+    }
+    catch (error) {
+        console.warn('Failed to save recent antenna:', error);
+    }
+}
+/**
+ * Clear recent antennas list
+ */
+export function clearRecentAntennas() {
+    try {
+        localStorage.removeItem(RECENT_ANTENNAS_KEY);
+    }
+    catch (error) {
+        console.warn('Failed to clear recent antennas:', error);
+    }
+}
+/**
+ * Sort antennas to show recent ones first, then alphabetical
+ */
+export function sortAntennasWithRecent(antennas) {
+    const recentAntennas = getRecentAntennas();
+    const recentIds = new Set(recentAntennas.map(a => a.id));
+    // Filter antennas that exist in current list and are recent
+    const recent = recentAntennas.filter(recentAntenna => antennas.some(antenna => antenna.id === recentAntenna.id));
+    // Get other antennas (not in recent list)
+    const others = antennas.filter(antenna => !recentIds.has(antenna.id));
+    return { recent, others };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smartnet360/svelte-components",
-	"version": "0.0.13",
+	"version": "0.0.15",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -60,11 +60,11 @@
 		"svelte"
 	],
 	"dependencies": {
-		"bootstrap": "^5.2.3",
-		"plotly.js-dist-min": "^3.1.0",
 		"@sveltejs/adapter-static": "^3.0.9",
+		"bootstrap": "^5.2.3",
 		"bootstrap-icons": "^1.13.1",
 		"chart.js": "^4.4.9",
-		"dexie": "^4.0.11"
+		"dexie": "^4.0.11",
+		"plotly.js-dist-min": "^3.1.0"
 	}
 }