@fde-desktop/fde-core 0.3.8 → 0.4.2

package/dist/chunk-YAIWI4Z5.js

@@ -0,0 +1,7 @@
+// src/hooks/useMenuBarUtils.ts
+function appendDirtyIndicator(items, isDirty) {
+  if (!isDirty) return items;
+  return [...items, { type: "dirty-indicator" }];
+}
+
+export { appendDirtyIndicator };

package/dist/chunk-YP2PLNOF.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var zustand = require('zustand');
+
+// src/stores/factories/createWindowStateStore.ts
+function createDirtyStateStore() {
+  const DEFAULT_STATE = { isDirty: false };
+  return zustand.create((set, get) => ({
+    states: {},
+    getIsDirty: (windowId) => get().states[windowId]?.isDirty ?? false,
+    setIsDirty: (windowId, isDirty) => {
+      const currentIsDirty = get().states[windowId]?.isDirty ?? false;
+      if (currentIsDirty === isDirty) return;
+      set((s) => ({
+        states: {
+          ...s.states,
+          [windowId]: { ...s.states[windowId] ?? DEFAULT_STATE, isDirty }
+        }
+      }));
+    },
+    reset: (windowId) => {
+      set((s) => ({
+        states: { ...s.states, [windowId]: DEFAULT_STATE }
+      }));
+    }
+  }));
+}
+
+// src/components/Apps/SettingsApp/settingsAppStore.ts
+var useSettingsAppStore = createDirtyStateStore();
+var useIsDirty = (windowId) => useSettingsAppStore((s) => s.states[windowId]?.isDirty ?? false);
+
+exports.useIsDirty = useIsDirty;
+exports.useSettingsAppStore = useSettingsAppStore;

package/dist/chunk-YSOLW4FS.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var chunk7Y7HB7FB_cjs = require('./chunk-7Y7HB7FB.cjs');
+
+// src/components/Shared/VscIcon.tsx
+var VscIcon = ({ name, size = 20, color }) => {
+  return chunk7Y7HB7FB_cjs.useVscIconElement(name, { size, color }) ?? null;
+};
+var VscIcon_default = VscIcon;
+
+exports.VscIcon_default = VscIcon_default;

package/dist/chunk-YY6OUR2U.js

@@ -0,0 +1,44 @@
+import { useState, useEffect, createElement } from 'react';
+
+// src/hooks/useDynamicIcon.ts
+var useDynamicIcon = (name, library) => {
+  const [Icon, setIcon] = useState(null);
+  useEffect(() => {
+    if (!name || typeof window === "undefined") return;
+    let cancelled = false;
+    const loadIcon = async () => {
+      try {
+        let mod;
+        if (library === "fi") {
+          mod = await import('react-icons/fi');
+        } else if (library === "vsc") {
+          mod = await import('react-icons/vsc');
+        } else {
+          mod = await import('react-icons/fc');
+        }
+        if (!cancelled) {
+          setIcon(() => mod[name] ?? null);
+        }
+      } catch {
+      }
+    };
+    loadIcon();
+    return () => {
+      cancelled = true;
+    };
+  }, [name, library]);
+  return Icon;
+};
+var useDynamicIconElement = (name, library, props) => {
+  const Icon = useDynamicIcon(name, library);
+  if (!Icon) return null;
+  return createElement(Icon, props);
+};
+var useFiIcon = (name) => useDynamicIcon(name, "fi");
+var useFcIcon = (name) => useDynamicIcon(name, "fc");
+var useVscIcon = (name) => useDynamicIcon(name, "vsc");
+var useFiIconElement = (name, props) => useDynamicIconElement(name, "fi", props);
+var useFcIconElement = (name, props) => useDynamicIconElement(name, "fc", props);
+var useVscIconElement = (name, props) => useDynamicIconElement(name, "vsc", props);
+
+export { useDynamicIcon, useDynamicIconElement, useFcIcon, useFcIconElement, useFiIcon, useFiIconElement, useVscIcon, useVscIconElement };

package/dist/chunk-YZWS7FDT.cjs

