alinea 2.0.0-preview.12 → 2.0.0-preview.13

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

@@ -0,0 +1,112 @@
+import type { Config } from 'alinea/core/Config';
+import type { EntryReference } from 'alinea/core/db/EntryReference';
+import type { EntryFields } from 'alinea/core/EntryFields';
+import type { Filter } from 'alinea/core/Filter';
+import type { Policy } from 'alinea/core/Role';
+import { type Atom, type PrimitiveAtom } from 'jotai';
+import { type EntryReferenceWithSource } from './entry.js';
+import type { ExplorerItemData, ExplorerLimitLocation } from './explorer.js';
+/** Deleting removes the entries, archiving unpublishes them until restored */
+export type RemoveAction = 'delete' | 'archive';
+/** An entry that is about to be removed, in the locale it is shown in */
+export interface RemoveSubject {
+    id: string;
+    title: string;
+    type: string;
+    workspace: string;
+    root: string;
+    /** Null for entries without languages */
+    locale: string | null;
+    parents: Array<string>;
+    hasChildren: boolean;
+}
+/** A translation that is removed, a null locale removes every version */
+export interface Removal {
+    id: string;
+    locale: string | null;
+}
+/** An entry that is removed with the translation of its parent */
+export interface RemovedDescendant extends Removal {
+    subjectId: string;
+}
+/** The public URL of a removed translation of a page */
+export interface RemovedUrl extends Removal {
+    url: string;
+}
+/** The page the URLs of the removed pages redirect to */
+export interface RedirectTarget {
+    id: string;
+    title: string;
+    url: string;
+    /** The languages of its versions, null for an entry without languages */
+    locales: Array<string | null>;
+}
+/** Which languages of the entries are removed and the links that will break */
+export interface RemovePlan {
+    subjects: Array<RemoveSubject>;
+    /** The languages of a single entry the user can pick to delete, undefined
+     * for a batch */
+    locales?: Array<string>;
+    /** The picked languages, the shown language at first */
+    selectedLocales: PrimitiveAtom<Array<string>>;
+    removals: Atom<Array<Removal>>;
+    /** The versions linking to the removed translations and their contents,
+     * that are not removed themselves */
+    references: Atom<Array<EntryReferenceWithSource>>;
+    /** How many entries the user can not read link to them, their titles stay
+     * hidden */
+    hiddenSources: Atom<number>;
+    /** Every removed translation is published and can be archived instead */
+    archivable: Atom<boolean>;
+    /** The public URLs of the removed translations of pages */
+    urls: Atom<Array<RemovedUrl>>;
+    /** The page the editor picked to redirect the URLs to */
+    redirect: PrimitiveAtom<RedirectTarget | undefined>;
+    /** The URLs the redirect target has no version for, they don't redirect */
+    unredirected: Atom<Array<RemovedUrl>>;
+}
+export interface RemovePlanOptions {
+    subjects: Array<RemoveSubject>;
+    locales?: Array<string>;
+    references?: Array<EntryReferenceWithSource>;
+    /** Links from versions the user can not read */
+    hidden?: Array<EntryReference>;
+    descendants?: Array<RemovedDescendant>;
+    /** The translations that can be archived */
+    archivable?: Array<Removal>;
+    /** The public URLs of the subjects, in each of their languages */
+    urls?: Array<RemovedUrl>;
+}
+/**
+ * Entries without languages are removed entirely, the others in the picked
+ * languages or, in a batch, the language they are shown in.
+ */
+export declare function createRemovePlan({ subjects, locales, references, hidden, descendants, archivable, urls }: RemovePlanOptions): RemovePlan;
+export interface RedirectPicker {
+    /** The entries of the types that hold URL aliases */
+    condition: Filter<EntryFields>;
+    /** The roots of the workspace of the removed entries */
+    locations: Array<ExplorerLimitLocation>;
+    /** Entries that are not removed and the user may add an alias to */
+    canSelect(item: ExplorerItemData): boolean;
+}
+/** Which pages the URLs of the removed entries can redirect to */
+export declare function redirectPicker(config: Config, policy: Policy, subjects: Array<RemoveSubject>): RedirectPicker;
+/** Loads the page the editor picked to redirect the URLs to */
+export declare const loadRedirectTargetAtom: import("jotai").WritableAtom<null, [id: string, locale: string | null], Promise<RedirectTarget | undefined>> & {
+    init: null;
+};
+/** Loads the references to the entries before the remove dialog opens */
+export declare const loadRemovePlanAtom: import("jotai").WritableAtom<null, [subjects: RemoveSubject[], locales?: string[] | undefined], Promise<RemovePlan>> & {
+    init: null;
+};
+/** Removes the translations and redirects their URLs in one commit */
+export declare const deleteEntriesAtom: import("jotai").WritableAtom<null, [plan: RemovePlan], Promise<void>> & {
+    init: null;
+};
+/** Archives the translations the plan would delete */
+export declare const archiveEntriesAtom: import("jotai").WritableAtom<null, [plan: RemovePlan], Promise<void>> & {
+    init: null;
+};
+/** Archive without asking first, until the browser session ends */
+export declare const archiveDirectlyAtom: import("jotai").WritableAtom<boolean, [boolean | typeof import("jotai/utils").RESET | ((prev: boolean) => boolean | typeof import("jotai/utils").RESET)], void>;

