@smartnet360/svelte-components 0.0.70 → 0.0.72

package/dist/map-v2/features/repeaters/stores/repeaterStoreContext.svelte.js

@@ -0,0 +1,222 @@
+/**
+ * Repeater Store Context - Reactive state for repeater feature
+ *
+ * Simplified store with fixed Tech → FBand tree structure
+ * Supports leaf-level coloring for each tech:fband combination
+ */
+const STORAGE_KEY = 'repeaterVisualSettings';
+function loadSettings() {
+    if (typeof window === 'undefined')
+        return {};
+    try {
+        const saved = localStorage.getItem(STORAGE_KEY);
+        if (saved) {
+            return JSON.parse(saved);
+        }
+    }
+    catch (error) {
+        console.warn('Failed to load repeater settings from localStorage:', error);
+    }
+    return {};
+}
+function saveSettings(settings) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
+    }
+    catch (error) {
+        console.warn('Failed to save repeater settings to localStorage:', error);
+    }
+}
+/**
+ * Default colors for tech:fband combinations
+ */
+const DEFAULT_TECH_BAND_COLORS = {
+    // 2G
+    '2G:900': '#FF6B6B',
+    '2G:1800': '#FF8E53',
+    // 4G
+    '4G:700': '#4ECDC4',
+    '4G:800': '#45B7D1',
+    '4G:900': '#96CEB4',
+    '4G:1800': '#FFEAA7',
+    '4G:2100': '#DFE6E9',
+    '4G:2600': '#74B9FF',
+    // 5G
+    '5G:2600': '#A29BFE',
+    '5G:3500': '#6C5CE7',
+    '5G:26000': '#FD79A8'
+};
+/**
+ * Create a repeater store context with reactive state
+ */
+export function createRepeaterStoreContext(repeaters) {
+    // Load persisted settings
+    const persistedSettings = loadSettings();
+    // Convert persisted arrays/objects back to Sets/Maps
+    const initialVisibleSet = new Set(persistedSettings.visibleTechBands || []);
+    const initialColorMap = new Map();
+    if (persistedSettings.techBandColors) {
+        Object.entries(persistedSettings.techBandColors).forEach(([key, value]) => {
+            initialColorMap.set(key, value);
+        });
+    }
+    // If no colors persisted, use defaults
+    if (initialColorMap.size === 0) {
+        Object.entries(DEFAULT_TECH_BAND_COLORS).forEach(([key, value]) => {
+            initialColorMap.set(key, value);
+        });
+    }
+    // Internal reactive state
+    let state = $state({
+        repeaters,
+        visibleTechBands: initialVisibleSet,
+        techBandColorMap: initialColorMap,
+        showRepeaters: persistedSettings.showRepeaters ?? true,
+        baseRadius: persistedSettings.baseRadius ?? 500,
+        fillOpacity: persistedSettings.fillOpacity ?? 0.4,
+        lineWidth: persistedSettings.lineWidth ?? 2,
+        currentZoom: 12, // Default zoom
+        // Label settings with defaults
+        showLabels: persistedSettings.showLabels ?? true, // Default to true
+        primaryLabelField: (persistedSettings.primaryLabelField ?? 'repeaterId'),
+        secondaryLabelField: (persistedSettings.secondaryLabelField ?? 'fband'),
+        labelSize: persistedSettings.labelSize ?? 12,
+        labelColor: persistedSettings.labelColor ?? '#ffffff', // White text
+        labelOffset: persistedSettings.labelOffset ?? 300,
+        labelHaloColor: persistedSettings.labelHaloColor ?? '#000000', // Black halo
+        labelHaloWidth: persistedSettings.labelHaloWidth ?? 2,
+        minLabelZoom: persistedSettings.minLabelZoom ?? 10 // Lower default to show labels at more zoom levels
+    });
+    // Derived: Filter repeaters by visible tech:fband combinations
+    let filteredRepeaters = $derived(state.repeaters.filter(r => {
+        const key = `${r.tech}:${r.fband}`;
+        return state.visibleTechBands.has(key);
+    }));
+    // Auto-save settings when they change
+    $effect(() => {
+        // Convert Set to Array and Map to Object for serialization
+        const visibleArray = Array.from(state.visibleTechBands);
+        const colorsObj = {};
+        state.techBandColorMap.forEach((color, key) => {
+            colorsObj[key] = color;
+        });
+        const settings = {
+            visibleTechBands: visibleArray,
+            techBandColors: colorsObj,
+            showRepeaters: state.showRepeaters,
+            baseRadius: state.baseRadius,
+            fillOpacity: state.fillOpacity,
+            lineWidth: state.lineWidth,
+            // Label settings
+            showLabels: state.showLabels,
+            primaryLabelField: state.primaryLabelField,
+            secondaryLabelField: state.secondaryLabelField,
+            labelSize: state.labelSize,
+            labelColor: state.labelColor,
+            labelOffset: state.labelOffset,
+            labelHaloColor: state.labelHaloColor,
+            labelHaloWidth: state.labelHaloWidth,
+            minLabelZoom: state.minLabelZoom
+        };
+        saveSettings(settings);
+    });
+    // Return store context
+    return {
+        // Data getters
+        get repeaters() { return state.repeaters; },
+        get filteredRepeaters() { return filteredRepeaters; },
+        get visibleTechBands() { return state.visibleTechBands; },
+        get techBandColorMap() { return state.techBandColorMap; },
+        // Visual getters
+        get showRepeaters() { return state.showRepeaters; },
+        get baseRadius() { return state.baseRadius; },
+        get fillOpacity() { return state.fillOpacity; },
+        get lineWidth() { return state.lineWidth; },
+        get currentZoom() { return state.currentZoom; },
+        // Label getters
+        get showLabels() { return state.showLabels; },
+        get primaryLabelField() { return state.primaryLabelField; },
+        get secondaryLabelField() { return state.secondaryLabelField; },
+        get labelSize() { return state.labelSize; },
+        get labelColor() { return state.labelColor; },
+        get labelOffset() { return state.labelOffset; },
+        get labelHaloColor() { return state.labelHaloColor; },
+        get labelHaloWidth() { return state.labelHaloWidth; },
+        get minLabelZoom() { return state.minLabelZoom; },
+        // Data methods
+        setRepeaters(repeaters) {
+            state.repeaters = repeaters;
+        },
+        toggleTechBand(tech, fband) {
+            const key = `${tech}:${fband}`;
+            if (state.visibleTechBands.has(key)) {
+                state.visibleTechBands.delete(key);
+            }
+            else {
+                state.visibleTechBands.add(key);
+            }
+            // Trigger reactivity by creating new Set
+            state.visibleTechBands = new Set(state.visibleTechBands);
+        },
+        isTechBandVisible(tech, fband) {
+            const key = `${tech}:${fband}`;
+            return state.visibleTechBands.has(key);
+        },
+        getTechBandColor(tech, fband) {
+            const key = `${tech}:${fband}`;
+            return state.techBandColorMap.get(key) || '#888888'; // Fallback gray
+        },
+        setTechBandColor(tech, fband, color) {
+            const key = `${tech}:${fband}`;
+            state.techBandColorMap.set(key, color);
+            // Trigger reactivity by creating new Map
+            state.techBandColorMap = new Map(state.techBandColorMap);
+        },
+        // Visual setters
+        setShowRepeaters(value) {
+            state.showRepeaters = value;
+        },
+        setBaseRadius(value) {
+            state.baseRadius = value;
+        },
+        setFillOpacity(value) {
+            state.fillOpacity = value;
+        },
+        setLineWidth(value) {
+            state.lineWidth = value;
+        },
+        setCurrentZoom(value) {
+            state.currentZoom = value;
+        },
+        // Label setters
+        setShowLabels(value) {
+            state.showLabels = value;
+        },
+        setPrimaryLabelField(field) {
+            state.primaryLabelField = field;
+        },
+        setSecondaryLabelField(field) {
+            state.secondaryLabelField = field;
+        },
+        setLabelSize(value) {
+            state.labelSize = value;
+        },
+        setLabelColor(value) {
+            state.labelColor = value;
+        },
+        setLabelOffset(value) {
+            state.labelOffset = value;
+        },
+        setLabelHaloColor(value) {
+            state.labelHaloColor = value;
+        },
+        setLabelHaloWidth(value) {
+            state.labelHaloWidth = value;
+        },
+        setMinLabelZoom(value) {
+            state.minLabelZoom = value;
+        }
+    };
+}

