@smartnet360/svelte-components 0.0.142 → 0.0.144

package/dist/shared/csv-import/column-detector.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared CSV Import - Column Detector
+ *
+ * Auto-detects column mappings based on header names.
+ * Uses expandable alias maps for flexible matching.
+ */
+import type { ColumnMapping, StandardFieldType, ImportFieldsConfig, ImportMode } from './types';
+/**
+ * Alias map for auto-detecting column types
+ * Add new aliases here to expand recognition
+ */
+export declare const COLUMN_ALIASES: Record<StandardFieldType, string[]>;
+/**
+ * Find the best matching field type for a column header
+ */
+export declare function detectFieldType(header: string): StandardFieldType | null;
+/**
+ * Auto-detect column mapping from headers
+ * Returns suggested mapping based on alias matching
+ */
+export declare function detectColumnMapping(headers: string[], fieldsConfig: ImportFieldsConfig): ColumnMapping;
+/**
+ * Validate that all required fields are mapped
+ */
+export declare function validateMapping(mapping: ColumnMapping, fieldsConfig: ImportFieldsConfig): {
+    valid: boolean;
+    missing: string[];
+};
+/**
+ * Detect the most likely import mode based on headers
+ * Returns 'point' if lat/lon found, 'site' if site-related, otherwise 'cell'
+ */
+export declare function detectImportMode(headers: string[]): ImportMode;
+/**
+ * Auto-detect import mode and get initial mapping
+ */
+export declare function autoDetectImport(headers: string[]): {
+    mode: ImportMode;
+    mapping: ColumnMapping;
+    fieldsConfig: ImportFieldsConfig;
+};
+/**
+ * Detect delimiter from CSV content
+ */
+export declare function detectDelimiter(headerLine: string): ',' | ';';
+/**
+ * Parse CSV header line and return headers array
+ */
+export declare function parseHeaderLine(line: string, delimiter: ',' | ';'): string[];
+/**
+ * Get CSV headers and suggested mapping
+ */
+export declare function analyzeCSVHeaders(csvContent: string, fieldsConfig: ImportFieldsConfig): {
+    headers: string[];
+    delimiter: ',' | ';';
+    suggestedMapping: ColumnMapping;
+    rowCount: number;
+};

package/dist/shared/csv-import/column-detector.js

