@fde-desktop/fde-core 0.3.8 → 0.4.1

package/dist/chunk-4ZCRYHL6.js

@@ -0,0 +1,407 @@
+import { useScrollback, useShell, useTerminalStore } from './chunk-NVEGEK3N.js';
+import { getRuntime } from './chunk-FRHBM2U7.js';
+import { Center, Stack, Text } from './chunk-BQL3YXMV.js';
+import { useRef, useState, useEffect, useCallback } from 'react';
+import { Terminal } from '@xterm/xterm';
+import { FitAddon } from '@xterm/addon-fit';
+import { ClipboardAddon } from '@xterm/addon-clipboard';
+import '@xterm/xterm/css/xterm.css';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { FcInfo } from 'react-icons/fc';
+import { useTranslation } from 'react-i18next';
+
+// src/components/Apps/TerminalApp/Terminal.module.css
+var Terminal_default = {};
+var MAX_RETRIES = 5;
+var BASE_RETRY_DELAY_MS = 1e3;
+var XTermTerminal = ({
+  shell,
+  scrollback,
+  onTerminalReady,
+  onConnectionChange
+}) => {
+  const containerRef = useRef(null);
+  const terminalRef = useRef(null);
+  const fitAddonRef = useRef(null);
+  const clipboardAddonRef = useRef(null);
+  const wsRef = useRef(null);
+  const retryCountRef = useRef(0);
+  const mountedRef = useRef(false);
+  const connectingRef = useRef(false);
+  const shellRef = useRef(shell);
+  const abortControllerRef = useRef(null);
+  const initializedRef = useRef(false);
+  const [status, setStatus] = useState("idle");
+  const [canReconnect, setCanReconnect] = useState(false);
+  const onTerminalReadyRef = useRef(onTerminalReady);
+  const onConnectionChangeRef = useRef(onConnectionChange);
+  useEffect(() => {
+    onTerminalReadyRef.current = onTerminalReady;
+  }, [onTerminalReady]);
+  useEffect(() => {
+    onConnectionChangeRef.current = onConnectionChange;
+  }, [onConnectionChange]);
+  useEffect(() => {
+    shellRef.current = shell;
+  }, [shell]);
+  const updateStatus = useCallback((newStatus) => {
+    if (!mountedRef.current) return;
+    setStatus(newStatus);
+    onConnectionChangeRef.current?.(newStatus);
+  }, []);
+  const disconnect = useCallback(() => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    const ws = wsRef.current;
+    if (ws) {
+      wsRef.current = null;
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        try {
+          ws.send(JSON.stringify({ type: "kill" }));
+        } catch {
+        }
+        ws.close();
+      }
+    }
+    connectingRef.current = false;
+  }, []);
+  const connect = useCallback(() => {
+    if (!mountedRef.current) return;
+    if (connectingRef.current) return;
+    if (wsRef.current?.readyState === WebSocket.OPEN) return;
+    connectingRef.current = true;
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const wsUrl = `${protocol}//${window.location.host}/api/pty`;
+    console.log(`[XTermTerminal] Connecting (attempt ${retryCountRef.current + 1}/${MAX_RETRIES})`);
+    updateStatus("connecting");
+    const ws = new WebSocket(wsUrl);
+    wsRef.current = ws;
+    ws.onopen = () => {
+      if (!mountedRef.current) return;
+      console.log("[XTermTerminal] WebSocket opened");
+    };
+    ws.onmessage = (event) => {
+      if (!mountedRef.current) return;
+      if (typeof event.data !== "string") return;
+      try {
+        const data = JSON.parse(event.data);
+        switch (data.type) {
+          case "ready":
+            console.log("[XTermTerminal] Server ready, sending start");
+            ws.send(
+              JSON.stringify({
+                type: "start",
+                shell: shellRef.current,
+                cwd: "/app/workspace",
+                cols: terminalRef.current?.cols || 80,
+                rows: terminalRef.current?.rows || 24
+              })
+            );
+            break;
+          case "started":
+            console.log("[XTermTerminal] PTY started");
+            retryCountRef.current = 0;
+            connectingRef.current = false;
+            setCanReconnect(false);
+            updateStatus("connected");
+            break;
+          case "exit":
+            console.log("[XTermTerminal] PTY exited:", data.code);
+            wsRef.current = null;
+            connectingRef.current = false;
+            updateStatus("disconnected");
+            setCanReconnect(true);
+            break;
+          case "error":
+            console.error("[XTermTerminal] Server error:", data.message);
+            connectingRef.current = false;
+            updateStatus("error");
+            setCanReconnect(true);
+            break;
+        }
+      } catch {
+        if (terminalRef.current) {
+          terminalRef.current.write(event.data);
+        }
+      }
+    };
+    ws.onclose = () => {
+      if (!mountedRef.current || abortController.signal.aborted) return;
+      console.log("[XTermTerminal] WebSocket closed");
+      wsRef.current = null;
+      connectingRef.current = false;
+      if (retryCountRef.current < MAX_RETRIES) {
+        retryCountRef.current++;
+        const delay = BASE_RETRY_DELAY_MS * Math.pow(2, retryCountRef.current - 1);
+        console.log(`[XTermTerminal] Retrying in ${delay}ms`);
+        setTimeout(() => {
+          if (mountedRef.current && !wsRef.current && !abortController.signal.aborted) {
+            connect();
+          }
+        }, delay);
+      } else {
+        updateStatus("disconnected");
+        setCanReconnect(true);
+      }
+    };
+    ws.onerror = () => {
+      if (!mountedRef.current) return;
+      console.error("[XTermTerminal] WebSocket error");
+      connectingRef.current = false;
+      ws.close();
+      updateStatus("error");
+      setCanReconnect(true);
+    };
+  }, [updateStatus]);
+  useEffect(() => {
+    if (initializedRef.current) return void 0;
+    initializedRef.current = true;
+    mountedRef.current = true;
+    if (!containerRef.current) return void 0;
+    const terminal = new Terminal({
+      fontFamily: "'Operator Mono', 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace",
+      fontSize: 14,
+      theme: {
+        background: "#1e1e1e",
+        foreground: "#d4d4d4",
+        cursor: "#ffffff",
+        selectionBackground: "#264f78"
+      },
+      cursorStyle: "underline",
+      cursorBlink: true,
+      scrollback
+    });
+    const fitAddon = new FitAddon();
+    const clipboardAddon = new ClipboardAddon();
+    terminal.loadAddon(fitAddon);
+    terminal.loadAddon(clipboardAddon);
+    terminal.open(containerRef.current);
+    fitAddon.fit();
+    terminalRef.current = terminal;
+    fitAddonRef.current = fitAddon;
+    clipboardAddonRef.current = clipboardAddon;
+    terminal.onData((data) => {
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        wsRef.current.send(JSON.stringify({ type: "input", data }));
+      }
+    });
+    terminal.onResize(({ cols, rows }) => {
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        wsRef.current.send(JSON.stringify({ type: "resize", cols, rows }));
+      }
+    });
+    onTerminalReadyRef.current?.({
+      clear: () => terminal.clear(),
+      reset: () => terminal.reset(),
+      write: (data) => terminal.write(data),
+      copy: async () => {
+        const selection = terminal.getSelection();
+        console.log("[XTermTerminal] Copy called, selection length:", selection?.length ?? 0);
+        if (!selection) {
+          console.log("[XTermTerminal] No selection to copy");
+          return;
+        }
+        try {
+          if (!navigator.clipboard) {
+            console.warn("[XTermTerminal] Clipboard API not available (non-secure context?)");
+            fallbackCopy(selection);
+            return;
+          }
+          await navigator.clipboard.writeText(selection);
+          console.log("[XTermTerminal] Copied to clipboard successfully");
+        } catch (err) {
+          console.error("[XTermTerminal] Clipboard write failed:", err);
+          fallbackCopy(selection);
+        }
+      },
+      paste: async () => {
+        console.log("[XTermTerminal] Paste called");
+        try {
+          if (!navigator.clipboard) {
+            console.warn("[XTermTerminal] Clipboard API not available");
+            return;
+          }
+          const text = await navigator.clipboard.readText();
+          console.log("[XTermTerminal] Paste text length:", text.length);
+          terminal.paste(text);
+        } catch (err) {
+          console.error("[XTermTerminal] Paste failed:", err);
+        }
+      },
+      reconnect
+    });
+    requestAnimationFrame(() => {
+      if (mountedRef.current) {
+        connect();
+      }
+    });
+    return () => {
+      console.log("[XTermTerminal] Cleanup");
+      mountedRef.current = false;
+      abortControllerRef.current?.abort();
+      abortControllerRef.current = null;
+      if (terminalRef.current) {
+        terminalRef.current.clear();
+      }
+      disconnect();
+      terminal.dispose();
+      terminalRef.current = null;
+      fitAddonRef.current = null;
+    };
+  }, []);
+  const reconnect = useCallback(() => {
+    console.log("[XTermTerminal] Reconnect triggered");
+    retryCountRef.current = 0;
+    setCanReconnect(false);
+    disconnect();
+    setTimeout(() => connect(), 100);
+  }, [disconnect, connect]);
+  useEffect(() => {
+    if (terminalRef.current) {
+      terminalRef.current.options.scrollback = scrollback;
+    }
+  }, [scrollback]);
+  useEffect(() => {
+    if (!containerRef.current) return void 0;
+    const observer = new ResizeObserver(() => {
+      fitAddonRef.current?.fit();
+    });
+    observer.observe(containerRef.current);
+    return () => observer.disconnect();
+  }, []);
+  return /* @__PURE__ */ jsxs("div", { className: Terminal_default.terminalContainer, children: [
+    /* @__PURE__ */ jsx("div", { className: Terminal_default.terminalWrapper, children: /* @__PURE__ */ jsx("div", { ref: containerRef, className: Terminal_default.terminal, "data-testid": "xterm-terminal" }) }),
+    /* @__PURE__ */ jsxs("div", { className: Terminal_default.statusBar, children: [
+      /* @__PURE__ */ jsxs("span", { className: Terminal_default.statusIndicator, "data-status": status, children: [
+        status === "idle" && "\u25CB",
+        status === "connecting" && "\u25CF",
+        status === "connected" && "\u25CF",
+        status === "disconnected" && "\u25CB",
+        status === "error" && "\u25CF"
+      ] }),
+      /* @__PURE__ */ jsxs("span", { className: Terminal_default.statusText, children: [
+        status === "idle" && "Idle",
+        status === "connecting" && "Connecting...",
+        status === "connected" && "Connected",
+        status === "disconnected" && "Disconnected",
+        status === "error" && "Error"
+      ] }),
+      canReconnect && /* @__PURE__ */ jsx("button", { onClick: reconnect, className: Terminal_default.reconnectButton, children: "Reconnect" })
+    ] })
+  ] });
+};
+function fallbackCopy(text) {
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  textarea.style.left = "-9999px";
+  textarea.style.opacity = "0";
+  document.body.appendChild(textarea);
+  textarea.select();
+  textarea.setSelectionRange(0, text.length);
+  try {
+    const success = document.execCommand("copy");
+    console.log("[XTermTerminal] Fallback copy result:", success ? "success" : "failed");
+  } catch (err) {
+    console.error("[XTermTerminal] Fallback copy failed:", err);
+  } finally {
+    document.body.removeChild(textarea);
+  }
+}
+var XTermTerminal_default = XTermTerminal;
+var TerminalNotSupported = () => {
+  const { t } = useTranslation("apps");
+  return /* @__PURE__ */ jsx(Center, { "data-testid": "terminal-not-supported", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsxs(Stack, { align: "center", gap: "lg", p: "xl", maw: 400, children: [
+    /* @__PURE__ */ jsx(Text, { size: "3rem", children: /* @__PURE__ */ jsx(FcInfo, {}) }),
+    /* @__PURE__ */ jsx(Text, { size: "lg", fw: 700, ta: "center", children: t("terminal.notAvailable") }),
+    /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", ta: "center", children: t("terminal.notAvailableMessage") }),
+    /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", ta: "center", children: t("terminal.dockerRequired") })
+  ] }) });
+};
+var TerminalNotSupported_default = TerminalNotSupported;
+var TerminalApp = ({ window: window2, notifyReady }) => {
+  const win = window2;
+  const windowId = win?.id ?? "";
+  const runtime = getRuntime();
+  const scrollback = useScrollback(windowId);
+  const storedShell = useShell(windowId);
+  const { setScrollback, setShell, reset } = useTerminalStore();
+  const terminalActionsRef = useRef(null);
+  const hasNotifiedRef = useRef(false);
+  const hasFetchedShellRef = useRef(false);
+  const [connectionStatus, setConnectionStatus] = useState("idle");
+  const [shellInfo, setShellInfo] = useState(null);
+  useEffect(() => {
+    if (runtime !== "docker" || hasFetchedShellRef.current) return;
+    hasFetchedShellRef.current = true;
+    const fetchShellInfo = async () => {
+      try {
+        const response = await fetch("/api/shell");
+        if (response.ok) {
+          const info = await response.json();
+          setShellInfo(info);
+          if (!storedShell || storedShell === "/bin/zsh") {
+            setShell(windowId, info.default);
+          }
+        }
+      } catch (err) {
+        console.error("[TerminalApp] Failed to fetch shell info:", err);
+        if (!storedShell) {
+          setShell(windowId, "/bin/zsh");
+        }
+      }
+    };
+    fetchShellInfo();
+  }, [runtime, storedShell, setShell, windowId]);
+  useEffect(() => {
+    reset(windowId);
+  }, [windowId, reset]);
+  const handleTerminalReady = useCallback((actions) => {
+    terminalActionsRef.current = actions;
+  }, []);
+  const handleConnectionChange = useCallback((status) => {
+    setConnectionStatus(status);
+  }, []);
+  useEffect(() => {
+    if (!hasNotifiedRef.current && notifyReady) {
+      hasNotifiedRef.current = true;
+      notifyReady({
+        ...win?.contentData ?? {},
+        clear: () => terminalActionsRef.current?.clear(),
+        reset: () => terminalActionsRef.current?.reset(),
+        copy: () => terminalActionsRef.current?.copy(),
+        paste: () => terminalActionsRef.current?.paste(),
+        reconnect: () => terminalActionsRef.current?.reconnect(),
+        setScrollback: (value) => setScrollback(windowId, value),
+        setShell: (value) => setShell(windowId, value),
+        connectionStatus
+      });
+    }
+  }, [notifyReady, setScrollback, setShell, windowId, win?.contentData, connectionStatus]);
+  useEffect(() => {
+    if (hasNotifiedRef.current && notifyReady) {
+      notifyReady({
+        ...win?.contentData ?? {},
+        connectionStatus
+      });
+    }
+  }, [connectionStatus, notifyReady, win?.contentData]);
+  if (runtime !== "docker") {
+    return /* @__PURE__ */ jsx(TerminalNotSupported_default, {});
+  }
+  const activeShell = storedShell || shellInfo?.default || "/bin/zsh";
+  return /* @__PURE__ */ jsx(
+    XTermTerminal_default,
+    {
+      shell: activeShell,
+      scrollback,
+      onTerminalReady: handleTerminalReady,
+      onConnectionChange: handleConnectionChange
+    }
+  );
+};
+var TerminalApp_default = TerminalApp;
+
+export { TerminalApp_default };

