@smartnet360/svelte-components 0.0.125 → 0.0.127

package/dist/map-v3/features/cells/custom/logic/csv-parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Custom Cells - CSV Parser
+ *
+ * Parses CSV files for custom cell sets.
+ * Required column: txId
+ * Optional columns: customGroup, sizeFactor, + any extras for tooltips
+ */
+import type { CustomCellImportResult } from '../types';
+import type { Cell } from '../../../../../shared/demo';
+/**
+ * Parse a CSV string into custom cells
+ * @param csvContent Raw CSV content
+ * @param cellLookup Map of txId -> Cell for resolving cell data
+ * @returns Import result with cells, unmatched IDs, groups, and extra columns
+ */
+export declare function parseCustomCellsCsv(csvContent: string, cellLookup: Map<string, Cell>): CustomCellImportResult;
+/**
+ * Build a cell lookup map from an array of cells
+ */
+export declare function buildCellLookup(cells: Cell[]): Map<string, Cell>;

package/dist/map-v3/features/cells/custom/logic/csv-parser.js

@@ -0,0 +1,164 @@
+/**
+ * Custom Cells - CSV Parser
+ *
+ * Parses CSV files for custom cell sets.
+ * Required column: txId
+ * Optional columns: customGroup, sizeFactor, + any extras for tooltips
+ */
+/**
+ * Known/reserved column names
+ */
+const RESERVED_COLUMNS = ['txId', 'txid', 'customGroup', 'customgroup', 'sizeFactor', 'sizefactor'];
+/**
+ * Normalize column name for matching
+ */
+function normalizeColumnName(name) {
+    return name.trim().toLowerCase();
+}
+/**
+ * Parse a CSV string into custom cells
+ * @param csvContent Raw CSV content
+ * @param cellLookup Map of txId -> Cell for resolving cell data
+ * @returns Import result with cells, unmatched IDs, groups, and extra columns
+ */
+export function parseCustomCellsCsv(csvContent, cellLookup) {
+    const lines = csvContent.trim().split('\n');
+    if (lines.length < 2) {
+        return {
+            cells: [],
+            unmatchedTxIds: [],
+            groups: [],
+            extraColumns: [],
+            totalRows: 0
+        };
+    }
+    // Parse header
+    const headerLine = lines[0];
+    const headers = parseCSVLine(headerLine);
+    const normalizedHeaders = headers.map(normalizeColumnName);
+    // Find required txId column
+    const txIdIndex = normalizedHeaders.findIndex(h => h === 'txid');
+    if (txIdIndex === -1) {
+        throw new Error('CSV must contain a "txId" column');
+    }
+    // Find optional columns
+    const groupIndex = normalizedHeaders.findIndex(h => h === 'customgroup');
+    const sizeFactorIndex = normalizedHeaders.findIndex(h => h === 'sizefactor');
+    // Find extra columns (not reserved)
+    const extraColumns = [];
+    const extraIndices = [];
+    headers.forEach((header, idx) => {
+        const normalized = normalizeColumnName(header);
+        if (!RESERVED_COLUMNS.includes(normalized)) {
+            extraColumns.push(header.trim());
+            extraIndices.push(idx);
+        }
+    });
+    // Parse data rows
+    const cells = [];
+    const unmatchedTxIds = [];
+    const groupsSet = new Set();
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        const values = parseCSVLine(line);
+        const txId = values[txIdIndex]?.trim();
+        if (!txId)
+            continue;
+        // Get custom group (default to 'default')
+        const customGroup = groupIndex !== -1
+            ? (values[groupIndex]?.trim() || 'default')
+            : 'default';
+        groupsSet.add(customGroup);
+        // Get size factor (default to 1)
+        let sizeFactor = 1;
+        if (sizeFactorIndex !== -1) {
+            const parsed = parseFloat(values[sizeFactorIndex]);
+            if (!isNaN(parsed) && parsed > 0) {
+                sizeFactor = parsed;
+            }
+        }
+        // Collect extra fields
+        const extraFields = {};
+        extraIndices.forEach((idx, i) => {
+            const value = values[idx]?.trim() || '';
+            // Try to parse as number
+            const numValue = parseFloat(value);
+            extraFields[extraColumns[i]] = isNaN(numValue) ? value : numValue;
+        });
+        // Resolve cell from lookup
+        const resolvedCell = cellLookup.get(txId);
+        if (resolvedCell) {
+            cells.push({
+                txId,
+                customGroup,
+                sizeFactor,
+                extraFields,
+                resolvedCell
+            });
+        }
+        else {
+            unmatchedTxIds.push(txId);
+        }
+    }
+    return {
+        cells,
+        unmatchedTxIds,
+        groups: Array.from(groupsSet).sort(),
+        extraColumns,
+        totalRows: lines.length - 1
+    };
+}
+/**
+ * Parse a single CSV line, handling quoted fields
+ */
+function parseCSVLine(line) {
+    const result = [];
+    let current = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        const nextChar = line[i + 1];
+        if (inQuotes) {
+            if (char === '"' && nextChar === '"') {
+                // Escaped quote
+                current += '"';
+                i++;
+            }
+            else if (char === '"') {
+                // End of quoted field
+                inQuotes = false;
+            }
+            else {
+                current += char;
+            }
+        }
+        else {
+            if (char === '"') {
+                inQuotes = true;
+            }
+            else if (char === ',') {
+                result.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+    }
+    result.push(current);
+    return result;
+}
+/**
+ * Build a cell lookup map from an array of cells
+ */
+export function buildCellLookup(cells) {
+    const lookup = new Map();
+    for (const cell of cells) {
+        if (cell.txId) {
+            lookup.set(cell.txId, cell);
+        }
+    }
+    return lookup;
+}

package/dist/map-v3/features/cells/custom/logic/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Custom Cells Logic - Barrel Export
+ */
+export { parseCustomCellsCsv, buildCellLookup } from './csv-parser';
+export { buildCustomCellTree, getGroupCounts } from './tree-adapter';

package/dist/map-v3/features/cells/custom/logic/index.js

@@ -0,0 +1,5 @@
+/**
+ * Custom Cells Logic - Barrel Export
+ */
+export { parseCustomCellsCsv, buildCellLookup } from './csv-parser';
+export { buildCustomCellTree, getGroupCounts } from './tree-adapter';

package/dist/map-v3/features/cells/custom/logic/tree-adapter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom Cells - Tree Adapter
+ *
+ * Builds tree structure for TreeView component, grouped by customGroup
+ */
+import type { TreeNode } from '../../../../../core/TreeView/tree.model';
+import type { CustomCellSet } from '../types';
+/**
+ * Metadata for tree nodes
+ */
+export interface CustomCellTreeMetadata {
+    color: string;
+    count: number;
+    groupId: string;
+    setId: string;
+}
+/**
+ * Build tree nodes for a custom cell set, grouped by customGroup
+ */
+export declare function buildCustomCellTree(set: CustomCellSet): TreeNode<CustomCellTreeMetadata>[];
+/**
+ * Get cell counts per group
+ */
+export declare function getGroupCounts(set: CustomCellSet): Map<string, number>;

package/dist/map-v3/features/cells/custom/logic/tree-adapter.js

@@ -0,0 +1,67 @@
+/**
+ * Custom Cells - Tree Adapter
+ *
+ * Builds tree structure for TreeView component, grouped by customGroup
+ */
+/**
+ * Build tree nodes for a custom cell set, grouped by customGroup
+ */
+export function buildCustomCellTree(set) {
+    // Group cells by customGroup
+    const groupMap = new Map();
+    for (const cell of set.cells) {
+        if (!cell.resolvedCell)
+            continue; // Skip unresolved cells
+        if (!groupMap.has(cell.customGroup)) {
+            groupMap.set(cell.customGroup, []);
+        }
+        groupMap.get(cell.customGroup).push(cell);
+    }
+    // Build leaf nodes for each group
+    const groupNodes = [];
+    for (const [group, cells] of groupMap) {
+        const color = set.groupColors[group] || set.defaultColor;
+        const isVisible = set.visibleGroups.has(group);
+        groupNodes.push({
+            id: `${set.id}__${group}`,
+            label: `${group} (${cells.length})`,
+            metadata: {
+                color,
+                count: cells.length,
+                groupId: group,
+                setId: set.id
+            },
+            defaultChecked: isVisible
+        });
+    }
+    // Sort groups alphabetically
+    groupNodes.sort((a, b) => a.label.localeCompare(b.label));
+    // Wrap in root node
+    const rootNode = {
+        id: `root-${set.id}`,
+        label: `${set.name} (${set.cells.length})`,
+        children: groupNodes,
+        defaultExpanded: true,
+        defaultChecked: set.visible,
+        metadata: {
+            color: set.defaultColor,
+            count: set.cells.length,
+            groupId: '__root__',
+            setId: set.id
+        }
+    };
+    return [rootNode];
+}
+/**
+ * Get cell counts per group
+ */
+export function getGroupCounts(set) {
+    const counts = new Map();
+    for (const cell of set.cells) {
+        if (!cell.resolvedCell)
+            continue;
+        const current = counts.get(cell.customGroup) || 0;
+        counts.set(cell.customGroup, current + 1);
+    }
+    return counts;
+}

package/dist/map-v3/features/cells/custom/stores/custom-cell-sets.svelte.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Custom Cell Sets Store
+ *
+ * Manages multiple custom cell sets, each loaded from a CSV file.
+ * Resolves cell data from the parent CellDataStore.
+ */
+import type { CellDataStore } from '../../stores/cell.data.svelte';
+import type { CustomCellSet, CustomCellImportResult } from '../types';
+/**
+ * Store for managing custom cell sets
+ */
+export declare class CustomCellSetsStore {
+    /** All custom cell sets */
+    sets: CustomCellSet[];
+    /** Version counter for reactivity */
+    version: number;
+    /** Reference to parent cell data store */
+    private cellDataStore;
+    /** Storage key for persistence */
+    private storageKey;
+    constructor(cellDataStore: CellDataStore, namespace?: string);
+    /**
+     * Import a CSV file and create a new custom cell set
+     */
+    importFromCsv(csvContent: string, fileName: string): CustomCellImportResult;
+    /**
+     * Create a new set from import result
+     */
+    createSet(name: string, importResult: CustomCellImportResult): CustomCellSet;
+    /**
+     * Remove a set by ID
+     */
+    removeSet(setId: string): boolean;
+    /**
+     * Get a set by ID
+     */
+    getSet(setId: string): CustomCellSet | undefined;
+    /**
+     * Toggle set visibility
+     */
+    toggleSetVisibility(setId: string): void;
+    /**
+     * Toggle group visibility within a set
+     */
+    toggleGroupVisibility(setId: string, group: string): void;
+    /**
+     * Set group color
+     */
+    setGroupColor(setId: string, group: string, color: string): void;
+    /**
+     * Update set display settings
+     */
+    updateSetSettings(setId: string, settings: Partial<Pick<CustomCellSet, 'baseSize' | 'opacity' | 'defaultColor'>>): void;
+    /**
+     * Rename a set
+     */
+    renameSet(setId: string, newName: string): void;
+    /**
+     * Get visible cells for a set (filtered by visible groups)
+     */
+    getVisibleCells(setId: string): import("..").CustomCell[];
+    /**
+     * Re-resolve cells after main cell data changes
+     */
+    refreshResolutions(): void;
+    /**
+     * Load from localStorage
+     */
+    private load;
+    /**
+     * Save to localStorage
+     */
+    private save;
+}
+/**
+ * Factory function to create a custom cell sets store
+ */
+export declare function createCustomCellSetsStore(cellDataStore: CellDataStore, namespace?: string): CustomCellSetsStore;

package/dist/map-v3/features/cells/custom/stores/custom-cell-sets.svelte.js

@@ -0,0 +1,242 @@
+/**
+ * Custom Cell Sets Store
+ *
+ * Manages multiple custom cell sets, each loaded from a CSV file.
+ * Resolves cell data from the parent CellDataStore.
+ */
+import { browser } from '$app/environment';
+import { CUSTOM_CELL_PALETTE } from '../types';
+import { parseCustomCellsCsv, buildCellLookup } from '../logic/csv-parser';
+/**
+ * Generate a unique ID for a new set
+ */
+function generateSetId() {
+    return `set-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * Store for managing custom cell sets
+ */
+export class CustomCellSetsStore {
+    /** All custom cell sets */
+    sets = $state([]);
+    /** Version counter for reactivity */
+    version = $state(0);
+    /** Reference to parent cell data store */
+    cellDataStore;
+    /** Storage key for persistence */
+    storageKey;
+    constructor(cellDataStore, namespace = 'default') {
+        this.cellDataStore = cellDataStore;
+        this.storageKey = `${namespace}:custom-cell-sets`;
+        if (browser) {
+            this.load();
+            // Auto-save on changes
+            $effect(() => {
+                // Read version to trigger on changes
+                const _v = this.version;
+                this.save();
+            });
+            // Re-resolve cells when main cell data changes
+            $effect(() => {
+                const cellCount = this.cellDataStore.rawCells.length;
+                if (cellCount > 0 && this.sets.length > 0) {
+                    // Check if any cells need resolution
+                    const needsResolution = this.sets.some(set => set.cells.some(c => !c.resolvedCell));
+                    if (needsResolution) {
+                        console.log('[CustomCellSetsStore] Re-resolving cells after main data loaded');
+                        this.refreshResolutions();
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Import a CSV file and create a new custom cell set
+     */
+    importFromCsv(csvContent, fileName) {
+        // Build lookup from all cells (unfiltered)
+        const cellLookup = buildCellLookup(this.cellDataStore.rawCells);
+        // Parse CSV
+        const result = parseCustomCellsCsv(csvContent, cellLookup);
+        return result;
+    }
+    /**
+     * Create a new set from import result
+     */
+    createSet(name, importResult) {
+        const id = generateSetId();
+        // Assign default colors to groups
+        const groupColors = {};
+        importResult.groups.forEach((group, idx) => {
+            groupColors[group] = CUSTOM_CELL_PALETTE[idx % CUSTOM_CELL_PALETTE.length];
+        });
+        const newSet = {
+            id,
+            name,
+            cells: importResult.cells,
+            unmatchedTxIds: importResult.unmatchedTxIds,
+            groups: importResult.groups,
+            extraColumns: importResult.extraColumns,
+            baseSize: 50,
+            opacity: 0.7,
+            defaultColor: CUSTOM_CELL_PALETTE[0],
+            groupColors,
+            visible: true,
+            visibleGroups: new Set(importResult.groups)
+        };
+        this.sets.push(newSet);
+        this.version++;
+        return newSet;
+    }
+    /**
+     * Remove a set by ID
+     */
+    removeSet(setId) {
+        const index = this.sets.findIndex(s => s.id === setId);
+        if (index !== -1) {
+            // Use filter to create a new array for proper reactivity
+            this.sets = this.sets.filter(s => s.id !== setId);
+            this.version++;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get a set by ID
+     */
+    getSet(setId) {
+        return this.sets.find(s => s.id === setId);
+    }
+    /**
+     * Toggle set visibility
+     */
+    toggleSetVisibility(setId) {
+        const set = this.getSet(setId);
+        if (set) {
+            set.visible = !set.visible;
+            this.version++;
+        }
+    }
+    /**
+     * Toggle group visibility within a set
+     */
+    toggleGroupVisibility(setId, group) {
+        const set = this.getSet(setId);
+        if (set) {
+            if (set.visibleGroups.has(group)) {
+                set.visibleGroups.delete(group);
+            }
+            else {
+                set.visibleGroups.add(group);
+            }
+            this.version++;
+        }
+    }
+    /**
+     * Set group color
+     */
+    setGroupColor(setId, group, color) {
+        const set = this.getSet(setId);
+        if (set) {
+            set.groupColors[group] = color;
+            this.version++;
+        }
+    }
+    /**
+     * Update set display settings
+     */
+    updateSetSettings(setId, settings) {
+        const set = this.getSet(setId);
+        if (set) {
+            if (settings.baseSize !== undefined)
+                set.baseSize = settings.baseSize;
+            if (settings.opacity !== undefined)
+                set.opacity = settings.opacity;
+            if (settings.defaultColor !== undefined)
+                set.defaultColor = settings.defaultColor;
+            this.version++;
+        }
+    }
+    /**
+     * Rename a set
+     */
+    renameSet(setId, newName) {
+        const set = this.getSet(setId);
+        if (set) {
+            set.name = newName;
+            this.version++;
+        }
+    }
+    /**
+     * Get visible cells for a set (filtered by visible groups)
+     */
+    getVisibleCells(setId) {
+        const set = this.getSet(setId);
+        if (!set || !set.visible)
+            return [];
+        return set.cells.filter(c => c.resolvedCell && set.visibleGroups.has(c.customGroup));
+    }
+    /**
+     * Re-resolve cells after main cell data changes
+     */
+    refreshResolutions() {
+        const cellLookup = buildCellLookup(this.cellDataStore.rawCells);
+        for (const set of this.sets) {
+            for (const cell of set.cells) {
+                cell.resolvedCell = cellLookup.get(cell.txId);
+            }
+        }
+        this.version++;
+    }
+    /**
+     * Load from localStorage
+     */
+    load() {
+        try {
+            const stored = localStorage.getItem(this.storageKey);
+            if (stored) {
+                const data = JSON.parse(stored);
+                // Reconstruct sets with proper Set objects
+                this.sets = data.map((setData) => ({
+                    ...setData,
+                    visibleGroups: new Set(setData.visibleGroups || []),
+                    cells: setData.cells || []
+                }));
+                // Re-resolve cells
+                this.refreshResolutions();
+            }
+        }
+        catch (e) {
+            console.warn('[CustomCellSetsStore] Failed to load from storage', e);
+        }
+    }
+    /**
+     * Save to localStorage
+     */
+    save() {
+        try {
+            // Convert Sets to arrays for JSON serialization
+            const data = this.sets.map(set => ({
+                ...set,
+                visibleGroups: Array.from(set.visibleGroups),
+                // Don't persist resolved cells - will re-resolve on load
+                cells: set.cells.map(c => ({
+                    txId: c.txId,
+                    customGroup: c.customGroup,
+                    sizeFactor: c.sizeFactor,
+                    extraFields: c.extraFields
+                }))
+            }));
+            localStorage.setItem(this.storageKey, JSON.stringify(data));
+        }
+        catch (e) {
+            console.warn('[CustomCellSetsStore] Failed to save to storage', e);
+        }
+    }
+}
+/**
+ * Factory function to create a custom cell sets store
+ */
+export function createCustomCellSetsStore(cellDataStore, namespace = 'default') {
+    return new CustomCellSetsStore(cellDataStore, namespace);
+}

package/dist/map-v3/features/cells/custom/stores/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Custom Cells Stores - Barrel Export
+ */
+export { CustomCellSetsStore, createCustomCellSetsStore } from './custom-cell-sets.svelte';

package/dist/map-v3/features/cells/custom/stores/index.js

@@ -0,0 +1,4 @@
+/**
+ * Custom Cells Stores - Barrel Export
+ */
+export { CustomCellSetsStore, createCustomCellSetsStore } from './custom-cell-sets.svelte';