alinea 1.7.0 → 2.0.0-preview.0

package/dist/dashboard/atoms/root.js

@@ -0,0 +1,444 @@
+import {
+  unwrap
+} from "../../chunks/chunk-STAJCW4Z.js";
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/root.ts
+import { Entry } from "alinea/core/Entry";
+import { Permission } from "alinea/core/Role";
+import { getRoot, getType, getWorkspace } from "alinea/core/Internal";
+import { Type } from "alinea/core/Type";
+import {
+  createExplorerAtoms
+} from "alinea/dashboard/atoms/explorer";
+import { LucideFile } from "../icons.js";
+import { viewAtoms } from "./config.js";
+import { configAtom, graphAtom } from "./core.js";
+import { shaAtom } from "./graph.js";
+import { pageAtom } from "./nav.js";
+import { policyAtom } from "./user.js";
+import {
+  acceptsDashboardEntryDrag,
+  dashboardEntryDragItem,
+  dashboardEntryDragTypes,
+  dispense
+} from "./utils.js";
+var emptyTreeSnapshot = {
+  expandedKeys: /* @__PURE__ */ new Set(),
+  items: [],
+  selectedKeys: /* @__PURE__ */ new Set()
+};
+var treeItemSelect = {
+  id: Entry.id,
+  title: Entry.title,
+  type: Entry.type,
+  status: Entry.status,
+  main: Entry.main,
+  locale: Entry.locale,
+  parentId: Entry.parentId,
+  parents: Entry.parents
+};
+function preferredLocaleEntries(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;
+  });
+}
+var TreeAtoms = class {
+  expandedKeys;
+  collapsedKeys;
+  #root;
+  #locale;
+  #selectedKeys;
+  constructor(root, locale, selectedKeys, viewState) {
+    this.#root = root;
+    this.#locale = locale;
+    this.#selectedKeys = selectedKeys;
+    this.expandedKeys = viewState?.expandedKeys ?? atom(/* @__PURE__ */ new Set());
+    this.collapsedKeys = viewState?.collapsedKeys ?? atom({
+      selectedId: void 0,
+      keys: /* @__PURE__ */ new Set()
+    });
+  }
+  #source = atom(async (get) => {
+    get(shaAtom);
+    const data = get(this.#root.data);
+    const config = get(configAtom);
+    const graph = get(graphAtom);
+    const policy = get(policyAtom);
+    const visibleTypes = Object.entries(config.schema).filter(([, type]) => !Type.isHidden(type)).map(([name]) => name);
+    const selectedKeys = new Set([...get(this.#selectedKeys)].map(String));
+    const selectedId = [...selectedKeys][0];
+    const requestedExpanded = get(this.expandedKeys);
+    const metadataIds = new Set(requestedExpanded);
+    if (selectedId) metadataIds.add(selectedId);
+    const metadata = metadataIds.size === 0 ? [] : await graph.find({
+      workspace: this.#root.workspace,
+      root: this.#root.key,
+      id: { in: [...metadataIds] },
+      filter: { _type: { in: visibleTypes } },
+      status: "preferDraft",
+      select: treeItemSelect
+    });
+    const metadataById = new Map(
+      preferredLocaleEntries(
+        metadata.filter((entry) => policy.canRead(entry)),
+        this.#locale
+      ).map((entry) => [entry.id, entry])
+    );
+    const selected = selectedId ? metadataById.get(selectedId) : void 0;
+    const collapsed = get(this.collapsedKeys);
+    const collapsedKeys = collapsed.selectedId === selectedId ? collapsed.keys : /* @__PURE__ */ new Set();
+    const expandedKeys = new Set(requestedExpanded);
+    for (const parentId of selected?.parents ?? [])
+      if (!collapsedKeys.has(parentId)) expandedKeys.add(parentId);
+    const parentIds = /* @__PURE__ */ new Set([null, ...expandedKeys]);
+    const missingParentIds = [...parentIds].filter(
+      (id) => id !== null && !metadataById.has(id)
+    );
+    if (missingParentIds.length > 0) {
+      const parents = await graph.find({
+        workspace: this.#root.workspace,
+        root: this.#root.key,
+        id: { in: missingParentIds },
+        filter: { _type: { in: visibleTypes } },
+        status: "preferDraft",
+        select: treeItemSelect
+      });
+      for (const parent of preferredLocaleEntries(
+        parents.filter((entry) => policy.canRead(entry)),
+        this.#locale
+      ))
+        metadataById.set(parent.id, parent);
+    }
+    const childLists = await Promise.all(
+      [...parentIds].map(async (parentId) => {
+        const parent = parentId === null ? void 0 : metadataById.get(parentId);
+        const entries2 = await graph.find({
+          workspace: this.#root.workspace,
+          root: this.#root.key,
+          parentId,
+          filter: { _type: { in: visibleTypes } },
+          status: "preferDraft",
+          orderBy: parent ? getType(config.schema[parent.type]).orderChildrenBy : data.orderChildrenBy,
+          select: treeItemSelect
+        });
+        return preferredLocaleEntries(
+          entries2.filter((entry) => policy.canRead(entry)),
+          this.#locale
+        );
+      })
+    );
+    const loadedEntries = childLists.flat();
+    const possibleChildren = loadedEntries.length === 0 ? [] : await graph.find({
+      workspace: this.#root.workspace,
+      root: this.#root.key,
+      parentId: { in: loadedEntries.map((entry) => entry.id) },
+      filter: { _type: { in: visibleTypes } },
+      status: "preferDraft",
+      select: treeItemSelect
+    });
+    const entriesWithChildren = new Set(
+      preferredLocaleEntries(
+        possibleChildren.filter((entry) => policy.canRead(entry)),
+        this.#locale
+      ).flatMap((entry) => entry.parentId ? [entry.parentId] : [])
+    );
+    const entries = /* @__PURE__ */ new Map();
+    const children = /* @__PURE__ */ new Map();
+    for (const entry of loadedEntries) {
+      const parent = entry.parentId ? metadataById.get(entry.parentId) : void 0;
+      entries.set(entry.id, {
+        ...entry,
+        dragDisabled: Boolean(
+          parent && getType(config.schema[parent.type]).orderChildrenBy
+        ),
+        hasChildren: entriesWithChildren.has(entry.id)
+      });
+      const ids = children.get(entry.parentId) ?? [];
+      ids.push(entry.id);
+      children.set(entry.parentId, ids);
+    }
+    function nested(parentId) {
+      return (children.get(parentId) ?? []).map((id) => ({
+        id,
+        children: nested(id)
+      }));
+    }
+    return {
+      entries,
+      snapshot: { expandedKeys, items: nested(null), selectedKeys }
+    };
+  });
+  #state = unwrap(this.#source, (previous) => previous);
+  snapshot = atom((get) => get(this.#state)?.snapshot ?? emptyTreeSnapshot);
+  items = atom((get) => [...get(this.#state)?.entries.values() ?? []]);
+  #itemSource = dispense(
+    (id) => atom(async (get) => {
+      const loaded = (await get(this.#source)).entries.get(id);
+      if (loaded) return loaded;
+      const config = get(configAtom);
+      const graph = get(graphAtom);
+      const policy = get(policyAtom);
+      const visibleTypes = Object.entries(config.schema).filter(([, type]) => !Type.isHidden(type)).map(([name]) => name);
+      const matches = await graph.find({
+        workspace: this.#root.workspace,
+        root: this.#root.key,
+        id,
+        filter: { _type: { in: visibleTypes } },
+        status: "preferDraft",
+        select: treeItemSelect
+      });
+      const entry = preferredLocaleEntries(
+        matches.filter((match) => policy.canRead(match)),
+        this.#locale
+      )[0];
+      if (!entry) throw new Error(`Tree item "${id}" not found`);
+      const parent = entry.parentId ? await graph.first({
+        workspace: this.#root.workspace,
+        root: this.#root.key,
+        id: entry.parentId,
+        status: "preferDraft",
+        select: { type: Entry.type }
+      }) : void 0;
+      const children = await graph.find({
+        workspace: this.#root.workspace,
+        root: this.#root.key,
+        parentId: id,
+        filter: { _type: { in: visibleTypes } },
+        status: "preferDraft",
+        select: treeItemSelect
+      });
+      return {
+        ...entry,
+        dragDisabled: Boolean(
+          parent && getType(config.schema[parent.type]).orderChildrenBy
+        ),
+        hasChildren: preferredLocaleEntries(
+          children.filter((child) => policy.canRead(child)),
+          this.#locale
+        ).length > 0
+      };
+    })
+  );
+  #itemState = dispense(
+    (id) => unwrap(this.#itemSource(id), (previous) => previous)
+  );
+  item = dispense(
+    (id) => atom((get) => {
+      const loaded = get(this.#state)?.entries.get(id);
+      if (loaded) return loaded;
+      const item = get(this.#itemState(id));
+      if (!item) throw get(this.#itemSource(id));
+      return item;
+    })
+  );
+  selectedItem = atom((get) => {
+    const state = get(this.#state);
+    const selectedId = state && [...state.snapshot.selectedKeys][0];
+    return selectedId ? state.entries.get(selectedId) : void 0;
+  });
+  ready = atom(async (get) => {
+    get(this.snapshot);
+    const source = await get(this.#source);
+    await Promise.all(
+      [...source.entries].map(([id]) => get(this.#itemSource(id)))
+    );
+    return source.snapshot;
+  });
+};
+var RootAtoms = class {
+  constructor(workspace, key) {
+    this.workspace = workspace;
+    this.key = key;
+    this.data = atom((get) => {
+      const config = get(configAtom);
+      const workspaceConfig = config.workspaces[this.workspace];
+      if (!workspaceConfig)
+        throw new Error(`Workspace "${this.workspace}" not found in config`);
+      const rootConfig = getWorkspace(workspaceConfig).roots[this.key];
+      if (!rootConfig)
+        throw new Error(
+          `Root "${this.key}" not found in workspace "${this.workspace}"`
+        );
+      return getRoot(rootConfig);
+    });
+    const selectedKeys = atom((get) => {
+      const page = get(pageAtom);
+      return page.workspace === this.workspace && page.root === this.key && page.entry ? /* @__PURE__ */ new Set([page.entry]) : /* @__PURE__ */ new Set();
+    });
+    const treeViewState = {
+      expandedKeys: atom(/* @__PURE__ */ new Set()),
+      collapsedKeys: atom({
+        selectedId: void 0,
+        keys: /* @__PURE__ */ new Set()
+      })
+    };
+    this.tree = dispense(
+      (locale) => new TreeAtoms(this, locale, selectedKeys, treeViewState)
+    );
+    this.explorer = this.children(null);
+  }
+  workspace;
+  key;
+  data;
+  tree;
+  explorer;
+  #explorerLocaleState = atom(null);
+  #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
+      );
+    }
+  );
+  createTree(locale, selectedKeys, expandedKeys) {
+    return new TreeAtoms(
+      this,
+      locale,
+      selectedKeys,
+      expandedKeys ? {
+        expandedKeys,
+        collapsedKeys: atom({
+          selectedId: void 0,
+          keys: /* @__PURE__ */ new Set()
+        })
+      } : void 0
+    );
+  }
+  children = dispense(
+    (parentId) => createExplorerAtoms(
+      {
+        workspace: this.workspace,
+        root: this.key,
+        parentId: parentId ?? void 0
+      },
+      {
+        defaultOrderBy: parentId === null ? atom((get) => get(this.data).orderChildrenBy) : void 0,
+        enableNavigation: true,
+        rootData: this.data,
+        selectedLocaleAtom: parentId === null ? this.#explorerLocale : void 0,
+        treeItems: (locale) => this.tree(locale).items,
+        selectionBehavior: "toggle",
+        selectionMode: "multiple"
+      }
+    )
+  );
+  label = atom((get) => get(this.data).label);
+  icon = atom((get) => get(this.data).icon ?? LucideFile);
+  i18n = atom((get) => {
+    const data = get(this.data);
+    return data.isMediaRoot ? void 0 : data.i18n;
+  });
+  isMedia = atom((get) => Boolean(get(this.data).isMediaRoot));
+  canCreate = atom((get) => {
+    return get(policyAtom).canCreate({
+      workspace: this.workspace,
+      root: this.key
+    });
+  });
+  view = atom((get) => {
+    const view = get(this.data).view;
+    if (!view) return void 0;
+    return typeof view === "string" ? get(viewAtoms(view)) : view;
+  });
+  acceptedDragTypes = [...dashboardEntryDragTypes];
+  getItems = atom(null, (_get, _set, 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);
+      const policy = get(policyAtom);
+      const moveTarget = event.target.key ? String(event.target.key) : this.key;
+      const targetType = event.target.key ? "entry" : "root";
+      for (const key of event.keys) {
+        const id = String(key);
+        const item = get(tree.item(id));
+        if (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
+        });
+      }
+    }
+  );
+};
+var rootAtoms = dispense(
+  (workspace, root) => new RootAtoms(workspace, root)
+);
+export {
+  RootAtoms,
+  TreeAtoms,
+  rootAtoms
+};

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

@@ -0,0 +1,9 @@
+export interface UploadFilesRequest {
+    files: Iterable<File> | ArrayLike<File>;
+    workspace: string;
+    root: string;
+    parentId?: string;
+}
+export declare const uploadFilesAtom: import("jotai").WritableAtom<null, [request: UploadFilesRequest], Promise<void>> & {
+    init: null;
+};

package/dist/dashboard/atoms/upload.js

@@ -0,0 +1,81 @@
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/upload.ts
+import { createPreview } from "alinea/core/media/CreatePreview.browser";
+import { createId } from "alinea/core/Id";
+import { Permission } from "alinea/core/Role";
+import { uploadProgressAtom } from "./activity.js";
+import { configAtom, graphAtom } from "./core.js";
+import { uploadSizeError } from "./utils.js";
+import { policyAtom } from "./user.js";
+var uploadFilesAtom = atom(
+  null,
+  async (get, set, request) => {
+    const files = Array.from(request.files);
+    if (files.length === 0) return;
+    const config = get(configAtom);
+    const graph = get(graphAtom);
+    get(policyAtom).assert(Permission.Upload, {
+      workspace: request.workspace,
+      root: request.root,
+      id: request.parentId
+    });
+    const destination = {
+      workspace: request.workspace,
+      root: request.root,
+      parentId: request.parentId
+    };
+    const invalidUploads = files.flatMap((file) => {
+      const error = uploadSizeError(file, config.maxUploadSize);
+      return error ? [{ id: createId(), file, error }] : [];
+    });
+    if (invalidUploads.length > 0)
+      set(uploadProgressAtom, {
+        type: "fail",
+        uploads: invalidUploads,
+        destination
+      });
+    const failedFiles = new Set(invalidUploads.map((upload) => upload.file));
+    const validFiles = files.filter((file) => !failedFiles.has(file));
+    const uploads = validFiles.map((file) => ({ id: createId(), file }));
+    if (uploads.length === 0) return;
+    set(uploadProgressAtom, { type: "start", uploads, destination });
+    await Promise.all(
+      uploads.map(async ({ id, file }) => {
+        try {
+          await graph.upload({
+            file,
+            createPreview,
+            parentId: request.parentId,
+            workspace: request.workspace,
+            root: request.root,
+            onProgress: (progress) => set(uploadProgressAtom, {
+              type: "progress",
+              id,
+              progress
+            })
+          });
+          set(uploadProgressAtom, { type: "finish", ids: [id] });
+        } catch (error) {
+          set(uploadProgressAtom, {
+            type: "fail",
+            uploads: [
+              {
+                id,
+                file,
+                error: error instanceof Error ? error.message : String(error)
+              }
+            ],
+            destination
+          });
+        }
+      })
+    );
+  }
+);
+export {
+  uploadFilesAtom
+};

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

@@ -0,0 +1,9 @@
+import { Policy } from 'alinea/core/Role';
+import type { User } from 'alinea/core/User';
+export declare const userAtom: import("jotai").Atom<User>;
+export declare const policyAtom: import("jotai").Atom<Policy>;
+export declare const preloadUserPolicyAtom: import("jotai").WritableAtom<null, [user: User, policy: Policy], void> & {
+    init: null;
+};
+export declare const authReady: import("jotai").Atom<Promise<void>>;
+export declare const canManageMembersAtom: import("jotai").Atom<Promise<boolean>>;

package/dist/dashboard/atoms/user.js

@@ -0,0 +1,75 @@
+import {
+  selectAtom,
+  unwrap
+} from "../../chunks/chunk-STAJCW4Z.js";
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/user.ts
+import { Policy } from "alinea/core/Role";
+import { assert } from "alinea/core/util/Assert";
+import { authAtom } from "./auth.js";
+import { clientAtom, configAtom, graphAtom } from "./core.js";
+import { shaAtom } from "./graph.js";
+var userResult = atom(async (get) => {
+  const auth = get(authAtom);
+  if (auth.status === "authenticated") return auth.user;
+  throw new Error("User is not authenticated");
+});
+var resolvedUser = unwrap(userResult, (previous) => previous);
+var preloadedUserAtom = atom();
+var preloadedPolicyAtom = atom();
+var userAtom = atom((get) => {
+  const user = get(preloadedUserAtom) ?? get(resolvedUser);
+  assert(user, "Dashboard user was not preloaded");
+  return user;
+});
+var policyResult = atom(async (get) => {
+  const user = await get(userResult);
+  if (!user?.roles) return Policy.ALLOW_NONE;
+  const graph = get(graphAtom);
+  get(shaAtom);
+  const roles = get(configAtom).roles ?? {};
+  return graph.createPolicy(user.roles.filter((role) => role in roles));
+});
+var resolvedPolicy = unwrap(policyResult, (previous) => previous);
+var resolvedPolicyAtom = selectAtom(
+  resolvedPolicy,
+  (policy) => policy,
+  (previous, next) => previous === next || Boolean(previous && next && previous.equals(next))
+);
+var policyAtom = atom((get) => {
+  const policy = get(preloadedPolicyAtom) ?? get(resolvedPolicyAtom);
+  assert(policy, "Dashboard policy was not preloaded");
+  return policy;
+});
+var preloadUserPolicyAtom = atom(
+  null,
+  (_get, set, user, policy) => {
+    set(preloadedUserAtom, user);
+    set(preloadedPolicyAtom, policy);
+  }
+);
+var authReady = atom(async (get) => {
+  get(resolvedUser);
+  await get(userResult);
+  get(userAtom);
+  get(resolvedPolicyAtom);
+  await get(policyResult);
+  get(policyAtom);
+});
+var canManageMembersAtom = atom(async (get) => {
+  const capabilities = await get(clientAtom).capabilities();
+  if (!capabilities.users) return false;
+  const policy = await get(policyResult);
+  return policy.canManageMembers();
+});
+export {
+  authReady,
+  canManageMembersAtom,
+  policyAtom,
+  preloadUserPolicyAtom,
+  userAtom
+};

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

@@ -0,0 +1,17 @@
+import type { DragItem, DragTypes } from '@react-types/shared';
+import { type Atom, type WritableAtom } from 'jotai';
+import type { Key } from 'react-aria-components';
+type RequiredAtom<Value> = WritableAtom<Value, [Value], void>;
+export declare function requiredAtom<Value>(name: string): RequiredAtom<Value>;
+export declare function atomWithPending<Value>(asyncAtom: Atom<Promise<Value> | Value>): Atom<readonly [false, Awaited<Value>] | readonly [true, Awaited<Value> | undefined]>;
+export declare function pendingTimerAtom(bufferMs: number, minimumMs: number): WritableAtom<boolean, [pending: boolean], void>;
+export declare function dispense<Keys extends ReadonlyArray<unknown>, Value>(fn: (...keys: Keys) => Value): (...keys: Keys) => Value;
+type Result<Value> = [value: Value, error: null] | [value: null, error: Error];
+type BatchLoadFn<V> = (keys: ReadonlyArray<string>) => Promise<ReadonlyArray<Result<V>>>;
+export declare function loader<Value>(fn: BatchLoadFn<Value>): (key: string) => Promise<Result<Value>>;
+export declare const dashboardEntryDragType = "application/x-alinea-entry-id";
+export declare const dashboardEntryDragTypes: readonly ["application/x-alinea-entry-id", 'text/plain'];
+export declare function acceptsDashboardEntryDrag(types: DragTypes): boolean;
+export declare function dashboardEntryDragItem(id: Key): DragItem;
+export declare function uploadSizeError(file: File, maxUploadSize: number | undefined): string | undefined;
+export {};