package/dist/chunk-54PYEQLK.js

@@ -0,0 +1,283 @@
+import { useOpenApp } from './chunk-PYTKNRGM.js';
+import { FileIcon_default } from './chunk-EAELL43F.js';
+import { useDesktopStore, generateUUID, getAppIdForMime, sortNodesByMode } from './chunk-NWMSWRUD.js';
+import { Breadcrumbs, Text, Anchor, UnstyledButton } from './chunk-BQL3YXMV.js';
+import { useCallback, useState, useEffect } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+var useNotifications = () => {
+  const notifications = useDesktopStore((state) => state.notifications);
+  const addNotification = useDesktopStore((state) => state.addNotification);
+  const removeNotification = useDesktopStore((state) => state.removeNotification);
+  const notify = useCallback(
+    (title, message, options) => {
+      const item = {
+        id: generateUUID(),
+        title,
+        message,
+        fcIcon: options?.fcIcon,
+        onClose: options?.onClose
+      };
+      addNotification(item);
+      return item.id;
+    },
+    [addNotification]
+  );
+  const dismiss = useCallback(
+    (id) => {
+      removeNotification(id);
+    },
+    [removeNotification]
+  );
+  return {
+    notifications,
+    notify,
+    dismiss,
+    addNotification,
+    removeNotification
+  };
+};
+
+// src/components/Apps/FilesApp/components/FolderTree.module.css
+var FolderTree_default = {};
+var FolderTreeItem = ({
+  node,
+  allNodes,
+  currentFolderId,
+  depth,
+  onNavigate
+}) => {
+  const children = allNodes.filter(
+    (n) => n.parentId === node.id && n.type === "folder"
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(
+      UnstyledButton,
+      {
+        className: FolderTree_default.item,
+        "data-active": currentFolderId === node.id || void 0,
+        style: { paddingLeft: 8 + depth * 14 },
+        onClick: () => onNavigate(node.id),
+        "aria-label": node.name,
+        "aria-current": currentFolderId === node.id ? "page" : void 0,
+        children: [
+          /* @__PURE__ */ jsx(FileIcon_default, { type: "folder", folderNode: node, size: 14 }),
+          /* @__PURE__ */ jsx(Text, { size: "xs", ml: 6, truncate: true, children: node.name })
+        ]
+      }
+    ),
+    children.map((child) => /* @__PURE__ */ jsx(
+      FolderTreeItem,
+      {
+        node: child,
+        allNodes,
+        currentFolderId,
+        depth: depth + 1,
+        onNavigate
+      },
+      child.id
+    ))
+  ] });
+};
+var FolderTree = ({ allNodes, currentFolderId, onNavigate }) => {
+  const rootFolders = allNodes.filter(
+    (n) => n.parentId === null && n.type === "folder"
+  );
+  return /* @__PURE__ */ jsxs("nav", { className: FolderTree_default.root, "aria-label": "Folder tree", children: [
+    /* @__PURE__ */ jsxs(
+      UnstyledButton,
+      {
+        className: FolderTree_default.item,
+        "data-active": currentFolderId === null || void 0,
+        style: { paddingLeft: 8 },
+        onClick: () => onNavigate(null),
+        "aria-label": "Home",
+        "aria-current": currentFolderId === null ? "page" : void 0,
+        children: [
+          /* @__PURE__ */ jsx(FileIcon_default, { type: "folder", size: 14 }),
+          /* @__PURE__ */ jsx(Text, { size: "xs", ml: 6, fw: 500, children: "Home" })
+        ]
+      }
+    ),
+    rootFolders.map((folder) => /* @__PURE__ */ jsx(
+      FolderTreeItem,
+      {
+        node: folder,
+        allNodes,
+        currentFolderId,
+        depth: 1,
+        onNavigate
+      },
+      folder.id
+    ))
+  ] });
+};
+var FolderTree_default2 = FolderTree;
+
+// src/components/Apps/FilesApp/components/FileList.module.css
+var FileList_default = {};
+var FileListItem = ({ node, onNavigate, onOpenFile, onContextMenu }) => {
+  const handleDoubleClick = () => {
+    if (node.type === "folder") {
+      onNavigate(node.id);
+    } else {
+      onOpenFile(node);
+    }
+  };
+  const label = node.type === "folder" ? `Open folder ${node.name}` : `Open file ${node.name}`;
+  return /* @__PURE__ */ jsxs(
+    UnstyledButton,
+    {
+      className: FileList_default.item,
+      onDoubleClick: handleDoubleClick,
+      onContextMenu: (e) => onContextMenu(e, node.id),
+      "aria-label": label,
+      role: "option",
+      children: [
+        /* @__PURE__ */ jsx("div", { className: FileList_default.icon, children: /* @__PURE__ */ jsx(
+          FileIcon_default,
+          {
+            type: node.type,
+            name: node.name,
+            folderNode: node.type === "folder" ? node : void 0,
+            size: 32
+          }
+        ) }),
+        /* @__PURE__ */ jsx(Text, { size: "xs", className: FileList_default.name, truncate: true, children: node.name })
+      ]
+    }
+  );
+};
+var FileList = ({ nodes, onNavigate, onOpenFile, onNodeContextMenu }) => {
+  const filesSortMode = useDesktopStore((state) => state.filesSortMode);
+  if (nodes.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: FileList_default.empty, children: /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: "This folder is empty" }) });
+  }
+  const sorted = sortNodesByMode(nodes, filesSortMode);
+  return /* @__PURE__ */ jsx("div", { className: FileList_default.grid, role: "listbox", "aria-label": "Files", children: sorted.map((node) => /* @__PURE__ */ jsx(
+    FileListItem,
+    {
+      node,
+      onNavigate,
+      onOpenFile,
+      onContextMenu: onNodeContextMenu
+    },
+    node.id
+  )) });
+};
+var FileList_default2 = FileList;
+
+// src/components/Apps/FilesApp/FilesApp.module.css
+var FilesApp_default = {};
+var FilesApp = ({ window }) => {
+  const win = window;
+  const initialFolderId = win?.contentData?.initialFolderId;
+  const fsNodes = useDesktopStore((state) => state.fsNodes);
+  const openContextMenu = useDesktopStore((state) => state.openContextMenu);
+  const setFilesCurrentFolderId = useDesktopStore((state) => state.setFilesCurrentFolderId);
+  const openApp = useOpenApp();
+  const { notify } = useNotifications();
+  const [currentFolderId, setCurrentFolderIdLocal] = useState(
+    initialFolderId ?? null
+  );
+  const setCurrentFolderId = useCallback(
+    (id) => {
+      setCurrentFolderIdLocal(id);
+      setFilesCurrentFolderId(id);
+    },
+    [setFilesCurrentFolderId]
+  );
+  useEffect(() => {
+    setFilesCurrentFolderId(initialFolderId ?? null);
+  }, [initialFolderId, setFilesCurrentFolderId]);
+  const currentNodes = currentFolderId === null ? fsNodes.filter((n) => n.parentId === null) : fsNodes.filter((n) => n.parentId === currentFolderId);
+  const buildBreadcrumbs = () => {
+    const crumbs2 = [{ id: null, name: "Home" }];
+    let id = currentFolderId;
+    const trail = [];
+    while (id !== null) {
+      const node = fsNodes.find((n) => n.id === id);
+      if (!node) break;
+      trail.unshift({ id: node.id, name: node.name });
+      id = node.parentId;
+    }
+    return [...crumbs2, ...trail];
+  };
+  const handleContextMenu = useCallback(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      openContextMenu(e.clientX, e.clientY, "files");
+    },
+    [openContextMenu]
+  );
+  const handleNodeContextMenu = useCallback(
+    (e, nodeId) => {
+      e.preventDefault();
+      e.stopPropagation();
+      openContextMenu(e.clientX, e.clientY, "files", nodeId);
+    },
+    [openContextMenu]
+  );
+  const handleOpenFile = useCallback(
+    (node) => {
+      try {
+        const result = getAppIdForMime(node);
+        if (result) {
+          openApp(result.appId, { contentData: result.contentData });
+        } else {
+          const mimeType = node.mimeType || "unknown";
+          console.warn(`[FilesApp] Unsupported file type: ${node.name} (${mimeType})`);
+          notify(
+            "Unsupported file type",
+            `Cannot open "${node.name}". File type "${mimeType}" is not supported.`,
+            { fcIcon: "FcDeleteRow" }
+          );
+        }
+      } catch (error) {
+        console.error("[FilesApp] Error opening file:", error);
+        notify("Error opening file", `An unexpected error occurred while opening "${node.name}".`, {
+          fcIcon: "FcHighPriority"
+        });
+      }
+    },
+    [openApp, notify]
+  );
+  const crumbs = buildBreadcrumbs();
+  return /* @__PURE__ */ jsxs("div", { className: FilesApp_default.root, onContextMenu: handleContextMenu, children: [
+    /* @__PURE__ */ jsx("div", { className: FilesApp_default.breadcrumbBar, children: /* @__PURE__ */ jsx(Breadcrumbs, { separator: "\u203A", classNames: { separator: FilesApp_default.breadcrumbSep }, children: crumbs.map((crumb, i) => {
+      const isLast = i === crumbs.length - 1;
+      return isLast ? /* @__PURE__ */ jsx(Text, { size: "xs", fw: 500, children: crumb.name }, crumb.id ?? "root") : /* @__PURE__ */ jsx(
+        Anchor,
+        {
+          size: "xs",
+          onClick: () => setCurrentFolderId(crumb.id),
+          children: crumb.name
+        },
+        crumb.id ?? "root"
+      );
+    }) }) }),
+    /* @__PURE__ */ jsxs("div", { className: FilesApp_default.body, children: [
+      /* @__PURE__ */ jsx("aside", { className: FilesApp_default.sidebar, children: /* @__PURE__ */ jsx(
+        FolderTree_default2,
+        {
+          allNodes: fsNodes,
+          currentFolderId,
+          onNavigate: setCurrentFolderId
+        }
+      ) }),
+      /* @__PURE__ */ jsx("main", { className: FilesApp_default.content, children: /* @__PURE__ */ jsx(
+        FileList_default2,
+        {
+          nodes: currentNodes,
+          onNavigate: setCurrentFolderId,
+          onOpenFile: handleOpenFile,
+          onNodeContextMenu: handleNodeContextMenu
+        }
+      ) })
+    ] })
+  ] });
+};
+var FilesApp_default2 = FilesApp;
+
+export { FilesApp_default2 as FilesApp_default, useNotifications };