@@ -0,0 +1,409 @@
+'use strict';
+
+var chunk5C6IQE42_cjs = require('./chunk-5C6IQE42.cjs');
+var chunkZ5YGWL65_cjs = require('./chunk-Z5YGWL65.cjs');
+var chunkE55VXNLK_cjs = require('./chunk-E55VXNLK.cjs');
+var react = require('react');
+var xterm = require('@xterm/xterm');
+var addonFit = require('@xterm/addon-fit');
+var addonClipboard = require('@xterm/addon-clipboard');
+require('@xterm/xterm/css/xterm.css');
+var jsxRuntime = require('react/jsx-runtime');
+var fc = require('react-icons/fc');
+var reactI18next = require('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 = react.useRef(null);
+  const terminalRef = react.useRef(null);
+  const fitAddonRef = react.useRef(null);
+  const clipboardAddonRef = react.useRef(null);
+  const wsRef = react.useRef(null);
+  const retryCountRef = react.useRef(0);
+  const mountedRef = react.useRef(false);
+  const connectingRef = react.useRef(false);
+  const shellRef = react.useRef(shell);
+  const abortControllerRef = react.useRef(null);
+  const initializedRef = react.useRef(false);
+  const [status, setStatus] = react.useState("idle");
+  const [canReconnect, setCanReconnect] = react.useState(false);
+  const onTerminalReadyRef = react.useRef(onTerminalReady);
+  const onConnectionChangeRef = react.useRef(onConnectionChange);
+  react.useEffect(() => {
+    onTerminalReadyRef.current = onTerminalReady;
+  }, [onTerminalReady]);
+  react.useEffect(() => {
+    onConnectionChangeRef.current = onConnectionChange;
+  }, [onConnectionChange]);
+  react.useEffect(() => {
+    shellRef.current = shell;
+  }, [shell]);
+  const updateStatus = react.useCallback((newStatus) => {
+    if (!mountedRef.current) return;
+    setStatus(newStatus);
+    onConnectionChangeRef.current?.(newStatus);
+  }, []);
+  const disconnect = react.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 = react.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]);
+  react.useEffect(() => {
+    if (initializedRef.current) return void 0;
+    initializedRef.current = true;
+    mountedRef.current = true;
+    if (!containerRef.current) return void 0;
+    const terminal = new xterm.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 addonFit.FitAddon();
+    const clipboardAddon = new addonClipboard.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 = react.useCallback(() => {
+    console.log("[XTermTerminal] Reconnect triggered");
+    retryCountRef.current = 0;
+    setCanReconnect(false);
+    disconnect();
+    setTimeout(() => connect(), 100);
+  }, [disconnect, connect]);
+  react.useEffect(() => {
+    if (terminalRef.current) {
+      terminalRef.current.options.scrollback = scrollback;
+    }
+  }, [scrollback]);
+  react.useEffect(() => {
+    if (!containerRef.current) return void 0;
+    const observer = new ResizeObserver(() => {
+      fitAddonRef.current?.fit();
+    });
+    observer.observe(containerRef.current);
+    return () => observer.disconnect();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: Terminal_default.terminalContainer, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: Terminal_default.terminalWrapper, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: Terminal_default.terminal, "data-testid": "xterm-terminal" }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: Terminal_default.statusBar, children: [
+      /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs("span", { className: Terminal_default.statusText, children: [
+        status === "idle" && "Idle",
+        status === "connecting" && "Connecting...",
+        status === "connected" && "Connected",
+        status === "disconnected" && "Disconnected",
+        status === "error" && "Error"
+      ] }),
+      canReconnect && /* @__PURE__ */ jsxRuntime.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 } = reactI18next.useTranslation("apps");
+  return /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Center, { "data-testid": "terminal-not-supported", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { align: "center", gap: "lg", p: "xl", maw: 400, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "3rem", children: /* @__PURE__ */ jsxRuntime.jsx(fc.FcInfo, {}) }),
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "lg", fw: 700, ta: "center", children: t("terminal.notAvailable") }),
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", c: "dimmed", ta: "center", children: t("terminal.notAvailableMessage") }),
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.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 = chunkZ5YGWL65_cjs.getRuntime();
+  const scrollback = chunk5C6IQE42_cjs.useScrollback(windowId);
+  const storedShell = chunk5C6IQE42_cjs.useShell(windowId);
+  const { setScrollback, setShell, reset } = chunk5C6IQE42_cjs.useTerminalStore();
+  const terminalActionsRef = react.useRef(null);
+  const hasNotifiedRef = react.useRef(false);
+  const hasFetchedShellRef = react.useRef(false);
+  const [connectionStatus, setConnectionStatus] = react.useState("idle");
+  const [shellInfo, setShellInfo] = react.useState(null);
+  react.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]);
+  react.useEffect(() => {
+    reset(windowId);
+  }, [windowId, reset]);
+  const handleTerminalReady = react.useCallback((actions) => {
+    terminalActionsRef.current = actions;
+  }, []);
+  const handleConnectionChange = react.useCallback((status) => {
+    setConnectionStatus(status);
+  }, []);
+  react.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]);
+  react.useEffect(() => {
+    if (hasNotifiedRef.current && notifyReady) {
+      notifyReady({
+        ...win?.contentData ?? {},
+        connectionStatus
+      });
+    }
+  }, [connectionStatus, notifyReady, win?.contentData]);
+  if (runtime !== "docker") {
+    return /* @__PURE__ */ jsxRuntime.jsx(TerminalNotSupported_default, {});
+  }
+  const activeShell = storedShell || shellInfo?.default || "/bin/zsh";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    XTermTerminal_default,
+    {
+      shell: activeShell,
+      scrollback,
+      onTerminalReady: handleTerminalReady,
+      onConnectionChange: handleConnectionChange
+    }
+  );
+};
+var TerminalApp_default = TerminalApp;
+
+exports.TerminalApp_default = TerminalApp_default;