package/dist/map-v2/features/repeaters/types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Repeater type definitions
+ */
+/**
+ * Repeater - Represents a cellular network repeater
+ *
+ * Repeaters amplify signals from donor cells to extend coverage.
+ * They are visualized as arc sectors with a fixed 30° beamwidth.
+ */
+export interface Repeater {
+    /** Unique repeater identifier */
+    repeaterId: string;
+    /** ID of the donor cell providing the signal */
+    donorCellId: string;
+    /** Human-readable name of the donor cell */
+    donorCellName: string;
+    /** Frequency band (e.g., "1800", "2600") */
+    fband: string;
+    /** Technology (e.g., "2G", "4G", "5G") */
+    tech: string;
+    /** Type discriminator */
+    type: 'REPEATER';
+    /** Direction the repeater faces (0-360°) */
+    azimuth: number;
+    /** Physical height (meters) */
+    height: number;
+    /** Geographic coordinates */
+    longitude: number;
+    latitude: number;
+    /** Coverage angle (degrees) - typically 30° for repeaters */
+    beamwidth: number;
+    /** Factory/hardware number */
+    factory_nbr: string;
+    /** Optional: Network operator */
+    provider?: string;
+    /** Optional: Custom grouping */
+    featureGroup?: string;
+    /** Optional: Repeater name */
+    name?: string;
+    /** Optional: Status */
+    status?: 'active' | 'inactive' | 'planned';
+}
+/**
+ * TreeNode - For the fixed Tech → FBand tree structure
+ */
+export interface RepeaterTreeNode {
+    /** Unique node ID (e.g., "4G", "4G:1800") */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Child nodes */
+    children: RepeaterTreeNode[];
+    /** Color for leaf nodes (tech:fband combinations) */
+    color?: string;
+    /** Whether this node is visible/selected */
+    visible?: boolean;
+    /** Repeater count for this node */
+    count?: number;
+}

