@smartnet360/svelte-components 0.0.102 → 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;
-}