alinea 2.0.0-preview.0 → 2.0.0-preview.2

package/dist/dashboard/atoms/entry.js

@@ -11,8 +11,10 @@ import { JsonLoader } from "alinea/backend/loader/JsonLoader";
 import { Config } from "alinea/core/Config";
 import { Entry } from "alinea/core/Entry";
 import { createRecord, parseRecord } from "alinea/core/EntryRecord";
-import { getRoot, getWorkspace } from "alinea/core/Internal";
+import { getRoot, getType, getWorkspace } from "alinea/core/Internal";
 import { createPreview } from "alinea/core/media/CreatePreview.browser";
+import { mediaAltText } from "alinea/core/media/MediaAltField";
+import { MediaFile } from "alinea/core/media/MediaTypes";
 import { Permission } from "alinea/core/Role";
 import { Root } from "alinea/core/Root";
 import { createFilePatch } from "alinea/core/source/FilePatch";
@@ -24,9 +26,10 @@ import { encodePreviewPayload } from "alinea/preview/PreviewPayload";
 import { parents, translations } from "alinea/query";
 import { clientAtom, configAtom, graphAtom } from "./core.js";
 import { entryRevisionAtom, shaAtom } from "./graph.js";
+import { getPreviewToken, retryPreviewToken } from "./preview.js";
 import { ReactiveNode } from "./ReactiveNode.js";
 import { policyAtom, userAtom } from "./user.js";
-import { dispense, loader } from "./utils.js";
+import { atomWithPending, dispense, loader } from "./utils.js";
 var selection = {
   id: Entry.id,
   type: Entry.type,
@@ -166,6 +169,46 @@ var EntryLocaleAtoms = class {
     });
     return new ReactiveNode(value, readOnly);
   });