package/dist/chunk-Z5YGWL65.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+// src/utils/getRuntime.ts
+function getRuntime() {
+  if (typeof window === "undefined") {
+    return "browser";
+  }
+  if (window.__FDE_IN_DOCKER__ === true) {
+    return "docker";
+  }
+  if (typeof navigator !== "undefined" && /Electron/i.test(navigator.userAgent)) {
+    return "electron";
+  }
+  return "browser";
+}
+function isDocker() {
+  return getRuntime() === "docker";
+}
+function isElectron() {
+  return getRuntime() === "electron";
+}
+function isBrowser() {
+  return getRuntime() === "browser";
+}
+function isDev() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  if (window.__IS_DEV__ === true) {
+    return true;
+  }
+  return window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1";
+}
+
+exports.getRuntime = getRuntime;
+exports.isBrowser = isBrowser;
+exports.isDev = isDev;
+exports.isDocker = isDocker;
+exports.isElectron = isElectron;

package/dist/chunk-ZBGWYTCU.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var chunk6QOUYSEE_cjs = require('./chunk-6QOUYSEE.cjs');
+var zustand = require('zustand');
+var react = require('react');
+
+var useCloseModalStore = zustand.create()((set) => ({
+  isOpen: false,
+  windowId: null,
+  onSave: null,
+  onDiscard: null,
+  openModal: (windowId, onSave, onDiscard) => set({
+    isOpen: true,
+    windowId,
+    onSave,
+    onDiscard
+  }),
+  closeModal: () => set({ isOpen: false, windowId: null, onSave: null, onDiscard: null })
+}));
+var closeInterceptors = /* @__PURE__ */ new Map();
+var registerCloseInterceptor = (windowId, interceptor) => {
+  closeInterceptors.set(windowId, interceptor);
+};
+var unregisterCloseInterceptor = (windowId) => {
+  closeInterceptors.delete(windowId);
+};
+var getCloseInterceptor = (windowId) => {
+  return closeInterceptors.get(windowId);
+};
+function useCloseInterceptor({
+  isDirtyGetter,
+  windowId,
+  onDiscard,
+  onSave
+}) {
+  const windows = chunk6QOUYSEE_cjs.useDesktopStore((state) => state.windows);
+  const closeWindow = chunk6QOUYSEE_cjs.useDesktopStore((state) => state.closeWindow);
+  const openModal = useCloseModalStore((state) => state.openModal);
+  const activeWindowId = windowId ?? windows.find((w) => w.isOpen)?.id;
+  const isDirtyGetterRef = react.useRef(isDirtyGetter);
+  const isActiveRef = react.useRef(false);
+  const onDiscardRef = react.useRef(onDiscard);
+  const onSaveRef = react.useRef(onSave);
+  react.useEffect(() => {
+    isDirtyGetterRef.current = isDirtyGetter;
+    onDiscardRef.current = onDiscard;
+    onSaveRef.current = onSave;
+  }, [isDirtyGetter, onDiscard, onSave]);
+  const handleDiscard = react.useCallback(() => {
+    if (!activeWindowId) return;
+    onDiscardRef.current?.();
+    closeWindow(activeWindowId);
+  }, [activeWindowId, closeWindow]);
+  const handleSave = react.useCallback(() => {
+    if (!activeWindowId) return;
+    onSaveRef.current?.();
+    closeWindow(activeWindowId);
+  }, [activeWindowId, closeWindow]);
+  react.useEffect(() => {
+    if (!activeWindowId) return;
+    isActiveRef.current = true;
+    const closeInterceptor = () => {
+      if (!isActiveRef.current) return true;
+      const isDirty = isDirtyGetterRef.current();
+      if (isDirty) {
+        openModal(activeWindowId, handleSave, handleDiscard);
+        return false;
+      }
+      return true;
+    };
+    registerCloseInterceptor(activeWindowId, closeInterceptor);
+    return () => {
+      isActiveRef.current = false;
+      unregisterCloseInterceptor(activeWindowId);
+    };
+  }, [activeWindowId, openModal, handleSave, handleDiscard]);
+}
+
+exports.getCloseInterceptor = getCloseInterceptor;
+exports.registerCloseInterceptor = registerCloseInterceptor;
+exports.unregisterCloseInterceptor = unregisterCloseInterceptor;
+exports.useCloseInterceptor = useCloseInterceptor;
+exports.useCloseModalStore = useCloseModalStore;