package/dist/map-v2/features/repeaters/types.js

@@ -0,0 +1,4 @@
+/**
+ * Repeater type definitions
+ */
+export {};

package/dist/map-v2/features/repeaters/utils/repeaterGeoJSON.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Repeater GeoJSON Conversion
+ *
+ * Convert repeater data to GeoJSON FeatureCollection with arc geometries
+ * Fixed 30° beamwidth for all repeaters
+ * Uses inverse zoom scaling like cells (larger arcs when zoomed out)
+ * Includes tech-band specific radius multipliers and z-ordering
+ */
+import type { FeatureCollection, Polygon } from 'geojson';
+import type { Repeater } from '../types';
+/**
+ * Convert repeaters to GeoJSON FeatureCollection with arc geometries
+ *
+ * @param repeaters - Array of repeaters to convert
+ * @param currentZoom - Current map zoom level for radius calculation
+ * @param baseRadius - Base radius in meters (zoom-reactive)
+ * @param techBandColorMap - Map of tech:fband -> color
+ * @returns GeoJSON FeatureCollection with arc polygons
+ */
+export declare function repeatersToGeoJSON(repeaters: Repeater[], currentZoom: number, baseRadius: number | undefined, techBandColorMap: Map<string, string>): FeatureCollection<Polygon>;

package/dist/map-v2/features/repeaters/utils/repeaterGeoJSON.js

