alinea 2.0.0-preview.9 → 2.0.0-rc2

package/dist/dashboard/atoms/root.js

@@ -1,21 +1,26 @@
 import {
+  selectAtom,
   unwrap
-} from "../../chunks/chunk-TIJTT5ZI.js";
+} from "../../chunks/chunk-G43W7AME.js";
 import {
   atom
 } from "../../chunks/chunk-CFNRVI3Y.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/atoms/root.ts
+import { Config } from "alinea/core/Config";
 import { Permission } from "alinea/core/Role";
+import { Root } from "alinea/core/Root";
 import { Schema } from "alinea/core/Schema";
 import { Type } from "alinea/core/Type";
-import { getRoot, getType, getWorkspace } from "alinea/core/Internal";
+import { getExpr, getRoot, getWorkspace } from "alinea/core/Internal";
 import {
-  createExplorerAtoms
+  ExplorerAtoms
 } from "alinea/dashboard/atoms/explorer";
 import { IcOutlineDescription } from "../icons.js";
 import { viewAtoms } from "./config.js";
+import { confirmMoveAtom, draggedEntriesAtom } from "./moveConfirmation.js";
+import { rootAcceptsType } from "./move.js";
 import { configAtom, graphAtom } from "./core.js";
 import {
   loadTreeChildren,
@@ -23,13 +28,19 @@ import {
   treeEntryAtoms
 } from "./entry.js";
 import { shaAtom } from "./graph.js";
-import { pageAtom } from "./nav.js";
+import {
+  overviewSortAtom,
+  overviewTabAtom,
+  pageAtom,
+  routeAtom
+} from "./nav.js";
 import { policyAtom } from "./user.js";
 import {
-  acceptsDashboardEntryDrag,
   dashboardEntryDragItem,
   dashboardEntryDragTypes,
-  dispense
+  dashboardEntryDropIds,
+  dispense,
+  moveEntries
 } from "./utils.js";
 var emptyTreeSnapshot = {
   expandedKeys: /* @__PURE__ */ new Set(),
@@ -43,31 +54,60 @@ var emptyTreeView = {
 var TreeAtoms = class {
   expandedKeys;
   collapsedKeys;
+  /** Entries closed by hand, which stay closed when their type expands */
+  closedKeys;
   #root;
   #locale;
   #selectedKeys;
-  constructor(root, locale, selectedKeys, viewState) {
+  #permission;
+  constructor(root, locale, selectedKeys, viewState, permission = Permission.Read) {
     this.#root = root;
     this.#locale = locale;
     this.#selectedKeys = selectedKeys;
+    this.#permission = permission;
     this.expandedKeys = viewState?.expandedKeys ?? atom(/* @__PURE__ */ new Set());
     this.collapsedKeys = viewState?.collapsedKeys ?? atom({
       selectedId: void 0,
       keys: /* @__PURE__ */ new Set()
     });
+    this.closedKeys = viewState?.closedKeys ?? atom(/* @__PURE__ */ new Set());
   }
   #source = atom(async (get) => {
     const config = get(configAtom);
-    const selectedKeys = new Set([...get(this.#selectedKeys)].map(String));
-    const selectedId = [...selectedKeys][0];
-    const selectedModel = selectedId ? treeEntryAtoms(selectedId) : void 0;
-    let selected;
-    try {
-      selected = selectedModel ? await get(selectedModel.summary(this.#locale)) : void 0;
-    } catch (error) {
-      if (!(error instanceof MissingEntryError)) throw error;
-      selected = void 0;
+    const locale = this.#locale;
+    const permission = this.#permission;
+    async function listed(model) {
+      try {
+        return await get(model.summary(locale));
+      } catch (error) {
+        if (error instanceof MissingEntryError) return void 0;
+        throw error;
+      }
+    }
+    async function ancestors(model) {
+      try {
+        return await get(model.parents);
+      } catch (error) {
+        if (error instanceof MissingEntryError) return [];
+        throw error;
+      }
+    }
+    let selectedKeys = new Set([...get(this.#selectedKeys)].map(String));
+    let locationKey;
+    const requestedId = [...selectedKeys][0];
+    let selectedModel = requestedId ? treeEntryAtoms(requestedId, permission) : void 0;
+    let selected = selectedModel ? await listed(selectedModel) : void 0;
+    if (selectedModel && !selected) {
+      for (const ancestor of (await ancestors(selectedModel)).toReversed()) {
+        selected = await listed(ancestor);
+        if (!selected) continue;
+        selectedModel = ancestor;
+        selectedKeys = /* @__PURE__ */ new Set();
+        locationKey = ancestor.id;
+        break;
+      }
     }
+    const selectedId = locationKey ?? [...selectedKeys][0];
     const parents = selectedModel && selected ? await get(selectedModel.parents) : [];
     const models = new Map(parents.map((parent) => [parent.id, parent]));
     if (selectedModel && selected) models.set(selectedModel.id, selectedModel);
@@ -76,46 +116,67 @@ var TreeAtoms = class {
     const expandedKeys = new Set(get(this.expandedKeys));
     for (const parentId of selected?.parents ?? [])
       if (!collapsedKeys.has(parentId)) expandedKeys.add(parentId);
-    const missingModels = (await Promise.all(
-      [...expandedKeys].filter((id) => !models.has(id)).map(async (id) => {
-        try {
-          return await get(treeEntryAtoms(id).ready);
-        } catch (error) {
-          if (error instanceof MissingEntryError) return void 0;
-          throw error;
-        }
-      })
-    )).filter((model) => Boolean(model));
-    for (const model of missingModels) models.set(model.id, model);
-    const expandedModels = [...expandedKeys].flatMap((id) => {
-      const model = models.get(id);
-      return model ? [model] : [];
-    });
-    const [rootModels, childLevels, parentEntries] = await Promise.all([
-      get(this.#root.treeEntries(this.#locale)),
-      Promise.all(
-        expandedModels.map((model) => get(model.children(this.#locale)))
-      ),
-      Promise.all(expandedModels.map((model) => get(model.raw(this.#locale))))
-    ]);
-    const levels = [rootModels, ...childLevels];
-    const parentTypes = [
-      null,
-      ...parentEntries.map((entry) => entry.type)
-    ];
-    const levelItems = await Promise.all(
-      levels.map(
-        (level, index) => Promise.all(
-          level.map(
-            async (model) => rootTreeItem(
-              config,
-              await get(model.summary(this.#locale)),
-              parentTypes[index] ?? null
+    const closedKeys = get(this.closedKeys);
+    const root = this.#root;
+    const treeLocale = this.#locale;
+    async function load() {
+      const missingModels = (await Promise.all(
+        [...expandedKeys].filter((id) => !models.has(id)).map(async (id) => {
+          try {
+            return await get(treeEntryAtoms(id, permission).ready);
+          } catch (error) {
+            if (error instanceof MissingEntryError) return void 0;
+            throw error;
+          }
+        })
+      )).filter((model) => Boolean(model));
+      for (const model of missingModels) models.set(model.id, model);
+      const expandedModels2 = [...expandedKeys].flatMap((id) => {
+        const model = models.get(id);
+        return model ? [model] : [];
+      });
+      const [rootModels, childLevels, parentEntries] = await Promise.all([
+        get(root.treeEntries(treeLocale, permission)),
+        Promise.all(
+          expandedModels2.map((model) => get(model.children(treeLocale)))
+        ),
+        Promise.all(expandedModels2.map((model) => get(model.raw(treeLocale))))
+      ]);
+      const levels = [rootModels, ...childLevels];
+      const levelOrders = [
+        Root.childrenOrder(get(root.data)),
+        ...parentEntries.map((entry) => {
+          const type = config.schema[entry.type];
+          return type && Type.childrenOrder(type);
+        })
+      ];
+      const levelItems2 = await Promise.all(
+        levels.map(
+          (level, index) => Promise.all(
+            level.map(
+              async (model) => rootTreeItem(
+                await get(model.summary(treeLocale)),
+                levelOrders[index]
+              )
             )
           )
         )
-      )
-    );
+      );
+      return { expandedModels: expandedModels2, levelItems: levelItems2 };
+    }
+    function expanding(items) {
+      return items.filter((item) => {
+        const type = config.schema[item.type];
+        return item.hasChildren && type && Type.expands(type) && !expandedKeys.has(item.id) && !closedKeys.has(item.id);
+      });
+    }
+    let loaded = await load();
+    let more;
+    while ((more = expanding(loaded.levelItems.flat())).length > 0) {
+      for (const item of more) expandedKeys.add(item.id);
+      loaded = await load();
+    }
+    const { expandedModels, levelItems } = loaded;
     const entries = /* @__PURE__ */ new Map();
     const children = /* @__PURE__ */ new Map();
     const parentIds = [
@@ -138,23 +199,51 @@ var TreeAtoms = class {
     }
     return {
       entries,
-      snapshot: { expandedKeys, items: nested(null), selectedKeys }
+      snapshot: { expandedKeys, items: nested(null), selectedKeys, locationKey }
     };
   });
+  /**
+   * Applies what the user expanded and collapsed. Keys closed by hand are
+   * remembered, so entries of types that expand from the start stay closed.
+   */
+  expand = atom(null, (get, set, next) => {
+    const current = get(this.snapshot).expandedKeys;
+    const opened = [...next].filter((id) => !current.has(id));
+    const closed = [...current].filter((id) => !next.has(id));
+    if (opened.length === 0 && closed.length === 0) return;
+    set(this.expandedKeys, (keys) => {
+      const result = new Set(keys);
+      for (const id of opened) result.add(id);
+      for (const id of closed) result.delete(id);
+      return result;
+    });
+    set(this.closedKeys, (keys) => {
+      const result = new Set(keys);
+      for (const id of closed) result.add(id);
+      for (const id of opened) result.delete(id);
+      return result;
+    });
+  });
   #state = unwrap(this.#source, (previous) => previous);
   view = atom((get) => get(this.#state) ?? emptyTreeView);
   snapshot = atom((get) => get(this.view).snapshot);
   items = atom((get) => [...get(this.view).entries.values()]);
   #itemSource = dispense(
     (id) => atom(async (get) => {
-      const model = treeEntryAtoms(id);
+      const model = treeEntryAtoms(id, this.#permission);
       const entry = await get(model.summary(this.#locale));
       const config = get(configAtom);
-      const parent = entry.parentId ? await get(treeEntryAtoms(entry.parentId).raw(this.#locale)) : void 0;
-      return rootTreeItem(config, entry, parent?.type ?? null);
+      const parent = entry.parentId ? await get(
+        treeEntryAtoms(entry.parentId, this.#permission).raw(this.#locale)
+      ) : void 0;
+      const parentType = parent ? config.schema[parent.type] : void 0;
+      const order = parent ? parentType && Type.childrenOrder(parentType) : Root.childrenOrder(get(this.#root.data));
+      return rootTreeItem(entry, order);
     })
   );
-  children = dispense((id) => treeEntryAtoms(id).children(this.#locale));
+  children = dispense(
+    (id) => treeEntryAtoms(id, this.#permission).children(this.#locale)
+  );
   #itemState = dispense(
     (id) => unwrap(this.#itemSource(id), (previous) => previous)
   );
@@ -173,10 +262,10 @@ var TreeAtoms = class {
       throw get(this.#itemSource(id));
     })
   );
+  /** The selected entry, or the location of a selected entry that is not listed */
   selectedItem = atom((get) => {
     const state = get(this.#state);
-    const selectedId = state && [...state.snapshot.selectedKeys][0];
-    return selectedId ? state.entries.get(selectedId) : void 0;
+    return state && locatedItem(state);
   });
   canCreate = atom((get) => {
     if (get(this.#root.canCreate)) return true;
@@ -205,7 +294,7 @@ var TreeAtoms = class {
     await Promise.all(
       [...source.entries.keys()].map((id) => get(this.#itemSource(id)))
     );
-    return source.snapshot;
+    return source;
   });
 };
 var RootAtoms = class {
@@ -233,7 +322,8 @@ var RootAtoms = class {
       collapsedKeys: atom({
         selectedId: void 0,
         keys: /* @__PURE__ */ new Set()
-      })
+      }),
+      closedKeys: atom(/* @__PURE__ */ new Set())
     };
     this.tree = dispense(
       (locale) => new TreeAtoms(this, locale, selectedKeys, treeViewState)
@@ -245,67 +335,98 @@ var RootAtoms = class {
   data;
   tree;
   explorer;
-  #explorerLocaleState = atom(null);
+  /**
+   * The last page shown within this root. Explorers keep reading it after
+   * navigating away, so the page that is still rendered while the next one
+   * loads does not reload in another locale.
+   */
+  #lastPage = selectAtom(
+    pageAtom,
+    (page, previous) => page.workspace === this.workspace && page.root === this.key ? page : previous
+  );
+  /** Explorers list the locale of the page, which the route selects */
   #explorerLocale = atom(
-    (get) => {
-      if (get(this.data).isMediaRoot) return null;
-      const page = get(pageAtom);
-      return page.workspace === this.workspace && page.root === this.key ? page.locale : get(this.#explorerLocaleState);
-    },
-    (get, set, update) => {
-      const page = get(pageAtom);
-      const current = page.workspace === this.workspace && page.root === this.key ? page.locale : get(this.#explorerLocaleState);
-      set(
-        this.#explorerLocaleState,
-        typeof update === "function" ? update(current) : update
-      );
+    (get) => get(this.data).isMediaRoot ? null : get(this.#lastPage)?.locale ?? null,
+    (_get, _set, _update) => {
     }
   );
-  createTree(locale, selectedKeys, expandedKeys) {
+  /** A tree that lists the entries the policy allows with the permission */
+  createTree(locale, selectedKeys, state = {}, permission = Permission.Read) {
     return new TreeAtoms(
       this,
       locale,
       selectedKeys,
-      expandedKeys ? {
-        expandedKeys,
+      {
+        expandedKeys: state.expandedKeys ?? atom(/* @__PURE__ */ new Set()),
         collapsedKeys: atom({
           selectedId: void 0,
           keys: /* @__PURE__ */ new Set()
-        })
-      } : void 0
+        }),
+        closedKeys: state.closedKeys ?? atom(/* @__PURE__ */ new Set())
+      },
+      permission
     );
   }
-  treeEntries = dispense(
-    (locale) => atom(async (get) => {
+  #treeEntries = dispense(
+    (locale, permission) => atom(async (get) => {
       get(shaAtom);
       const data = get(this.data);
       return loadTreeChildren(
         get,
         { workspace: this.workspace, root: this.key, parentId: null },
         locale,
-        data.orderChildrenBy
+        permission,
+        Root.childrenOrder(data)
       );
     })
   );
-  children = dispense(
-    (parentId) => createExplorerAtoms(
-      {
-        workspace: this.workspace,
-        root: this.key,
-        parentId: parentId ?? void 0
-      },
+  treeEntries(locale, permission = Permission.Read) {
+    return this.#treeEntries(locale, permission);
+  }
+  /**
+   * The scroll offsets of the explorers of this root. The root explorer and
+   * the overview of an entry can list the same location, which then keeps its
+   * scroll offset when the editor returns to it through either of them.
+   */
+  explorerScrollOffset = dispense((_key) => atom(0));
+  children = dispense((parentId) => {
+    const location = {
+      workspace: this.workspace,
+      root: this.key,
+      parentId: parentId ?? void 0
+    };
+    return new ExplorerAtoms(
+      // The explorer of a page lists the location of its route, browsing to
+      // another location navigates to its page
+      atom(
+        () => location,
+        (get, set, update) => {
+          const next = typeof update === "function" ? update(location) : update;
+          set(routeAtom, {
+            workspace: next.workspace,
+            root: next.root,
+            entry: next.parentId,
+            locale: next.locale ?? get(this.#explorerLocale) ?? void 0,
+            view: next.parentId ? "overview" : void 0
+          });
+        }
+      ),
       {
-        defaultOrderBy: parentId === null ? atom((get) => get(this.data).orderChildrenBy) : void 0,
         enableNavigation: true,
+        sortState: overviewSortAtom(this.workspace, this.key, parentId),
+        tabState: overviewTabAtom(this.workspace, this.key, parentId),
         rootData: this.data,
+        // The filters picked in this list, kept when the editor comes back to
+        // it, like its sort, but not applied to the lists of other entries
+        filterState: atom({}),
+        scrollOffset: this.explorerScrollOffset,
         selectedLocaleAtom: this.#explorerLocale,
-        treeItems: (locale) => this.tree(locale).items,
-        treeReady: (locale) => this.tree(locale).ready,
         selectionBehavior: "toggle",
         selectionMode: "multiple"
-      }
-    )
-  );
+      },
+      location
+    );
+  });
   label = atom((get) => get(this.data).label);
   icon = atom((get) => get(this.data).icon ?? IcOutlineDescription);
   i18n = atom((get) => {
@@ -326,85 +447,94 @@ var RootAtoms = class {
     return typeof view === "string" ? get(viewAtoms(view)) : view;
   });
   acceptedDragTypes = [...dashboardEntryDragTypes];
-  getItems = atom(null, (_get, _set, keys) => {
-    return [...keys].map(dashboardEntryDragItem);
-  });
+  getItems = atom(
+    null,
+    (_get, set, keys) => {
+      set(draggedEntriesAtom, keys);
+      return [...keys].map(dashboardEntryDragItem);
+    }
+  );
   dragDisabled = atom((get) => {
     const policy = get(policyAtom);
     const resource = { workspace: this.workspace, root: this.key };
     return !policy.canMove(resource) && !policy.canReorder(resource);
   });
-  getDropOperation = atom(
-    null,
-    (_get, _set, _target, types, allowedOperations) => {
-      if (!acceptsDashboardEntryDrag(types)) return "cancel";
-      return allowedOperations.includes("move") ? "move" : "cancel";
-    }
-  );
   onMove = atom(
     null,
-    async (get, _set, event, tree) => {
-      const graph = get(graphAtom);
+    async (get, set, event, tree) => {
       const policy = get(policyAtom);
-      const moveTarget = event.target.key ? String(event.target.key) : this.key;
-      const targetType = event.target.key ? "entry" : "root";
-      const items = get(tree.items);
-      for (const key of event.keys) {
-        const id = String(key);
-        const item = items.find((candidate) => candidate.id === id);
-        if (!item || item.dragDisabled) continue;
-        policy.assert(
-          event.target.dropPosition === "on" ? Permission.Move : Permission.Reorder,
-          {
-            workspace: this.workspace,
-            root: this.key,
-            id,
-            type: item.type,
-            locale: item.locale,
-            parents: item.parents
-          }
-        );
-        await graph.move({
-          id,
-          target: moveTarget,
-          targetType,
-          dropPosition: event.target.dropPosition
-        });
-      }
-    }
-  );
-  onDrop = atom(
-    null,
-    async (get, _set, event) => {
-      const keys = /* @__PURE__ */ new Set();
-      for (const item of event.items) {
-        if (item.kind !== "text" || !item.types || !item.getText) continue;
-        let id = null;
-        if (item.types.has(dashboardEntryDragTypes[0]))
-          id = await item.getText(dashboardEntryDragTypes[0]);
-        else if (item.types.has("text/plain"))
-          id = await item.getText("text/plain");
-        if (id) keys.add(id);
-      }
-      const graph = get(graphAtom);
-      const moveTarget = event.target.key ? String(event.target.key) : this.key;
-      const targetType = event.target.key ? "entry" : "root";
-      for (const key of keys) {
-        const id = String(key);
-        await graph.move({
-          id,
-          target: moveTarget,
-          targetType,
-          dropPosition: event.target.dropPosition
+      const permission = event.target.position === "on" ? Permission.Move : Permission.Reorder;
+      const { entries } = get(tree.view);
+      const accepted = treeAcceptsDrop(
+        get(configAtom),
+        get(this.data),
+        entries,
+        event.target,
+        event.keys
+      );
+      if (!accepted) return;
+      const moving = get(tree.items).filter((item) => event.keys.has(item.id));
+      for (const item of moving)
+        policy.assert(permission, {
+          workspace: this.workspace,
+          root: this.key,
+          id: item.id,
+          type: item.type,
+          locale: item.locale,
+          parents: item.parents
         });
-      }
+      const ids = moving.map((item) => item.id);
+      if (!await set(confirmMoveAtom, ids, event.target)) return;
+      await moveEntries(get(graphAtom), ids, event.target);
     }
   );
+  onDrop = atom(null, async (get, set, event) => {
+    const ids = dashboardEntryDropIds(event.items);
+    if (!await set(confirmMoveAtom, ids, event.target)) return;
+    await moveEntries(get(graphAtom), ids, event.target);
+  });
 };
 var rootAtoms = dispense(
   (workspace, root) => new RootAtoms(workspace, root)
 );
-function rootTreeItem(config, entry, parentType) {
+function treeAcceptsDrop(config, rootData, entries, target, keys = /* @__PURE__ */ new Set()) {
+  const entry = entries.get(String(target.key));
+  if (!entry || entry.parents.some((id) => keys.has(id))) return false;
+  const into = target.position === "on";
+  if (into ? keys.has(entry.id) : entry.ordered) return false;
+  const parentId = into ? entry.id : entry.parentId;
+  const parent = parentId ? entries.get(parentId) : void 0;
+  const parentType = parent && config.schema[parent.type];
+  if (into && !(parentType && Type.isContainer(parentType))) return false;
+  for (const key of keys) {
+    const dragged = entries.get(String(key));
+    if (!dragged || !config.schema[dragged.type]) continue;
+    if (dragged.parentId === parentId) continue;
+    if (parentId && !parentType) continue;
+    const accepted = parentType ? Config.typeContains(config, parentType, config.schema[dragged.type]) : rootAcceptsType(config, rootData, dragged.type);
+    if (!accepted) return false;
+  }
+  return true;
+}
+function locatedItem({
+  entries,
+  snapshot
+}) {
+  const id = snapshot.locationKey ?? [...snapshot.selectedKeys][0];
+  return id ? entries.get(id) : void 0;
+}
+function ordersType(order, type) {
+  const [first] = order ? [order].flat() : [];
+  if (!first) return false;
+  let expr = getExpr(first.asc ?? first.desc);
+  if (expr.type === "typeSwitch") {
+    const inner = expr.cases[type];
+    if (!inner) return true;
+    expr = getExpr(inner);
+  }
+  return !first.asc || expr.type !== "entryField" || expr.name !== "index";
+}
+function rootTreeItem(entry, order) {
   return {
     id: entry.id,
     title: entry.title,
@@ -415,9 +545,7 @@ function rootTreeItem(config, entry, parentType) {
     parentId: entry.parentId,
     parents: entry.parents,
     hasChildren: entry.hasChildren,
-    dragDisabled: Boolean(
-      parentType && getType(config.schema[parentType]).orderChildrenBy
-    )
+    ordered: ordersType(order, entry.type)
   };
 }
 function containsCreatableType(get, resource, contains) {
@@ -440,5 +568,7 @@ function containsCreatableType(get, resource, contains) {
 export {
   RootAtoms,
   TreeAtoms,
-  rootAtoms
+  locatedItem,
+  rootAtoms,
+  treeAcceptsDrop
 };