package/dist/dashboard/atoms/remove.js

@@ -0,0 +1,268 @@
+import {
+  atomWithStorage,
+  createJSONStorage
+} from "../../chunks/chunk-G43W7AME.js";
+import {
+  atom
+} from "../../chunks/chunk-CFNRVI3Y.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/remove.ts
+import { Entry } from "alinea/core/Entry";
+import { getWorkspace } from "alinea/core/Internal";
+import { MediaFile, MediaLibrary } from "alinea/core/media/MediaTypes";
+import { Root } from "alinea/core/Root";
+import { entries } from "alinea/core/util/Objects";
+import { dataWithUrlAliases, hasUrlAliases } from "alinea/database/EntryUrlAliases";
+import { configAtom, graphAtom } from "./core.js";
+import { loadIncomingReferences } from "./entry.js";
+import { policyAtom } from "./user.js";
+function createRemovePlan({
+  subjects,
+  locales,
+  references = [],
+  hidden = [],
+  descendants = [],
+  archivable = [],
+  urls = []
+}) {
+  const shown = subjects[0]?.locale;
+  const selectedLocales = atom(
+    shown && locales?.includes(shown) ? [shown] : Array()
+  );
+  const removals = atom((get) => {
+    const selected = get(selectedLocales);
+    return subjects.flatMap(({ id, locale }) => {
+      if (locale === null || !locales) return [{ id, locale }];
+      return selected.map((locale2) => ({ id, locale: locale2 }));
+    });
+  });
+  const removed = atom(
+    (get) => get(removals).flatMap((removal) => [
+      removal,
+      ...descendants.filter(
+        ({ subjectId, locale }) => subjectId === removal.id && locale === removal.locale
+      )
+    ])
+  );
+  const breaks = (reference, removed2) => !removed2.some(
+    ({ id, locale }) => id === reference.sourceId && locale === reference.sourceLocale
+  ) && // References hold the language of the linking entry: links from an
+  // entry without languages can point to any language
+  removed2.some(
+    ({ id, locale }) => id === reference.targetId && (locale === null || reference.sourceLocale === null || locale === reference.sourceLocale)
+  );
+  const removedUrls = atom(
+    (get) => get(removals).flatMap(
+      ({ id, locale }) => urls.filter((url) => url.id === id && url.locale === locale)
+    )
+  );
+  const redirect = atom(void 0);
+  return {
+    subjects,
+    locales,
+    selectedLocales,
+    removals,
+    references: atom((get) => {
+      const current = get(removed);
+      return references.filter(({ reference }) => breaks(reference, current));
+    }),
+    hiddenSources: atom((get) => {
+      const current = get(removed);
+      const sources = hidden.filter((reference) => breaks(reference, current)).map((reference) => reference.sourceId);
+      return new Set(sources).size;
+    }),
+    archivable: atom((get) => {
+      const current = get(removals);
+      return current.length > 0 && current.every(
+        ({ id, locale }) => archivable.some((item) => item.id === id && item.locale === locale)
+      );
+    }),
+    urls: removedUrls,
+    redirect,
+    unredirected: atom((get) => {
+      const target = get(redirect);
+      if (!target) return [];
+      return get(removedUrls).filter(
+        (url) => redirectLocale(target.locales, url.locale) === void 0
+      );
+    })
+  };
+}
+function redirectLocale(locales, locale) {
+  if (locales.includes(locale)) return locale;
+  if (locales.includes(null)) return null;
+  return void 0;
+}
+function hasUrl(type) {
+  if (!type || type === MediaFile || type === MediaLibrary) return false;
+  return hasUrlAliases(type);
+}
+var redirectStatuses = ["published", "draft"];
+function redirectPicker(config, policy, subjects) {
+  const [first] = subjects;
+  const removed = new Set(subjects.map((subject) => subject.id));
+  const types = entries(config.schema).filter(([, type]) => hasUrl(type)).map(([name]) => name);
+  const workspace = first && config.workspaces[first.workspace];
+  const roots = workspace ? entries(getWorkspace(workspace).roots) : [];
+  const locations = roots.filter(([, root]) => !Root.isMediaRoot(root)).map(([root]) => ({ workspace: first.workspace, root }));
+  return {
+    condition: { _type: { in: types } },
+    locations,
+    canSelect(item) {
+      if (removed.has(item.id)) return false;
+      if (item.parents.some((parent) => removed.has(parent))) return false;
+      return policy.canUpdate({ ...item, field: "metadata.aliases" }) && policy.canPublish(item);
+    }
+  };
+}
+var loadRedirectTargetAtom = atom(
+  null,
+  async (get, _set, id, locale) => {
+    const versions = await get(graphAtom).find({
+      id,
+      status: "all",
+      versionStatus: { in: redirectStatuses },
+      select: { title: Entry.title, locale: Entry.locale, url: Entry.url }
+    });
+    const shown = versions.find((version) => version.locale === locale) ?? versions[0];
+    if (!shown) return void 0;
+    const locales = new Set(versions.map((version) => version.locale));
+    return { id, title: shown.title, url: shown.url, locales: [...locales] };
+  }
+);
+var loadRemovePlanAtom = atom(
+  null,
+  async (get, _set, subjects, locales) => {
+    const config = get(configAtom);
+    const policy = get(policyAtom);
+    const [first] = subjects;
+    const versions = await get(graphAtom).find({
+      id: { in: subjects.map((subject) => subject.id) },
+      status: "all",
+      select: {
+        id: Entry.id,
+        locale: Entry.locale,
+        status: Entry.status,
+        active: Entry.active,
+        url: Entry.url,
+        descendants: {
+          edge: "children",
+          // The deepest level queried, queries are sent as JSON
+          depth: 999,
+          status: "all",
+          select: Entry.id
+        }
+      }
+    });
+    const descendants = versions.flatMap(
+      (version) => version.descendants.map((id) => ({
+        id,
+        locale: version.locale,
+        subjectId: version.id
+      }))
+    );
+    const subjectOf = (id) => subjects.find((subject) => subject.id === id);
+    const archivable = versions.flatMap(({ id, locale, status, active }) => {
+      const subject = subjectOf(id);
+      if (!subject || !active || status !== "published") return [];
+      if (config.schema[subject.type] === MediaFile) return [];
+      if (!policy.canArchive({ ...subject, locale })) return [];
+      return [{ id, locale }];
+    });
+    const urls = versions.flatMap(({ id, locale, status, url }) => {
+      const subject = subjectOf(id);
+      if (!subject || status !== "published" || !url) return [];
+      if (!hasUrl(config.schema[subject.type])) return [];
+      return [{ id, locale, url }];
+    });
+    const targetIds = new Set(
+      subjects.map((subject) => subject.id).concat(descendants.map((d) => d.id))
+    );
+    const { references, hidden } = await loadIncomingReferences(
+      get,
+      Array.from(targetIds)
+    );
+    return createRemovePlan({
+      subjects,
+      locales: locales?.filter((locale) => policy.canDelete({ ...first, locale })),
+      references,
+      hidden,
+      descendants,
+      archivable,
+      urls: urls.filter(
+        (url, index) => urls.findIndex(
+          (other) => other.id === url.id && other.locale === url.locale
+        ) === index
+      )
+    });
+  }
+);
+async function redirects(get, plan) {
+  const target = get(plan.redirect);
+  const urls = get(plan.urls);
+  if (!target || urls.length === 0) return [];
+  const versions = await get(graphAtom).find({
+    id: target.id,
+    status: "all",
+    versionStatus: { in: redirectStatuses },
+    select: {
+      locale: Entry.locale,
+      status: Entry.versionStatus,
+      data: Entry.data
+    }
+  });
+  const locales = versions.map((version) => version.locale);
+  return versions.flatMap(({ locale, status, data }) => {
+    const redirected = urls.filter((url) => redirectLocale(locales, url.locale) === locale).map((url) => url.url);
+    const next = dataWithUrlAliases(data, redirected);
+    if (next === data) return [];
+    const set = { metadata: next.metadata };
+    return [{ op: "update", id: target.id, locale, status, set }];
+  });
+}
+var deleteEntriesAtom = atom(
+  null,
+  async (get, _set, plan) => {
+    const removals = get(plan.removals).map(
+      (removal) => ({ op: "remove", ...removal })
+    );
+    const updates = await redirects(get, plan);
+    await get(graphAtom).mutate(removals.concat(updates));
+  }
+);
+var archiveEntriesAtom = atom(
+  null,
+  async (get, _set, plan) => {
+    const removals = get(plan.removals).map(
+      (removal) => ({ op: "archive", ...removal })
+    );
+    const updates = await redirects(get, plan);
+    await get(graphAtom).mutate(removals.concat(updates));
+  }
+);
+var noStorage = { getItem: () => null, setItem() {
+}, removeItem() {
+} };
+function session() {
+  try {
+    return globalThis.sessionStorage ?? noStorage;
+  } catch {
+    return noStorage;
+  }
+}
+var archiveDirectlyAtom = atomWithStorage(
+  "alinea-dashboard-archive-directly",
+  false,
+  createJSONStorage(session),
+  { getOnInit: true }
+);
+export {
+  archiveDirectlyAtom,
+  archiveEntriesAtom,
+  createRemovePlan,
+  deleteEntriesAtom,
+  loadRedirectTargetAtom,
+  loadRemovePlanAtom,
+  redirectPicker
+};

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

