@fde-desktop/fde-core 0.3.8 → 0.4.2

package/dist/chunk-C6BEZNAM.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var chunkSBE4SZAN_cjs = require('./chunk-SBE4SZAN.cjs');
+var react = require('react');
+var reactI18next = require('react-i18next');
+var jsxRuntime = require('react/jsx-runtime');
+
+var usePdfMenuBarElements = (options) => {
+  const { contentData, onExit } = options;
+  const { t } = reactI18next.useTranslation("common");
+  const setPickerOpen = contentData?.setPickerOpen;
+  return react.useMemo(() => {
+    return [
+      {
+        type: "menu",
+        label: t("menu.file"),
+        items: [
+          {
+            type: "item",
+            label: t("actions.open"),
+            icon: "FcOpenedFolder",
+            onClick: () => setPickerOpen?.()
+          },
+          { type: "divider" },
+          {
+            type: "item",
+            label: t("actions.exit"),
+            icon: "FcLeft",
+            onClick: onExit
+          }
+        ]
+      }
+    ];
+  }, [t, setPickerOpen, onExit]);
+};
+var PdfMenuBar = react.memo(({ windowId, contentData, onExit }) => {
+  const elements = usePdfMenuBarElements({
+    contentData,
+    onExit
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(chunkSBE4SZAN_cjs.AppMenuBar_default, { elements });
+});
+PdfMenuBar.displayName = "PdfMenuBar";
+
+exports.PdfMenuBar = PdfMenuBar;

package/dist/chunk-CFWV2JMR.js

@@ -0,0 +1,234 @@
+import { useOpenApp } from './chunk-PYTKNRGM.js';
+import { DownloadProgress_default } from './chunk-HWHBSAUC.js';
+import { FolderPickerModal } from './chunk-4MCFQPKY.js';
+import { useDesktopStore, fileSystem, getAppIdForMime } from './chunk-NWMSWRUD.js';
+import { useFcIconElement } from './chunk-YY6OUR2U.js';
+import { Paper, Box, Text, Group, Button, Stepper, FileButton } from './chunk-BQL3YXMV.js';
+import { useState, useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/utils/formatBytes.ts
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const index = Math.min(i, sizes.length - 1);
+  return `${parseFloat((bytes / Math.pow(k, index)).toFixed(1))} ${sizes[index]}`;
+}
+
+// src/components/Apps/UploaderApp/UploaderApp.module.css
+var UploaderApp_default = {};
+var UploaderApp = ({ window: win }) => {
+  const { t } = useTranslation("apps");
+  const createFile = useDesktopStore((state) => state.createFile);
+  const openApp = useOpenApp();
+  const [activeStep, setActiveStep] = useState(0);
+  const [file, setFile] = useState(null);
+  const [selectedFolderId, setSelectedFolderId] = useState(null);
+  const [folderSelected, setFolderSelected] = useState(false);
+  const [pickerOpen, setPickerOpen] = useState(false);
+  const [uploadStarted, setUploadStarted] = useState(false);
+  const [uploadState, setUploadState] = useState({
+    status: "idle",
+    progress: { status: "idle", loaded: 0, total: null, percent: null, error: null }
+  });
+  const [createdFileId, setCreatedFileId] = useState(null);
+  const uploadIcon = useFcIconElement("FcUpload", { size: 120 });
+  const checkIconLg = useFcIconElement("FcCheckmark", { size: 64 });
+  const checkIconSm = useFcIconElement("FcCheckmark", { size: 14 });
+  const infoIcon = useFcIconElement("FcInfo", { size: 64 });
+  const handleFileChange = useCallback((selectedFile) => {
+    if (selectedFile) {
+      setFile(selectedFile);
+      setActiveStep(1);
+    }
+  }, []);
+  const handleFolderSelect = useCallback((folderId) => {
+    setSelectedFolderId(folderId);
+    setFolderSelected(true);
+    setPickerOpen(false);
+    setActiveStep(2);
+  }, []);
+  const handleUpload = useCallback(async () => {
+    if (!file) return;
+    console.log("[UploaderApp] Starting upload for file:", file.name, "size:", file.size);
+    setUploadStarted(true);
+    setUploadState({
+      status: "reading",
+      progress: { status: "downloading", loaded: 0, total: file.size, percent: 0, error: null }
+    });
+    try {
+      setUploadState((prev) => ({
+        ...prev,
+        progress: {
+          status: "downloading",
+          loaded: 0,
+          total: file.size,
+          percent: 0,
+          error: null
+        }
+      }));
+      for (let i = 0; i <= 50; i += 10) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        setUploadState((prev) => ({
+          ...prev,
+          progress: {
+            status: "downloading",
+            loaded: Math.floor(file.size * i / 100),
+            total: file.size,
+            percent: i,
+            error: null
+          }
+        }));
+      }
+      console.log("[UploaderApp] Calling saveBlob...");
+      const saveBlobStart = Date.now();
+      const idbUrl = await fileSystem.saveBlob(file);
+      console.log(
+        "[UploaderApp] saveBlob completed in",
+        Date.now() - saveBlobStart,
+        "ms, url:",
+        idbUrl
+      );
+      setUploadState((prev) => ({
+        ...prev,
+        progress: {
+          status: "downloading",
+          loaded: Math.floor(file.size * 80 / 100),
+          total: file.size,
+          percent: 80,
+          error: null
+        }
+      }));
+      console.log("[UploaderApp] Calling createFile with folderId:", selectedFolderId);
+      const createStart = Date.now();
+      const createdFile = await createFile(file.name, "", selectedFolderId, idbUrl);
+      console.log(
+        "[UploaderApp] createFile completed in",
+        Date.now() - createStart,
+        "ms, id:",
+        createdFile.id
+      );
+      setCreatedFileId(createdFile.id);
+      setUploadState({
+        status: "done",
+        progress: {
+          status: "done",
+          loaded: file.size,
+          total: file.size,
+          percent: 100,
+          error: null
+        }
+      });
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      setActiveStep(3);
+    } catch (err) {
+      console.error("[UploaderApp] Upload FAILED:", err);
+      setUploadState((prev) => ({
+        ...prev,
+        status: "error",
+        error: err instanceof Error ? err.message : "Upload failed"
+      }));
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      setActiveStep(3);
+    }
+  }, [file, selectedFolderId, createFile]);
+  const handleShowFile = useCallback(() => {
+    if (!selectedFolderId) {
+      openApp("files");
+    } else {
+      openApp("files", { contentData: { initialFolderId: selectedFolderId } });
+    }
+  }, [selectedFolderId, openApp]);
+  const handleOpenFile = useCallback(() => {
+    if (!createdFileId) return;
+    const createdNode = useDesktopStore.getState().fsNodes.find((n) => n.id === createdFileId);
+    if (!createdNode || createdNode.type !== "file") return;
+    const fileNode = createdNode;
+    const result = getAppIdForMime(fileNode);
+    if (result) {
+      openApp(result.appId, { contentData: result.contentData });
+    }
+  }, [createdFileId, openApp]);
+  if (!win) return null;
+  const isSuccess = uploadState.status === "done";
+  const errorMessage = uploadState.error;
+  if (activeStep === 3) {
+    return /* @__PURE__ */ jsx("div", { className: UploaderApp_default.container, children: /* @__PURE__ */ jsxs(Paper, { shadow: "sm", className: UploaderApp_default.resultPaper, children: [
+      /* @__PURE__ */ jsx(Box, { className: UploaderApp_default.resultIcon, children: isSuccess ? checkIconLg : infoIcon }),
+      /* @__PURE__ */ jsx(Text, { size: "lg", fw: 500, ta: "center", children: isSuccess ? t("uploader.uploadComplete") : `${t("uploader.uploadFailed")}: ${errorMessage}` }),
+      isSuccess && /* @__PURE__ */ jsxs(Group, { mt: "md", justify: "center", children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "default",
+            size: "sm",
+            onClick: handleShowFile,
+            "data-testid": "uploader-show-file",
+            children: t("uploader.showFile")
+          }
+        ),
+        /* @__PURE__ */ jsx(Button, { size: "sm", onClick: handleOpenFile, "data-testid": "uploader-open-file", children: t("uploader.openFile") })
+      ] })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: UploaderApp_default.container, children: [
+    uploadIcon && /* @__PURE__ */ jsx("div", { className: UploaderApp_default.backgroundIcon, children: uploadIcon }),
+    /* @__PURE__ */ jsxs(Stepper, { active: activeStep, orientation: "horizontal", size: "sm", className: UploaderApp_default.stepper, children: [
+      /* @__PURE__ */ jsx(Stepper.Step, { label: t("uploader.stepSelect"), description: t("uploader.clickToUpload"), children: /* @__PURE__ */ jsx(FileButton, { accept: "*", onChange: handleFileChange, children: (props) => /* @__PURE__ */ jsx(Button, { ...props, size: "sm", "data-testid": "uploader-select-file", children: t("uploader.clickToUpload") }) }) }),
+      /* @__PURE__ */ jsxs(
+        Stepper.Step,
+        {
+          label: t("uploader.stepDestination"),
+          description: folderSelected ? /* @__PURE__ */ jsxs(Group, { gap: 4, align: "center", style: { display: "inline-flex" }, children: [
+            checkIconSm,
+            /* @__PURE__ */ jsx("span", { children: t("uploader.folderSelected") })
+          ] }) : t("uploader.selectDestination"),
+          children: [
+            file && /* @__PURE__ */ jsxs(Box, { className: UploaderApp_default.fileInfo, children: [
+              /* @__PURE__ */ jsx(Text, { size: "sm", fw: 500, children: file.name }),
+              /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: formatBytes(file.size) })
+            ] }),
+            /* @__PURE__ */ jsxs(Group, { mt: "md", children: [
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  variant: "default",
+                  size: "xs",
+                  onClick: () => setPickerOpen(true),
+                  "data-testid": "uploader-select-folder",
+                  children: t("uploader.selectDestination")
+                }
+              ),
+              /* @__PURE__ */ jsx(Button, { size: "xs", onClick: () => setActiveStep(2), "data-testid": "uploader-skip-folder", children: t("uploader.next", { defaultValue: "Next" }) })
+            ] }),
+            /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", mt: "xs", children: selectedFolderId ? `${t("uploader.uploadTo")}: ${useDesktopStore.getState().fsNodes.find((n) => n.id === selectedFolderId)?.name || ""}` : t("uploader.uploadToRoot") })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(Stepper.Step, { label: t("uploader.stepUpload"), description: t("uploader.uploading"), children: !uploadStarted ? /* @__PURE__ */ jsxs(Box, { className: UploaderApp_default.readyContainer, children: [
+        /* @__PURE__ */ jsx(Text, { size: "sm", ta: "center", children: t("uploader.readyToUpload") }),
+        /* @__PURE__ */ jsx(Group, { justify: "center", children: /* @__PURE__ */ jsx(Button, { size: "sm", onClick: handleUpload, "data-testid": "uploader-upload", children: t("uploader.upload") }) })
+      ] }) : /* @__PURE__ */ jsx(
+        DownloadProgress_default,
+        {
+          state: uploadState.progress,
+          ariaLabel: t("uploader.uploadProgress")
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      FolderPickerModal,
+      {
+        opened: pickerOpen,
+        onConfirm: handleFolderSelect,
+        onCancel: () => setPickerOpen(false)
+      }
+    )
+  ] });
+};
+var UploaderApp_default2 = UploaderApp;
+
+export { UploaderApp_default2 as UploaderApp_default, formatBytes };

package/dist/chunk-CV5PUHAE.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+var chunkSBE4SZAN_cjs = require('./chunk-SBE4SZAN.cjs');
+var chunkUIQCTAVM_cjs = require('./chunk-UIQCTAVM.cjs');
+var react = require('react');
+var reactI18next = require('react-i18next');
+var jsxRuntime = require('react/jsx-runtime');
+
+var ZOOM_MARKS = [
+  { value: 25, label: "25%" },
+  { value: 50, label: "50%" },
+  { value: 75, label: "75%" },
+  { value: 100, label: "100%" },
+  { value: 200, label: "200%" }
+];
+var useImageViewerMenuBarElements = (options) => {
+  const { windowId, onOpenPicker, onExit } = options;
+  const { t } = reactI18next.useTranslation("common");
+  const { t: tApps } = reactI18next.useTranslation("apps");
+  const displayZoom = chunkUIQCTAVM_cjs.useDisplayZoom(windowId);
+  const fitToWindow = chunkUIQCTAVM_cjs.useFitToWindow(windowId);
+  const setUserZoom = chunkUIQCTAVM_cjs.useImageViewerStore((s) => s.setUserZoom);
+  const setFitToWindow = chunkUIQCTAVM_cjs.useImageViewerStore((s) => s.setFitToWindow);
+  const handleFitChange = react.useCallback(
+    (checked) => setFitToWindow(windowId, checked),
+    [windowId, setFitToWindow]
+  );
+  const handleZoomChange = react.useCallback(
+    (value) => setUserZoom(windowId, value),
+    [windowId, setUserZoom]
+  );
+  return react.useMemo(() => {
+    const zoomLabel = `${tApps("imageViewer.zoom")}: ${displayZoom}%`;
+    return [
+      {
+        type: "menu",
+        label: t("menu.file"),
+        items: [
+          {
+            type: "item",
+            label: t("actions.open"),
+            icon: "FcOpenedFolder",
+            onClick: onOpenPicker ?? (() => {
+            })
+          },
+          { type: "divider" },
+          {
+            type: "item",
+            label: t("actions.exit"),
+            icon: "FcLeft",
+            onClick: onExit
+          }
+        ]
+      },
+      {
+        type: "switch",
+        label: tApps("imageViewer.fitToWindow"),
+        checked: fitToWindow,
+        onChange: handleFitChange
+      },
+      {
+        type: "slider",
+        label: zoomLabel,
+        min: 10,
+        max: 200,
+        value: displayZoom,
+        onChange: handleZoomChange,
+        marks: ZOOM_MARKS,
+        labelFormat: (value) => `${value}%`
+      }
+    ];
+  }, [t, tApps, onOpenPicker, onExit, displayZoom, fitToWindow, handleFitChange, handleZoomChange]);
+};
+var ImageViewerMenuBar = react.memo(
+  ({ windowId, contentData, onExit }) => {
+    const elements = useImageViewerMenuBarElements({
+      windowId,
+      onOpenPicker: contentData?.setPickerOpen,
+      onExit
+    });
+    return /* @__PURE__ */ jsxRuntime.jsx(chunkSBE4SZAN_cjs.AppMenuBar_default, { elements });
+  }
+);
+ImageViewerMenuBar.displayName = "ImageViewerMenuBar";
+
+exports.ImageViewerMenuBar = ImageViewerMenuBar;

package/dist/chunk-D5MVFFID.js

@@ -0,0 +1,42 @@
+import { create } from 'zustand';
+
+// src/components/Apps/MenuEditApp/menuEditStore.ts
+var useMenuEditStore = create((set, get) => ({
+  windows: {},
+  reset: (windowId) => {
+    set((state) => ({
+      windows: {
+        ...state.windows,
+        [windowId]: { isDirty: false, snapshot: null }
+      }
+    }));
+  },
+  setIsDirty: (windowId, isDirty) => {
+    set((state) => {
+      const windowState = state.windows[windowId];
+      if (windowState?.isDirty === isDirty) return state;
+      return {
+        windows: {
+          ...state.windows,
+          [windowId]: { ...windowState, isDirty }
+        }
+      };
+    });
+  },
+  takeSnapshot: (windowId, folders) => {
+    set((state) => ({
+      windows: {
+        ...state.windows,
+        [windowId]: { isDirty: false, snapshot: folders }
+      }
+    }));
+  },
+  getSnapshot: (windowId) => {
+    return get().windows[windowId]?.snapshot ?? null;
+  }
+}));
+var useIsDirty = (windowId) => {
+  return useMenuEditStore((state) => state.windows[windowId]?.isDirty ?? false);
+};
+
+export { useIsDirty, useMenuEditStore };