alinea 1.7.0 → 2.0.0-preview.1

package/dist/dashboard/app/modals/CreateEntry.js

@@ -0,0 +1,283 @@
+import {
+  useAtomValue,
+  useSetAtom
+} from "../../../chunks/chunk-U4VOHNR2.js";
+import {
+  atom
+} from "../../../chunks/chunk-Y7XOMJOC.js";
+import {
+  dist_default
+} from "../../../chunks/chunk-I4OYYAX5.js";
+import "../../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/app/modals/CreateEntry.tsx
+import {
+  Button,
+  Label,
+  Select,
+  SelectItem,
+  TextField,
+  ToggleButton,
+  ToggleButtonGroup
+} from "alinea/components";
+import { getType } from "alinea/core/Internal";
+import { Reference } from "alinea/core/Reference";
+import { Schema } from "alinea/core/Schema";
+import { Type, type as createType } from "alinea/core/Type";
+import { createEntryAtom } from "alinea/dashboard/atoms/create";
+import { configAtom } from "alinea/dashboard/atoms/core";
+import { ReactiveNode } from "alinea/dashboard/atoms/ReactiveNode";
+import { policyAtom } from "alinea/dashboard/atoms/user";
+import { useDashboardContext } from "alinea/dashboard/hooks";
+import { entry as entryField } from "alinea/field/link";
+import { EntryReference } from "alinea/picker/entry/EntryReference";
+import {
+  Suspense,
+  useMemo,
+  useState
+} from "react";
+import { IcRoundFirstPage, IcRoundLastPage } from "../../icons.js";
+import { NodeEditor } from "../EntryFields.js";
+import {
+  DashboardModalContent,
+  DashboardModalDialog,
+  DashboardModalFooter,
+  useDashboardModal
+} from "../ui/DashboardModal.js";
+
+// src/dashboard/app/modals/CreateEntry.module.css
+var CreateEntry_default = {
+  "CreateEntry-parentRow": "alinea-CreateEntry-parentRow",
+  "CreateEntryParentRow": "alinea-CreateEntry-parentRow",
+  "CreateEntry-message": "alinea-CreateEntry-message",
+  "CreateEntryMessage": "alinea-CreateEntry-message",
+  "CreateEntry-parentField": "alinea-CreateEntry-parentField",
+  "CreateEntryParentField": "alinea-CreateEntry-parentField",
+  "CreateEntry-insertOrder": "alinea-CreateEntry-insertOrder",
+  "CreateEntryInsertOrder": "alinea-CreateEntry-insertOrder"
+};
+
+// src/dashboard/app/modals/CreateEntry.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var styles = dist_default(CreateEntry_default);
+function entryReference(id, key) {
+  return {
+    [Reference.id]: key,
+    [Reference.type]: "entry",
+    [EntryReference.entry]: id
+  };
+}
+function entryIdOf(value) {
+  return EntryReference.isEntryReference(value) ? value[EntryReference.entry] : void 0;
+}
+function buildTypeOptions(schema, types) {
+  return types.map((type) => {
+    const schemaType = schema[type];
+    if (!schemaType || Type.isHidden(schemaType)) return null;
+    return { id: type, label: getType(schemaType).label };
+  }).filter((option) => option !== null);
+}
+function createLinkEditor(key, field, initialValue) {
+  const formType = createType(`${key} link`, { fields: { [key]: field } });
+  const value = Type.initialValue(formType);
+  if (initialValue !== void 0) value[key] = initialValue;
+  const node = new ReactiveNode(value);
+  return {
+    node,
+    type: formType,
+    value: node.field(key)
+  };
+}
+function CreateEntryLoading() {
+  return /* @__PURE__ */ jsx(
+    DashboardModalDialog,
+    {
+      "aria-label": "Create entry",
+      variant: "explorer",
+      isLoading: true
+    }
+  );
+}
+function CreateEntryForm() {
+  const modal = useDashboardModal();
+  const { page, root } = useDashboardContext();
+  const createEntry = useSetAtom(createEntryAtom);
+  const config = useAtomValue(configAtom).schema;
+  const policy = useAtomValue(policyAtom);
+  const { locale } = page;
+  const tree = root.tree(locale);
+  const selectedItem = useAtomValue(tree.selectedItem);
+  const rootData = useAtomValue(root.data);
+  const initialParentId = useMemo(() => {
+    if (!page.entry || !selectedItem) return void 0;
+    const type = config[selectedItem.type];
+    return type && Type.isContainer(type) ? selectedItem.id : selectedItem.parentId ?? void 0;
+  }, [config, page.entry, selectedItem]);
+  const [title, setTitle] = useState("");
+  const [selectedTypeOverride, setSelectedType] = useState(null);
+  const [insertOrder, setInsertOrder] = useState("last");
+  const [isCreating, setIsCreating] = useState(false);
+  const containerTypes = useMemo(
+    () => Object.entries(config).filter(([, type]) => Type.isContainer(type) && !Type.isHidden(type)).map(([name]) => name),
+    [config]
+  );
+  const parent = useMemo(() => {
+    const field = entryField("Parent", {
+      condition: { _type: { in: containerTypes } },
+      initialValue: initialParentId ? entryReference(initialParentId, "parent") : null,
+      location: { workspace: root.workspace, root: root.key },
+      title: "Select parent"
+    });
+    return createLinkEditor(
+      "parent",
+      field,
+      initialParentId ? entryReference(initialParentId, "parent") : null
+    );
+  }, [containerTypes, initialParentId, root.key, root.workspace]);
+  const parentValue = useAtomValue(parent.value);
+  const parentId = entryIdOf(parentValue);
+  const parentItemAtom = useMemo(
+    () => atom((get) => {
+      const id = entryIdOf(get(parent.value));
+      return id ? get(tree.item(id)) : void 0;
+    }),
+    [parent.value, tree]
+  );
+  const parentItem = useAtomValue(parentItemAtom);
+  const parentType = parentItem ? config[parentItem.type] : void 0;
+  const allowed = parentType ? Schema.contained(config, Type.contains(parentType)) : Schema.contained(config, rootData.contains ?? []);
+  const parentIds = parentItem ? [parentItem.id, ...parentItem.parents] : [];
+  const typeOptions = buildTypeOptions(config, allowed).filter(
+    (option) => policy.canCreate({
+      workspace: root.workspace,
+      root: root.key,
+      locale,
+      parents: parentIds,
+      type: option.id
+    })
+  );
+  const selectedType = selectedTypeOverride && typeOptions.some((option) => option.id === selectedTypeOverride) ? selectedTypeOverride : typeOptions[0]?.id ?? null;
+  const copyFrom = useMemo(() => {
+    const field = entryField("Copy content from", {
+      condition: { _type: selectedType ?? "" },
+      location: { workspace: root.workspace, root: root.key },
+      readOnly: !selectedType,
+      title: "Select entry"
+    });
+    return createLinkEditor("copyFrom", field);
+  }, [root.key, root.workspace, selectedType]);
+  const copyFromValue = useAtomValue(copyFrom.value);
+  const copyFromId = entryIdOf(copyFromValue);
+  const showInsertOrder = parentType ? Type.insertOrder(parentType) === "free" : true;
+  async function onSubmit(event) {
+    event.preventDefault();
+    const nextTitle = title.trim();
+    if (isCreating || !selectedType || !nextTitle) return;
+    setIsCreating(true);
+    try {
+      await createEntry({
+        workspace: root.workspace,
+        root: root.key,
+        locale,
+        parentId,
+        type: selectedType,
+        title: nextTitle,
+        copyFrom: copyFromId,
+        insertOrder: showInsertOrder ? insertOrder : void 0
+      });
+      modal.close();
+    } finally {
+      setIsCreating(false);
+    }
+  }
+  const canCreate = Boolean(selectedType && title.trim());
+  return /* @__PURE__ */ jsxs(
+    DashboardModalDialog,
+    {
+      "aria-label": "Create entry",
+      variant: "explorer",
+      label: "Create entry",
+      children: [
+        /* @__PURE__ */ jsx("form", { onSubmit, id: "submit", children: /* @__PURE__ */ jsxs(DashboardModalContent, { children: [
+          /* @__PURE__ */ jsx(
+            TextField,
+            {
+              autoFocus: true,
+              value: title,
+              onChange: setTitle,
+              label: "Title",
+              isRequired: true
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Select,
+            {
+              label: "Type",
+              selectedKey: selectedType,
+              onSelectionChange: (key) => {
+                setSelectedType(key ? String(key) : null);
+              },
+              isRequired: true,
+              children: typeOptions.map((option) => /* @__PURE__ */ jsx(SelectItem, { id: option.id, children: option.label }, option.id))
+            }
+          ),
+          typeOptions.length === 0 && /* @__PURE__ */ jsx("p", { className: styles.CreateEntry.message(), children: "No entry types are available at this location." }),
+          /* @__PURE__ */ jsxs("div", { className: styles.CreateEntry.parentRow(), children: [
+            /* @__PURE__ */ jsx("div", { className: styles.CreateEntry.parentField(), children: /* @__PURE__ */ jsx(NodeEditor, { node: parent.node, type: parent.type }) }),
+            showInsertOrder && /* @__PURE__ */ jsx(
+              Label,
+              {
+                label: "Insert",
+                className: styles.CreateEntry.insertOrder(),
+                children: /* @__PURE__ */ jsxs(
+                  ToggleButtonGroup,
+                  {
+                    "aria-label": "Insert",
+                    selectionMode: "single",
+                    disallowEmptySelection: true,
+                    selectedKeys: [insertOrder],
+                    onSelectionChange: (key) => {
+                      if (key.has("first")) setInsertOrder("first");
+                      else if (key.has("last")) setInsertOrder("last");
+                    },
+                    children: [
+                      /* @__PURE__ */ jsxs(ToggleButton, { id: "first", children: [
+                        /* @__PURE__ */ jsx(IcRoundFirstPage, { "data-slot": "icon" }),
+                        " First"
+                      ] }),
+                      /* @__PURE__ */ jsxs(ToggleButton, { id: "last", children: [
+                        /* @__PURE__ */ jsx(IcRoundLastPage, { "data-slot": "icon" }),
+                        " Last"
+                      ] })
+                    ]
+                  }
+                )
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(NodeEditor, { node: copyFrom.node, type: copyFrom.type })
+        ] }) }),
+        /* @__PURE__ */ jsxs(DashboardModalFooter, { children: [
+          /* @__PURE__ */ jsx(Button, { type: "button", appearance: "outline", onPress: modal.close, children: "Cancel" }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "submit",
+              form: "submit",
+              intent: "primary",
+              isDisabled: !canCreate,
+              isPending: isCreating,
+              children: "Create entry"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function CreateEntry() {
+  return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(CreateEntryLoading, {}), children: /* @__PURE__ */ jsx(CreateEntryForm, {}) });
+}
+export {
+  CreateEntry
+};

package/dist/dashboard/app/pages/EntryPage.d.ts

@@ -0,0 +1,11 @@
+import { Page } from 'alinea/dashboard/atoms/nav';
+export declare const entryPage: (page: Page, get: import("jotai").Getter) => import("react").ReactNode | Promise<import("react").ReactNode>;
+export interface NotFoundPanelProps {
+    title: string;
+    message: string;
+    requestedLabel: string;
+    requestedValue: string;
+    actionLabel?: string;
+    onAction?: () => void;
+}
+export declare function NotFoundPanel({ title, message, requestedLabel, requestedValue, actionLabel, onAction }: NotFoundPanelProps): import("react").JSX.Element;

package/dist/dashboard/app/pages/EntryPage.js

@@ -0,0 +1,356 @@
+import {
+  useAtom,
+  useAtomValue,
+  useSetAtom
+} from "../../../chunks/chunk-U4VOHNR2.js";
+import "../../../chunks/chunk-Y7XOMJOC.js";
+import {
+  styler
+} from "../../../chunks/chunk-I4OYYAX5.js";
+import "../../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/app/pages/EntryPage.tsx
+import { Button, Icon, Surface, Tooltip } from "alinea/components";
+import { MediaFile, MediaLibrary } from "alinea/core/media/MediaTypes";
+import { assert } from "alinea/core/util/Assert";
+import { typeAtoms } from "alinea/dashboard/atoms/config";
+import { entrySidebarOpenAtom } from "alinea/dashboard/atoms/dashboard";
+import {
+  entryAtoms,
+  MissingEntryError
+} from "alinea/dashboard/atoms/entry";
+import {
+  page,
+  routeAtom,
+  routeBlockAtom,
+  routeGuardAtom
+} from "alinea/dashboard/atoms/nav";
+import { rootAtoms } from "alinea/dashboard/atoms/root";
+import { useEffect, useLayoutEffect, useRef, useTransition } from "react";
+import { EntryScope } from "../../hooks.js";
+import {
+  IcBaselineErrorOutline,
+  IcOutlineViewList,
+  IcRoundEdit
+} from "../../icons.js";
+import { FileEditor } from "./../editor/FileEditor.js";
+import { CreateEntryButton } from "./../DashboardLayout.js";
+import { EntryFields, NodeEditor } from "./../EntryFields.js";
+import { EntryHeader } from "./../EntryHeader.js";
+import {
+  EntrySidebar,
+  entrySidebar
+} from "./../EntrySidebar.js";
+import { EntryTranslationBanner } from "./../EntryTranslationBanner.js";
+import { Explorer } from "./../Explorer.js";
+import {
+  DashboardModal,
+  DashboardModalContent,
+  DashboardModalDialog,
+  DashboardModalFooter
+} from "./../ui/DashboardModal.js";
+import { Rail, RailBody, RailContent } from "./../ui/Rail.js";
+
+// src/dashboard/app/pages/EntryPage.module.css
+var EntryPage_default = {
+  "EntryEditor-title": "alinea-EntryEditor-title",
+  "EntryEditorTitle": "alinea-EntryEditor-title",
+  "MissingEntry-title": "alinea-MissingEntry-title",
+  "MissingEntryTitle": "alinea-MissingEntry-title",
+  "MissingEntry-message": "alinea-MissingEntry-message",
+  "MissingEntryMessage": "alinea-MissingEntry-message",
+  "EntryEditor-fields": "alinea-EntryEditor-fields",
+  "EntryEditorFields": "alinea-EntryEditor-fields",
+  "EntryEditor-banner": "alinea-EntryEditor-banner",
+  "EntryEditorBanner": "alinea-EntryEditor-banner",
+  "EntryEditor-header": "alinea-EntryEditor-header",
+  "EntryEditorHeader": "alinea-EntryEditor-header",
+  "EntryOverview-mobileActions": "alinea-EntryOverview-mobileActions",
+  "EntryOverviewMobileActions": "alinea-EntryOverview-mobileActions",
+  "MissingEntry-card": "alinea-MissingEntry-card",
+  "MissingEntryCard": "alinea-MissingEntry-card",
+  "EntryEditor-toolbar": "alinea-EntryEditor-toolbar",
+  "EntryEditorToolbar": "alinea-EntryEditor-toolbar",
+  "MissingEntry": "alinea-MissingEntry",
+  "MissingEntry-icon": "alinea-MissingEntry-icon",
+  "MissingEntryIcon": "alinea-MissingEntry-icon",
+  "EntryEditor-body": "alinea-EntryEditor-body",
+  "EntryEditorBody": "alinea-EntryEditor-body",
+  "MissingEntry-id": "alinea-MissingEntry-id",
+  "MissingEntryId": "alinea-MissingEntry-id"
+};
+
+// src/dashboard/app/pages/EntryPage.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var styles = styler(EntryPage_default);
+var entryPage = page(async (page2, get) => {
+  assert(page2.entry, "Entry id expected");
+  try {
+    const entry = await get(entryAtoms(page2.entry));
+    const localeData = entry.locales(page2.locale);
+    const type = get(typeAtoms(get(entry.type)));
+    const view = page2.view ?? get(entry.view);
+    const selectedEntry = await get(localeData.selectedEntry);
+    if (view === "overview") {
+      const root = rootAtoms(get(entry.workspace), get(entry.root));
+      const explorerPage = await get(root.children(entry.id).pageReady);
+      return /* @__PURE__ */ jsx(
+        EntryOverview,
+        {
+          entry,
+          explorerPage,
+          page: page2,
+          root,
+          selectedEntry
+        }
+      );
+    }
+    const selectedNode = await get(localeData.selectedNode);
+    const parentNeedsTranslation = type.customView ? false : await get(localeData.parentNeedsTranslation);
+    const sourceLocale = get(localeData.translationSourceLocale);
+    const sidebar = await entrySidebar(get, entry, localeData);
+    return /* @__PURE__ */ jsx(
+      EntryEditorContent,
+      {
+        entry,
+        localeData,
+        node: selectedNode,
+        page: page2,
+        parentNeedsTranslation,
+        selectedEntry,
+        sidebar,
+        sourceLocale
+      }
+    );
+  } catch (error) {
+    if (!(error instanceof MissingEntryError)) throw error;
+    return /* @__PURE__ */ jsx(MissingEntry, { page: page2 });
+  }
+});
+function MissingEntry({ page: page2 }) {
+  assert(page2.workspace && page2.root && page2.entry);
+  const root = useAtomValue(rootAtoms(page2.workspace, page2.root).data);
+  const setRoute = useSetAtom(routeAtom);
+  return /* @__PURE__ */ jsx(
+    NotFoundPanel,
+    {
+      title: "Entry not found",
+      message: "The requested entry could not be found. It may have been deleted, moved, or is no longer available.",
+      requestedLabel: "Requested id",
+      requestedValue: page2.entry,
+      actionLabel: `Go to ${root.label}`,
+      onAction: () => setRoute({
+        workspace: page2.workspace,
+        root: page2.root,
+        locale: page2.locale ?? void 0
+      })
+    }
+  );
+}
+function NotFoundPanel({
+  title,
+  message,
+  requestedLabel,
+  requestedValue,
+  actionLabel,
+  onAction
+}) {
+  return /* @__PURE__ */ jsx(Rail, { main: true, children: /* @__PURE__ */ jsx(RailBody, { className: styles.MissingEntry(), children: /* @__PURE__ */ jsxs(Surface, { className: styles.MissingEntry.card(), children: [
+    /* @__PURE__ */ jsx("div", { className: styles.MissingEntry.icon(), children: /* @__PURE__ */ jsx(Icon, { icon: IcBaselineErrorOutline }) }),
+    /* @__PURE__ */ jsx("h1", { className: styles.MissingEntry.title(), children: title }),
+    /* @__PURE__ */ jsx("p", { className: styles.MissingEntry.message(), children: message }),
+    /* @__PURE__ */ jsxs("p", { className: styles.MissingEntry.message(), children: [
+      requestedLabel,
+      ":",
+      " ",
+      /* @__PURE__ */ jsx("code", { className: styles.MissingEntry.id(), children: requestedValue })
+    ] }),
+    onAction && actionLabel && /* @__PURE__ */ jsx(Button, { onPress: onAction, children: actionLabel })
+  ] }) }) });
+}
+function EntryViewToggle({ entry, page: page2 }) {
+  const entryView = useAtomValue(entry.view);
+  const view = page2.view ?? entryView;
+  const setRoute = useSetAtom(routeAtom);
+  const [isPending, startTransition] = useTransition();
+  const nextView = view === "overview" ? "edit" : "overview";
+  const label = nextView === "overview" ? "Show overview" : "Edit entry";
+  const tooltip = nextView === "overview" ? "Overview view" : "Edit view";
+  const ViewIcon = nextView === "overview" ? IcOutlineViewList : IcRoundEdit;
+  return /* @__PURE__ */ jsx(Tooltip, { delay: 300, tooltip, children: /* @__PURE__ */ jsx(
+    Button,
+    {
+      "aria-label": label,
+      appearance: "plain",
+      icon: ViewIcon,
+      isDisabled: isPending,
+      size: "icon",
+      onPress: () => setRoute({
+        workspace: page2.workspace,
+        root: page2.root,
+        entry: page2.entry,
+        locale: page2.locale ?? void 0,
+        view: nextView
+      })
+    }
+  ) });
+}
+function EntryOverview({
+  entry,
+  explorerPage,
+  page: page2,
+  root,
+  selectedEntry
+}) {
+  const setRoute = useSetAtom(routeAtom);
+  const parentId = selectedEntry.parentId;
+  return /* @__PURE__ */ jsx(Rail, { main: true, children: /* @__PURE__ */ jsx(
+    Explorer,
+    {
+      controls: /* @__PURE__ */ jsx("div", { className: styles.EntryOverview.mobileActions(), children: /* @__PURE__ */ jsx(CreateEntryButton, { root, toolbar: true }) }),
+      explorer: root.children(entry.id),
+      page: explorerPage,
+      headerEntry: {
+        backLabel: parentId ? "Back to parent entry" : "Back to root",
+        title: selectedEntry.title,
+        onBack() {
+          setRoute({
+            workspace: selectedEntry.workspace,
+            root: selectedEntry.root,
+            entry: parentId ?? void 0,
+            locale: page2.locale ?? void 0
+          });
+        }
+      },
+      titleControls: /* @__PURE__ */ jsx(EntryViewToggle, { entry, page: page2 })
+    }
+  ) });
+}
+function EntryEditorContent({
+  page: page2,
+  entry,
+  localeData,
+  parentNeedsTranslation,
+  selectedEntry,
+  sidebar,
+  sourceLocale,
+  node
+}) {
+  const typeName = useAtomValue(entry.type);
+  const type = useAtomValue(typeAtoms(typeName));
+  const hasChildren = useAtomValue(entry.hasChildren);
+  const defaultView = useAtomValue(entry.view);
+  const sourceLocales = useAtomValue(entry.translationSourceLocales);
+  const parentPaths = useAtomValue(entry.parentPaths);
+  const View = type.customView;
+  const { locale } = page2;
+  const isUntranslated = selectedEntry.locale !== locale;
+  const setEditing = useSetAtom(localeData.currentlyEditing);
+  const setSourceLocale = useSetAtom(localeData.translationSourceLocale);
+  const saveDraft = useSetAtom(localeData.saveDraft);
+  const publishEdits = useSetAtom(localeData.publishEdits);
+  const reset = useSetAtom(node.reset);
+  const [routeBlock, setRouteBlock] = useAtom(routeBlockAtom);
+  const setRouteGuard = useSetAtom(routeGuardAtom);
+  const [isSidebarOpen, setSidebarOpen] = useAtom(entrySidebarOpenAtom);
+  const editorBodyRef = useRef(null);
+  const isMediaFile = type.type === MediaFile;
+  const isMediaLibrary = type.type === MediaLibrary;
+  const mediaDraftsDisabled = isMediaFile || isMediaLibrary;
+  const discardAndConfirm = () => {
+    reset();
+    routeBlock?.confirm();
+  };
+  const saveAndConfirm = async () => {
+    if (mediaDraftsDisabled) await publishEdits(node);
+    else await saveDraft(node);
+    routeBlock?.confirm();
+  };
+  useEffect(() => {
+    setEditing(node.readOnly && !isUntranslated ? void 0 : node);
+  }, [isUntranslated, node, setEditing]);
+  useEffect(() => {
+    setRouteGuard(node.isDirty);
+    return () => {
+      setRouteGuard((current) => current === node.isDirty ? null : current);
+    };
+  }, [node, setRouteGuard]);
+  useLayoutEffect(() => {
+    if (editorBodyRef.current) editorBodyRef.current.scrollTop = 0;
+  }, [entry.id]);
+  let editorBody = /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(RailBody, { ref: editorBodyRef, className: styles.EntryEditor.body(), children: /* @__PURE__ */ jsxs(RailContent, { className: styles.EntryEditor.fields(), children: [
+    isUntranslated && /* @__PURE__ */ jsx("div", { className: styles.EntryEditor.banner(), children: /* @__PURE__ */ jsx(
+      EntryTranslationBanner,
+      {
+        parentNeedsTranslation,
+        sourceLocale,
+        sourceLocales,
+        onSourceLocaleChange: setSourceLocale
+      }
+    ) }),
+    /* @__PURE__ */ jsx(NodeEditor, { node, type: type.type, children: /* @__PURE__ */ jsx(EntryFields, {}) })
+  ] }) }) });
+  if (isMediaFile) {
+    editorBody = /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(RailBody, { ref: editorBodyRef, className: styles.EntryEditor.body(), children: /* @__PURE__ */ jsx(NodeEditor, { node, type: type.type, children: /* @__PURE__ */ jsx(FileEditor, { entry: selectedEntry, parentPaths }) }) }) });
+  }
+  if (View) {
+    return /* @__PURE__ */ jsx(
+      EntryScope,
+      {
+        entry,
+        localeData,
+        selectedEntry,
+        children: /* @__PURE__ */ jsx(View, { type: type.type })
+      }
+    );
+  }
+  const mainEditor = /* @__PURE__ */ jsxs(Rail, { main: true, children: [
+    /* @__PURE__ */ jsx(
+      EntryHeader,
+      {
+        controls: hasChildren || defaultView === "overview" ? /* @__PURE__ */ jsx(EntryViewToggle, { entry, page: page2 }) : void 0,
+        entry,
+        isSidebarOpen,
+        localeData,
+        node,
+        onSidebarOpenChange: sidebar ? setSidebarOpen : void 0,
+        parentNeedsTranslation,
+        selectedEntry
+      }
+    ),
+    editorBody,
+    /* @__PURE__ */ jsx("div", { id: "alinea-toolbar", className: styles.EntryEditor.toolbar() })
+  ] });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      DashboardModal,
+      {
+        isOpen: Boolean(routeBlock),
+        onOpenChange: (open) => !open && setRouteBlock(null),
+        children: routeBlock && /* @__PURE__ */ jsxs(DashboardModalDialog, { label: "Confirm navigation", children: [
+          /* @__PURE__ */ jsx(DashboardModalContent, { children: "This entry has unsaved changes" }),
+          /* @__PURE__ */ jsxs(DashboardModalFooter, { children: [
+            /* @__PURE__ */ jsx(Button, { onPress: discardAndConfirm, intent: "secondary", children: "Discard my changes" }),
+            /* @__PURE__ */ jsx(Button, { onPress: saveAndConfirm, intent: "primary", children: mediaDraftsDisabled ? "Publish" : "Save as draft" })
+          ] })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      EntryScope,
+      {
+        entry,
+        localeData,
+        selectedEntry,
+        children: [
+          mainEditor,
+          sidebar && isSidebarOpen && /* @__PURE__ */ jsx(EntrySidebar, { ...sidebar, onOpenChange: setSidebarOpen })
+        ]
+      }
+    )
+  ] });
+}
+export {
+  NotFoundPanel,
+  entryPage
+};

package/dist/dashboard/app/pages/RootPage.d.ts

@@ -0,0 +1,9 @@
+import { type Page } from 'alinea/dashboard/atoms/nav';
+import { type RootAtoms } from 'alinea/dashboard/atoms/root';
+export declare const rootPage: (page: Page, get: import("jotai").Getter) => import("react").ReactNode | Promise<import("react").ReactNode>;
+export interface MissingRootProps {
+    page: Page;
+    requestedRoot: string;
+    root: RootAtoms;
+}
+export declare function MissingRoot({ page, requestedRoot, root }: MissingRootProps): import("react").JSX.Element;