@powerhousedao/network-admin 0.0.1

package/dist/editors/network-admin/components/FolderTree.js

@@ -0,0 +1,44 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from "react";
+/**
+ * Hierarchical folder tree navigation component.
+ * Displays folders in a tree structure with expand/collapse functionality.
+ */
+export function FolderTree({ folders, files, selectedNodeId, onSelectNode, onSelectFile, }) {
+    // Track which folders are expanded
+    const [expandedFolders, setExpandedFolders] = useState(new Set());
+    // Toggle folder expansion state
+    const toggleFolder = (folderId) => {
+        setExpandedFolders((prev) => {
+            const next = new Set(prev);
+            if (next.has(folderId)) {
+                next.delete(folderId);
+            }
+            else {
+                next.add(folderId);
+            }
+            return next;
+        });
+    };
+    // Recursive function to render folder tree structure
+    const renderFolder = (folder, level = 0) => {
+        const hasChildFolders = folders.some((f) => f.parentFolder === folder.id);
+        const hasChildFiles = files.some((f) => f.parentFolder === folder.id);
+        const hasChildren = hasChildFolders || hasChildFiles;
+        const isExpanded = expandedFolders.has(folder.id);
+        const isSelected = selectedNodeId === folder.id;
+        return (_jsxs("div", { children: [_jsxs("div", { className: `flex cursor-pointer items-center rounded px-2 py-1 text-sm hover:bg-gray-100 ${isSelected ? "bg-blue-100 text-blue-800" : ""}`, style: { paddingLeft: `${level * 16 + 8}px` }, onClick: () => onSelectNode(folder.id), children: [hasChildren && (_jsxs("button", { className: "mr-1 flex h-4 w-4 items-center justify-center", onClick: (e) => {
+                                e.stopPropagation();
+                                toggleFolder(folder.id);
+                            }, children: [isExpanded ? "▼" : "▶", " "] })), !hasChildren && _jsx("div", { className: "mr-1 w-5" }), _jsxs("span", { children: ["\uD83D\uDCC1 ", folder.name] })] }), isExpanded && hasChildren && (_jsxs("div", { children: [folders
+                            .filter((f) => f.parentFolder === folder.id)
+                            .map((child) => renderFolder(child, level + 1)), files
+                            .filter((f) => f.parentFolder === folder.id)
+                            .map((file) => (_jsxs("div", { className: `flex cursor-pointer items-center rounded px-2 py-1 text-sm hover:bg-gray-100 ${selectedNodeId === file.id ? "bg-blue-100 text-blue-800" : ""}`, style: { paddingLeft: `${(level + 1) * 16 + 8}px` }, onClick: () => onSelectFile(file), children: [_jsx("div", { className: "mr-1 w-5" }), _jsxs("span", { children: ["\uD83D\uDCC4 ", file.name] })] }, file.id)))] }))] }, folder.id));
+    };
+    return (_jsxs("div", { className: "space-y-1", children: [_jsx("div", { className: `flex cursor-pointer items-center rounded px-2 py-1 text-sm hover:bg-gray-100 ${!selectedNodeId ? "bg-blue-100 text-blue-800" : ""}`, onClick: () => onSelectNode(undefined), children: _jsx("span", { children: "\uD83C\uDFE0 Root" }) }), folders
+                .filter((folder) => !folder.parentFolder)
+                .map((folder) => renderFolder(folder)), files
+                .filter((file) => !file.parentFolder)
+                .map((file) => (_jsxs("div", { className: `flex cursor-pointer items-center rounded px-2 py-1 text-sm hover:bg-gray-100 ${selectedNodeId === file.id ? "bg-blue-100 text-blue-800" : ""}`, style: { paddingLeft: "8px" }, onClick: () => onSelectFile(file), children: [_jsx("div", { className: "mr-1 w-5" }), _jsxs("span", { children: ["\uD83D\uDCC4 ", file.name] })] }, file.id)))] }));
+}

package/dist/editors/network-admin/components/IsolatedSidebar.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+/**
+ * Isolated Sidebar component that uses our custom context instead of the global one
+ * This prevents interference with other sidebars in the application
+ */
+export declare const IsolatedSidebar: React.FC<{
+    nodes: any[];
+    activeNodeId?: string;
+    onActiveNodeChange?: (nodeId: string) => void;
+    sidebarTitle?: string;
+    showSearchBar?: boolean;
+    allowPinning?: boolean;
+    resizable?: boolean;
+    initialWidth?: number;
+    maxWidth?: number;
+    enableMacros?: number;
+    handleOnTitleClick?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+}>;
+//# sourceMappingURL=IsolatedSidebar.d.ts.map

