@smartnet360/svelte-components 0.0.105 → 0.0.106

package/dist/shared/demo/cell-generator.js

@@ -0,0 +1,254 @@
+/**
+ * Cell Generator - Configurable Demo Cell Data Generator
+ *
+ * Generates realistic cell network data with configurable parameters.
+ * Supports density zones, multiple technologies, and various site configurations.
+ */
+/**
+ * Preset configurations
+ */
+export const GENERATOR_PRESETS = {
+    /** Small dataset for quick demos - 10 sites, ~300 cells */
+    small: {
+        numSites: 10,
+        centerLat: 47.4979,
+        centerLng: 19.0402,
+        radiusKm: 3
+    },
+    /** Medium dataset for testing - 100 sites, ~3000 cells */
+    medium: {
+        numSites: 100,
+        centerLat: 47.4979,
+        centerLng: 19.0402,
+        radiusKm: 8
+    },
+    /** Large dataset for performance testing - 500 sites, ~15000 cells */
+    large: {
+        numSites: 500,
+        centerLat: 47.4979,
+        centerLng: 19.0402,
+        radiusKm: 12
+    },
+    /** Extra large dataset - 2000 sites, ~60000 cells */
+    xlarge: {
+        numSites: 2000,
+        centerLat: 47.4979,
+        centerLng: 19.0402,
+        radiusKm: 15
+    }
+};
+// Density zones (distance from center as fraction of radius)
+const DENSITY_ZONES = [
+    { maxRadius: 0.3, minSpacing: 0.0008, maxSpacing: 0.0015, name: 'Very Dense Core' },
+    { maxRadius: 0.5, minSpacing: 0.0015, maxSpacing: 0.003, name: 'Dense Inner' },
+    { maxRadius: 0.7, minSpacing: 0.003, maxSpacing: 0.006, name: 'Medium' },
+    { maxRadius: 0.85, minSpacing: 0.006, maxSpacing: 0.012, name: 'Sparse Suburban' },
+    { maxRadius: 1.0, minSpacing: 0.012, maxSpacing: 0.025, name: 'Very Sparse Rural' }
+];
+// Cell tech-band definitions
+const TECH_BANDS = [
+    { tech: '2G', band: '900', fband: 'GSM900' },
+    { tech: '2G', band: '1800', fband: 'GSM1800' },
+    { tech: '4G', band: '700', fband: 'LTE700' },
+    { tech: '4G', band: '800', fband: 'LTE800' },
+    { tech: '4G', band: '900', fband: 'LTE900' },
+    { tech: '4G', band: '1800', fband: 'LTE1800' },
+    { tech: '4G', band: '2100', fband: 'LTE2100' },
+    { tech: '4G', band: '2600', fband: 'LTE2600' },
+    { tech: '5G', band: '700', fband: '5G-700' },
+    { tech: '5G', band: '2100', fband: '5G-2100' },
+    { tech: '5G', band: '3500', fband: '5G-3500' }
+];
+// Sector configurations
+const SECTORS = [
+    { azimuth: 0, sectorNum: 1 },
+    { azimuth: 120, sectorNum: 2 },
+    { azimuth: 240, sectorNum: 3 }
+];
+// Status distribution
+const STATUSES = [
+    'On_Air', 'On_Air', 'On_Air', 'On_Air',
+    'On_Air_UNDER_CONSTRUCTION', 'On_Air_Locked',
+    'RF_Plan_Ready', 'RF_Plan_Ready',
+    'Re-Planned_RF_Plan_Ready', 'Tavlati_RF_Plan_Ready',
+    'On_Air', 'On_Air'
+];
+const BEAMWIDTH = 65;
+/**
+ * Simple seeded random number generator
+ */
+function createRandom(seed) {
+    if (seed === undefined) {
+        return Math.random;
+    }
+    let s = seed;
+    return () => {
+        s = (s * 1103515245 + 12345) & 0x7fffffff;
+        return s / 0x7fffffff;
+    };
+}
+/**
+ * Get density zone for a given normalized radius
+ */
+function getDensityZone(normalizedRadius) {
+    for (const zone of DENSITY_ZONES) {
+        if (normalizedRadius <= zone.maxRadius) {
+            return zone;
+        }
+    }
+    return DENSITY_ZONES[DENSITY_ZONES.length - 1];
+}
+/**
+ * Generate cell name from site, sector, and band index
+ * Format: SSSS S BB (e.g., "1000141")
+ */
+function generateCellName(siteNum, sectorNum, bandIndex) {
+    const siteId = String(siteNum + 1000).padStart(4, '0');
+    const cellSuffix = String(41 + bandIndex).padStart(2, '0');
+    return `${siteId}${sectorNum}${cellSuffix}`;
+}
+/**
+ * Generate demo cells with configurable parameters
+ */
+export function generateCells(config) {
+    const { numSites, centerLat, centerLng, radiusKm, seed } = config;
+    const random = createRandom(seed);
+    const radiusDegrees = radiusKm / 111;
+    const cells = [];
+    const usedPositions = [];
+    let cellCounter = 1;
+    let actualSiteIndex = 0;
+    /**
+     * Generate random point within circle
+     */
+    function generateRandomPointInCircle() {
+        const r = Math.sqrt(random()) * radiusDegrees;
+        const theta = random() * 2 * Math.PI;
+        return {
+            lat: centerLat + r * Math.cos(theta),
+            lng: centerLng + r * Math.sin(theta),
+            normalizedRadius: r / radiusDegrees
+        };
+    }
+    /**
+     * Check if position is too close to existing sites
+     */
+    function isTooClose(lat, lng, minSpacing) {
+        for (const pos of usedPositions) {
+            const distance = Math.sqrt(Math.pow(lat - pos.lat, 2) + Math.pow(lng - pos.lng, 2));
+            const requiredSpacing = (minSpacing + pos.minSpacing) / 2;
+            if (distance < requiredSpacing) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Add jitter to coordinate
+     */
+    function addJitter(value, maxJitter) {
+        return value + (random() - 0.5) * 2 * maxJitter;
+    }
+    // Generate sites
+    for (let attempt = 0; attempt < numSites * 3 && actualSiteIndex < numSites; attempt++) {
+        const { lat, lng, normalizedRadius } = generateRandomPointInCircle();
+        const zone = getDensityZone(normalizedRadius);
+        const minSpacing = zone.minSpacing + random() * (zone.maxSpacing - zone.minSpacing);
+        if (isTooClose(lat, lng, minSpacing)) {
+            continue;
+        }
+        const jitterAmount = minSpacing * 0.3;
+        const siteLat = addJitter(lat, jitterAmount);
+        const siteLng = addJitter(lng, jitterAmount);
+        usedPositions.push({ lat: siteLat, lng: siteLng, minSpacing });
+        const siteNum = actualSiteIndex;
+        const siteId = String(siteNum + 1000).padStart(4, '0');
+        actualSiteIndex++;
+        // 10% chance of 1-2 sectors instead of 3
+        const numSectors = random() < 0.1 ? (random() < 0.5 ? 1 : 2) : 3;
+        const sectorsToGenerate = SECTORS.slice(0, numSectors);
+        for (const sector of sectorsToGenerate) {
+            for (let bandIndex = 0; bandIndex < TECH_BANDS.length; bandIndex++) {
+                const techBand = TECH_BANDS[bandIndex];
+                const cellName = generateCellName(siteNum, sector.sectorNum, bandIndex);
+                const status = STATUSES[bandIndex % STATUSES.length];
+                cells.push({
+                    id: cellName,
+                    txId: cellName,
+                    cellID: cellName,
+                    cellID2G: techBand.tech === '2G' ? cellName : '',
+                    cellName: cellName,
+                    siteId: siteId,
+                    tech: techBand.tech,
+                    fband: techBand.fband,
+                    frq: techBand.band,
+                    type: 'MACRO',
+                    status: status,
+                    onAirDate: '2024-01-15',
+                    bcch: techBand.tech === '2G' ? 100 + bandIndex : 0,
+                    ctrlid: techBand.tech === '2G' ? `CTRL-${cellName}` : '',
+                    dlEarfn: techBand.tech === '4G' ? 6200 + bandIndex * 100 : 0,
+                    antenna: 'DEMO-ANTENNA-MODEL',
+                    azimuth: sector.azimuth,
+                    height: 30,
+                    electricalTilt: '3',
+                    beamwidth: BEAMWIDTH,
+                    latitude: siteLat,
+                    longitude: siteLng,
+                    dx: 0,
+                    dy: 0,
+                    siteLatitude: siteLat,
+                    siteLongitude: siteLng,
+                    comment: `Demo ${techBand.tech} ${techBand.band} cell at azimuth ${sector.azimuth}°`,
+                    planner: 'Demo User',
+                    atollETP: 43.0,
+                    atollPW: 20.0,
+                    atollRS: 500.0 + (techBand.band === '700' ? 200 : 0),
+                    atollBW: parseFloat(techBand.band) / 100,
+                    cellId3: `${cellName}-3G`,
+                    nwtP1: 20,
+                    nwtP2: 40,
+                    pci1: cellCounter % 504,
+                    nwtRS: 450.0,
+                    nwtBW: 10.0,
+                    other: {
+                        demoCell: true,
+                        siteNumber: actualSiteIndex,
+                        sector: sector.sectorNum,
+                        techBandKey: `${techBand.tech}_${techBand.band}`,
+                        radius: normalizedRadius,
+                        densityZone: zone.name
+                    },
+                    customSubgroup: `Sector-${sector.sectorNum}`
+                });
+                cellCounter++;
+            }
+        }
+    }
+    return cells;
+}
+/**
+ * Generate cells using a preset configuration
+ */
+export function generateCellsFromPreset(preset, seed) {
+    const config = { ...GENERATOR_PRESETS[preset], seed };
+    return generateCells(config);
+}
+/**
+ * Get info about generated data
+ */
+export function getGeneratorInfo(cells) {
+    const siteIds = new Set(cells.map(c => c.siteId));
+    const techBreakdown = {};
+    const statusBreakdown = {};
+    for (const cell of cells) {
+        techBreakdown[cell.tech] = (techBreakdown[cell.tech] || 0) + 1;
+        statusBreakdown[cell.status] = (statusBreakdown[cell.status] || 0) + 1;
+    }
+    return {
+        totalCells: cells.length,
+        totalSites: siteIds.size,
+        techBreakdown,
+        statusBreakdown
+    };
+}

package/dist/shared/demo/cell-types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared Demo Data - Cell Types
+ *
+ * Core cell interface used across all components
+ */
+/**
+ * Cell data model - represents a radio cell/sector
+ */
+export interface Cell {
+    id: string;
+    txId: string;
+    cellID: string;
+    cellID2G: string;
+    cellName: string;
+    siteId: string;
+    tech: string;
+    fband: string;
+    frq: string;
+    type: string;
+    status: string;
+    onAirDate: string;
+    bcch: number;
+    ctrlid: string;
+    dlEarfn: number;
+    antenna: string;
+    azimuth: number;
+    height: number;
+    electricalTilt: string;
+    beamwidth: number;
+    latitude: number;
+    longitude: number;
+    dx: number;
+    dy: number;
+    siteLatitude: number;
+    siteLongitude: number;
+    comment: string;
+    planner: string;
+    atollETP: number;
+    atollPW: number;
+    atollRS: number;
+    atollBW: number;
+    cellId3: string;
+    nwtP1: number;
+    nwtP2: number;
+    pci1: number;
+    nwtRS: number;
+    nwtBW: number;
+    other?: Record<string, unknown>;
+    customSubgroup: string;
+}
+/**
+ * Supported cell sector status values
+ */
+export type CellStatus = 'On_Air' | 'On_Air_UNDER_CONSTRUCTION' | 'On_Air_Locked' | 'RF_Plan_Ready' | 'Re-Planned_RF_Plan_Ready' | 'Tavlati_RF_Plan_Ready';
+/**
+ * Technology-Band combination key
+ */
+export type TechnologyBandKey = string;
+/**
+ * Grouping fields for views
+ */
+export type CellGroupingField = 'tech' | 'fband' | 'frq' | 'status' | 'siteId' | 'none';

package/dist/shared/demo/cell-types.js

@@ -0,0 +1,6 @@
+/**
+ * Shared Demo Data - Cell Types
+ *
+ * Core cell interface used across all components
+ */
+export {};

package/dist/shared/demo/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared Demo Data Module
+ *
+ * Provides common demo data generators and types for use across components.
+ */
+export type { Cell, CellStatus, CellGroupingField } from './cell-types';
+export { generateCells, generateCellsFromPreset, getGeneratorInfo, GENERATOR_PRESETS, type CellGeneratorConfig, type GeneratorPreset } from './cell-generator';

package/dist/shared/demo/index.js

@@ -0,0 +1,7 @@
+/**
+ * Shared Demo Data Module
+ *
+ * Provides common demo data generators and types for use across components.
+ */
+// Generator
+export { generateCells, generateCellsFromPreset, getGeneratorInfo, GENERATOR_PRESETS } from './cell-generator';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smartnet360/svelte-components",
-	"version": "0.0.105",
+	"version": "0.0.106",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",

package/dist/core/CellTable/demo-data.d.ts

@@ -1,5 +0,0 @@
-import type { CellData } from './types';
-/**
- * Demo cell data for testing the CellTable component
- */
-export declare const demoCells: CellData[];