@smartnet360/svelte-components 0.0.102 → 0.0.104

package/dist/apps/site-check/transforms-old.js

@@ -1,273 +0,0 @@
-/**
- * Data Transforms for Site Check Component
- * Converts raw CSV data to TreeView nodes and Chart configurations
- */
-import { log } from '../../core/logger';
-/**
- * Band frequency mapping for consistent ordering
- * Maps band strings to their actual frequencies in MHz
- */
-const BAND_FREQUENCY_ORDER = {
-    // LTE Bands (by frequency)
-    'LTE700': 700,
-    'LTE800': 800,
-    'LTE900': 900,
-    'LTE1800': 1800,
-    'LTE2100': 2100,
-    'LTE2600': 2600,
-    // NR/5G Bands (by frequency)
-    'NR700': 700.1, // Slightly higher to sort after LTE700
-    'NR2100': 2100.1,
-    'NR3500': 3500,
-    'NR26000': 26000 // mmWave
-};
-/**
- * Extract band from cell name using regex pattern matching
- * @param cellName - Cell name like "LTE700_1", "NR3500_2", etc.
- * @returns Band string like "LTE700", "NR3500" or null if not found
- * @deprecated Use the band field from CellTrafficRecord instead
- */
-export function extractBandFromCell(cellName) {
-    // Match patterns like "LTE700", "NR3500", etc.
-    const match = cellName.match(/(LTE|NR)(\d+)/i);
-    return match ? `${match[1].toUpperCase()}${match[2]}` : null;
-}
-/**
- * Get frequency order for a band (for sorting)
- * @param band - Band string like "LTE700", "NR3500"
- * @returns Frequency number or high value for unknown bands
- */
-export function getBandFrequency(band) {
-    if (!band)
-        return 999999; // Unknown bands go to end
-    return BAND_FREQUENCY_ORDER[band] || 999999;
-}
-/**
- * Sort items by band frequency using actual band data from records
- * @param items - Array of [cellName, record] tuples
- * @returns Sorted array (ascending frequency order)
- */
-export function sortCellsByBandFrequency(items) {
-    return items.sort((a, b) => {
-        const [cellNameA, recordA] = a;
-        const [cellNameB, recordB] = b;
-        const freqA = getBandFrequency(recordA.band);
-        const freqB = getBandFrequency(recordB.band);
-        // Primary sort: by frequency
-        if (freqA !== freqB) {
-            return freqA - freqB;
-        }
-        // Secondary sort: by cell name for same frequency
-        return cellNameA.localeCompare(cellNameB);
-    });
-}
-/**
- * Build hierarchical tree structure: Site → Sector (Azimuth) → Cell (Band)
- */
-export function buildTreeNodes(data) {
-    log('🔄 Building tree nodes', { recordCount: data.length });
-    // Group by site → azimuth → cell
-    const siteMap = new Map();
-    data.forEach((record) => {
-        if (!siteMap.has(record.siteName)) {
-            siteMap.set(record.siteName, new Map());
-        }
-        const azimuthMap = siteMap.get(record.siteName);
-        if (!azimuthMap.has(record.azimuth)) {
-            azimuthMap.set(record.azimuth, new Map());
-        }
-        const cellMap = azimuthMap.get(record.azimuth);
-        // Store one record per cell (we just need metadata, not all time series)
-        if (!cellMap.has(record.cellName)) {
-            cellMap.set(record.cellName, record);
-        }
-    });
-    // Build tree structure
-    const treeNodes = [];
-    Array.from(siteMap.entries())
-        .sort(([a], [b]) => a.localeCompare(b))
-        .forEach(([siteName, azimuthMap]) => {
-        const siteNode = {
-            id: siteName, // Simple ID
-            label: `Site ${siteName}`,
-            // icon: '📡',
-            metadata: { type: 'site', siteName },
-            defaultExpanded: false,
-            defaultChecked: false, // Don't check parent nodes
-            children: []
-        };
-        Array.from(azimuthMap.entries())
-            .sort(([a], [b]) => a - b)
-            .forEach(([azimuth, cellMap]) => {
-            const sectorNode = {
-                id: `${azimuth}`, // Simple ID (just azimuth)
-                label: `${azimuth}° Sector`,
-                // icon: '📍',
-                metadata: { type: 'sector', azimuth, siteName },
-                defaultExpanded: false,
-                defaultChecked: false, // Don't check parent nodes
-                children: []
-            };
-            // Sort cells by band frequency (LTE700, LTE800, etc.)
-            const sortedCells = sortCellsByBandFrequency(Array.from(cellMap.entries()));
-            sortedCells.forEach(([cellName, record]) => {
-                const cellNode = {
-                    id: cellName, // Simple ID (just cell name)
-                    label: `${cellName} (${record.band})`,
-                    icon: getBandIcon(record.band),
-                    metadata: {
-                        type: 'cell',
-                        cellName,
-                        band: record.band,
-                        siteName: record.siteName,
-                        sector: record.sector,
-                        azimuth: record.azimuth
-                    },
-                    defaultChecked: true
-                };
-                sectorNode.children.push(cellNode);
-            });
-            siteNode.children.push(sectorNode);
-        });
-        treeNodes.push(siteNode);
-    });
-    log('✅ Tree nodes built', {
-        totalNodes: treeNodes.length,
-        totalSites: siteMap.size,
-        sampleSite: treeNodes[0]?.label
-    });
-    return treeNodes;
-}
-/**
- * Get icon emoji based on band technology
- */
-function getBandIcon(band) {
-    return '';
-    if (band.startsWith('NR'))
-        return '📶'; // 5G
-    if (band.startsWith('LTE'))
-        return '📱'; // 4G
-    return '📡'; // Fallback
-}
-/**
- * Filter chart data based on selected tree paths
- * Only include cells that are checked in the tree
- */
-export function filterChartData(data, checkedPaths) {
-    log('🔄 Filtering chart data', {
-        totalRecords: data.length,
-        checkedPathsCount: checkedPaths.size,
-        paths: Array.from(checkedPaths)
-    });
-    // Extract cell names from checked leaf paths (format: "site:azimuth:cellName")
-    const selectedCells = new Set();
-    checkedPaths.forEach((path) => {
-        const parts = path.split(':');
-        if (parts.length === 3) {
-            // This is a cell-level path (site:azimuth:cellName)
-            selectedCells.add(parts[2]);
-        }
-    });
-    // Filter data to only include selected cells
-    const filtered = data.filter((record) => selectedCells.has(record.cellName));
-    log('✅ Data filtered', {
-        selectedCells: Array.from(selectedCells),
-        filteredRecords: filtered.length,
-        uniqueCells: new Set(filtered.map(r => r.cellName)).size
-    });
-    return filtered;
-}
-/**
- * Transform data for chart component consumption
- * Pivots data so each cell becomes its own KPI column
- * Transforms from long format (many rows per cell) to wide format (one column per cell)
- *
- * @param data - Filtered cell traffic records
- * @param baseMetrics - Array of metric names to pivot (e.g., ['dlGBytes', 'ulGBytes'])
- */
-export function transformChartData(data, baseMetrics) {
-    log('🔄 Transforming chart data', {
-        inputRecords: data.length,
-        baseMetrics,
-        uniqueCells: new Set(data.map(r => r.cellName)).size
-    });
-    // Group data by date
-    const dateMap = new Map();
-    data.forEach((record) => {
-        if (!dateMap.has(record.date)) {
-            dateMap.set(record.date, new Map());
-        }
-        dateMap.get(record.date).set(record.cellName, record);
-    });
-    // Build pivoted data: one row per date, one column per cell per metric
-    const pivotedData = [];
-    dateMap.forEach((cellsOnDate, date) => {
-        const row = {
-            TIMESTAMP: date
-        };
-        cellsOnDate.forEach((record, cellName) => {
-            // Pivot each base metric into cell-specific columns
-            baseMetrics.forEach((metricName) => {
-                const value = record.metrics[metricName];
-                if (value !== undefined) {
-                    row[`${metricName}_${cellName}`] = value;
-                }
-            });
-            // Store metadata for reference (band, azimuth, etc.)
-            row[`BAND_${cellName}`] = record.band;
-            row[`AZIMUTH_${cellName}`] = record.azimuth;
-        });
-        pivotedData.push(row);
-    });
-    // Sort by date
-    pivotedData.sort((a, b) => a.TIMESTAMP.localeCompare(b.TIMESTAMP));
-    log('✅ Data transformed', {
-        outputRows: pivotedData.length,
-        dateRange: pivotedData.length > 0 ?
-            `${pivotedData[0].TIMESTAMP} to ${pivotedData[pivotedData.length - 1].TIMESTAMP}` :
-            'none',
-        columnsPerRow: pivotedData[0] ? Object.keys(pivotedData[0]).length : 0,
-        sampleRow: pivotedData[0]
-    });
-    return pivotedData;
-}
-/**
- * Apply cell styling based on band and sector
- * Modifies KPI objects to include color (from band) and lineStyle (from sector)
- * Updates KPI name to format: Band_Azimuth°
- *
- * @param metricName - Base metric name (e.g., 'dlGBytes')
- * @param cellRecord - Cell traffic record with band, sector, azimuth metadata
- * @param unit - Unit string for the metric
- * @param stylingConfig - Optional cell styling configuration (band colors, sector line styles)
- * @returns Styled KPI object
- */
-export function createStyledKPI(metricName, cellRecord, unit, stylingConfig) {
-    const { band, sector, azimuth, cellName } = cellRecord;
-    // Get color from band (if config provided)
-    const color = stylingConfig?.bandColors?.[band];
-    // Get line style from sector (if config provided)
-    const lineStyle = stylingConfig?.sectorLineStyles?.[sector.toString()];
-    // Format name as: Band_Azimuth°
-    const displayName = `${band}_${azimuth}°`;
-    // Build KPI with cell-specific styling
-    const kpi = {
-        rawName: `${metricName}_${cellName}`, // Column name in pivoted data
-        name: displayName,
-        scale: 'absolute',
-        unit,
-        ...(color && { color }),
-        ...(lineStyle && { lineStyle })
-    };
-    log('🎨 Styled KPI created', {
-        metricName,
-        cellName,
-        displayName,
-        band,
-        sector,
-        azimuth,
-        color,
-        lineStyle
-    });
-    return kpi;
-}