@@ -0,0 +1,90 @@
+/**
+ * Repeater GeoJSON Conversion
+ *
+ * Convert repeater data to GeoJSON FeatureCollection with arc geometries
+ * Fixed 30° beamwidth for all repeaters
+ * Uses inverse zoom scaling like cells (larger arcs when zoomed out)
+ * Includes tech-band specific radius multipliers and z-ordering
+ */
+import { createArcPolygon } from '../../cells/utils/arcGeometry';
+import { getRepeaterRadiusMultiplier } from '../constants/radiusMultipliers';
+import { getRepeaterZOrder } from '../constants/techBandZOrder';
+/** Fixed beamwidth for all repeaters */
+const REPEATER_BEAMWIDTH = 30;
+/** Reference zoom level where base radius is used as-is */
+const REFERENCE_ZOOM = 12;
+/**
+ * Get zoom factor for visual size scaling (inverse scaling)
+ * Lower zoom = larger radius (to compensate for zoomed out view)
+ * Higher zoom = smaller radius (to compensate for zoomed in view)
+ *
+ * Formula: 2^((referenceZoom - currentZoom) / 2)
+ * - At zoom 12: factor = 1.0
+ * - At zoom 10: factor = 2.0 (double the radius)
+ * - At zoom 14: factor = 0.5 (half the radius)
+ */
+function getZoomFactor(currentZoom) {
+    return Math.pow(2, (REFERENCE_ZOOM - currentZoom) / 2);
+}
+/**
+ * Convert repeaters to GeoJSON FeatureCollection with arc geometries
+ *
+ * @param repeaters - Array of repeaters to convert
+ * @param currentZoom - Current map zoom level for radius calculation
+ * @param baseRadius - Base radius in meters (zoom-reactive)
+ * @param techBandColorMap - Map of tech:fband -> color
+ * @returns GeoJSON FeatureCollection with arc polygons
+ */
+export function repeatersToGeoJSON(repeaters, currentZoom, baseRadius = 500, techBandColorMap) {
+    const features = repeaters.map((repeater) => {
+        // Get color for this tech:fband combination
+        const key = `${repeater.tech}:${repeater.fband}`;
+        const color = techBandColorMap.get(key) || '#888888'; // Fallback gray
+        // Calculate zoom-reactive radius with inverse scaling (like cells)
+        const zoomFactor = getZoomFactor(currentZoom);
+        // Apply tech-band specific radius multiplier
+        const techBandMultiplier = getRepeaterRadiusMultiplier(repeater.tech, repeater.fband);
+        const radius = baseRadius * zoomFactor * techBandMultiplier;
+        // Get z-order for layering (higher frequency = higher z-order = on top)
+        const zOrder = getRepeaterZOrder(repeater.tech, repeater.fband);
+        // Create arc polygon geometry with fixed 30° beamwidth
+        const center = [repeater.longitude, repeater.latitude];
+        const arc = createArcPolygon(center, repeater.azimuth, REPEATER_BEAMWIDTH, radius);
+        // Build feature with properties
+        return {
+            type: 'Feature',
+            geometry: arc.geometry,
+            properties: {
+                // Repeater identification
+                repeaterId: repeater.repeaterId,
+                factory_nbr: repeater.factory_nbr,
+                name: repeater.name || repeater.repeaterId,
+                // Donor cell info
+                donorCellId: repeater.donorCellId,
+                donorCellName: repeater.donorCellName,
+                // Technical attributes
+                tech: repeater.tech,
+                fband: repeater.fband,
+                azimuth: repeater.azimuth,
+                beamwidth: REPEATER_BEAMWIDTH,
+                height: repeater.height,
+                // Optional attributes
+                provider: repeater.provider || '',
+                featureGroup: repeater.featureGroup || '',
+                status: repeater.status || 'active',
+                // Styling properties for Mapbox
+                techBandKey: key,
+                techBandColor: color,
+                lineColor: color,
+                lineOpacity: 0.8,
+                // Z-order for layering (higher frequency on top)
+                zOrder: zOrder,
+                sortKey: zOrder // Used by Mapbox for layer ordering
+            }
+        };
+    });
+    return {
+        type: 'FeatureCollection',
+        features
+    };
+}

package/dist/map-v2/features/repeaters/utils/repeaterTree.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Repeater Tree Utilities
+ *
+ * Builds a fixed Tech→FBand two-level tree structure for repeater filtering.
+ * Leaf nodes (tech:fband) can have custom colors.
+ */
+import type { Repeater } from '../types';
+import type { TreeNode } from '../../../../core/TreeView/tree.model';
+/**
+ * Build a two-level tree: Tech → FBand
+ *
+ * @param repeaters - All repeaters
+ * @param colorMap - Map of tech:fband to color
+ * @returns Root tree node
+ */
+export declare function buildRepeaterTree(repeaters: Repeater[], colorMap: Map<string, string>): TreeNode;
+/**
+ * Get set of selected tech:fband keys from checked paths
+ *
+ * @param checkedPaths - Set of checked node paths from tree
+ * @returns Set of "tech:fband" keys that are checked
+ */
+export declare function getFilteredRepeaters(checkedPaths: Set<string>): Set<string>;