package/dist/editors/network-admin/components/IsolatedSidebar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsolatedSidebar.d.ts","sourceRoot":"","sources":["../../../../editors/network-admin/components/IsolatedSidebar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwC,MAAM,OAAO,CAAC;AAI7D;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC;IACrC,KAAK,EAAE,GAAG,EAAE,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;IAEhC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B,CAgTA,CAAC"}

package/dist/editors/network-admin/components/IsolatedSidebar.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useRef, useCallback } from "react";
+import { Icon } from "@powerhousedao/document-engineering";
+import { useIsolatedSidebar } from "./IsolatedSidebarProvider.js";
+/**
+ * Isolated Sidebar component that uses our custom context instead of the global one
+ * This prevents interference with other sidebars in the application
+ */
+export const IsolatedSidebar = ({ nodes, activeNodeId, onActiveNodeChange, sidebarTitle = "Network Admin", showSearchBar = true, allowPinning = true, resizable = true, initialWidth = 300, maxWidth = 500, enableMacros = 3, handleOnTitleClick, className, style, children, }) => {
+    const sidebarContext = useIsolatedSidebar();
+    const [isCollapsed, setIsCollapsed] = useState(false);
+    const [searchTerm, setSearchTerm] = useState("");
+    const sidebarRef = useRef(null);
+    const handleToggleCollapse = useCallback(() => {
+        setIsCollapsed(!isCollapsed);
+    }, [isCollapsed]);
+    const handleNodeClick = useCallback((nodeId) => {
+        sidebarContext.toggleNode(nodeId);
+        if (onActiveNodeChange) {
+            onActiveNodeChange(nodeId);
+        }
+    }, [sidebarContext, onActiveNodeChange]);
+    const handleSearchChange = useCallback((e) => {
+        const term = e.target.value;
+        setSearchTerm(term);
+        // Simple search implementation
+        if (term.trim() === "") {
+            sidebarContext.setSearchResults([]);
+            sidebarContext.setIsSearching(false);
+            sidebarContext.setActiveSearchIndex(0);
+        }
+        else {
+            sidebarContext.setIsSearching(true);
+            // Filter nodes based on search term
+            const searchInNodes = (nodes, searchTerm) => {
+                const results = [];
+                for (const node of nodes) {
+                    const nodeName = node.name || node.title || "";
+                    if (nodeName &&
+                        nodeName.toLowerCase().includes(searchTerm.toLowerCase())) {
+                        results.push(node);
+                    }
+                    if (node.children && node.children.length > 0) {
+                        results.push(...searchInNodes(node.children, searchTerm));
+                    }
+                }
+                return results;
+            };
+            const searchResults = searchInNodes(sidebarContext.nodes, term);
+            sidebarContext.setSearchResults(searchResults);
+            sidebarContext.setIsSearching(false);
+            sidebarContext.setActiveSearchIndex(0);
+        }
+    }, [sidebarContext]);
+    const renderNode = (node, depth = 0) => {
+        const isActive = activeNodeId === node.id;
+        const isExpanded = sidebarContext.expandedNodes.has(node.id);
+        const hasChildren = node.children && node.children.length > 0;
+        // Check if this node is the active search result
+        const isSearchActive = sidebarContext.searchResults.length > 0 &&
+            sidebarContext.searchResults[sidebarContext.activeSearchIndex]?.id ===
+                node.id;
+        // Check if this node matches the search term
+        const nodeName = node.name || node.title || "";
+        const matchesSearch = searchTerm && nodeName.toLowerCase().includes(searchTerm.toLowerCase());
+        return (_jsxs("div", { className: "select-none", children: [_jsxs("div", { className: `flex items-center py-2 px-3 cursor-pointer hover:bg-gray-200 rounded-md mx-2 ${isActive
+                        ? "bg-blue-100 text-blue-600"
+                        : isSearchActive
+                            ? "bg-yellow-100 dark:bg-[#604B0033] text-gray-700"
+                            : "text-gray-700"}`, style: { paddingLeft: `${depth * 16 + 12}px` }, onClick: () => handleNodeClick(node.id), children: [hasChildren && (_jsx("button", { className: "mr-2 p-1 hover:bg-gray-300 rounded transition-colors", onClick: (e) => {
+                                e.stopPropagation();
+                                sidebarContext.toggleNode(node.id);
+                            }, children: _jsx(Icon, { name: isExpanded ? "ChevronDown" : "CaretRight", size: 12, className: "text-gray-500" }) })), !hasChildren && _jsx("div", { className: "w-6 mr-2" }), _jsx("span", { className: "text-sm truncate font-medium", children: matchesSearch && searchTerm ? (_jsx("span", { dangerouslySetInnerHTML: {
+                                    __html: nodeName.replace(new RegExp(searchTerm, "gi"), (match) => `<span class="bg-yellow-300 dark:bg-[#604B00]">${match}</span>`),
+                                } })) : (nodeName) })] }), hasChildren && isExpanded && (_jsx("div", { children: node.children.map((child) => renderNode(child, depth + 1)) }))] }, node.id));
+    };
+    const filteredNodes = searchTerm
+        ? sidebarContext.searchResults.length > 0
+            ? sidebarContext.searchResults
+            : sidebarContext.nodes.filter((node) => {
+                const nodeName = node.name || node.title || "";
+                return (nodeName &&
+                    nodeName.toLowerCase().includes(searchTerm.toLowerCase()));
+            })
+        : sidebarContext.nodes;
+    // Don't render anything when collapsed, just the toggle button
+    if (isCollapsed) {
+        return (_jsx("div", { className: "relative", children: resizable && (_jsx("div", { className: "group/sidebar-resizer absolute right-0 top-0 h-full w-[24px] translate-x-1/2 cursor-ew-resize select-none", children: _jsx("div", { className: "relative h-full w-px translate-x-[12px] transition-colors group-hover/sidebar-resizer:bg-gray-500 dark:group-hover/sidebar-resizer:bg-gray-600", children: _jsx("button", { type: "button", className: "absolute right-0 top-14 size-4 translate-x-1/2 rounded-full bg-gray-500 dark:bg-gray-900 opacity-100", onClick: handleToggleCollapse, title: "Expand sidebar", children: _jsx(Icon, { name: "Caret", size: 16, className: "min-w-4 text-gray-50 dark:text-gray-500" }) }) }) })) }));
+    }
+    return (_jsxs("div", { ref: sidebarRef, className: `group peer relative flex h-full flex-col bg-gray-50 shadow-lg transition-[width] duration-75 ease-linear dark:bg-slate-600 ${className || ""}`, style: {
+            width: initialWidth,
+            minWidth: resizable ? 200 : initialWidth,
+            maxWidth: resizable ? maxWidth : initialWidth,
+            ...style,
+        }, children: [_jsxs("div", { className: "flex items-center justify-between gap-2 border-b border-gray-300 bg-gray-50 p-4 dark:border-gray-800 dark:bg-slate-600", children: [!isCollapsed && (_jsx("div", { className: "flex items-center gap-2 truncate", children: _jsx("h2", { className: "truncate text-sm font-semibold text-gray-700 dark:text-gray-300 cursor-pointer hover:text-gray-600", onClick: handleOnTitleClick, children: sidebarTitle }) })), !isCollapsed && enableMacros > 0 && (_jsx("div", { className: "flex select-none items-center gap-2", children: Array.from({ length: Math.min(enableMacros, 4) }).map((_, index) => {
+                            const isDisabled = index + 1 > sidebarContext.maxDepth;
+                            return (_jsx("div", { role: "button", tabIndex: 2, className: `w-[26px] rounded-lg p-1 text-center text-xs ${!isDisabled
+                                    ? "bg-slate-50 text-slate-100 hover:bg-slate-100 hover:text-slate-200 dark:bg-gray-900 dark:text-slate-200 dark:hover:bg-gray-600 dark:hover:text-slate-50"
+                                    : "cursor-not-allowed bg-gray-100 text-[#E2E4E7] dark:bg-[#252728] dark:text-slate-500"}`, onClick: () => {
+                                    if (!isDisabled) {
+                                        // Use the context's openLevel function for proper toggle behavior
+                                        sidebarContext.openLevel(index + 1);
+                                    }
+                                }, children: index + 1 }, `macro-${index}`));
+                        }) }))] }), !isCollapsed && (_jsx("div", { className: "flex-1 overflow-y-auto bg-gray-50", children: filteredNodes.length === 0 ? (_jsxs("div", { className: "p-4 text-center text-gray-500", children: [_jsx(Icon, { name: "FolderOpen", size: 24, className: "mx-auto mb-2 text-gray-300" }), _jsx("p", { className: "text-sm", children: "This node is empty" })] })) : (_jsx("div", { className: "py-2", children: filteredNodes.map((node) => renderNode(node)) })) })), !isCollapsed && showSearchBar && (_jsx("div", { className: "p-3 border-t border-gray-200 bg-gray-50", children: _jsxs("div", { className: "relative", children: [_jsx(Icon, { name: "Search", size: 16, className: "absolute left-3 top-1/2 transform -translate-y-1/2 text-gray-400" }), _jsx("input", { type: "text", placeholder: "Search...", value: searchTerm, onChange: handleSearchChange, className: "w-full pl-9 pr-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent bg-white" })] }) })), children, resizable && (_jsx("div", { className: "group/sidebar-resizer absolute right-0 top-0 h-full w-[24px] translate-x-1/2 cursor-ew-resize select-none", children: _jsx("div", { className: "relative h-full w-px translate-x-[12px] transition-colors group-hover/sidebar-resizer:bg-gray-500 dark:group-hover/sidebar-resizer:bg-gray-600", children: _jsx("button", { type: "button", className: "absolute right-0 top-14 size-4 translate-x-1/2 rounded-full bg-gray-500 dark:bg-gray-900 opacity-0 group-hover/sidebar-resizer:opacity-100 transition-opacity", onClick: handleToggleCollapse, title: "Collapse sidebar", children: _jsx(Icon, { name: "Caret", size: 16, className: "min-w-4 text-gray-50 dark:text-gray-500 -rotate-180" }) }) }) }))] }));
+};