package/dist/core/TreeView/tree.store.d.ts

@@ -1,10 +0,0 @@
-/**
- * Tree Store
- * Svelte writable store for managing tree state with persistence
- */
-import { type Writable } from 'svelte/store';
-import type { TreeConfig, TreeStoreValue } from './tree.model';
-/**
- * Create a tree store with state management and persistence
- */
-export declare function createTreeStore<T = any>(config: TreeConfig<T>): Writable<TreeStoreValue>;

package/dist/core/TreeView/tree.store.js

@@ -1,320 +0,0 @@
-/**
- * Tree Store
- * Svelte writable store for managing tree state with persistence
- */
-import { writable } from 'svelte/store';
-import { flattenTree, buildInitialState, calculateIndeterminateStates, getDescendantPaths, getParentPath, getAncestorPaths, saveStateToStorage, loadStateFromStorage, clearStorageForNamespace } from './tree-utils';
-import { log } from '../logger';
-/**
- * Create a tree store with state management and persistence
- */
-export function createTreeStore(config) {
-    log('🌲 Creating TreeStore', {
-        namespace: config.namespace,
-        nodeCount: config.nodes.length,
-        persistState: config.persistState,
-        defaultExpandAll: config.defaultExpandAll
-    });
-    const separator = config.pathSeparator || ':';
-    // Flatten tree structure
-    const nodesMap = flattenTree(config.nodes, config);
-    log('📊 Tree flattened', {
-        totalNodes: nodesMap.size,
-        separator
-    });
-    // Build initial state
-    let state = buildInitialState(nodesMap, config);
-    log('🔧 Initial state built', {
-        checkedPaths: state.checkedPaths.size,
-        expandedPaths: state.expandedPaths.size
-    });
-    // Load persisted state if enabled
-    if (config.persistState && config.namespace) {
-        const persistedState = loadStateFromStorage(config.namespace, state);
-        state = { ...state, ...persistedState };
-        log('💾 Loaded persisted state', {
-            namespace: config.namespace,
-            checkedPaths: state.checkedPaths.size,
-            expandedPaths: state.expandedPaths.size
-        });
-    }
-    // Create writable store
-    const store = writable({
-        state,
-        config,
-        toggle: () => { },
-        toggleExpand: () => { },
-        expandAll: () => { },
-        collapseAll: () => { },
-        checkAll: () => { },
-        uncheckAll: () => { },
-        getCheckedPaths: () => [],
-        getCheckedLeafPaths: () => [],
-        clearStorage: () => { }
-    });
-    /**
-     * Update state and trigger reactivity
-     */
-    function updateState(updater) {
-        store.update(current => {
-            const newState = updater(current.state);
-            // Persist if enabled
-            if (config.persistState && config.namespace) {
-                saveStateToStorage(config.namespace, newState);
-            }
-            return {
-                ...current,
-                state: newState
-            };
-        });
-    }
-    /**
-     * Toggle a node's checked state (with cascading)
-     *
-     * Logic:
-     * 1. Toggle the clicked node
-     * 2. Cascade DOWN to all descendants (check/uncheck all children)
-     * 3. Propagate UP to all ancestors (update based on their children's states)
-     */
-    function toggle(path) {
-        log('🔄 Toggling node', { path });
-        updateState(state => {
-            const nodeState = state.nodes.get(path);
-            if (!nodeState) {
-                log('⚠️ Node not found', { path });
-                return state;
-            }
-            const newChecked = !state.checkedPaths.has(path);
-            const newCheckedPaths = new Set(state.checkedPaths);
-            log('📌 Toggle action', { path, newChecked });
-            // STEP 0: If singleRootSelect mode and this is a root node being checked, uncheck all other roots
-            if (config.singleRootSelect && newChecked && nodeState.level === 0) {
-                log('🔘 Single root select mode: unchecking other roots', { path });
-                // Uncheck all root nodes and their descendants
-                state.rootPaths.forEach(rootPath => {
-                    if (rootPath !== path) {
-                        newCheckedPaths.delete(rootPath);
-                        // Also uncheck all descendants of this root
-                        const rootDescendants = getDescendantPaths(rootPath, state.nodes, separator);
-                        rootDescendants.forEach(descendantPath => {
-                            newCheckedPaths.delete(descendantPath);
-                        });
-                    }
-                });
-            }
-            // STEP 0.5: If singleLevel1Select mode and this is a Level 1 node being checked, uncheck sibling Level 1 nodes
-            if (config.singleLevel1Select && newChecked && nodeState.level === 1) {
-                log('🔘 Single Level 1 select mode: unchecking sibling Level 1 nodes', { path });
-                const parentPath = nodeState.parentPath;
-                // Find and uncheck all Level 1 siblings (same parent, same level, different path)
-                state.nodes.forEach((node, nodePath) => {
-                    if (node.level === 1 &&
-                        node.parentPath === parentPath &&
-                        nodePath !== path) {
-                        newCheckedPaths.delete(nodePath);
-                        // Also uncheck all descendants of this sibling
-                        const siblingDescendants = getDescendantPaths(nodePath, state.nodes, separator);
-                        siblingDescendants.forEach(descendantPath => {
-                            newCheckedPaths.delete(descendantPath);
-                        });
-                    }
-                });
-            }
-            // STEP 1: Update this node
-            if (newChecked) {
-                newCheckedPaths.add(path);
-            }
-            else {
-                newCheckedPaths.delete(path);
-            }
-            // STEP 2: CASCADE DOWN - Update all descendants to match
-            const descendants = getDescendantPaths(path, state.nodes, separator);
-            log('⬇️ Cascading to descendants', {
-                path,
-                descendantCount: descendants.length,
-                newChecked
-            });
-            descendants.forEach(descendantPath => {
-                if (newChecked) {
-                    newCheckedPaths.add(descendantPath);
-                }
-                else {
-                    newCheckedPaths.delete(descendantPath);
-                }
-            });
-            // STEP 3: PROPAGATE UP - Update all ancestors based on their children
-            // We need to update from the deepest ancestor up to the root
-            const ancestorPaths = getAncestorPaths(path, separator);
-            log('⬆️ Propagating to ancestors', {
-                path,
-                ancestorCount: ancestorPaths.length,
-                ancestors: ancestorPaths
-            });
-            // Process ancestors from deepest to shallowest (reverse order)
-            // This ensures we calculate states correctly as we go up
-            for (let i = ancestorPaths.length - 1; i >= 0; i--) {
-                const ancestorPath = ancestorPaths[i];
-                const ancestor = state.nodes.get(ancestorPath);
-                if (!ancestor)
-                    continue;
-                // Count how many direct children are checked
-                const checkedChildrenCount = ancestor.childPaths.filter(childPath => newCheckedPaths.has(childPath)).length;
-                const totalChildren = ancestor.childPaths.length;
-                log('👨‍👧‍👦 Checking ancestor children', {
-                    ancestorPath,
-                    checkedChildrenCount,
-                    totalChildren
-                });
-                // Update ancestor based on children states:
-                // - All children checked → check parent
-                // - No children checked → uncheck parent
-                // - Some children checked → uncheck parent (will show indeterminate)
-                if (checkedChildrenCount === totalChildren) {
-                    newCheckedPaths.add(ancestorPath);
-                    log('✅ All children checked, checking parent', { ancestorPath });
-                }
-                else {
-                    newCheckedPaths.delete(ancestorPath);
-                    if (checkedChildrenCount > 0) {
-                        log('➖ Some children checked, parent will be indeterminate', { ancestorPath });
-                    }
-                    else {
-                        log('❌ No children checked, unchecking parent', { ancestorPath });
-                    }
-                }
-            }
-            // STEP 4: Recalculate indeterminate states
-            const newIndeterminatePaths = calculateIndeterminateStates(state.nodes, newCheckedPaths);
-            log('✅ Toggle complete', {
-                path,
-                newChecked,
-                totalChecked: newCheckedPaths.size,
-                indeterminate: newIndeterminatePaths.size
-            });
-            return {
-                ...state,
-                checkedPaths: newCheckedPaths,
-                indeterminatePaths: newIndeterminatePaths
-            };
-        });
-    }
-    /**
-     * Toggle expanded/collapsed state
-     */
-    function toggleExpand(path) {
-        updateState(state => {
-            const newExpandedPaths = new Set(state.expandedPaths);
-            if (newExpandedPaths.has(path)) {
-                newExpandedPaths.delete(path);
-            }
-            else {
-                newExpandedPaths.add(path);
-            }
-            return {
-                ...state,
-                expandedPaths: newExpandedPaths
-            };
-        });
-    }
-    /**
-     * Expand all nodes
-     */
-    function expandAll() {
-        updateState(state => {
-            const newExpandedPaths = new Set();
-            // Add all nodes with children
-            state.nodes.forEach((nodeState, path) => {
-                if (nodeState.childPaths.length > 0) {
-                    newExpandedPaths.add(path);
-                }
-            });
-            return {
-                ...state,
-                expandedPaths: newExpandedPaths
-            };
-        });
-    }
-    /**
-     * Collapse all nodes
-     */
-    function collapseAll() {
-        updateState(state => ({
-            ...state,
-            expandedPaths: new Set()
-        }));
-    }
-    /**
-     * Check all nodes
-     */
-    function checkAll() {
-        log('✅ Check all nodes');
-        updateState(state => {
-            const newCheckedPaths = new Set();
-            state.nodes.forEach((_, path) => {
-                newCheckedPaths.add(path);
-            });
-            log('✅ All nodes checked', { totalChecked: newCheckedPaths.size });
-            return {
-                ...state,
-                checkedPaths: newCheckedPaths,
-                indeterminatePaths: new Set() // No indeterminate when all checked
-            };
-        });
-    }
-    /**
-     * Uncheck all nodes
-     */
-    function uncheckAll() {
-        log('❌ Uncheck all nodes');
-        updateState(state => ({
-            ...state,
-            checkedPaths: new Set(),
-            indeterminatePaths: new Set()
-        }));
-    }
-    /**
-     * Get all checked paths
-     */
-    function getCheckedPaths() {
-        let result = [];
-        store.subscribe(value => {
-            result = Array.from(value.state.checkedPaths);
-        })();
-        return result;
-    }
-    /**
-     * Get only checked leaf paths (nodes without children)
-     */
-    function getCheckedLeafPaths() {
-        let result = [];
-        store.subscribe(value => {
-            result = Array.from(value.state.checkedPaths).filter(path => {
-                const node = value.state.nodes.get(path);
-                return node && node.childPaths.length === 0;
-            });
-        })();
-        return result;
-    }
-    /**
-     * Clear localStorage
-     */
-    function clearStorage() {
-        if (config.namespace) {
-            clearStorageForNamespace(config.namespace);
-        }
-    }
-    // Initialize store with methods
-    store.update(current => ({
-        ...current,
-        toggle,
-        toggleExpand,
-        expandAll,
-        collapseAll,
-        checkAll,
-        uncheckAll,
-        getCheckedPaths,
-        getCheckedLeafPaths,
-        clearStorage
-    }));
-    return store;
-}