package/dist/map-v2/features/repeaters/utils/repeaterTree.js

@@ -0,0 +1,111 @@
+/**
+ * Repeater Tree Utilities
+ *
+ * Builds a fixed Tech→FBand two-level tree structure for repeater filtering.
+ * Leaf nodes (tech:fband) can have custom colors.
+ */
+/**
+ * Build a two-level tree: Tech → FBand
+ *
+ * @param repeaters - All repeaters
+ * @param colorMap - Map of tech:fband to color
+ * @returns Root tree node
+ */
+export function buildRepeaterTree(repeaters, colorMap) {
+    // Group repeaters by tech, then by fband
+    const techMap = new Map();
+    for (const repeater of repeaters) {
+        const { tech, fband } = repeater;
+        if (!techMap.has(tech)) {
+            techMap.set(tech, new Map());
+        }
+        const fbandMap = techMap.get(tech);
+        if (!fbandMap.has(fband)) {
+            fbandMap.set(fband, []);
+        }
+        fbandMap.get(fband).push(repeater);
+    }
+    // Build tree structure
+    const techNodes = [];
+    // Sort technologies: 2G, 4G, 5G
+    const sortedTechs = Array.from(techMap.keys()).sort((a, b) => {
+        const order = { '2G': 1, '4G': 2, '5G': 3 };
+        return (order[a] || 99) - (order[b] || 99);
+    });
+    for (const tech of sortedTechs) {
+        const fbandMap = techMap.get(tech);
+        const fbandNodes = [];
+        // Sort fbands alphabetically
+        const sortedFbands = Array.from(fbandMap.keys()).sort();
+        for (const fband of sortedFbands) {
+            const repeatersInFband = fbandMap.get(fband);
+            const techBandKey = `${tech}:${fband}`;
+            const color = colorMap.get(techBandKey) || '#808080';
+            fbandNodes.push({
+                id: techBandKey,
+                label: `${fband} (${repeatersInFband.length})`,
+                defaultChecked: true,
+                defaultExpanded: false,
+                children: [],
+                metadata: { color } // Leaf nodes have colors in metadata
+            });
+        }
+        techNodes.push({
+            id: tech,
+            label: `${tech} (${Array.from(fbandMap.values()).flat().length})`,
+            defaultChecked: true,
+            defaultExpanded: true,
+            children: fbandNodes
+        });
+    }
+    // Root node
+    return {
+        id: 'root',
+        label: `All Repeaters (${repeaters.length})`,
+        defaultChecked: true,
+        defaultExpanded: true,
+        children: techNodes
+    };
+}
+/**
+ * Get set of selected tech:fband keys from checked paths
+ *
+ * @param checkedPaths - Set of checked node paths from tree
+ * @returns Set of "tech:fband" keys that are checked
+ */
+export function getFilteredRepeaters(checkedPaths) {
+    const selected = new Set();
+    console.log('getFilteredRepeaters - checkedPaths:', Array.from(checkedPaths));
+    // If only root is checked, all tech:fbands are visible
+    if (checkedPaths.has('root') && checkedPaths.size === 1) {
+        console.log('Only root checked - returning empty set for "all visible"');
+        return selected;
+    }
+    // Check each path - leaf nodes have tech:fband in their ID
+    for (const path of checkedPaths) {
+        // Paths are like "root:2G:2G:GSM900" where the node ID is the last segment
+        // The node ID for leaf nodes is "tech:fband" format
+        const parts = path.split(':');
+        console.log('Processing path:', path, 'parts:', parts);
+        // Check if this is a leaf node (contains tech:fband format)
+        // Leaf node IDs are like "2G:GSM900", "4G:LTE1800"
+        // The path would be "root:2G:2G:GSM900" (root -> tech -> tech:fband)
+        if (parts.length === 4 && parts[0] === 'root') {
+            // This is a leaf node: root:tech:tech:fband
+            const techBandKey = `${parts[2]}:${parts[3]}`;
+            console.log('Adding tech:fband key:', techBandKey);
+            selected.add(techBandKey);
+        }
+        else if (parts.length === 3 && parts[0] === 'root') {
+            // This might be "root:2G:GSM900" if node ID is "2G:GSM900"
+            const nodeId = parts[2];
+            if (nodeId && nodeId.includes(':')) {
+                // This is already in tech:fband format
+                console.log('Adding tech:fband key (alternative format):', nodeId);
+                selected.add(nodeId);
+            }
+        }
+    }
+    console.log('getFilteredRepeaters - selected tech:bands:', Array.from(selected));
+    return selected;
+}

