alinea 2.0.0-preview.9 → 2.0.0-rc2

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

@@ -9,9 +9,25 @@ export declare const navigationSidebarWidthAtom: import("jotai").PrimitiveAtom<n
 export declare const entrySidebarWidthAtom: import("jotai").PrimitiveAtom<number> & {
     init: number;
 };
+export type EntrySidebarTab = 'preview' | 'history' | 'references';
+/** The requested tab of the entry sidebar */
+export declare const entrySidebarTabAtom: import("jotai").PrimitiveAtom<EntrySidebarTab> & {
+    init: EntrySidebarTab;
+};
 export declare const entrySidebarOpenAtom: import("jotai").PrimitiveAtom<boolean> & {
     init: boolean;
 };
+/**
+ * Entries without a preview only have history and references in the sidebar,
+ * so it starts closed for them (like the 1.x preview pane) and remembers its
+ * own state, leaving the room to the form and wide custom views
+ */
+export declare const entrySidebarOpenWithoutPreviewAtom: import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare function entrySidebarOpen(hasPreview: boolean): import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
 export declare const themeAtom: import("jotai").WritableAtom<DashboardTheme, [update: SetStateAction<DashboardTheme>], void> & {
     onMount(setTheme: (update: SetStateAction<DashboardTheme>) => void): void;
 };

package/dist/dashboard/atoms/dashboard.js

@@ -1,6 +1,6 @@
 import {
   atomWithStorage
-} from "../../chunks/chunk-TIJTT5ZI.js";
+} from "../../chunks/chunk-G43W7AME.js";
 import {
   atom
 } from "../../chunks/chunk-CFNRVI3Y.js";
@@ -30,9 +30,14 @@ dashboardMobileAtom.onMount = (setMobile) => {
 };
 var navigationSidebarWidthAtom = atom(320);
 var entrySidebarWidthAtom = atom(320);
+var entrySidebarTabAtom = atom("preview");
 var entrySidebarOpenAtom = atom(
   typeof window === "undefined" || !window.matchMedia?.("(max-width: 768px)").matches
 );
+var entrySidebarOpenWithoutPreviewAtom = atom(false);
+function entrySidebarOpen(hasPreview) {
+  return hasPreview ? entrySidebarOpenAtom : entrySidebarOpenWithoutPreviewAtom;
+}
 var themeAtom = Object.assign(
   atom(
     (get) => get(themeStorageAtom),
@@ -75,13 +80,18 @@ function applyDashboardTheme(theme) {
       });
     });
   }