package/dist/editors/network-admin/components/IsolatedSidebarProvider.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { SidebarNode } from '@powerhousedao/document-engineering';
+/**
+ * Isolated SidebarProvider that doesn't interfere with other sidebars
+ * Uses a completely separate React context and state management
+ */
+export declare const IsolatedSidebarProvider: React.FC<{
+    children: React.ReactNode;
+    nodes?: SidebarNode[];
+}>;
+/**
+ * Hook to use the isolated sidebar context
+ */
+export declare const useIsolatedSidebar: () => any;
+//# sourceMappingURL=IsolatedSidebarProvider.d.ts.map

package/dist/editors/network-admin/components/IsolatedSidebarProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsolatedSidebarProvider.d.ts","sourceRoot":"","sources":["../../../../editors/network-admin/components/IsolatedSidebarProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmG,MAAM,OAAO,CAAC;AACxH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AA4EvE;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC7C,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;CACvB,CAuTA,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,WAM9B,CAAC"}

package/dist/editors/network-admin/components/IsolatedSidebarProvider.js

@@ -0,0 +1,367 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useReducer, useRef, useState, useCallback, useEffect, useMemo } from 'react';
+// Create a completely isolated context for Network Admin sidebar
+const NetworkAdminSidebarContext = createContext(null);
+// Initial state for the isolated sidebar
+const initialSidebarState = {
+    nodes: [],
+    expandedNodes: new Set(),
+    activeNodeId: undefined,
+    searchTerm: '',
+    searchResults: [],
+    isSearching: false,
+    activeSearchIndex: 0,
+    pinnedNodePath: [],
+    isStatusFilterEnabled: false,
+};
+// Action types for the isolated sidebar
+const SidebarActionType = {
+    SET_NODES: 'SET_NODES',
+    TOGGLE_NODE: 'TOGGLE_NODE',
+    SET_ACTIVE_NODE: 'SET_ACTIVE_NODE',
+    SET_SEARCH_TERM: 'SET_SEARCH_TERM',
+    SET_SEARCH_RESULTS: 'SET_SEARCH_RESULTS',
+    SET_IS_SEARCHING: 'SET_IS_SEARCHING',
+    SET_ACTIVE_SEARCH_INDEX: 'SET_ACTIVE_SEARCH_INDEX',
+    SET_PINNED_NODE_PATH: 'SET_PINNED_NODE_PATH',
+    TOGGLE_STATUS_FILTER: 'TOGGLE_STATUS_FILTER',
+    OPEN_NODE: 'OPEN_NODE',
+    CLOSE_NODE: 'CLOSE_NODE',
+    SET_EXPANDED_NODES: 'SET_EXPANDED_NODES',
+};
+// Reducer for the isolated sidebar
+const networkAdminSidebarReducer = (state, action) => {
+    switch (action.type) {
+        case SidebarActionType.SET_NODES:
+            return { ...state, nodes: action.payload };
+        case SidebarActionType.TOGGLE_NODE:
+            const newExpandedNodes = new Set(state.expandedNodes);
+            if (newExpandedNodes.has(action.payload)) {
+                newExpandedNodes.delete(action.payload);
+            }
+            else {
+                newExpandedNodes.add(action.payload);
+            }
+            return { ...state, expandedNodes: newExpandedNodes };
+        case SidebarActionType.SET_ACTIVE_NODE:
+            return { ...state, activeNodeId: action.payload };
+        case SidebarActionType.SET_SEARCH_TERM:
+            return { ...state, searchTerm: action.payload };
+        case SidebarActionType.SET_SEARCH_RESULTS:
+            return { ...state, searchResults: action.payload };
+        case SidebarActionType.SET_IS_SEARCHING:
+            return { ...state, isSearching: action.payload };
+        case SidebarActionType.SET_PINNED_NODE_PATH:
+            return { ...state, pinnedNodePath: action.payload };
+        case SidebarActionType.TOGGLE_STATUS_FILTER:
+            return { ...state, isStatusFilterEnabled: !state.isStatusFilterEnabled };
+        case SidebarActionType.OPEN_NODE:
+            const openExpandedNodes = new Set(state.expandedNodes);
+            openExpandedNodes.add(action.payload);
+            return { ...state, expandedNodes: openExpandedNodes };
+        case SidebarActionType.CLOSE_NODE:
+            const closeExpandedNodes = new Set(state.expandedNodes);
+            closeExpandedNodes.delete(action.payload);
+            return { ...state, expandedNodes: closeExpandedNodes };
+        case SidebarActionType.SET_ACTIVE_SEARCH_INDEX:
+            return { ...state, activeSearchIndex: action.payload };
+        case SidebarActionType.SET_EXPANDED_NODES:
+            return { ...state, expandedNodes: action.payload };
+        default:
+            return state;
+    }
+};
+/**
+ * Isolated SidebarProvider that doesn't interfere with other sidebars
+ * Uses a completely separate React context and state management
+ */
+export const IsolatedSidebarProvider = ({ children, nodes: initialNodes = [] }) => {
+    const [state, dispatch] = useReducer(networkAdminSidebarReducer, {
+        ...initialSidebarState,
+        nodes: initialNodes,
+    });
+    const virtualListRef = useRef(null);
+    const [onActiveNodeChange, setOnActiveNodeChange] = useState(() => () => undefined);
+    const setNodes = useCallback((newNodes) => {
+        dispatch({ type: SidebarActionType.SET_NODES, payload: newNodes });
+    }, []);
+    const toggleNode = useCallback((nodeId) => {
+        dispatch({ type: SidebarActionType.TOGGLE_NODE, payload: nodeId });
+    }, []);
+    const setActiveNodeId = useCallback((nodeId) => {
+        dispatch({ type: SidebarActionType.SET_ACTIVE_NODE, payload: nodeId });
+    }, []);
+    const setSearchTerm = useCallback((term) => {
+        dispatch({ type: SidebarActionType.SET_SEARCH_TERM, payload: term });
+    }, []);
+    const setSearchResults = useCallback((results) => {
+        dispatch({ type: SidebarActionType.SET_SEARCH_RESULTS, payload: results });
+    }, []);
+    const setIsSearching = useCallback((isSearching) => {
+        dispatch({ type: SidebarActionType.SET_IS_SEARCHING, payload: isSearching });
+    }, []);
+    const setActiveSearchIndex = useCallback((index) => {
+        dispatch({ type: SidebarActionType.SET_ACTIVE_SEARCH_INDEX, payload: index });
+    }, []);
+    const nextSearchResult = useCallback(() => {
+        if (state.searchResults.length > 0) {
+            const nextIndex = Math.min(state.searchResults.length - 1, state.activeSearchIndex + 1);
+            setActiveSearchIndex(nextIndex);
+        }
+    }, [state.searchResults.length, state.activeSearchIndex, setActiveSearchIndex]);
+    const previousSearchResult = useCallback(() => {
+        if (state.searchResults.length > 0) {
+            const prevIndex = Math.max(0, state.activeSearchIndex - 1);
+            setActiveSearchIndex(prevIndex);
+        }
+    }, [state.searchResults.length, state.activeSearchIndex, setActiveSearchIndex]);
+    const setPinnedNodePath = useCallback((path) => {
+        dispatch({ type: SidebarActionType.SET_PINNED_NODE_PATH, payload: path });
+    }, []);
+    const toggleStatusFilter = useCallback(() => {
+        dispatch({ type: SidebarActionType.TOGGLE_STATUS_FILTER });
+    }, []);
+    const openNode = useCallback((nodeId) => {
+        dispatch({ type: SidebarActionType.OPEN_NODE, payload: nodeId });
+    }, []);
+    const closeNode = useCallback((nodeId) => {
+        dispatch({ type: SidebarActionType.CLOSE_NODE, payload: nodeId });
+    }, []);
+    const setExpandedNodes = useCallback((nodes) => {
+        dispatch({ type: SidebarActionType.SET_EXPANDED_NODES, payload: nodes });
+    }, []);
+    const setActiveNodeChangeCallback = useCallback((callback) => {
+        setOnActiveNodeChange(() => callback);
+    }, []);
+    const syncActiveNodeId = useCallback((nodeId) => {
+        dispatch({ type: SidebarActionType.SET_ACTIVE_NODE, payload: nodeId });
+    }, []);
+    // Update nodes when initialNodes change
+    useEffect(() => {
+        if (initialNodes.length > 0) {
+            setNodes(initialNodes);
+        }
+    }, [initialNodes, setNodes]);
+    // Calculate flattened nodes
+    const flattenedNodes = useMemo(() => {
+        const flattened = [];
+        const dfs = (node, depth) => {
+            const flatNode = {
+                ...node,
+                depth,
+                isExpanded: state.expandedNodes.has(node.id),
+            };
+            flattened.push(flatNode);
+            if (Array.isArray(node.children) && state.expandedNodes.has(node.id)) {
+                for (const child of node.children) {
+                    dfs(child, depth + 1);
+                }
+            }
+        };
+        for (const node of state.nodes) {
+            dfs(node, 0);
+        }
+        return flattened;
+    }, [state.nodes, state.expandedNodes]);
+    // Calculate max depth
+    const maxDepth = useMemo(() => {
+        const getMaxDepth = (nodes, currentLevel = 0) => {
+            if (!nodes || nodes.length === 0)
+                return currentLevel;
+            let max = currentLevel;
+            for (const node of nodes) {
+                if (node.children && node.children.length > 0) {
+                    const childDepth = getMaxDepth(node.children, currentLevel + 1);
+                    max = Math.max(max, childDepth);
+                }
+            }
+            return max;
+        };
+        const depth = getMaxDepth(state.nodes, 0);
+        // Return depth count (number of levels) instead of level number (0-based index)
+        const depthCount = depth + 1;
+        return depthCount;
+    }, [state.nodes]);
+    // Utility function to check if a level is open
+    const isOpenLevel = useCallback((items, expandedNodes, level) => {
+        if (!items.length || level < 1) {
+            return false;
+        }
+        // Check if all levels up to the target level are open
+        const queue = [...items];
+        for (let i = 0; i < level; i++) {
+            const nextLevelQueue = [];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (!current)
+                    continue;
+                // Check if current level is expanded
+                if (!expandedNodes.has(current.id)) {
+                    return false;
+                }
+                // Add children to next level queue
+                if (current.children?.length) {
+                    nextLevelQueue.push(...current.children);
+                }
+            }
+            // Move to next level
+            queue.push(...nextLevelQueue);
+            if (queue.length === 0)
+                break;
+        }
+        return true;
+    }, []);
+    // Utility function to get nodes that should be expanded for a specific level
+    const getOpenLevels = useCallback((items, level) => {
+        if (level < 1) {
+            return new Set();
+        }
+        const result = new Set();
+        const traverse = (nodes, currentLevel) => {
+            for (const node of nodes) {
+                // Add current node if we're not at the target level yet
+                if (currentLevel < level) {
+                    result.add(node.id);
+                }
+                // Continue traversing children if we haven't reached the target level
+                if (node.children?.length && currentLevel < level - 1) {
+                    traverse(node.children, currentLevel + 1);
+                }
+            }
+        };
+        traverse(items, 0); // Start from level 0 (root)
+        return result;
+    }, []);
+    const openLevel = useCallback((targetLevel) => {
+        // Check if the target level is currently visible by checking if nodes at that level are expanded
+        const isTargetLevelVisible = (() => {
+            if (targetLevel === 1) {
+                // For level 1, check if root nodes are expanded
+                return state.nodes.every((node) => state.expandedNodes.has(node.id));
+            }
+            else if (targetLevel === 2) {
+                // For level 2, check if folder nodes are expanded
+                const folderNodes = state.nodes.flatMap((node) => node.children || []);
+                return folderNodes.length > 0 && folderNodes.every((folder) => state.expandedNodes.has(folder.id));
+            }
+            else if (targetLevel === 3) {
+                // For level 3, check if document nodes are expanded
+                const documentNodes = state.nodes.flatMap((node) => (node.children || []).flatMap((folder) => folder.children || []));
+                return documentNodes.length > 0 && documentNodes.every((doc) => state.expandedNodes.has(doc.id));
+            }
+            return false;
+        })();
+        if (isTargetLevelVisible) {
+            // If the target level is visible, hide it by closing nodes at that level
+            if (targetLevel === 1) {
+                // Close root nodes
+                const newExpandedNodes = new Set(state.expandedNodes);
+                state.nodes.forEach((node) => newExpandedNodes.delete(node.id));
+                dispatch({ type: SidebarActionType.SET_EXPANDED_NODES, payload: newExpandedNodes });
+            }
+            else if (targetLevel === 2) {
+                // Close folder nodes
+                const newExpandedNodes = new Set(state.expandedNodes);
+                state.nodes.forEach((node) => {
+                    if (node.children) {
+                        node.children.forEach((folder) => newExpandedNodes.delete(folder.id));
+                    }
+                });
+                dispatch({ type: SidebarActionType.SET_EXPANDED_NODES, payload: newExpandedNodes });
+            }
+            else if (targetLevel === 3) {
+                // Close document nodes
+                const newExpandedNodes = new Set(state.expandedNodes);
+                state.nodes.forEach((node) => {
+                    if (node.children) {
+                        node.children.forEach((folder) => {
+                            if (folder.children) {
+                                folder.children.forEach((doc) => newExpandedNodes.delete(doc.id));
+                            }
+                        });
+                    }
+                });
+                dispatch({ type: SidebarActionType.SET_EXPANDED_NODES, payload: newExpandedNodes });
+            }
+        }
+        else {
+            // If the target level is not visible, show it by opening nodes at that level
+            if (targetLevel === 1) {
+                // Open root nodes
+                const newExpandedNodes = new Set(state.expandedNodes);
+                state.nodes.forEach((node) => newExpandedNodes.add(node.id));
+                dispatch({ type: SidebarActionType.SET_EXPANDED_NODES, payload: newExpandedNodes });
+            }
+            else if (targetLevel === 2) {
+                // Open folder nodes (and root nodes if not already open)
+                const newExpandedNodes = new Set(state.expandedNodes);
+                state.nodes.forEach((node) => {
+                    newExpandedNodes.add(node.id); // Ensure root is open
+                    if (node.children) {
+                        node.children.forEach((folder) => newExpandedNodes.add(folder.id));
+                    }
+                });
+                dispatch({ type: SidebarActionType.SET_EXPANDED_NODES, payload: newExpandedNodes });
+            }
+            else if (targetLevel === 3) {
+                // Open document nodes (and root + folder nodes if not already open)
+                const newExpandedNodes = new Set(state.expandedNodes);
+                state.nodes.forEach((node) => {
+                    newExpandedNodes.add(node.id); // Ensure root is open
+                    if (node.children) {
+                        node.children.forEach((folder) => {
+                            newExpandedNodes.add(folder.id); // Ensure folder is open
+                            if (folder.children) {
+                                folder.children.forEach((doc) => newExpandedNodes.add(doc.id));
+                            }
+                        });
+                    }
+                });
+                dispatch({ type: SidebarActionType.SET_EXPANDED_NODES, payload: newExpandedNodes });
+            }
+        }
+    }, [state.nodes, state.expandedNodes]);
+    const contextValue = {
+        nodes: state.nodes,
+        flattenedNodes,
+        expandedNodes: state.expandedNodes,
+        pinnedNodePath: state.pinnedNodePath,
+        maxDepth,
+        searchTerm: state.searchTerm,
+        searchResults: state.searchResults,
+        isSearching: state.isSearching,
+        activeSearchIndex: state.activeSearchIndex,
+        isStatusFilterEnabled: state.isStatusFilterEnabled,
+        virtualListRef,
+        activeNodeId: state.activeNodeId,
+        toggleNode,
+        openNode,
+        closeNode,
+        togglePin: () => { }, // Simplified for now
+        openLevel,
+        changeSearchTerm: setSearchTerm,
+        nextSearchResult,
+        previousSearchResult,
+        setNodes,
+        syncActiveNodeId,
+        onActiveNodeChange,
+        setActiveNodeChangeCallback,
+        toggleStatusFilter,
+        setSearchTerm,
+        setSearchResults,
+        setIsSearching,
+        setActiveSearchIndex,
+        setExpandedNodes,
+    };
+    return (_jsx(NetworkAdminSidebarContext.Provider, { value: contextValue, children: children }));
+};
+/**
+ * Hook to use the isolated sidebar context
+ */
+export const useIsolatedSidebar = () => {
+    const context = useContext(NetworkAdminSidebarContext);
+    if (!context) {
+        throw new Error('useIsolatedSidebar must be used within IsolatedSidebarProvider');
+    }
+    return context;
+};

