@smartnet360/svelte-components 0.0.101 → 0.0.103

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;
-}

package/dist/map-v3/features/selection/layers/SelectionHighlightLayers.svelte

@@ -1,209 +0,0 @@
-<script lang="ts">
-	import { getContext } from 'svelte';
-	import type { MapStore } from '../../../core/stores/map.store.svelte';
-	import type { CellDataStore } from '../../cells/stores/cell.data.svelte';
-	import type { CellDisplayStore } from '../../cells/stores/cell.display.svelte';
-	import type { SelectedFeature } from '../types';
-	import { generateCellArc, calculateRadiusInMeters } from '../../cells/logic/geometry';
-	import type mapboxgl from 'mapbox-gl';
-
-	interface Props {
-		selectedFeatures: SelectedFeature[];
-		cellDataStore?: CellDataStore;
-		cellDisplayStore?: CellDisplayStore;
-		highlightColor?: string;
-		highlightWidth?: number;
-	}
-
-	let {
-		selectedFeatures,
-		cellDataStore,
-		cellDisplayStore,
-		highlightColor = '#FF6B00',
-		highlightWidth = 4
-	}: Props = $props();
-
-	const mapStore = getContext<MapStore>('MAP_CONTEXT');
-	
-	let cellsSourceId = 'cells-selection-source';
-	let cellsLayerId = 'cells-selection-highlight';
-	let sitesSourceId = 'sites-selection-source';
-	let sitesLayerId = 'sites-selection-highlight';
-
-	// Track current zoom level for radius calculation
-	let currentZoom = $state(13);
-	let centerLat = $state(0);
-
-	// Update zoom level when map changes
-	$effect(() => {
-		const map = mapStore.map;
-		if (!map) return;
-
-		const updateZoom = () => {
-			currentZoom = map.getZoom();
-			centerLat = map.getCenter().lat;
-		};
-
-		updateZoom();
-		map.on('zoom', updateZoom);
-		map.on('move', updateZoom);
-
-		return () => {
-			map.off('zoom', updateZoom);
-			map.off('move', updateZoom);
-		};
-	});
-
-	// Derive highlighted cells based on selected features
-	let highlightedCells = $derived.by(() => {
-		if (!cellDataStore) return [];
-		
-		const cellIds = selectedFeatures
-			.filter(f => f.layerId === 'cells-layer')
-			.map(f => f.id);
-		
-		if (cellIds.length === 0) return [];
-		
-		return cellDataStore.filteredCells.filter(cell => 
-			cellIds.includes(cell.siteId) || 
-			cellIds.includes(cell.cellName) ||
-			cellIds.includes(cell.cellID)
-		);
-	});
-
-	// Derive highlighted sites based on selected features
-	// TODO: Add site highlighting when SiteDataStore is available
-	let highlightedSites = $derived.by(() => {
-		return [];
-	});
-
-	// Generate GeoJSON for cell highlights
-	let cellHighlightGeoJSON = $derived.by(() => {
-		if (!cellDisplayStore || highlightedCells.length === 0) {
-			return { type: 'FeatureCollection', features: [] };
-		}
-		
-		// Calculate radius for current zoom level (same as CellsLayer does)
-		const radiusMeters = calculateRadiusInMeters(centerLat, currentZoom, cellDisplayStore.targetPixelSize);
-		
-		const features = highlightedCells.map(cell =>
-			generateCellArc(cell, radiusMeters, 100, highlightColor)
-		);
-		
-		return {
-			type: 'FeatureCollection' as const,
-			features
-		};
-	});
-
-	// Generate GeoJSON for site highlights
-	let siteHighlightGeoJSON = $derived.by(() => {
-		if (highlightedSites.length === 0) {
-			return { type: 'FeatureCollection', features: [] };
-		}
-		
-		const features = highlightedSites.map((site: any) => ({
-			type: 'Feature' as const,
-			geometry: {
-				type: 'Point' as const,
-				coordinates: [site.longitude, site.latitude]
-			},
-			properties: { siteId: site.siteId }
-		}));
-		
-		return {
-			type: 'FeatureCollection' as const,
-			features
-		};
-	});
-
-	// Initialize and manage layers
-	$effect(() => {
-		const map = mapStore.map;
-		if (!map) return;
-
-		const addLayers = () => {
-			// Cell Selection Highlight Layer
-			if (!map.getSource(cellsSourceId)) {
-				map.addSource(cellsSourceId, {
-					type: 'geojson',
-					data: { type: 'FeatureCollection', features: [] }
-				});
-			}
-
-			if (!map.getLayer(cellsLayerId)) {
-				map.addLayer({
-					id: cellsLayerId,
-					type: 'line',
-					source: cellsSourceId,
-					paint: {
-						'line-color': highlightColor,
-						'line-width': highlightWidth,
-						'line-opacity': 1
-					}
-				});
-			}
-
-			// Site Selection Highlight Layer
-			if (!map.getSource(sitesSourceId)) {
-				map.addSource(sitesSourceId, {
-					type: 'geojson',
-					data: { type: 'FeatureCollection', features: [] }
-				});
-			}
-
-			if (!map.getLayer(sitesLayerId)) {
-				map.addLayer({
-					id: sitesLayerId,
-					type: 'circle',
-					source: sitesSourceId,
-					paint: {
-						'circle-radius': 12,
-						'circle-color': 'transparent',
-						'circle-stroke-color': highlightColor,
-						'circle-stroke-width': highlightWidth,
-						'circle-stroke-opacity': 1
-					}
-				});
-			}
-		};
-
-		// Initial setup
-		addLayers();
-
-		// Events
-		map.on('style.load', addLayers);
-
-		// Cleanup
-		return () => {
-			map.off('style.load', addLayers);
-			
-			if (map.getLayer(cellsLayerId)) map.removeLayer(cellsLayerId);
-			if (map.getLayer(sitesLayerId)) map.removeLayer(sitesLayerId);
-			if (map.getSource(cellsSourceId)) map.removeSource(cellsSourceId);
-			if (map.getSource(sitesSourceId)) map.removeSource(sitesSourceId);
-		};
-	});
-
-	// Update cell highlight source
-	$effect(() => {
-		const map = mapStore.map;
-		if (!map) return;
-
-		const source = map.getSource(cellsSourceId) as mapboxgl.GeoJSONSource;
-		if (source) {
-			source.setData(cellHighlightGeoJSON as any);
-		}
-	});
-
-	// Update site highlight source
-	$effect(() => {
-		const map = mapStore.map;
-		if (!map) return;
-
-		const source = map.getSource(sitesSourceId) as mapboxgl.GeoJSONSource;
-		if (source) {
-			source.setData(siteHighlightGeoJSON as any);
-		}
-	});
-</script>

package/dist/map-v3/features/selection/layers/SelectionHighlightLayers.svelte.d.ts

@@ -1,13 +0,0 @@
-import type { CellDataStore } from '../../cells/stores/cell.data.svelte';
-import type { CellDisplayStore } from '../../cells/stores/cell.display.svelte';
-import type { SelectedFeature } from '../types';
-interface Props {
-    selectedFeatures: SelectedFeature[];
-    cellDataStore?: CellDataStore;
-    cellDisplayStore?: CellDisplayStore;
-    highlightColor?: string;
-    highlightWidth?: number;
-}
-declare const SelectionHighlightLayers: import("svelte").Component<Props, {}, "">;
-type SelectionHighlightLayers = ReturnType<typeof SelectionHighlightLayers>;
-export default SelectionHighlightLayers;