alinea 2.0.0-preview.11 → 2.0.0-preview.13

package/dist/dashboard/atoms/move.js

@@ -7,12 +7,12 @@ import "../../chunks/chunk-CQ52GEHY.js";
 import { Config } from "alinea/core/Config";
 import { MoveOperation } from "alinea/core/db/Operation";
 import { Entry } from "alinea/core/Entry";
+import { getRoot, getWorkspace } from "alinea/core/Internal";
 import { MediaFile } from "alinea/core/media/MediaTypes";
 import { Schema } from "alinea/core/Schema";
 import { Type } from "alinea/core/Type";
 import { entries } from "alinea/core/util/Objects";
 import { configAtom, graphAtom } from "./core.js";
-import { rootAtoms } from "./root.js";
 import { policyAtom } from "./user.js";
 function rootAcceptsType(config, rootData, typeName) {
   const contains = rootData.contains;
@@ -36,10 +36,34 @@ function moveTargets(config, policy, rootData, selected, translated) {
   const containers = entries(config.schema).filter(
     ([, parent]) => movable && !Type.isHidden(parent) && types.every((type) => type && Config.typeContains(config, parent, type))
   ).map(([name]) => name);
+  const canSelect = (item) => !moving.has(item.id) && !item.parents.some((parent) => moving.has(parent)) && (!translated || translated.has(item.id)) && policy.canMove(item);
   return {
     subjects,
     condition: { _type: { in: containers } },
-    canSelect: (item) => !moving.has(item.id) && !item.parents.some((parent) => moving.has(parent)) && (!translated || translated.has(item.id)) && policy.canMove(item),
+    canSelect,
+    refusal(parent) {
+      if (!movable) return "These entries can't be moved.";
+      const single = subjects.length === 1;
+      const these = single ? `"${first.title}"` : "these entries";
+      const These = single ? these : "These entries";
+      const kinds = typeNames.map((name) => Type.label(config.schema[name])).join(" or ");
+      if (!parent) {
+        if (!typeNames.every((name) => rootAcceptsType(config, rootData, name)))
+          return `${rootData.label} doesn't hold ${kinds} at its top level.`;
+        if (!policy.canMove({ workspace: first.workspace, root: first.root }))
+          return `You can't move entries to the top level of ${rootData.label}.`;
+        return void 0;
+      }
+      if (moving.has(parent.id) || parent.parents.some((id) => moving.has(id)))
+        return `${These} can't be moved into itself.`;
+      if (!containers.includes(parent.type))
+        return `"${parent.title}" can't hold ${kinds}.`;
+      if (translated && !translated.has(parent.id))
+        return `"${parent.title}" doesn't exist in every language of ${these}.`;
+      if (!policy.canMove(parent))
+        return `You can't move entries into "${parent.title}".`;
+      return void 0;
+    },
     rootAccepts: movable && typeNames.every((name) => rootAcceptsType(config, rootData, name)) && policy.canMove({ workspace: first.workspace, root: first.root })
   };
 }
@@ -49,7 +73,9 @@ var loadMoveTargetsAtom = atom(
     const config = get(configAtom);
     const policy = get(policyAtom);
     const [{ workspace, root }] = subjects;
-    const rootData = get(rootAtoms(workspace, root).data);
+    const rootData = getRoot(
+      getWorkspace(config.workspaces[workspace]).roots[root]
+    );
     const targets = moveTargets(config, policy, rootData, subjects);
     if (!rootData.i18n) return targets;
     const graph = get(graphAtom);

package/dist/dashboard/atoms/moveConfirmation.d.ts

@@ -0,0 +1,34 @@
+import type { DropTarget, Key } from 'alinea/components';
+/**
+ * A dragged move to confirm: the pages it gives another parent, and so
+ * another url, or why it can not move there
+ */
+export interface MoveConfirmation {
+    pages: Array<{
+        id: string;
+        title: string;
+    }>;
+    refusal?: string;
+    resolve(confirmed: boolean): void;
+}
+/** Whether moving pages asks first, until the editor stops it here */
+export declare const confirmMovesAtom: import("jotai").WritableAtom<boolean, [boolean | typeof import("jotai/utils").RESET | ((prev: boolean) => boolean | typeof import("jotai/utils").RESET)], void>;
+/**
+ * The entries being dragged, known from the start of a drag so that drop
+ * targets can turn down the ones they can not hold
+ */
+export declare const draggedEntriesAtom: import("jotai").PrimitiveAtom<ReadonlySet<Key>> & {
+    init: ReadonlySet<Key>;
+};
+export declare const moveConfirmationAtom: import("jotai").PrimitiveAtom<MoveConfirmation | undefined> & {
+    init: MoveConfirmation | undefined;
+};
+/**
+ * Whether entries dropped on a target can move there, and the editor agrees:
+ * entries that get another parent follow the rules of moving them with the
+ * move dialog, and entries of a document type ask first, as their url and
+ * those of the pages below them change.
+ */
+export declare const confirmMoveAtom: import("jotai").WritableAtom<null, [ids: Iterable<string>, target: DropTarget], Promise<boolean>> & {
+    init: null;
+};

package/dist/dashboard/atoms/moveConfirmation.js

@@ -0,0 +1,95 @@
+import {
+  atomWithStorage
+} from "../../chunks/chunk-G43W7AME.js";
+import {
+  atom
+} from "../../chunks/chunk-CFNRVI3Y.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/moveConfirmation.ts
+import { isDocument } from "alinea/core/Document";
+import { Entry } from "alinea/core/Entry";
+import { configAtom, graphAtom } from "./core.js";
+import { loadMoveTargetsAtom } from "./move.js";
+import { policyAtom } from "./user.js";
+var confirmMovesAtom = atomWithStorage(
+  "alinea-dashboard-confirm-moves",
+  true,
+  void 0,
+  { getOnInit: true }
+);
+var draggedEntriesAtom = atom(/* @__PURE__ */ new Set());
+var moveConfirmationAtom = atom(
+  void 0
+);
+var moveItem = {
+  id: Entry.id,
+  title: Entry.title,
+  type: Entry.type,
+  workspace: Entry.workspace,
+  root: Entry.root,
+  locale: Entry.locale,
+  parentId: Entry.parentId,
+  parents: Entry.parents,
+  seeded: Entry.seeded
+};
+var confirmMoveAtom = atom(
+  null,
+  async (get, set, ids, target) => {
+    const graph = get(graphAtom);
+    const query = { status: "preferDraft", select: moveItem };
+    const [rows, dropped] = await Promise.all([
+      graph.find({ ...query, id: { in: [...ids] } }),
+      graph.first({ ...query, id: String(target.key) })
+    ]);
+    if (!dropped) return false;
+    const subjects = [...new Map(rows.map((row) => [row.id, row])).values()];
+    const parentId = target.position === "on" ? dropped.id : dropped.parentId;
+    const moved = subjects.filter(
+      (subject) => subject.parentId !== parentId || subject.workspace !== dropped.workspace || subject.root !== dropped.root
+    );
+    if (moved.length === 0) return true;
+    const ask = (question) => new Promise(
+      (resolve) => set(moveConfirmationAtom, {
+        ...question,
+        resolve(confirmed) {
+          set(moveConfirmationAtom, void 0);
+          resolve(confirmed);
+        }
+      })
+    );
+    const refusal = await moveRefusal(get, set, moved, dropped, parentId);
+    if (refusal) return ask({ pages: [], refusal }).then(() => false);
+    const { schema } = get(configAtom);
+    const pages = moved.filter((subject) => {
+      const type = schema[subject.type];
+      return type && isDocument(type);
+    });
+    if (pages.length === 0 || !get(confirmMovesAtom)) return true;
+    return ask({ pages: pages.map(({ id, title }) => ({ id, title })) });
+  }
+);
+async function moveRefusal(get, set, moved, dropped, parentId) {
+  const policy = get(policyAtom);
+  for (const subject of moved) {
+    if (subject.workspace !== dropped.workspace || subject.root !== dropped.root)
+      return "Entries can't be moved out of their root.";
+    if (subject.seeded)
+      return `"${subject.title}" is part of the site setup and can't be moved.`;
+    if (!policy.canMove(subject)) return `You can't move "${subject.title}".`;
+  }
+  const targets = await set(loadMoveTargetsAtom, moved);
+  if (parentId === null) return targets.refusal(null);
+  const parent = parentId === dropped.id ? dropped : await get(graphAtom).first({
+    id: parentId,
+    status: "preferDraft",
+    select: moveItem
+  });
+  return parent ? targets.refusal(parent) : "The new parent can't be found.";
+}
+export {
+  confirmMoveAtom,
+  confirmMovesAtom,
+  draggedEntriesAtom,
+  moveConfirmationAtom
+};

package/dist/dashboard/atoms/nav.d.ts

@@ -1,4 +1,4 @@
-import { Atom, Getter } from 'jotai';
+import { Atom, type Getter } from 'jotai';
 import type { OverviewSort } from 'alinea/core/Overview';
 import type { EntryDefaultView } from 'alinea/core/Type';
 import { ReactNode } from 'react';
@@ -12,7 +12,9 @@ export declare const routeBlockAtom: import("jotai").PrimitiveAtom<RouteBlock |
     init: RouteBlock | null;
 };
 export interface DashboardRoute {
-    page?: 'splash' | 'entry' | 'users';
+    /** An edit link names an entry by its url, until it is looked up */
+    page?: 'splash' | 'entry' | 'users' | 'edit';
+    url?: string;
     workspace?: string;
     root?: string;
     entry?: string;
@@ -24,11 +26,13 @@ export interface DashboardRoute {
     replace?: boolean;
 }
 interface ResolvedDashboardRoute extends DashboardRoute {
-    page: 'splash' | 'entry' | 'users';
+    page: 'splash' | 'entry' | 'users' | 'edit';
 }
 export declare const nav: {
     splash(): string;
     users(): string;
+    /** The editor of the entry at `url`, as linked from a page of the site */
+    edit(url: string, workspace?: string, root?: string): string;
     entry(workspace?: string, root?: string, entryId?: string, locale?: string | null, view?: EntryDefaultView, sort?: string): string;
 };
 /** The url parameter of an overview sort: the column, prefixed with - when descending */
@@ -40,11 +44,11 @@ interface NavigationRequest {
     route: ResolvedDashboardRoute;
 }
 /** @internal */
-export declare const routeAtom: import("jotai").WritableAtom<ResolvedDashboardRoute, [update: DashboardRoute | NavigationRequest], void> & {
+export declare const routeAtom: import("jotai").WritableAtom<ResolvedDashboardRoute, [update: DashboardRoute | NavigationRequest], void | Promise<void>> & {
     onMount(navigate: (request: NavigationRequest) => void): (() => void) | undefined;
 };
 export interface Page {
-    type: 'splash' | 'users' | 'entry';
+    type: 'splash' | 'users' | 'entry' | 'edit';
     workspace: string | undefined;
     root: string | undefined;
     requestedRoot?: string;

package/dist/dashboard/atoms/nav.js

@@ -58,9 +58,10 @@ function atomWithLocation(options) {
 }
 
 // src/dashboard/atoms/nav.ts
+import { Entry } from "alinea/core/Entry";
 import { getRoot } from "alinea/core/Internal";
 import { workspaceAtom, workspacesAtom } from "./config.js";
-import { configAtom } from "./core.js";
+import { configAtom, graphAtom } from "./core.js";
 import { policyAtom } from "./user.js";
 import { dispense } from "./utils.js";
 var routeGuardAtom = atom(null);
@@ -72,6 +73,13 @@ var nav = {
   users() {
     return "/users";
   },
+  /** The editor of the entry at `url`, as linked from a page of the site */
+  edit(url, workspace, root) {
+    const params = new URLSearchParams({ url });
+    if (workspace) params.set("workspace", workspace);
+    if (root) params.set("root", root);
+    return `/edit?${params}`;
+  },
   entry(workspace, root, entryId, locale, view, sort) {
     const rootPart = root ? `${root}${locale ? `:${locale}` : ""}` : "";
     const path = `/entry/${[workspace, rootPart, entryId].filter(Boolean).join("/")}`;
@@ -100,9 +108,17 @@ var overviewSortMemoryAtom = atom(/* @__PURE__ */ new Map());
 function routeFromHash(hash) {
   const [path, search = ""] = hash.slice(1).split("?");
   const [action, workspace, rootPart = "", entry] = path.split("/").slice(1);
+  const params = new URLSearchParams(search);
+  const url = params.get("url");
+  if (action === "edit" && url)
+    return {
+      page: "edit",
+      url,
+      workspace: params.get("workspace") ?? void 0,
+      root: params.get("root") ?? void 0
+    };
   const page2 = action === "users" ? "users" : action === "entry" ? "entry" : "splash";
   const [root, locale] = rootPart.split(":");
-  const params = new URLSearchParams(search);
   const view = params.get("view");
   const sort = params.get("sort");
   return {
@@ -118,6 +134,13 @@ function routeFromHash(hash) {
 function routeFromUpdate(update) {
   if (update.page === "users") return { page: "users" };
   if (update.page === "splash") return { page: "splash" };
+  if (update.page === "edit")
+    return update.url ? {
+      page: "edit",
+      url: update.url,
+      workspace: update.workspace,
+      root: update.root
+    } : { page: "splash" };
   return {
     page: "entry",
     workspace: update.workspace,
@@ -129,6 +152,8 @@ function routeFromUpdate(update) {
   };
 }
 function hashFromRoute(route) {
+  if (route.page === "edit")
+    return `#${nav.edit(route.url ?? "/", route.workspace, route.root)}`;
   return route.page === "splash" ? `#${nav.splash()}` : route.page === "users" ? `#${nav.users()}` : `#${nav.entry(
     route.workspace,
     route.root,
@@ -155,6 +180,7 @@ var initialRoute = routeFromHash(
 );
 var currentRouteAtom = atom(initialRoute);
 var ignoredBrowserHash;
+var linkLookups = 0;
 var routeAtom = Object.assign(
   atom(
     (get) => get(currentRouteAtom),
@@ -163,58 +189,31 @@ var routeAtom = Object.assign(
         route: routeFromUpdate(update),
         replace: update.replace
       };
-      let { route } = request;
-      const key = sortKey(get, request);
-      const explicit = request.browser || route.sort !== void 0 || "sort" in update;
-      if (key && !explicit) {
-        const sort = get(overviewSortMemoryAtom).get(key);
-        if (sort) route = { ...route, sort: formatOverviewSort(sort) };
-      }
-      const previous = get(currentRouteAtom);
-      const commit = (replace = request.replace ?? false, syncLocation = !request.browser) => {
-        set(currentRouteAtom, route);
-        if (key)
-          set(
-            overviewSortMemoryAtom,
-            (memory) => remember(memory, key, route.sort)
-          );
-        if (!syncLocation) return;
-        set(
-          locationAtom,
-          (location) => ({ ...location, hash: hashFromRoute(route) }),
-          { replace }
-        );
-      };
-      const guard = get(routeGuardAtom);
-      if (guard && get(guard)) {
-        if (request.browser) {
-          ignoredBrowserHash = hashFromRoute(previous);
-          set(
-            locationAtom,
-            (location) => ({ ...location, hash: hashFromRoute(previous) }),
-            { replace: true }
-          );
-        }
-        set(routeBlockAtom, {
-          confirm() {
-            set(routeBlockAtom, null);
-            commit(request.browser, true);
-          }
-        });
-        return;
-      }
-      commit();
+      if (request.route.page !== "edit")
+        return navigate(get, set, request, "sort" in update);
+      const current = get(currentRouteAtom);
+      const lookup = ++linkLookups;
+      set(
+        locationAtom,
+        (location) => ({ ...location, hash: hashFromRoute(current) }),
+        { replace: true }
+      );
+      return linkedRoute(get, request.route).catch(() => ({ page: "splash" })).then((route) => {
+        if (lookup !== linkLookups || get(currentRouteAtom) !== current)
+          return;
+        navigate(get, set, { route, replace: true }, true);
+      });
     }
   ),
   {
-    onMount(navigate) {
+    onMount(navigate2) {
       if (typeof window === "undefined") return;
       const onNavigation = () => {
         if (window.location.hash === ignoredBrowserHash) {
           ignoredBrowserHash = void 0;
           return;
         }
-        navigate({ browser: true, route: routeFromHash(window.location.hash) });
+        navigate2({ browser: true, route: routeFromHash(window.location.hash) });
       };
       window.addEventListener("hashchange", onNavigation);
       window.addEventListener("popstate", onNavigation);
@@ -226,6 +225,73 @@ var routeAtom = Object.assign(
     }
   }
 );
+function navigate(get, set, request, sortGiven) {
+  let { route } = request;
+  const key = sortKey(get, request);
+  const explicit = request.browser || route.sort !== void 0 || sortGiven;
+  if (key && !explicit) {
+    const sort = get(overviewSortMemoryAtom).get(key);
+    if (sort) route = { ...route, sort: formatOverviewSort(sort) };
+  }
+  const previous = get(currentRouteAtom);
+  const commit = (replace = request.replace ?? false, syncLocation = !request.browser) => {
+    set(currentRouteAtom, route);
+    if (key)
+      set(overviewSortMemoryAtom, (memory) => remember(memory, key, route.sort));
+    if (!syncLocation) return;
+    set(locationAtom, (location) => ({ ...location, hash: hashFromRoute(route) }), {
+      replace
+    });
+  };
+  const guard = get(routeGuardAtom);
+  if (guard && get(guard)) {
+    if (request.browser) {
+      ignoredBrowserHash = hashFromRoute(previous);
+      set(
+        locationAtom,
+        (location) => ({ ...location, hash: hashFromRoute(previous) }),
+        { replace: true }
+      );
+    }
+    set(routeBlockAtom, {
+      confirm() {
+        set(routeBlockAtom, null);
+        commit(request.browser, true);
+      }
+    });
+    return;
+  }
+  commit();
+}
+async function linkedRoute(get, { url = "/", workspace, root }) {
+  const graph = get(graphAtom);
+  const query = {
+    workspace,
+    root,
+    status: "preferDraft",
+    select: {
+      entry: Entry.id,
+      locale: Entry.locale,
+      workspace: Entry.workspace,
+      root: Entry.root
+    }
+  };
+  const urls = [.../* @__PURE__ */ new Set([withoutSlash(url), withoutSlash(decoded(url))])];
+  const live = { ...query, filter: { _status: { isNot: "archived" } } };
+  const found = await graph.first({ ...live, url: { in: urls } }) ?? await graph.first({ ...live, alias: { in: urls } }) ?? await graph.first({ ...query, url: { in: urls } });
+  if (!found) return { page: "splash" };
+  return { page: "entry", ...found, locale: found.locale ?? void 0 };
+}
+function decoded(url) {
+  try {
+    return decodeURI(url);
+  } catch {
+    return url;
+  }
+}
+function withoutSlash(url) {
+  return url.length > 1 && url.endsWith("/") ? url.slice(0, -1) : url;
+}
 function sortKey(get, { browser, route }) {
   if (route.page !== "entry") return void 0;
   if (route.workspace && route.root)
@@ -244,6 +310,15 @@ function remember(memory, key, value) {
 }
 var pageAtom = atom((get) => resolvePage(get, get(routeAtom)));
 function resolvePage(get, route) {
+  if (route.page === "edit")
+    return {
+      type: "edit",
+      workspace: void 0,
+      root: void 0,
+      entry: void 0,
+      locale: null,
+      view: void 0
+    };
   const config = get(configAtom);
   const policy = get(policyAtom);
   const workspaces = get(workspacesAtom);

package/dist/dashboard/atoms/overview.d.ts

@@ -11,7 +11,7 @@ import { type RootData } from 'alinea/core/Root';
 import { Type } from 'alinea/core/Type';
 import type { View } from 'alinea/core/View';
 /** The columns every overview can show next to its configured columns */
-export type OverviewBuiltinColumn = 'type' | 'status' | 'updated' | 'author';
+export type OverviewBuiltinColumn = 'type' | 'updated' | 'author';
 /** The number of `overview: true` fields shown when a parent has no columns */
 export declare const overviewFieldColumnLimit = 5;
 /** Where a list of entries lives, its overview is configured there */
@@ -109,7 +109,7 @@ export interface OverviewResolveOptions {
      */
     mixed?: boolean;
     /**
-     * The listed children grouped by type and status, see `summarizeRows`.
+     * The listed children grouped by type, see `summarizeRows`.
      * The columns then follow the children: the types present, and built-in
      * columns only when they tell the children apart.
      */
@@ -158,6 +158,8 @@ export interface OverviewRow {
     path: string;
     url?: string;
     status?: EntryStatus;
+    /** The version is the main one, a draft then was never published */
+    main?: boolean;
     locale: string | null;
     workspace: string;
     root: string;
@@ -186,17 +188,16 @@ export declare function linkedEntryId(value: unknown): string | undefined;
 export declare const openEntryAtom: import("jotai").WritableAtom<null, [id: string, locale: string | null], Promise<void>> & {
     init: null;
 };
-/** The listed children that share a type and status */
+/** The listed children that share a type */
 export interface OverviewChildren {
     type: string;
-    status: EntryStatus;
     /** Some of these children store when they were last edited */
     updatedAt: boolean;
     /** Some of these children store who last edited them */
     updatedBy: boolean;
 }
 /**
- * Groups rows by type and status, noting whether they store audit
+ * Groups rows by type, noting whether they store audit
  * metadata. Lists load every child of their parent and searches their
  * shown results, so this covers every row and the columns stay put.
  */

package/dist/dashboard/atoms/overview.js

@@ -23,7 +23,6 @@ import { graphAtom } from "./core.js";
 import { routeAtom } from "./nav.js";
 var builtinColumns = [
   "type",
-  "status",
   "updated",
   "author"
 ];
@@ -49,15 +48,6 @@ function builtinColumn(key) {
         collapsible: true,
         sortBy: Entry.type
       };
-    case "status":
-      return {
-        key,
-        builtin: key,
-        header: "Status",
-        width: 120,
-        collapsible: true,
-        sortBy: Entry.status
-      };
     case "updated":
       return {
         key,
@@ -129,7 +119,6 @@ function resolveOverviewOptions(config, overview, types, sort, options = {}) {
   const audited = childTypes.some(hasAuditMetadata);
   const defaults = {
     type: children ? new Set(children.map((group) => group.type)).size > 1 : Boolean(options.mixed) || listed.length > 1,
-    status: children ? new Set(children.map((group) => group.status)).size > 1 : true,
     updated: children ? children.some((group) => group.updatedAt) : audited,
     author: children ? children.some((group) => group.updatedBy) : audited
   };
@@ -456,17 +445,14 @@ var openEntryAtom = atom(
 function summarizeRows(rows) {
   const groups = /* @__PURE__ */ new Map();
   for (const row of rows) {
-    const status = row.status ?? "published";
-    const key = `${row.type}\0${status}`;
-    const group = groups.get(key) ?? {
+    const group = groups.get(row.type) ?? {
       type: row.type,
-      status,
       updatedAt: false,
       updatedBy: false
     };
     group.updatedAt ||= hasAuditValue(row, "updatedAt");
     group.updatedBy ||= hasAuditValue(row, "updatedBy");
-    groups.set(key, group);
+    groups.set(row.type, group);
   }
   return [...groups.values()];
 }