@@ -1,7 +1,7 @@
+import { Config } from 'alinea/core/Config';
 import type { EntryStatus } from 'alinea/core/Entry';
 import { Permission } from 'alinea/core/Role';
 import { type RootData, type RootI18n } from 'alinea/core/Root';
-import { Schema } from 'alinea/core/Schema';
 import { ExplorerAtoms } from 'alinea/dashboard/atoms/explorer';
 import { type Atom, type PrimitiveAtom } from 'jotai';
 import type { ComponentType } from 'react';
@@ -113,7 +113,7 @@ export declare const rootAtoms: (workspace: string, root: string) => RootAtoms;
  * Entries can be dropped on a container, but only placed before or after the
  * children of a parent that does not order them, and never inside themselves
  */
-export declare function treeAcceptsDrop(schema: Schema, entries: Map<string, RootTreeItem>, target: DropTarget, keys?: ReadonlySet<Key>): boolean;
+export declare function treeAcceptsDrop(config: Config, rootData: RootData, entries: Map<string, RootTreeItem>, target: DropTarget, keys?: ReadonlySet<Key>): boolean;
 /** The selected entry, or the location of a selected entry that is not listed */
 export declare function locatedItem({ entries, snapshot }: TreeView): RootTreeItem | undefined;
 export {};

