alinea 1.7.0 → 2.0.0-preview.1

package/dist/dashboard/atoms/root.js

@@ -0,0 +1,383 @@
+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 { Permission } from "alinea/core/Role";
+import { getRoot, getType, getWorkspace } from "alinea/core/Internal";
+import {
+  createExplorerAtoms
+} from "alinea/dashboard/atoms/explorer";
+import { LucideFile } from "../icons.js";
+import { viewAtoms } from "./config.js";
+import { configAtom, graphAtom } from "./core.js";
+import {
+  loadTreeChildren,
+  MissingEntryError,
+  treeEntryAtoms
+} from "./entry.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()
+};
+function rootTreeItem(config, entry, parentType) {
+  return {
+    id: entry.id,
+    title: entry.title,
+    type: entry.type,
+    status: entry.status,
+    main: entry.main,
+    locale: entry.locale,
+    parentId: entry.parentId,
+    parents: entry.parents,
+    hasChildren: entry.hasChildren,
+    dragDisabled: Boolean(
+      parentType && getType(config.schema[parentType]).orderChildrenBy
+    )
+  };
+}
+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) => {
+    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 parents = selectedModel && selected ? await get(selectedModel.parents) : [];
+    const models = new Map(parents.map((parent) => [parent.id, parent]));
+    if (selectedModel) models.set(selectedModel.id, selectedModel);
+    const collapsed = get(this.collapsedKeys);
+    const collapsedKeys = collapsed.selectedId === selectedId ? collapsed.keys : /* @__PURE__ */ new Set();
+    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((id) => get(treeEntryAtoms(id).ready))
+    );
+    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 entries = /* @__PURE__ */ new Map();
+    const children = /* @__PURE__ */ new Map();
+    const parentIds = [
+      null,
+      ...expandedModels.map((model) => model.id)
+    ];
+    for (const [index, level] of levelItems.entries()) {
+      const parentId = parentIds[index] ?? null;
+      children.set(
+        parentId,
+        level.map((entry) => entry.id)
+      );
+      for (const entry of level) entries.set(entry.id, entry);
+    }
+    function nested(parentId) {
+      return (children.get(parentId) ?? []).map((id) => ({
+        id,
+        children: expandedKeys.has(id) ? 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 model = treeEntryAtoms(id);
+      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);
+    })
+  );
+  children = dispense((id) => treeEntryAtoms(id).children(this.#locale));
+  #itemState = dispense(
+    (id) => unwrap(this.#itemSource(id), (previous) => previous)
+  );
+  item = dispense(
+    (id) => atom((get) => {
+      const item = get(this.#itemState(id));
+      if (item) return item;
+      const loaded = get(this.#state)?.entries.get(id);
+      if (loaded) return loaded;
+      throw get(this.#itemSource(id));
+    })
+  );
+  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.keys()].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
+    );
+  }
+  treeEntries = dispense(
+    (locale) => atom(async (get) => {
+      get(shaAtom);
+      const data = get(this.data);
+      return loadTreeChildren(
+        get,
+        { workspace: this.workspace, root: this.key, parentId: null },
+        locale,
+        data.orderChildrenBy
+      );
+    })
+  );
+  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: this.#explorerLocale,
+        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 {};