package/dist/chunk-ZHB5Q2M6.js

@@ -0,0 +1,36 @@
+import { BREAKPOINTS } from './chunk-NWMSWRUD.js';
+import { useState, useCallback, useEffect } from 'react';
+
+var DIMENSIONS = {
+  mobile: { defaultWidth: 300, defaultHeight: 500, minWidth: 280, minHeight: 400 },
+  tablet: { defaultWidth: 600, defaultHeight: 450, minWidth: 400, minHeight: 350 },
+  desktop: { defaultWidth: 800, defaultHeight: 600, minWidth: 640, minHeight: 480 },
+  largeDesktop: { defaultWidth: 1e3, defaultHeight: 700, minWidth: 800, minHeight: 600 }
+};
+var LARGE_DESKTOP = 1440;
+var getAdaptiveDimensions = () => {
+  const width = window.innerWidth;
+  if (width < BREAKPOINTS.MOBILE) {
+    return DIMENSIONS.mobile;
+  }
+  if (width < BREAKPOINTS.TABLET) {
+    return DIMENSIONS.tablet;
+  }
+  if (width < LARGE_DESKTOP) {
+    return DIMENSIONS.desktop;
+  }
+  return DIMENSIONS.largeDesktop;
+};
+function useAdaptiveDimensions() {
+  const [dimensions, setDimensions] = useState(() => getAdaptiveDimensions());
+  const updateDimensions = useCallback(() => {
+    setDimensions(getAdaptiveDimensions());
+  }, []);
+  useEffect(() => {
+    window.addEventListener("resize", updateDimensions);
+    return () => window.removeEventListener("resize", updateDimensions);
+  }, [updateDimensions]);
+  return dimensions;
+}
+
+export { useAdaptiveDimensions };