package/dist/dashboard/atoms/root.js

@@ -1,13 +1,14 @@
 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";
@@ -18,6 +19,8 @@ import {
 } 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,
@@ -381,11 +384,6 @@ var RootAtoms = class {
    * scroll offset when the editor returns to it through either of them.
    */
   explorerScrollOffset = dispense((_key) => atom(0));
-  /**
-   * The filters picked in the explorers of this root, kept while the editor
-   * opens entries and folders. Each overview applies the ones it declares.
-   */
-  #explorerFilters = atom({});
   children = dispense((parentId) => {
     const location = {
       workspace: this.workspace,
@@ -412,7 +410,9 @@ var RootAtoms = class {
         enableNavigation: true,
         sortState: overviewSortAtom(this.workspace, this.key, parentId),
         rootData: this.data,
-        filterState: this.#explorerFilters,
+        // 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,
         selectionBehavior: "toggle",
@@ -443,7 +443,8 @@ var RootAtoms = class {
   acceptedDragTypes = [...dashboardEntryDragTypes];
   getItems = atom(
     null,
-    (_get, _set, keys) => {
+    (_get, set, keys) => {
+      set(draggedEntriesAtom, keys);
       return [...keys].map(dashboardEntryDragItem);
     }
   );
@@ -454,12 +455,18 @@ var RootAtoms = class {
   });
   onMove = atom(
     null,
-    async (get, _set, event, tree) => {
+    async (get, set, event, tree) => {
       const policy = get(policyAtom);
       const permission = event.target.position === "on" ? Permission.Move : Permission.Reorder;
-      const { schema } = get(configAtom);
       const { entries } = get(tree.view);
-      if (!treeAcceptsDrop(schema, entries, event.target, event.keys)) return;
+      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, {
@@ -470,30 +477,38 @@ var RootAtoms = class {
           locale: item.locale,
           parents: item.parents
         });
-      await moveEntries(
-        get(graphAtom),
-        moving.map((item) => item.id),
-        event.target
-      );
+      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) => {
-    await moveEntries(
-      get(graphAtom),
-      dashboardEntryDropIds(event.items),
-      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 treeAcceptsDrop(schema, entries, target, keys = /* @__PURE__ */ new Set()) {
+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;
-  if (target.position !== "on") return !entry.ordered;
-  const type = schema[entry.type];
-  return !keys.has(entry.id) && Boolean(type && Type.isContainer(type));
+  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,

package/dist/dashboard/atoms/user.js

@@ -1,7 +1,7 @@
 import {
   selectAtom,
   unwrap
-} from "../../chunks/chunk-TIJTT5ZI.js";
+} from "../../chunks/chunk-G43W7AME.js";
 import {
   atom
 } from "../../chunks/chunk-CFNRVI3Y.js";

package/dist/dashboard/atoms/utils.js

@@ -1,6 +1,6 @@
 import {
   unwrap
-} from "../../chunks/chunk-TIJTT5ZI.js";
+} from "../../chunks/chunk-G43W7AME.js";
 import {
   atom
 } from "../../chunks/chunk-CFNRVI3Y.js";

package/dist/dashboard/boot/Boot.js

@@ -5,7 +5,6 @@ import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/boot/Boot.tsx
 import { IndexEvent } from "alinea/core/db/IndexEvent";
-import { MemorySource } from "alinea/core/source/MemorySource";
 import { createRoot } from "react-dom/client";
 import { App } from "../App.js";
 import { ActivityEvent } from "./ActivityEvent.js";
@@ -18,15 +17,7 @@ async function boot(gen) {
   if (inWorker) {
     loadWorker(gen);
   } else {
-    let events;
-    let worker;
-    try {
-      ;
-      [events, worker] = createSharedWorker();
-    } catch {
-      console.warn("Shared worker not supported, falling back to local worker.");
-      events = worker = new DashboardWorker(new MemorySource());
-    }
+    const [events, worker] = connect();
     const scripts = document.getElementsByTagName("script");
     const element = scripts[scripts.length - 1];
     const into = document.createElement("div");
@@ -56,20 +47,37 @@ async function boot(gen) {
     }
   }
 }
-function createSharedWorker() {
+function connect() {
+  const options = { type: "module", name: "Alinea dashboard" };
+  try {
+    const worker = new SharedWorker(import.meta.url, options);
+    return [listen(worker.port), wrap2(worker.port)];
+  } catch {
+    console.warn("Shared worker not supported, falling back to a worker.");
+  }
+  try {
+    const worker = new Worker(import.meta.url, options);
+    return [listen(worker), wrap2(worker)];
+  } catch {
+    console.warn("Worker not supported, running on the main thread.");
+    const worker = new DashboardWorker();
+    return [worker, worker];
+  }
+}
+function wrap2(endpoint) {
+  return wrap(endpoint);
+}
+function listen(source) {
   const events = new EventTarget();
-  const worker = new SharedWorker(import.meta.url, {
-    type: "module",
-    name: "Alinea dashboard"
-  });
-  worker.port.addEventListener("message", ({ data }) => {
+  source.addEventListener("message", (event) => {
+    const { data } = event;
     if (data.type === IndexEvent.type) {
       events.dispatchEvent(new IndexEvent(data.data));
     } else if (data.type === ActivityEvent.type) {
       events.dispatchEvent(new ActivityEvent(data.activities));
     }
   });
-  return [events, wrap(worker.port)];
+  return events;
 }
 function isWorkerScope() {
   return typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;

package/dist/dashboard/boot/DashboardWorker.d.ts

@@ -7,6 +7,7 @@ import { EntryStore } from 'alinea/database/EntryStore';
 import { type Activity } from './ActivityEvent.js';
 export declare class DashboardWorker extends EventTarget {
     #private;
+    /** Keep the content in memory with `source`, instead of in the browser. */
     constructor(source?: Source);
     get db(): EntryStore | Promise<EntryStore>;
     sync(): Promise<string>;