strapi-plugin-timeline 0.0.0

package/dist/admin/App-BYK_GACN.mjs

@@ -0,0 +1,559 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useFetchClient, useNotification, useAuth, Layouts, Page } from "@strapi/strapi/admin";
+import { useSearchParams, NavLink, Routes, Route } from "react-router-dom";
+import { useState, useEffect, useCallback } from "react";
+import { Main, Box, Flex, Typography, Button, Grid, Field, MultiSelect, MultiSelectOption, DatePicker, Combobox, ComboboxOption, Table, Thead, Tr, Th, Tbody, Td, Badge, Link, IconButton, Pagination, PreviousLink, PageLink, NextLink, Dialog } from "@strapi/design-system";
+import { Trash, Eye, ArrowClockwise, CaretUp, CaretDown } from "@strapi/icons";
+import { P as PLUGIN_ID, T as TimelineDetailModal, R as RestoreDiffTable } from "./index-DWXpMwlf.mjs";
+const ACTION_COLORS = {
+  create: { bg: "success100", text: "success700" },
+  update: { bg: "warning100", text: "warning700" },
+  publish: { bg: "primary100", text: "primary700" },
+  delete: { bg: "danger100", text: "danger700" },
+  clean: { bg: "danger100", text: "danger700" },
+  restore: { bg: "primary100", text: "primary700" }
+};
+const HomePage = () => {
+  const { get, del, put, post } = useFetchClient();
+  const { toggleNotification } = useNotification();
+  const { user: currentUser } = useAuth("Timeline", (auth) => ({ user: auth.user }));
+  const [searchParams, setSearchParams] = useSearchParams();
+  const selectedContentTypes = searchParams.getAll("contentType");
+  const selectedUsers = searchParams.getAll("userId");
+  const selectedActions = searchParams.getAll("action");
+  const entryDocumentId = searchParams.get("entryDocumentId") || "";
+  const selectedLocales = searchParams.getAll("locale");
+  const dateFrom = searchParams.get("dateFrom") || "";
+  const dateTo = searchParams.get("dateTo") || "";
+  const sort = searchParams.get("sort") || "createdAt";
+  const sortOrder = searchParams.get("sortOrder") || "desc";
+  const page = parseInt(searchParams.get("page") || "1", 10);
+  const [entries, setEntries] = useState([]);
+  const [contentTypes, setContentTypes] = useState([]);
+  const [users, setUsers] = useState([]);
+  const [pagination, setPagination] = useState({
+    page: 1,
+    pageSize: 20,
+    total: 0,
+    pageCount: 0
+  });
+  const [loading, setLoading] = useState(true);
+  const [viewEntry, setViewEntry] = useState(null);
+  const [canReadUsers, setCanReadUsers] = useState(false);
+  const [showCleanDialog, setShowCleanDialog] = useState(false);
+  const [cleanContentTypes, setCleanContentTypes] = useState([]);
+  const [isCleaning, setIsCleaning] = useState(false);
+  const [restoreTarget, setRestoreTarget] = useState(null);
+  const [isRestoring, setIsRestoring] = useState(false);
+  const [currentDocForRestore, setCurrentDocForRestore] = useState(null);
+  const [fetchingCurrentDoc, setFetchingCurrentDoc] = useState(false);
+  const [docIdSearch, setDocIdSearch] = useState(entryDocumentId);
+  const [locales, setLocales] = useState([]);
+  useEffect(() => {
+    const checkPermissions = async () => {
+      try {
+        const res = await get("/admin/permissions/check", {
+          params: { permissions: [{ action: "admin::users.read" }] }
+        });
+        setCanReadUsers(res?.data?.data?.[0]?.hasPermission ?? false);
+      } catch {
+        setCanReadUsers(false);
+      }
+    };
+    checkPermissions();
+  }, [get]);
+  useEffect(() => {
+    loadContentTypes();
+    loadUsers();
+    loadLocales();
+  }, []);
+  useEffect(() => {
+    loadEntries();
+  }, [searchParams]);
+  useEffect(() => {
+    if (!restoreTarget) {
+      setCurrentDocForRestore(null);
+      return;
+    }
+    let cancelled = false;
+    const fetchCurrentDoc = async () => {
+      setFetchingCurrentDoc(true);
+      setCurrentDocForRestore(null);
+      try {
+        const ct = contentTypes.find((c) => c.uid === restoreTarget.contentType);
+        const kind = ct?.kind || "collectionType";
+        let url = kind === "singleType" ? `/content-manager/single-types/${restoreTarget.contentType}` : `/content-manager/collection-types/${restoreTarget.contentType}/${restoreTarget.entryDocumentId}`;
+        if (restoreTarget.locale) url += `?locale=${restoreTarget.locale}`;
+        const resp = await get(url);
+        if (!cancelled) setCurrentDocForRestore(resp.data?.data || resp.data || null);
+      } catch {
+        if (!cancelled) setCurrentDocForRestore(null);
+      } finally {
+        if (!cancelled) setFetchingCurrentDoc(false);
+      }
+    };
+    fetchCurrentDoc();
+    return () => {
+      cancelled = true;
+    };
+  }, [restoreTarget]);
+  const updateParams = useCallback(
+    (updates) => {
+      setSearchParams((prev) => {
+        const next = new URLSearchParams();
+        prev.forEach((value, key) => {
+          if (!(key in updates)) next.append(key, value);
+        });
+        for (const [key, val] of Object.entries(updates)) {
+          if (val === null || val === "" || Array.isArray(val) && val.length === 0) continue;
+          if (Array.isArray(val)) {
+            val.forEach((v) => next.append(key, v));
+          } else {
+            next.set(key, val);
+          }
+        }
+        return next;
+      });
+    },
+    [setSearchParams]
+  );
+  const loadContentTypes = async () => {
+    try {
+      const res = await get(`/${PLUGIN_ID}/content-types`);
+      setContentTypes(res.data.data || []);
+    } catch {
+      toggleNotification({ type: "danger", message: "Failed to load content types." });
+    }
+  };
+  const loadUsers = async () => {
+    try {
+      const res = await get(`/${PLUGIN_ID}/entries/users`);
+      setUsers(res.data.data || []);
+    } catch {
+    }
+  };
+  const loadLocales = async () => {
+    try {
+      const res = await get(`/${PLUGIN_ID}/entries/locales`);
+      setLocales(res.data.data || []);
+    } catch {
+    }
+  };
+  const loadEntries = async () => {
+    setLoading(true);
+    try {
+      const params = new URLSearchParams();
+      params.set("page", String(page));
+      params.set("pageSize", "20");
+      params.set("sort", sort);
+      params.set("sortOrder", sortOrder);
+      selectedContentTypes.forEach((ct) => params.append("contentType", ct));
+      selectedUsers.forEach((u) => params.append("userId", u));
+      selectedActions.forEach((a) => params.append("action", a));
+      selectedLocales.forEach((l) => params.append("locale", l));
+      if (entryDocumentId) params.set("entryDocumentId", entryDocumentId);
+      if (dateFrom) params.set("dateFrom", dateFrom);
+      if (dateTo) params.set("dateTo", dateTo);
+      const res = await get(`/${PLUGIN_ID}/entries?${params.toString()}`);
+      setEntries(res.data.data || []);
+      setPagination(res.data.meta?.pagination || pagination);
+    } catch {
+      toggleNotification({ type: "danger", message: "Failed to load timeline entries." });
+    } finally {
+      setLoading(false);
+    }
+  };
+  const getDisplayName = (uid) => {
+    const ct = contentTypes.find((c) => c.uid === uid);
+    return ct?.displayName || uid.split(".").pop() || uid;
+  };
+  const getContentTypeKind = (uid) => {
+    const ct = contentTypes.find((c) => c.uid === uid);
+    return ct?.kind || "collectionType";
+  };
+  const getContentManagerLink = (entry) => {
+    const kind = getContentTypeKind(entry.contentType);
+    if (kind === "singleType") {
+      return `/content-manager/single-types/${entry.contentType}`;
+    }
+    return `/content-manager/collection-types/${entry.contentType}/${entry.entryDocumentId}`;
+  };
+  const formatDate2 = (dateStr) => new Date(dateStr).toLocaleString();
+  const getUserLink = (entry) => {
+    if (!entry.userId) return null;
+    if (currentUser && entry.userId === currentUser.id) return "/me";
+    if (canReadUsers) return `/settings/users/${entry.userId}`;
+    return null;
+  };
+  const handleClean = async () => {
+    if (cleanContentTypes.length === 0) {
+      toggleNotification({ type: "warning", message: "Please select at least one content type to clean." });
+      return;
+    }
+    setIsCleaning(true);
+    try {
+      await post(`/${PLUGIN_ID}/entries/clean`, { contentTypes: cleanContentTypes });
+      toggleNotification({ type: "success", message: "Selected timeline entries cleaned." });
+      setShowCleanDialog(false);
+      setCleanContentTypes([]);
+      loadEntries();
+      loadUsers();
+    } catch {
+      toggleNotification({ type: "danger", message: "Failed to clean timeline entries." });
+    } finally {
+      setIsCleaning(false);
+    }
+  };
+  const handleRestore = async (entry) => {
+    setIsRestoring(true);
+    try {
+      const snapshot = entry.content;
+      if (!snapshot || typeof snapshot !== "object") {
+        toggleNotification({ type: "danger", message: "Invalid snapshot data." });
+        return;
+      }
+      const SYSTEM_FIELDS = /* @__PURE__ */ new Set([
+        "id",
+        "documentId",
+        "createdAt",
+        "updatedAt",
+        "publishedAt",
+        "createdBy",
+        "updatedBy",
+        "created_by_id",
+        "updated_by_id",
+        "created_at",
+        "updated_at",
+        "published_at",
+        "locale",
+        "localizations"
+      ]);
+      const restoreData = {};
+      for (const [key, value] of Object.entries(snapshot)) {
+        if (!SYSTEM_FIELDS.has(key)) {
+          restoreData[key] = value;
+        }
+      }
+      await post(`/${PLUGIN_ID}/entries/snapshot-before-restore`, {
+        contentType: entry.contentType,
+        entryDocumentId: entry.entryDocumentId,
+        locale: entry.locale || null,
+        restoreData
+      });
+      toggleNotification({
+        type: "success",
+        message: "Entry restored from timeline snapshot."
+      });
+      loadEntries();
+    } catch (err) {
+      toggleNotification({
+        type: "danger",
+        message: err?.response?.data?.error?.message || err?.message || "Failed to restore entry."
+      });
+    } finally {
+      setIsRestoring(false);
+      setRestoreTarget(null);
+    }
+  };
+  const handleSort = (field) => {
+    const newOrder = sort === field && sortOrder === "desc" ? "asc" : "desc";
+    updateParams({ sort: field, sortOrder: newOrder, page: "1" });
+  };
+  const handlePageChange = (newPage) => {
+    updateParams({ page: String(newPage) });
+  };
+  const renderSortIcon = (field) => {
+    if (sort !== field) return null;
+    return sortOrder === "asc" ? /* @__PURE__ */ jsx(CaretUp, { width: 10, height: 10 }) : /* @__PURE__ */ jsx(CaretDown, { width: 10, height: 10 });
+  };
+  const SortHeader = ({ field, children }) => /* @__PURE__ */ jsx(Th, { children: /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      onClick: () => handleSort(field),
+      style: {
+        background: "none",
+        border: "none",
+        cursor: "pointer",
+        display: "inline-flex",
+        alignItems: "center",
+        gap: "4px",
+        padding: 0
+      },
+      children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "sigma", children }),
+        renderSortIcon(field)
+      ]
+    }
+  ) });
+  return /* @__PURE__ */ jsxs(Main, { padding: 8, children: [
+    /* @__PURE__ */ jsx(Box, { paddingBottom: 6, children: /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "flex-start", children: [
+      /* @__PURE__ */ jsx(Flex, { gap: 3, alignItems: "center", children: /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "alpha", tag: "h1", children: "Timeline" }),
+        /* @__PURE__ */ jsx(Typography, { variant: "epsilon", textColor: "neutral600", children: "Content history log across tracked content types." })
+      ] }) }),
+      /* @__PURE__ */ jsx(Button, { variant: "danger-light", startIcon: /* @__PURE__ */ jsx(Trash, {}), onClick: () => setShowCleanDialog(true), children: "Clean" })
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { paddingBottom: 4, children: /* @__PURE__ */ jsxs(Grid.Root, { gap: 4, children: [
+      /* @__PURE__ */ jsx(Grid.Item, { col: 4, xs: 8, children: /* @__PURE__ */ jsxs(Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsx(Field.Label, { children: "Content Type" }),
+        /* @__PURE__ */ jsx(
+          MultiSelect,
+          {
+            value: selectedContentTypes,
+            onChange: (values) => updateParams({ contentType: values, page: "1" }),
+            placeholder: "All content types",
+            onClear: () => updateParams({ contentType: null, page: "1" }),
+            withTags: true,
+            children: contentTypes.map((ct) => /* @__PURE__ */ jsx(MultiSelectOption, { value: ct.uid, children: ct.displayName }, ct.uid))
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 2, xs: 4, children: /* @__PURE__ */ jsxs(Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsx(Field.Label, { children: "Locale" }),
+        /* @__PURE__ */ jsx(
+          MultiSelect,
+          {
+            value: selectedLocales,
+            onChange: (values) => updateParams({ locale: values, page: "1" }),
+            placeholder: "All locales",
+            onClear: () => updateParams({ locale: null, page: "1" }),
+            withTags: true,
+            children: locales.map((l) => /* @__PURE__ */ jsx(MultiSelectOption, { value: l, children: l.toUpperCase() }, l))
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 3, xs: 6, children: /* @__PURE__ */ jsxs(Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsx(Field.Label, { children: "From date" }),
+        /* @__PURE__ */ jsx(
+          DatePicker,
+          {
+            value: dateFrom ? new Date(dateFrom) : void 0,
+            onChange: (date) => updateParams({
+              dateFrom: date ? date.toISOString().split("T")[0] : null,
+              page: "1"
+            }),
+            onClear: () => updateParams({ dateFrom: null, page: "1" })
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 3, xs: 6, children: /* @__PURE__ */ jsxs(Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsx(Field.Label, { children: "To date" }),
+        /* @__PURE__ */ jsx(
+          DatePicker,
+          {
+            value: dateTo ? new Date(dateTo) : void 0,
+            onChange: (date) => updateParams({
+              dateTo: date ? date.toISOString().split("T")[0] : null,
+              page: "1"
+            }),
+            onClear: () => updateParams({ dateTo: null, page: "1" })
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 6, xs: 12, children: /* @__PURE__ */ jsxs(Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsx(Field.Label, { children: "Document ID" }),
+        /* @__PURE__ */ jsx(
+          Combobox,
+          {
+            value: entryDocumentId || void 0,
+            onChange: (value) => {
+              setDocIdSearch(value || "");
+              updateParams({ entryDocumentId: value || null, page: "1" });
+            },
+            onClear: () => {
+              setDocIdSearch("");
+              updateParams({ entryDocumentId: null, page: "1" });
+            },
+            onTextValueChange: (text) => setDocIdSearch(text),
+            placeholder: "Search document ID…",
+            allowCustomValue: true,
+            noOptionsMessage: () => "No matching IDs",
+            children: [...new Set(entries.map((e) => e.entryDocumentId))].filter((id) => !docIdSearch || id.toLowerCase().includes(docIdSearch.toLowerCase())).slice(0, 20).map((id) => /* @__PURE__ */ jsx(ComboboxOption, { value: id, children: id }, id))
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 1, xs: 12, children: /* @__PURE__ */ jsxs(Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsx(Field.Label, { children: "Action" }),
+        /* @__PURE__ */ jsx(
+          MultiSelect,
+          {
+            value: selectedActions,
+            onChange: (values) => updateParams({ action: values, page: "1" }),
+            placeholder: "All actions",
+            onClear: () => updateParams({ action: null, page: "1" }),
+            withTags: true,
+            children: ["create", "update", "publish", "delete", "clean", "restore"].map((a) => /* @__PURE__ */ jsx(MultiSelectOption, { value: a, children: a }, a))
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 5, xs: 12, children: /* @__PURE__ */ jsxs(Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsx(Field.Label, { children: "User" }),
+        /* @__PURE__ */ jsx(
+          MultiSelect,
+          {
+            value: selectedUsers,
+            onChange: (values) => updateParams({ userId: values, page: "1" }),
+            placeholder: "All users",
+            onClear: () => updateParams({ userId: null, page: "1" }),
+            withTags: true,
+            children: users.map((u) => /* @__PURE__ */ jsx(MultiSelectOption, { value: String(u.userId), children: u.userName }, u.userId))
+          }
+        )
+      ] }) })
+    ] }) }),
+    /* @__PURE__ */ jsxs(Box, { background: "neutral0", shadow: "tableShadow", borderRadius: "4px", children: [
+      /* @__PURE__ */ jsxs(Table, { colCount: 8, rowCount: entries.length + 1, children: [
+        /* @__PURE__ */ jsx(Thead, { children: /* @__PURE__ */ jsxs(Tr, { children: [
+          /* @__PURE__ */ jsx(SortHeader, { field: "action", children: "Action" }),
+          /* @__PURE__ */ jsx(SortHeader, { field: "contentType", children: "Content" }),
+          /* @__PURE__ */ jsx(SortHeader, { field: "userName", children: "User" }),
+          /* @__PURE__ */ jsx(SortHeader, { field: "createdAt", children: "Date" }),
+          /* @__PURE__ */ jsx(Th, { style: { justifyItems: "center" }, children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", children: "View" }) }),
+          /* @__PURE__ */ jsx(Th, { style: { justifyItems: "center" }, children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", children: "Restore" }) })
+        ] }) }),
+        /* @__PURE__ */ jsx(Tbody, { children: loading ? /* @__PURE__ */ jsx(Tr, { children: /* @__PURE__ */ jsx(Td, { colSpan: 8, children: /* @__PURE__ */ jsx(Box, { padding: 4, children: /* @__PURE__ */ jsx(Typography, { textColor: "neutral600", children: "Loading…" }) }) }) }) : entries.length === 0 ? /* @__PURE__ */ jsx(Tr, { children: /* @__PURE__ */ jsx(Td, { colSpan: 8, children: /* @__PURE__ */ jsx(Box, { padding: 4, children: /* @__PURE__ */ jsx(Typography, { textColor: "neutral600", children: "No timeline entries found." }) }) }) }) : entries.map((entry) => {
+          const colors = ACTION_COLORS[entry.action] || ACTION_COLORS.update;
+          const userLink = getUserLink(entry);
+          return /* @__PURE__ */ jsxs(Tr, { children: [
+            /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Badge, { backgroundColor: colors.bg, textColor: colors.text, children: entry.action }) }),
+            /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, alignItems: "flex-start", children: [
+              /* @__PURE__ */ jsx(Typography, { fontWeight: "bold", variant: "omega", children: getDisplayName(entry.contentType) }),
+              entry.entryDocumentId && entry.action !== "clean" && /* @__PURE__ */ jsx(Typography, { variant: "omega", textColor: "primary600", children: /* @__PURE__ */ jsxs(
+                Link,
+                {
+                  tag: NavLink,
+                  to: getContentManagerLink(entry),
+                  style: { color: "inherit", textDecoration: "none" },
+                  children: [
+                    entry.entryDocumentId,
+                    entry.locale && /* @__PURE__ */ jsx(Badge, { backgroundColor: "primary100", textColor: "primary500", marginLeft: 2, children: entry.locale ? entry.locale.toUpperCase() : "—" })
+                  ]
+                }
+              ) })
+            ] }) }),
+            /* @__PURE__ */ jsx(Td, { children: userLink ? /* @__PURE__ */ jsxs(Typography, { variant: "omega", textColor: "primary600", children: [
+              /* @__PURE__ */ jsx(Link, { tag: NavLink, to: userLink, style: { color: "inherit", textDecoration: "none" }, children: entry.userName || `User #${entry.userId}` }),
+              entry.userId && /* @__PURE__ */ jsxs(Badge, { backgroundColor: "primary100", textColor: "primary500", marginLeft: 2, children: [
+                "ID ",
+                entry.userId
+              ] })
+            ] }) : /* @__PURE__ */ jsxs(Typography, { variant: "omega", children: [
+              entry.userName || (entry.userId ? `User #${entry.userId}` : "—"),
+              entry.userId && ` (ID: ${entry.userId})`
+            ] }) }),
+            /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { variant: "omega", children: formatDate2(entry.createdAt) }) }),
+            /* @__PURE__ */ jsx(Td, { style: { justifyItems: "center" }, children: /* @__PURE__ */ jsx(IconButton, { label: "View details", onClick: () => setViewEntry(entry), children: /* @__PURE__ */ jsx(Eye, {}) }) }),
+            /* @__PURE__ */ jsx(Td, { style: { justifyItems: "center" }, children: entry.action !== "delete" && entry.action !== "publish" ? /* @__PURE__ */ jsx(
+              IconButton,
+              {
+                label: "Restore this snapshot",
+                onClick: () => setRestoreTarget(entry),
+                children: /* @__PURE__ */ jsx(ArrowClockwise, {})
+              }
+            ) : /* @__PURE__ */ jsx(Typography, { variant: "omega", textColor: "neutral400" }) })
+          ] }, entry.id);
+        }) })
+      ] }),
+      pagination.pageCount > 1 && /* @__PURE__ */ jsx(Box, { padding: 4, children: /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", children: [
+        /* @__PURE__ */ jsxs(Typography, { variant: "pi", textColor: "neutral600", children: [
+          pagination.total,
+          " entries total"
+        ] }),
+        /* @__PURE__ */ jsxs(Pagination, { activePage: pagination.page, pageCount: pagination.pageCount, children: [
+          /* @__PURE__ */ jsx(
+            PreviousLink,
+            {
+              onClick: () => handlePageChange(Math.max(1, pagination.page - 1))
+            }
+          ),
+          Array.from({ length: pagination.pageCount }, (_, i) => i + 1).map((p) => /* @__PURE__ */ jsx(PageLink, { number: p, onClick: () => handlePageChange(p), children: p }, p)),
+          /* @__PURE__ */ jsx(
+            NextLink,
+            {
+              onClick: () => handlePageChange(Math.min(pagination.pageCount, pagination.page + 1))
+            }
+          )
+        ] })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      TimelineDetailModal,
+      {
+        entry: viewEntry,
+        open: !!viewEntry,
+        onClose: () => setViewEntry(null),
+        contentTypes
+      }
+    ),
+    /* @__PURE__ */ jsx(Dialog.Root, { open: !!restoreTarget, onOpenChange: (open) => !open && setRestoreTarget(null), children: /* @__PURE__ */ jsxs(Dialog.Content, { children: [
+      /* @__PURE__ */ jsx(Dialog.Header, { children: "Restore from Timeline" }),
+      /* @__PURE__ */ jsx(Dialog.Body, { children: restoreTarget && /* @__PURE__ */ jsx(
+        RestoreDiffTable,
+        {
+          currentData: currentDocForRestore,
+          snapshotData: restoreTarget.content && typeof restoreTarget.content === "object" ? restoreTarget.content : {},
+          loading: fetchingCurrentDoc
+        }
+      ) }),
+      /* @__PURE__ */ jsxs(Dialog.Footer, { children: [
+        /* @__PURE__ */ jsx(Dialog.Cancel, { children: /* @__PURE__ */ jsx(Button, { variant: "tertiary", children: "Cancel" }) }),
+        /* @__PURE__ */ jsx(Dialog.Action, { children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "danger-light",
+            onClick: () => restoreTarget && handleRestore(restoreTarget),
+            loading: isRestoring,
+            children: "Restore"
+          }
+        ) })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsx(Dialog.Root, { open: showCleanDialog, onOpenChange: (open) => {
+      if (!open) {
+        setShowCleanDialog(false);
+        setCleanContentTypes([]);
+      }
+    }, children: /* @__PURE__ */ jsxs(Dialog.Content, { children: [
+      /* @__PURE__ */ jsx(Dialog.Header, { children: "Clean timeline entries" }),
+      /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Typography, { children: 'Select the content types whose timeline entries you want to remove. A "clean" action will be logged for each.' }),
+        /* @__PURE__ */ jsx(Box, { paddingTop: 4, children: /* @__PURE__ */ jsxs(Field.Root, { children: [
+          /* @__PURE__ */ jsx(Field.Label, { children: "Content Types" }),
+          /* @__PURE__ */ jsx(
+            MultiSelect,
+            {
+              value: cleanContentTypes,
+              onChange: (values) => setCleanContentTypes(values),
+              placeholder: "Select content types…",
+              withTags: true,
+              children: contentTypes.map((ct) => /* @__PURE__ */ jsx(MultiSelectOption, { value: ct.uid, children: ct.displayName }, ct.uid))
+            }
+          )
+        ] }) })
+      ] }) }),
+      /* @__PURE__ */ jsxs(Dialog.Footer, { children: [
+        /* @__PURE__ */ jsx(Dialog.Cancel, { children: /* @__PURE__ */ jsx(Button, { variant: "tertiary", children: "Cancel" }) }),
+        /* @__PURE__ */ jsx(Dialog.Action, { children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "danger",
+            onClick: handleClean,
+            loading: isCleaning,
+            disabled: cleanContentTypes.length === 0,
+            children: "Clean"
+          }
+        ) })
+      ] })
+    ] }) })
+  ] });
+};
+const App = () => {
+  return /* @__PURE__ */ jsx(Layouts.Root, { children: /* @__PURE__ */ jsxs(Routes, { children: [
+    /* @__PURE__ */ jsx(Route, { index: true, element: /* @__PURE__ */ jsx(HomePage, {}) }),
+    /* @__PURE__ */ jsx(Route, { path: "*", element: /* @__PURE__ */ jsx(Page.Error, {}) })
+  ] }) });
+};
+export {
+  App
+};