package/dist/map-v2/shared/controls/FeatureSettingsControl.svelte

@@ -12,6 +12,7 @@
 	import RepeaterSettingsPanel from './panels/RepeaterSettingsPanel.svelte';
 	import type { SiteStoreContext } from '../../features/sites/stores/siteStoreContext.svelte';
 	import type { CellStoreContext } from '../../features/cells/stores/cellStoreContext.svelte';
+	import type { RepeaterStoreContext } from '../../features/repeaters/stores/repeaterStoreContext.svelte';
 	import type { Cell, CellGroupingLabels } from '../../features/cells/types';
 
 	interface Props {
@@ -19,6 +20,8 @@
 		siteStore: SiteStoreContext;
 		/** Cell store context */
 		cellStore: CellStoreContext;
+		/** Repeater store context (optional) */
+		repeaterStore?: RepeaterStoreContext;
 		/** Available label field options for 4G/5G cells */
 		labelFieldOptions4G5G: Array<keyof Cell>;
 		/** Available label field options for 2G cells */
@@ -40,6 +43,7 @@
 	let {
 		siteStore,
 		cellStore,
+		repeaterStore,
 		labelFieldOptions4G5G,
 		labelFieldOptions2G,
 		fieldLabels,
@@ -111,30 +115,32 @@
 			</div>
 		</div>
 
-		<!-- Repeater Settings Accordion Item (Placeholder) -->
-		<div class="accordion-item">
-			<h2 class="accordion-header" id="heading-repeaters">
-				<button 
-					class="accordion-button collapsed" 
-					type="button" 
-					data-bs-toggle="collapse" 
-					data-bs-target="#collapse-repeaters" 
-					aria-expanded="false" 
-					aria-controls="collapse-repeaters"
+		<!-- Repeater Settings Accordion Item -->
+		{#if repeaterStore}
+			<div class="accordion-item">
+				<h2 class="accordion-header" id="heading-repeaters">
+					<button 
+						class="accordion-button collapsed" 
+						type="button" 
+						data-bs-toggle="collapse" 
+						data-bs-target="#collapse-repeaters" 
+						aria-expanded="false" 
+						aria-controls="collapse-repeaters"
+					>
+						Repeater Settings
+					</button>
+				</h2>
+				<div 
+					id="collapse-repeaters" 
+					class="accordion-collapse collapse" 
+					aria-labelledby="heading-repeaters"
 				>
-					Repeater Settings
-				</button>
-			</h2>
-			<div 
-				id="collapse-repeaters" 
-				class="accordion-collapse collapse" 
-				aria-labelledby="heading-repeaters"
-			>
-				<div class="accordion-body">
-					<RepeaterSettingsPanel />
+					<div class="accordion-body">
+						<RepeaterSettingsPanel store={repeaterStore} />
+					</div>
 				</div>
 			</div>
-		</div>
+		{/if}
 	</div>
 </MapControl>
 

package/dist/map-v2/shared/controls/FeatureSettingsControl.svelte.d.ts

@@ -1,11 +1,14 @@
 import type { SiteStoreContext } from '../../features/sites/stores/siteStoreContext.svelte';
 import type { CellStoreContext } from '../../features/cells/stores/cellStoreContext.svelte';
+import type { RepeaterStoreContext } from '../../features/repeaters/stores/repeaterStoreContext.svelte';
 import type { Cell, CellGroupingLabels } from '../../features/cells/types';
 interface Props {
     /** Site store context */
     siteStore: SiteStoreContext;
     /** Cell store context */
     cellStore: CellStoreContext;
+    /** Repeater store context (optional) */
+    repeaterStore?: RepeaterStoreContext;
     /** Available label field options for 4G/5G cells */
     labelFieldOptions4G5G: Array<keyof Cell>;
     /** Available label field options for 2G cells */