@@ -0,0 +1,228 @@
+/**
+ * Shared CSV Import - Column Detector
+ *
+ * Auto-detects column mappings based on header names.
+ * Uses expandable alias maps for flexible matching.
+ */
+import { getFieldsForMode } from './types';
+/**
+ * Alias map for auto-detecting column types
+ * Add new aliases here to expand recognition
+ */
+export const COLUMN_ALIASES = {
+    // Universal identifiers
+    id: [
+        'id', 'cellname', 'cell_name', 'txid', 'tx_id',
+        'site_id', 'siteid', 'site_code', 'sitecode',
+        'name', 'code', 'identifier', 'key', 'cell_id', 'cellid'
+    ],
+    // Coordinates
+    lat: [
+        'lat', 'latitude', 'y', 'y_coord', 'ycoord',
+        'northing', 'north', 'lat_deg', 'latitude_deg'
+    ],
+    lon: [
+        'lon', 'lng', 'long', 'longitude', 'x', 'x_coord', 'xcoord',
+        'easting', 'east', 'lon_deg', 'longitude_deg'
+    ],
+    // Grouping
+    group: [
+        'customgroup', 'custom_group', 'group', 'category',
+        'type', 'region', 'area', 'zone', 'cluster', 'segment'
+    ],
+    // Sizing
+    sizeFactor: [
+        'sizefactor', 'size_factor', 'size', 'scale', 'weight', 'factor'
+    ],
+    // Cell-specific
+    tech: [
+        'tech', 'technology', 'rat', 'radio', 'system',
+        'network_type', 'networktype', 'access_technology'
+    ],
+    band: [
+        'band', 'fband', 'frequency_band', 'frequencyband',
+        'freq', 'frequency', 'carrier', 'earfcn', 'arfcn'
+    ],
+    azimuth: [
+        'azimuth', 'az', 'bearing', 'direction', 'heading',
+        'antenna_azimuth', 'ant_azimuth', 'ant_az'
+    ],
+    tilt: [
+        'tilt', 'downtilt', 'etilt', 'mtilt', 'electrical_tilt',
+        'mechanical_tilt', 'antenna_tilt', 'ant_tilt'
+    ],
+    siteId: [
+        'siteid', 'site_id', 'site', 'location_id', 'locationid',
+        'enodeb_id', 'enodebid', 'gnodeb_id', 'gnodebid', 'bts_id'
+    ],
+    siteName: [
+        'sitename', 'site_name', 'location_name', 'locationname',
+        'site_label', 'sitelabel', 'station_name'
+    ],
+    status: [
+        'status', 'state', 'cell_status', 'cellstatus',
+        'operational_status', 'op_status', 'active'
+    ],
+    height: [
+        'height', 'antenna_height', 'ant_height', 'agl',
+        'elevation', 'tower_height', 'mast_height'
+    ],
+    power: [
+        'power', 'tx_power', 'txpower', 'eirp',
+        'transmit_power', 'output_power', 'pwr'
+    ]
+};
+/**
+ * Normalize a column header for comparison
+ */
+function normalizeHeader(header) {
+    return header
+        .trim()
+        .toLowerCase()
+        .replace(/[\s\-\.]/g, '_'); // Normalize separators to underscore
+}
+/**
+ * Find the best matching field type for a column header
+ */
+export function detectFieldType(header) {
+    const normalized = normalizeHeader(header);
+    for (const [fieldType, aliases] of Object.entries(COLUMN_ALIASES)) {
+        if (aliases.some(alias => normalized === alias || normalized.includes(alias))) {
+            return fieldType;
+        }
+    }
+    return null;
+}
+/**
+ * Auto-detect column mapping from headers
+ * Returns suggested mapping based on alias matching
+ */
+export function detectColumnMapping(headers, fieldsConfig) {
+    const mapping = {};
+    const usedIndices = new Set();
+    // Get all field types we're looking for
+    const allFields = [...fieldsConfig.required, ...fieldsConfig.optional];
+    // First pass: exact matches and strong matches
+    for (const field of allFields) {
+        const aliases = COLUMN_ALIASES[field.type] || [];
+        for (let i = 0; i < headers.length; i++) {
+            if (usedIndices.has(i))
+                continue;
+            const normalized = normalizeHeader(headers[i]);
+            // Check for exact match first
+            if (aliases.includes(normalized)) {
+                mapping[field.type] = i;
+                usedIndices.add(i);
+                break;
+            }
+        }
+    }
+    // Second pass: partial matches for unmapped fields
+    for (const field of allFields) {
+        if (mapping[field.type] !== undefined)
+            continue;
+        const aliases = COLUMN_ALIASES[field.type] || [];
+        for (let i = 0; i < headers.length; i++) {
+            if (usedIndices.has(i))
+                continue;
+            const normalized = normalizeHeader(headers[i]);
+            // Check for partial match
+            if (aliases.some(alias => normalized.includes(alias) || alias.includes(normalized))) {
+                mapping[field.type] = i;
+                usedIndices.add(i);
+                break;
+            }
+        }
+    }
+    // Set null for any fields not found
+    for (const field of allFields) {
+        if (mapping[field.type] === undefined) {
+            mapping[field.type] = null;
+        }
+    }
+    return mapping;
+}
+/**
+ * Validate that all required fields are mapped
+ */
+export function validateMapping(mapping, fieldsConfig) {
+    const missing = [];
+    for (const field of fieldsConfig.required) {
+        if (mapping[field.type] === null || mapping[field.type] === undefined) {
+            missing.push(field.label);
+        }
+    }
+    return {
+        valid: missing.length === 0,
+        missing
+    };
+}
+/**
+ * Detect the most likely import mode based on headers
+ * Returns 'point' if lat/lon found, 'site' if site-related, otherwise 'cell'
+ */
+export function detectImportMode(headers) {
+    const normalizedHeaders = headers.map(h => normalizeHeader(h));
+    // Check for lat/lon presence
+    const hasLat = normalizedHeaders.some(h => COLUMN_ALIASES.lat.some(alias => h === alias || h.includes(alias)));
+    const hasLon = normalizedHeaders.some(h => COLUMN_ALIASES.lon.some(alias => h === alias || h.includes(alias)));
+    const hasLatLon = hasLat && hasLon;
+    // Check for site-specific headers
+    const hasSiteId = normalizedHeaders.some(h => COLUMN_ALIASES.siteId.some(alias => h === alias || h.includes(alias)));
+    const hasSiteName = normalizedHeaders.some(h => COLUMN_ALIASES.siteName.some(alias => h === alias || h.includes(alias)));
+    // Check for cell-specific headers
+    const hasCellId = normalizedHeaders.some(h => ['cellname', 'cell_name', 'cellid', 'cell_id', 'txid', 'tx_id'].some(alias => h === alias || h.includes(alias)));
+    // Decision logic:
+    // 1. If has lat/lon AND site-specific headers → site mode
+    // 2. If has lat/lon AND no cell-specific headers → point mode
+    // 3. Otherwise → cell mode (ID resolves against existing cells)
+    if (hasLatLon && (hasSiteId || hasSiteName) && !hasCellId) {
+        return 'site';
+    }
+    if (hasLatLon && !hasCellId) {
+        return 'point';
+    }
+    return 'cell';
+}
+/**
+ * Auto-detect import mode and get initial mapping
+ */
+export function autoDetectImport(headers) {
+    const mode = detectImportMode(headers);
+    const fieldsConfig = getFieldsForMode(mode);
+    const mapping = detectColumnMapping(headers, fieldsConfig);
+    return { mode, mapping, fieldsConfig };
+}
+/**
+ * Detect delimiter from CSV content
+ */
+export function detectDelimiter(headerLine) {
+    const commaCount = (headerLine.match(/,/g) || []).length;
+    const semicolonCount = (headerLine.match(/;/g) || []).length;
+    return semicolonCount > commaCount ? ';' : ',';
+}
+/**
+ * Parse CSV header line and return headers array
+ */
+export function parseHeaderLine(line, delimiter) {
+    // Simple parse (doesn't handle quoted fields with delimiters inside)
+    return line.split(delimiter).map(h => h.trim().replace(/^["']|["']$/g, ''));
+}
+/**
+ * Get CSV headers and suggested mapping
+ */
+export function analyzeCSVHeaders(csvContent, fieldsConfig) {
+    const lines = csvContent.trim().split('\n');
+    if (lines.length === 0) {
+        return { headers: [], delimiter: ',', suggestedMapping: {}, rowCount: 0 };
+    }
+    const delimiter = detectDelimiter(lines[0]);
+    const headers = parseHeaderLine(lines[0], delimiter);
+    const suggestedMapping = detectColumnMapping(headers, fieldsConfig);
+    return {
+        headers,
+        delimiter,
+        suggestedMapping,
+        rowCount: lines.length - 1
+    };
+}

package/dist/shared/csv-import/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * CSV Import Module
+ *
+ * Shared utilities for flexible CSV column mapping.
+ * Supports auto-detection of columns via aliases and manual mapping UI.
+ */
+export type { StandardFieldType, FieldDefinition, ColumnMapping, ImportFieldsConfig, ImportMode } from './types';
+export { CUSTOM_POINTS_FIELDS, CELL_IMPORT_FIELDS, CELL_MODE_FIELDS, POINT_MODE_FIELDS, SITE_MODE_FIELDS, getFieldsForMode } from './types';
+export { COLUMN_ALIASES, detectColumnMapping, detectImportMode, autoDetectImport, validateMapping, analyzeCSVHeaders } from './column-detector';
+export { default as ColumnMapper } from './ColumnMapper.svelte';

package/dist/shared/csv-import/index.js

@@ -0,0 +1,12 @@
+/**
+ * CSV Import Module
+ *
+ * Shared utilities for flexible CSV column mapping.
+ * Supports auto-detection of columns via aliases and manual mapping UI.
+ */
+// Field configurations
+export { CUSTOM_POINTS_FIELDS, CELL_IMPORT_FIELDS, CELL_MODE_FIELDS, POINT_MODE_FIELDS, SITE_MODE_FIELDS, getFieldsForMode } from './types';
+// Column detection utilities
+export { COLUMN_ALIASES, detectColumnMapping, detectImportMode, autoDetectImport, validateMapping, analyzeCSVHeaders } from './column-detector';
+// UI Component
+export { default as ColumnMapper } from './ColumnMapper.svelte';

package/dist/shared/csv-import/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared CSV Import - Types
+ *
+ * Reusable types for CSV column mapping across different import features.
+ */
+/**
+ * Import mode - determines which fields are shown and required
+ */
+export type ImportMode = 'cell' | 'point' | 'site';
+/**
+ * Standard field types that can be mapped
+ */
+export type StandardFieldType = 'id' | 'lat' | 'lon' | 'group' | 'sizeFactor' | 'tech' | 'band' | 'azimuth' | 'tilt' | 'siteId' | 'siteName' | 'status' | 'height' | 'power';
+/**
+ * Definition of a field for mapping
+ */
+export interface FieldDefinition {
+    /** Field type identifier */
+    type: StandardFieldType;
+    /** Display label for UI */
+    label: string;
+    /** Whether this field is required */
+    required: boolean;
+    /** Description/help text */
+    description?: string;
+}
+/**
+ * Mapping of field types to CSV column indices
+ */
+export interface ColumnMapping {
+    [fieldType: string]: number | null;
+}
+/**
+ * Result of parsing CSV headers
+ */
+export interface CsvHeadersResult {
+    /** All column headers from CSV */
+    headers: string[];
+    /** Detected delimiter */
+    delimiter: ',' | ';';
+    /** Auto-detected column mapping (best guesses) */
+    suggestedMapping: ColumnMapping;
+    /** Total row count (excluding header) */
+    rowCount: number;
+}
+/**
+ * Configuration for a specific import context
+ */
+export interface ImportFieldsConfig {
+    /** Fields that must be mapped */
+    required: FieldDefinition[];
+    /** Fields that can optionally be mapped */
+    optional: FieldDefinition[];
+}
+/**
+ * Predefined field configurations for import modes
+ */
+/** Cell mode - ID resolves against existing cell data */
+export declare const CELL_MODE_FIELDS: ImportFieldsConfig;
+/** Point mode - creates markers at lat/lon coordinates */
+export declare const POINT_MODE_FIELDS: ImportFieldsConfig;
+/** Site mode - creates site markers at lat/lon */
+export declare const SITE_MODE_FIELDS: ImportFieldsConfig;
+/** Get field config for a given import mode */
+export declare function getFieldsForMode(mode: ImportMode): ImportFieldsConfig;
+export declare const CUSTOM_POINTS_FIELDS: ImportFieldsConfig;
+export declare const CELL_IMPORT_FIELDS: ImportFieldsConfig;

package/dist/shared/csv-import/types.js

@@ -0,0 +1,70 @@
+/**
+ * Shared CSV Import - Types
+ *
+ * Reusable types for CSV column mapping across different import features.
+ */
+/**
+ * Predefined field configurations for import modes
+ */
+/** Cell mode - ID resolves against existing cell data */
+export const CELL_MODE_FIELDS = {
+    required: [
+        { type: 'id', label: 'Cell ID', required: true, description: 'e.g. cellName, txId' }
+    ],
+    optional: [
+        { type: 'group', label: 'Group', required: false, description: 'e.g. customGroup, category' },
+        { type: 'sizeFactor', label: 'Size', required: false, description: 'e.g. sizeFactor, weight' }
+    ]
+};
+/** Point mode - creates markers at lat/lon coordinates */
+export const POINT_MODE_FIELDS = {
+    required: [
+        { type: 'id', label: 'ID / Name', required: true, description: 'e.g. name, label, id' },
+        { type: 'lat', label: 'Latitude', required: true, description: 'e.g. lat, latitude, y' },
+        { type: 'lon', label: 'Longitude', required: true, description: 'e.g. lon, lng, longitude, x' }
+    ],
+    optional: [
+        { type: 'group', label: 'Group', required: false, description: 'e.g. category, type' },
+        { type: 'sizeFactor', label: 'Size', required: false, description: 'e.g. size, weight' }
+    ]
+};
+/** Site mode - creates site markers at lat/lon */
+export const SITE_MODE_FIELDS = {
+    required: [
+        { type: 'id', label: 'Site ID', required: true, description: 'e.g. siteId, site_id, enodeb_id' },
+        { type: 'lat', label: 'Latitude', required: true, description: 'e.g. lat, latitude' },
+        { type: 'lon', label: 'Longitude', required: true, description: 'e.g. lon, longitude' }
+    ],
+    optional: [
+        { type: 'siteName', label: 'Site Name', required: false, description: 'e.g. site_name, location' },
+        { type: 'group', label: 'Group', required: false, description: 'e.g. region, area' }
+    ]
+};
+/** Get field config for a given import mode */
+export function getFieldsForMode(mode) {
+    switch (mode) {
+        case 'cell': return CELL_MODE_FIELDS;
+        case 'point': return POINT_MODE_FIELDS;
+        case 'site': return SITE_MODE_FIELDS;
+    }
+}
+// Legacy exports for backward compatibility
+export const CUSTOM_POINTS_FIELDS = CELL_MODE_FIELDS;
+export const CELL_IMPORT_FIELDS = {
+    required: [
+        { type: 'id', label: 'Cell ID', required: true, description: 'Unique cell identifier' },
+        { type: 'lat', label: 'Latitude', required: true },
+        { type: 'lon', label: 'Longitude', required: true },
+        { type: 'azimuth', label: 'Azimuth', required: true, description: 'Antenna direction (0-360°)' }
+    ],
+    optional: [
+        { type: 'siteId', label: 'Site ID', required: false },
+        { type: 'siteName', label: 'Site Name', required: false },
+        { type: 'tech', label: 'Technology', required: false, description: 'e.g., LTE, NR, GSM' },
+        { type: 'band', label: 'Band', required: false, description: 'Frequency band' },
+        { type: 'tilt', label: 'Tilt', required: false },
+        { type: 'height', label: 'Height', required: false },
+        { type: 'power', label: 'Power', required: false },
+        { type: 'status', label: 'Status', required: false }
+    ]
+};

package/package.json

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