@smartnet360/svelte-components 0.0.22 → 0.0.24

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

@@ -0,0 +1,225 @@
+/**
+ * Tree Store
+ * Svelte writable store for managing tree state with persistence
+ */
+import { writable } from 'svelte/store';
+import { flattenTree, buildInitialState, calculateIndeterminateStates, getDescendantPaths, getParentPath, saveStateToStorage, loadStateFromStorage, clearStorageForNamespace } from './tree-utils';
+/**
+ * Create a tree store with state management and persistence
+ */
+export function createTreeStore(config) {
+    const separator = config.pathSeparator || ':';
+    // Flatten tree structure
+    const nodesMap = flattenTree(config.nodes, config);
+    // Build initial state
+    let state = buildInitialState(nodesMap, config);
+    // Load persisted state if enabled
+    if (config.persistState && config.namespace) {
+        const persistedState = loadStateFromStorage(config.namespace, state);
+        state = { ...state, ...persistedState };
+    }
+    // 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)
+     */
+    function toggle(path) {
+        updateState(state => {
+            const nodeState = state.nodes.get(path);
+            if (!nodeState)
+                return state;
+            const newChecked = !state.checkedPaths.has(path);
+            const newCheckedPaths = new Set(state.checkedPaths);
+            // Update this node
+            if (newChecked) {
+                newCheckedPaths.add(path);
+            }
+            else {
+                newCheckedPaths.delete(path);
+            }
+            // Cascade to all descendants
+            const descendants = getDescendantPaths(path, state.nodes, separator);
+            descendants.forEach(descendantPath => {
+                if (newChecked) {
+                    newCheckedPaths.add(descendantPath);
+                }
+                else {
+                    newCheckedPaths.delete(descendantPath);
+                }
+            });
+            // Update ancestors (check for indeterminate states)
+            let currentPath = path;
+            while (true) {
+                const parentPath = getParentPath(currentPath, separator);
+                if (!parentPath)
+                    break;
+                const parent = state.nodes.get(parentPath);
+                if (!parent)
+                    break;
+                // Count checked children
+                const checkedChildren = parent.childPaths.filter(childPath => newCheckedPaths.has(childPath));
+                // If all children checked, check parent; if none checked, uncheck parent
+                if (checkedChildren.length === parent.childPaths.length) {
+                    newCheckedPaths.add(parentPath);
+                }
+                else if (checkedChildren.length === 0) {
+                    newCheckedPaths.delete(parentPath);
+                }
+                // If some checked, parent state depends on whether we're checking or unchecking
+                // For better UX: leave parent as-is (will show indeterminate)
+                currentPath = parentPath;
+            }
+            // Recalculate indeterminate states
+            const newIndeterminatePaths = calculateIndeterminateStates(state.nodes, newCheckedPaths);
+            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() {
+        updateState(state => {
+            const newCheckedPaths = new Set();
+            state.nodes.forEach((_, path) => {
+                newCheckedPaths.add(path);
+            });
+            return {
+                ...state,
+                checkedPaths: newCheckedPaths,
+                indeterminatePaths: new Set() // No indeterminate when all checked
+            };
+        });
+    }
+    /**
+     * Uncheck all nodes
+     */
+    function uncheckAll() {
+        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/core/index.d.ts

@@ -1,2 +1,4 @@
 export * from './Desktop/index.js';
 export * from './Charts/index.js';
+export * from './TreeView/index.js';
+export * from './TreeChartView/index.js';

package/dist/core/index.js

@@ -4,3 +4,7 @@
 export * from './Desktop/index.js';
 // Chart visualization components  
 export * from './Charts/index.js';
+// TreeView generic hierarchical component
+export * from './TreeView/index.js';
+// TreeChartView combined layout component
+export * from './TreeChartView/index.js';

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './core/index.js';
 export * from './apps/index.js';
+export * from './cellular/index.js';

package/dist/index.js

@@ -1,6 +1,8 @@
 // Main library export - clean barrel export pattern
 // This approach keeps the main index clean and allows for easy expansion
-// Core components (Desktop orchestration + Charts)
+// Core components (Desktop orchestration + Charts + TreeView)
 export * from './core/index.js';
 // Complete applications
 export * from './apps/index.js';
+// Cellular network components
+export * from './cellular/index.js';

package/package.json

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