+  richTextImages = atom(async (get) => {
+    const entry = await get(this.selectedEntry);
+    const config = get(configAtom);
+    const type = config.schema[entry.type];
+    assert(type, `Type "${entry.type}" not found in config`);
+    const value = Type.withInitialValue(type, {
+      ...Type.initialValue(type),
+      ...entry.data
+    });
+    const imageIds = Array.from(
+      new Set(
+        Type.references(type, value).filter((reference) => reference.linkType === "image").map((reference) => reference.targetId)
+      )
+    );
+    if (imageIds.length === 0) return /* @__PURE__ */ new Map();
+    const graph = get(graphAtom);
+    const images = await graph.find({
+      id: { in: imageIds },
+      preferredLocale: this.requestedLocale ?? entry.locale ?? void 0,
+      status: "preferDraft",
+      select: {
+        id: Entry.id,
+        url: Entry.url,
+        alt: MediaFile.alt
+      }
+    });
+    const baseUrl = Config.baseUrl(config) ?? (typeof location === "undefined" ? void 0 : location.href);
+    return new Map(
+      images.map((image) => [
+        image.id,
+        {
+          src: URL.parse(image.url, baseUrl)?.href ?? "",
+          alt: mediaAltText(
+            image.alt,
+            this.requestedLocale ?? entry.locale ?? void 0
+          )
+        }
+      ])
+    );
+  });
   anchors = atom(async (get) => {
     const entry = await get(this.selectedEntry);
     const node = await get(this.selectedNode);
@@ -173,9 +216,10 @@ var EntryLocaleAtoms = class {
     assert(type, `Type "${entry.type}" not found in config`);
     return Type.anchors(type, get(node.value));
   });
-  #previewRetry = atom(0);
+  #previewUrlRetry = atom(0);
   retryPreviewUrl = atom(null, (get, set) => {
-    set(this.#previewRetry, (current) => current + 1);
+    retryPreviewToken(get(clientAtom));
+    set(this.#previewUrlRetry, (current) => current + 1);
   });
   previewEntryReady = atom(async (get) => {
     const activeEntry = await get(this.selectedEntry);
@@ -189,31 +233,27 @@ var EntryLocaleAtoms = class {
     };
   });
   previewEntry = unwrap(this.previewEntryReady, (previous) => previous);
-  #previewTargetUrl = atom((get) => {
-    const versions = get(this.versions);
-    const entry = Array.from(versions.values()).find((version) => version.active) ?? versions.values().next().value;
-    return entry?.url;
-  });
   previewUrlReady = atom(async (get) => {
-    get(this.#previewRetry);
-    const targetUrl = get(this.#previewTargetUrl);
+    get(this.#previewUrlRetry);
+    const versions = get(this.versions);
+    const targetUrl = Array.from(versions.values()).find((version) => version.active)?.url ?? versions.values().next().value?.url;
     if (!targetUrl) return void 0;
     const config = get(configAtom);
-    const client = get(clientAtom);
-    if (typeof client.previewToken !== "function") return void 0;
     try {
       const base = new URL(
-        config.handlerUrl ?? "",
+        Config.handlerUrl(config),
         Config.baseUrl(config) ?? (typeof location === "undefined" ? "http://localhost" : location.href)
       );
-      base.searchParams.set("preview", await client.previewToken());
+      const previewToken = await getPreviewToken(get(clientAtom));
+      if (!previewToken) return void 0;
+      base.searchParams.set("preview", previewToken);
       base.searchParams.set("returnTo", targetUrl);
       return base.toString();
     } catch {
       return void 0;
     }
   });
-  previewUrl = unwrap(this.previewUrlReady, (previous) => previous);
+  previewUrlState = atomWithPending(this.previewUrlReady);
   previewPayloadSignal = atom((get) => {
     const version = get(this.selectedVersion);
     const editing = get(this.currentlyEditing);
@@ -501,6 +541,9 @@ var EntryAtoms = class {
   parentId = atom((get) => get(this.data).parentId);
   workspace = atom((get) => get(this.data).workspace);
   root = atom((get) => get(this.data).root);
+  parentPaths = atom(
+    (get) => get(this.data).parents.filter((parent) => parent.main).map((parent) => parent.path)
+  );
   hasChildren = atom((get) => get(this.data).hasChildren);
   canPublishParents = atom(
     (get) => get(this.data).parents.every((parent) => parent.status === "published")
@@ -601,9 +644,171 @@ var MissingEntryError = class extends Error {
   }
   id;
 };
+var treeEntrySelect = {
+  id: Entry.id,
+  title: Entry.title,
+  type: Entry.type,
+  status: Entry.status,
+  main: Entry.main,
+  locale: Entry.locale,
+  parentId: Entry.parentId,
+  parents: Entry.parents,
+  workspace: Entry.workspace,
+  root: Entry.root
+};
+var treeChildSelect = {
+  id: Entry.id,
+  type: Entry.type,
+  locale: Entry.locale,
+  parentId: Entry.parentId,
+  parents: Entry.parents,
+  workspace: Entry.workspace,
+  root: Entry.root
+};
+function preferredTreeEntries(items, locale) {
+  const translated = new Set(
+    items.filter((item) => item.locale === locale).map((item) => item.id)
+  );
+  const untranslated = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    if (translated.has(item.id)) return item.locale === locale;
+    if (untranslated.has(item.id)) return false;
+    untranslated.add(item.id);
+    return true;
+  });
+}
+async function loadTreeChildren(get, location2, locale, orderBy) {
+  const config = get(configAtom);
+  const graph = get(graphAtom);
+  const policy = get(policyAtom);
+  const visibleTypes = entries(config.schema).filter(([, type]) => !Type.isHidden(type)).map(([name]) => name);
+  const matches = await graph.find({
+    ...location2,
+    filter: { _type: { in: visibleTypes } },
+    orderBy,
+    select: treeChildSelect,
+    status: "preferDraft"
+  });
+  return preferredTreeEntries(
+    matches.filter((entry) => policy.canRead(entry)),
+    locale
+  ).map((entry) => treeEntryAtoms(entry.id));
+}
+var treeEntryLoader = atom((get) => {
+  const config = get(configAtom);
+  const graph = get(graphAtom);
+  const policy = get(policyAtom);
+  const visibleTypes = entries(config.schema).filter(([, type]) => !Type.isHidden(type)).map(([name]) => name);
+  return loader(async (ids) => {
+    const [rows, children] = await Promise.all([
+      graph.find({
+        id: { in: ids },
+        select: treeEntrySelect,
+        status: "preferDraft"
+      }),
+      graph.find({
+        filter: { _type: { in: visibleTypes } },
+        parentId: { in: ids },
+        select: treeChildSelect,
+        status: "preferDraft"
+      })
+    ]);
+    const entriesById = /* @__PURE__ */ new Map();
+    for (const entry of rows) {
+      const versions = entriesById.get(entry.id) ?? [];
+      versions.push(entry);
+      entriesById.set(entry.id, versions);
+    }
+    const parentsWithChildren = new Set(
+      children.filter((child) => policy.canRead(child)).flatMap((child) => child.parentId ? [child.parentId] : [])
+    );
+    return ids.map((id) => {
+      const entryVersions = entriesById.get(id);
+      if (!entryVersions) return [null, new MissingEntryError(id)];
+      return [
+        {
+          entries: entryVersions,
+          hasChildren: parentsWithChildren.has(id)
+        },
+        null
+      ];
+    });
+  });
+});
+var TreeEntryAtoms = class {
+  constructor(id) {
+    this.id = id;
+  }
+  id;
+  #data = atom(async (get) => {
+    get(entryRevisionAtom(this.id));
+    const [data, error] = await get(treeEntryLoader)(this.id);
+    if (error) throw error;
+    assert(data, `Tree entry "${this.id}" not found`);
+    return data;
+  });
+  ready = atom(async (get) => {
+    await get(this.#data);
+    return this;
+  });
+  raw = dispense(
+    (locale) => atom(async (get) => {
+      const data = await get(this.#data);
+      const entry = preferredTreeEntries(data.entries, locale)[0];
+      assert(entry, `Tree entry "${this.id}" has no versions`);
+      return entry;
+    })
+  );
+  summary = dispense(
+    (locale) => atom(async (get) => {
+      const data = await get(this.#data);
+      const config = get(configAtom);
+      const policy = get(policyAtom);
+      const entry = preferredTreeEntries(
+        data.entries.filter((candidate) => {
+          const type = config.schema[candidate.type];
+          return Boolean(
+            type && !Type.isHidden(type) && policy.canRead(candidate)
+          );
+        }),
+        locale
+      )[0];
+      if (!entry) throw new MissingEntryError(this.id);
+      return { ...entry, hasChildren: data.hasChildren };
+    })
+  );
+  parents = atom(async (get) => {
+    const entry = await get(this.raw(null));
+    const models = entry.parents.map(treeEntryAtoms);
+    await Promise.all(models.map((model) => get(model.ready)));
+    return models;
+  });
+  children = dispense(
+    (locale) => atom(async (get) => {
+      get(shaAtom);
+      const entry = await get(this.raw(locale));
+      const type = get(configAtom).schema[entry.type];
+      assert(type, `Type "${entry.type}" not found in config`);
+      return loadTreeChildren(
+        get,
+        {
+          workspace: entry.workspace,
+          root: entry.root,
+          parentId: this.id
+        },
+        locale,
+        getType(type).orderChildrenBy
+      );
+    })
+  );
+};
+var treeEntryAtoms = dispense((id) => new TreeEntryAtoms(id));
 export {
   EntryAtoms,
   EntryLocaleAtoms,
   MissingEntryError,
-  entryAtoms
+  TreeEntryAtoms,
+  entryAtoms,
+  loadTreeChildren,
+  treeEntryAtoms
 };

package/dist/dashboard/atoms/explorer.js

@@ -354,7 +354,7 @@ var ExplorerAtoms = class {
   );
   sort = atom(
     (get) => get(this.#selectedSort) ?? {
-      sortBy: get(this.isMedia) ? "title" : "index",
+      sortBy: "index",
       direction: "asc"
     },
     (get, set, sortBy) => {
@@ -496,6 +496,7 @@ var ExplorerAtoms = class {
       const graph = get(graphAtom);
       const sort = get(this.sort);
       const filter = get(this.filter);
+      const orderField = sort.sortBy === "title" ? Entry.title : sort.sortBy === "path" ? Entry.path : sort.sortBy === "size" ? MediaFile.size : sort.sortBy === "id" ? Entry.id : Entry.index;
       const entries = await graph.find({
         workspace: entry.workspace,
         root: entry.root,
@@ -505,10 +506,7 @@ var ExplorerAtoms = class {
         type: filter,
         status: "preferDraft",
         groupBy: Entry.id,
-        orderBy: {
-          [sort.direction]: sort.sortBy === "title" ? Entry.title : sort.sortBy === "path" ? Entry.path : sort.sortBy === "size" ? MediaFile.size : sort.sortBy === "id" ? Entry.id : Entry.index,
-          caseSensitive: sort.sortBy !== "id"
-        },
+        orderBy: sort.direction === "asc" ? { asc: orderField, caseSensitive: sort.sortBy !== "id" } : { desc: orderField, caseSensitive: sort.sortBy !== "id" },
         select: {
           active: Entry.active,
           createdAt: Entry.createdAt,
@@ -596,10 +594,7 @@ var ExplorerAtoms = class {
         type: filter,
         status: "preferDraft",
         groupBy: Entry.id,
-        orderBy: search ? void 0 : selectedSort === void 0 && defaultOrderBy !== void 0 ? defaultOrderBy : {
-          [sort.direction]: orderField,
-          caseSensitive: sort.sortBy !== "id"
-        },
+        orderBy: search ? void 0 : selectedSort === void 0 && defaultOrderBy !== void 0 ? defaultOrderBy : sort.direction === "asc" ? { asc: orderField, caseSensitive: sort.sortBy !== "id" } : { desc: orderField, caseSensitive: sort.sortBy !== "id" },
         select: {
           active: Entry.active,
           createdAt: Entry.createdAt,

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

@@ -1,4 +1,7 @@
+import type { LocalConnection } from 'alinea/core/Connection';
 import type { PreviewMetadata } from 'alinea/core/Preview';
+export declare function getPreviewToken(client: LocalConnection): Promise<string | undefined>;
+export declare function retryPreviewToken(client: LocalConnection): void;
 export declare const previewMetadataAtom: import("jotai").PrimitiveAtom<PreviewMetadata | undefined> & {
     init: PreviewMetadata | undefined;
 };

package/dist/dashboard/atoms/preview.js

@@ -4,7 +4,24 @@ import {
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/atoms/preview.ts
+var previewTokens = /* @__PURE__ */ new WeakMap();
+function getPreviewToken(client) {
+  const current = previewTokens.get(client);
+  if (current) return current;
+  const request = typeof client.previewToken === "function" ? client.previewToken() : Promise.resolve(void 0);
+  const token = request.catch((error) => {
+    if (previewTokens.get(client) === token) previewTokens.delete(client);
+    throw error;
+  });
+  previewTokens.set(client, token);
+  return token;
+}
+function retryPreviewToken(client) {
+  previewTokens.delete(client);
+}
 var previewMetadataAtom = atom(void 0);
 export {
-  previewMetadataAtom
+  getPreviewToken,
+  previewMetadataAtom,
+  retryPreviewToken
 };

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

@@ -1,4 +1,4 @@
-import { type EntryStatus } from 'alinea/core/Entry';
+import type { EntryStatus } from 'alinea/core/Entry';
 import type { RootData, RootI18n } from 'alinea/core/Root';
 import type { DragItem, DragTypes, DropOperation, DropTarget } from '@react-types/shared';
 import { type ExplorerAtoms } from 'alinea/dashboard/atoms/explorer';
@@ -6,6 +6,7 @@ import { type Atom, type PrimitiveAtom } from 'jotai';
 import type { ComponentType } from 'react';
 import type { DroppableCollectionInsertDropEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, Key } from 'react-aria-components';
 import { LucideFile } from '../icons.js';
+import { type TreeEntryAtoms } from './entry.js';
 export interface RootViewProps {
     root: RootData;
 }
@@ -45,6 +46,7 @@ export declare class TreeAtoms {
     constructor(root: RootAtoms, locale: string | null, selectedKeys: Atom<Set<Key>>, viewState?: TreeViewState);
     snapshot: Atom<TreeSnapshot>;
     items: Atom<RootTreeItem[]>;
+    children: (id: string) => Atom<Promise<TreeEntryAtoms[]>>;
     item: (id: string) => Atom<RootTreeItem>;
     selectedItem: Atom<RootTreeItem | undefined>;
     ready: Atom<Promise<{
@@ -62,6 +64,7 @@ export declare class RootAtoms {
     explorer: ExplorerAtoms;
     constructor(workspace: string, key: string);
     createTree(locale: string | null, selectedKeys: Atom<Set<Key>>, expandedKeys?: PrimitiveAtom<Set<string>>): TreeAtoms;
+    treeEntries: (locale: string | null) => Atom<Promise<TreeEntryAtoms[]>>;
     children: (parentId: string | null) => ExplorerAtoms;
     label: Atom<string>;
     icon: Atom<typeof LucideFile | ComponentType>;