package/dist/editors/network-admin/editor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Base editor component that renders the drive explorer interface.
+ * Customize document opening behavior and drive-level actions here.
+ */
+export declare function BaseEditor(props: any): import("react/jsx-runtime").JSX.Element;
+/**
+ * Main editor entry point with required providers.
+ */
+export default function Editor(props: any): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=editor.d.ts.map

package/dist/editors/network-admin/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../editors/network-admin/editor.tsx"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,GAAG,2CAOpC;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,KAAK,EAAE,GAAG,2CAaxC"}

package/dist/editors/network-admin/editor.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { WagmiContext } from "@powerhousedao/design-system";
+import { AnalyticsProvider, DriveContextProvider, useAppConfig, } from "@powerhousedao/reactor-browser";
+import { DriveExplorer } from "./components/DriveExplorer.js";
+/**
+ * Base editor component that renders the drive explorer interface.
+ * Customize document opening behavior and drive-level actions here.
+ */
+export function BaseEditor(props) {
+    const { context, document } = props;
+    return (_jsx("div", { className: "h-full w-full", children: _jsx(DriveExplorer, { document: document, context: context }) }));
+}
+/**
+ * Main editor entry point with required providers.
+ */
+export default function Editor(props) {
+    const appConfig = useAppConfig();
+    const analyticsDatabaseName = appConfig?.analyticsDatabaseName;
+    return (
+    // Required context providers for drive functionality
+    _jsx(DriveContextProvider, { value: props.context, children: _jsx(WagmiContext, { children: _jsx(AnalyticsProvider, { databaseName: analyticsDatabaseName, children: _jsx(BaseEditor, { ...props }) }) }) }));
+}

package/dist/editors/network-admin/index.d.ts

@@ -0,0 +1,4 @@
+import { type DriveEditorModule } from "@powerhousedao/reactor-browser";
+export declare const module: DriveEditorModule;
+export default module;
+//# sourceMappingURL=index.d.ts.map

package/dist/editors/network-admin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../editors/network-admin/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAGxE,eAAO,MAAM,MAAM,EAAE,iBASpB,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/editors/network-admin/index.js

@@ -0,0 +1,12 @@
+import Editor from "./editor.js";
+export const module = {
+    Component: Editor,
+    documentTypes: ["powerhouse/document-drive"],
+    config: {
+        id: "network-admin",
+        disableExternalControls: true,
+        documentToolbarEnabled: true,
+        showSwitchboardLink: true,
+    },
+};
+export default module;