+  if (!documentElement.hasAttribute("data-alinea-theme"))
+    documentElement.setAttribute("data-alinea-theme", "");
   if (theme === "system") documentElement.removeAttribute("data-theme");
   else documentElement.dataset.theme = theme;
 }
 export {
   canLogoutAtom,
   dashboardMobileAtom,
+  entrySidebarOpen,
   entrySidebarOpenAtom,
+  entrySidebarOpenWithoutPreviewAtom,
+  entrySidebarTabAtom,
   entrySidebarWidthAtom,
   logoutAtom,
   navigationSidebarWidthAtom,

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

@@ -32,8 +32,12 @@ export interface EditorSection {
     }> | ((props: {
         section: Section;
     }) => ReactNode) | undefined>;
+    /** The section has a view or at least one field that is not hidden */
+    visible: Atom<boolean>;
 }
 export interface EditorField {
+    /** The editor of the entry, row or object the field belongs to */
+    editor: EditorModel;
     key: string;
     value: WritableAtom<unknown, [unknown], void>;
     options: Atom<FieldOptions<unknown>>;
@@ -61,13 +65,15 @@ export declare class EntryEditor implements EditorModel {
 }
 export declare function rootEditor(editor: EditorModel): EditorModel;
 export declare class EntryEditorSection implements EditorSection {
+    editor: EditorModel;
     section: Section;
-    constructor(section: Section);
+    constructor(editor: EditorModel, section: Section);
     view: Atom<((props: {
         section: Section;
     }) => ReactNode) | ComponentType<{
         section: Section;
     }> | undefined>;
+    visible: Atom<boolean>;
 }
 declare class EntryEditorField implements EditorField {
     #private;

package/dist/dashboard/atoms/editor.js

@@ -5,11 +5,15 @@ import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/atoms/editor.ts
 import { Field } from "alinea/core/Field";
-import { getScope } from "alinea/core/Scope";
 import { Section } from "alinea/core/Section";
-import { optionTrackerOf } from "alinea/core/Tracker";
 import { Type } from "alinea/core/Type";
 import { assert } from "alinea/core/util/Assert";
+import { HiddenField } from "alinea/field/hidden";
+import {
+  fieldError,
+  policyFieldOptions,
+  trackedFieldOptions
+} from "alinea/core/Validation";
 import { configAtom, viewsAtom } from "./core.js";
 import { dispense } from "./utils.js";
 var emptyResolvedImages = /* @__PURE__ */ new Map();
@@ -29,7 +33,7 @@ var EntryEditor = class {
       (get) => Type.anchors(type, get(node.value))
     );
     this.sections = Type.sections(type).map(
-      (section) => new EntryEditorSection(section)
+      (section) => new EntryEditorSection(this, section)
     );
   }
   type;
@@ -59,9 +63,11 @@ function rootEditor(editor) {
   return editor;
 }
 var EntryEditorSection = class {
-  constructor(section) {
+  constructor(editor, section) {
+    this.editor = editor;
     this.section = section;
   }
+  editor;
   section;
   view = atom((get) => {
     const view = Section.view(this.section);
@@ -69,6 +75,15 @@ var EntryEditorSection = class {
       return get(viewsAtom)[view];
     return view;
   });
+  visible = atom((get) => {
+    if (Section.view(this.section)) return true;
+    return Object.values(Section.definition(this.section)).some((value) => {
+      if (!Field.isField(value)) return true;
+      if (value instanceof HiddenField) return false;
+      const info = this.editor.get(value);
+      return !info || !get(info.options).hidden;
+    });
+  });
 };
 var EntryEditorField = class {
   constructor(editor, key, field) {
@@ -89,46 +104,18 @@ var EntryEditorField = class {
     });
   });
   options = atom((get) => {
-    const defaultOptions = Field.options(this.field);
-    const tracker = optionTrackerOf(this.field);
-    const update = tracker ? tracker(get(this.#getter)) : void 0;
-    const trackedOptions = { ...defaultOptions, ...update };
-    const options = this.editor.readOnly ? { ...trackedOptions, readOnly: true } : trackedOptions;
-    const resource = this.editor.resource;
-    if (!resource) return options;
-    const fieldName = getScope(get(configAtom)).nameOf(this.field);
-    if (!fieldName) return options;
-    const policy = this.editor.policy;
-    if (!policy) return options;
-    const fieldResource = { ...resource, field: fieldName };
-    return {
-      ...options,
-      hidden: options.hidden || !policy.canRead(fieldResource),
-      readOnly: options.readOnly || !policy.canUpdate(fieldResource)
-    };
+    const tracked = trackedFieldOptions(this.field, get(this.#getter));
+    const options = this.editor.readOnly ? { ...tracked, readOnly: true } : tracked;
+    const { resource, policy } = this.editor;
+    if (!resource || !policy) return options;
+    return policyFieldOptions(
+      get(configAtom),
+      policy,
+      resource
+    )(this.field, options);
   });
   error = atom((get) => {
-    const options = get(this.options);
-    const value = get(this.value);
-    const { min, max } = options;
-    if (Array.isArray(value)) {
-      if (typeof min === "number" && value.length < min)
-        return `Add at least ${min} ${min === 1 ? "item" : "items"}`;
-      if (typeof max === "number" && value.length > max)
-        return `Add at most ${max} ${max === 1 ? "item" : "items"}`;
-    }
-    if (options.validate) {
-      const result = options.validate(value);
-      if (typeof result === "boolean")
-        return result ? "Field is invalid" : void 0;
-      return result;
-    }
-    if (options.required) {
-      if (value === void 0 || value === null) return "Field is required";
-      if (typeof value === "string" && value === "") return "Field is required";
-      if (Array.isArray(value) && value.length === 0) return "Field is required";
-    }
-    return void 0;
+    return fieldError(this.field, get(this.options), get(this.value));
   });
   view = atom((get) => {
     const view = Field.view(this.field);

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

@@ -1,7 +1,9 @@
 import type { EntryReference } from 'alinea/core/db/EntryReference';
 import { Entry, EntryStatus } from 'alinea/core/Entry';
 import type { Order } from 'alinea/core/Graph';
+import { Permission } from 'alinea/core/Role';
 import { type EntryDefaultView } from 'alinea/core/Type';
+import { type FieldValidationError } from 'alinea/core/Validation';
 import { Atom, Getter } from 'jotai';
 import type { ResolvedEditorImage } from './editor.js';
 import { ReactiveNode } from './ReactiveNode.js';
@@ -23,6 +25,8 @@ interface EntryData {
 }
 export interface EntryReferences {
     references: Array<EntryReferenceWithSource>;
+    /** Links from versions the user can not read, without their contents */
+    hidden: Array<EntryReference>;
     total: number;
 }
 export interface EntryReferenceWithSource {
@@ -133,6 +137,13 @@ export declare class EntryLocaleAtoms {
     updatePreviewPayload: import("jotai").WritableAtom<null, [], Promise<string | undefined>> & {
         init: null;
     };
+    /**
+     * Field validation errors of the edited values. Publishing is blocked while
+     * there are any, drafts can be saved with errors.
+     */
+    errors: (node: ReactiveNode<object>) => Atom<FieldValidationError[]>;
+    /** Whether the edited values have validation errors */
+    hasErrors: (node: ReactiveNode<object>) => Atom<boolean>;
     saveDraft: import("jotai").WritableAtom<null, [node: ReactiveNode<object>], Promise<void>> & {
         init: null;
     };
@@ -157,9 +168,6 @@ export declare class EntryLocaleAtoms {
     publishArchived: import("jotai").WritableAtom<null, [], Promise<void>> & {
         init: null;
     };
-    deleteEntry: import("jotai").WritableAtom<null, [], Promise<void>> & {
-        init: null;
-    };
     replaceFile: import("jotai").WritableAtom<null, [file: File], Promise<void>> & {
         init: null;
     };
@@ -170,40 +178,8 @@ export declare class EntryAtoms {
     readonly data: Atom<EntryData>;
     constructor(id: string, data: Atom<EntryData>);
     previousVersionsOpen: import("jotai").WritableAtom<boolean, [open: boolean], void>;
-    incomingReferencesReady: Atom<Promise<{
-        references: {
-            reference: EntryReference;
-            source: {
-                id: string;
-                title: string;
-                type: string;
-                workspace: string;
-                root: string;
-                locale: string | null;
-                status: EntryStatus;
-                path: string;
-                url: string;
-            };
-        }[];
-        total: number;
-    }>>;
-    incomingReferences: Atom<{
-        references: {
-            reference: EntryReference;
-            source: {
-                id: string;
-                title: string;
-                type: string;
-                workspace: string;
-                root: string;
-                locale: string | null;
-                status: EntryStatus;
-                path: string;
-                url: string;
-            };
-        }[];
-        total: number;
-    } | undefined>;
+    incomingReferencesReady: Atom<Promise<EntryReferences>>;
+    incomingReferences: Atom<EntryReferences | undefined>;
     type: Atom<string>;
     parentId: Atom<string | null>;
     workspace: Atom<string>;
@@ -212,13 +188,18 @@ export declare class EntryAtoms {
     hasChildren: Atom<boolean>;
     canPublishParents: Atom<boolean>;
     parentUnpublished: Atom<boolean>;
-    mediaI18n: Atom<import("alinea/core/Root").RootI18n | undefined>;
+    fieldI18n: Atom<import("alinea/core/Root").RootI18n | undefined>;
     preview: Atom<import("../../core/Preview.js").Preview | undefined>;
     translationSourceLocales: Atom<string[]>;
     view: import("jotai").WritableAtom<EntryDefaultView, [next: EntryDefaultView], void>;
     locales: (locale: string | null) => EntryLocaleAtoms;
 }
-export declare const entryAtoms: (entryId: string) => Atom<Promise<EntryAtoms>>;
+/** An entry with the versions the policy allows with the permission */
+export declare function entryAtoms(entryId: string, permission?: Permission): Atom<Promise<EntryAtoms>>;
+/** The versions linking to an entry, that the user can read */
+export declare const incomingReferencesAtoms: (targetId: string) => Atom<Promise<EntryReferences>>;
+/** The versions linking to the entries, that the user can read */
+export declare function loadIncomingReferences(get: Getter, targetId: string | Array<string>): Promise<EntryReferences>;
 export declare class MissingEntryError extends Error {
     id: string;
     constructor(id: string);
@@ -241,11 +222,16 @@ interface TreeChildrenLocation {
     root: string;
     parentId: string | null;
 }
-export declare function loadTreeChildren(get: Getter, location: TreeChildrenLocation, locale: string | null, orderBy?: Order | Array<Order>): Promise<Array<TreeEntryAtoms>>;
+export declare function preferredTreeEntries<Item extends {
+    id: string;
+    locale: string | null;
+}>(items: Array<Item>, locale: string | null): Array<Item>;
+export declare function loadTreeChildren(get: Getter, location: TreeChildrenLocation, locale: string | null, permission: Permission, orderBy?: Order | Array<Order>): Promise<Array<TreeEntryAtoms>>;
 export declare class TreeEntryAtoms {
     #private;
     readonly id: string;
-    constructor(id: string);
+    readonly permission: Permission;
+    constructor(id: string, permission: Permission);
     ready: Atom<Promise<this>>;
     raw: (locale: string | null) => Atom<Promise<Omit<TreeEntrySummary, "hasChildren">>>;
     summary: (locale: string | null) => Atom<Promise<{
@@ -264,5 +250,9 @@ export declare class TreeEntryAtoms {
     parents: Atom<Promise<TreeEntryAtoms[]>>;
     children: (locale: string | null) => Atom<Promise<TreeEntryAtoms[]>>;
 }
-export declare const treeEntryAtoms: (id: string) => TreeEntryAtoms;
+/**
+ * An entry of a tree that lists what the policy allows with the permission.
+ * Pickers list what can be explored, the sidebar what can be read.
+ */
+export declare function treeEntryAtoms(id: string, permission?: Permission): TreeEntryAtoms;
 export {};