alinea 1.7.0 → 2.0.0-preview.1

package/dist/dashboard/atoms/explorer.js

@@ -0,0 +1,677 @@
+import {
+  unwrap
+} from "../../chunks/chunk-STAJCW4Z.js";
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/explorer.ts
+import { Entry } from "alinea/core/Entry";
+import { filterChecker } from "alinea/core/db/EntryResolver";
+import { Field } from "alinea/core/Field";
+import { getRoot, getType, getWorkspace } from "alinea/core/Internal";
+import { MediaFile } from "alinea/core/media/MediaTypes";
+import { Permission } from "alinea/core/Role";
+import { Type } from "alinea/core/Type";
+import { parents } from "alinea/query";
+import { LucideFile } from "../icons.js";
+import { activityAtom } from "./activity.js";
+import { configAtom, graphAtom } from "./core.js";
+import { shaAtom } from "./graph.js";
+import { routeAtom } from "./nav.js";
+import { uploadFilesAtom } from "./upload.js";
+import { policyAtom } from "./user.js";
+import {
+  acceptsDashboardEntryDrag,
+  dashboardEntryDragItem,
+  dashboardEntryDragTypes,
+  dispense
+} from "./utils.js";
+var dashboardEntryOverviewColumnCount = 5;
+function constrainLocation(location, limits) {
+  if (!limits?.length) return location;
+  if (limits.some(
+    (limit) => limit.workspace === location.workspace && limit.root === location.root
+  ))
+    return location;
+  const sameWorkspace = limits.find(
+    (limit) => limit.workspace === location.workspace
+  );
+  if (sameWorkspace)
+    return { workspace: sameWorkspace.workspace, root: sameWorkspace.root };
+  const [fallback] = limits;
+  return fallback ? { workspace: fallback.workspace, root: fallback.root } : location;
+}
+function explorerPageIsPending(page, location, locale) {
+  return page.locale !== locale || page.location.workspace !== location.workspace || page.location.root !== location.root || page.location.parentId !== location.parentId;
+}
+function explorerItemField(item, name) {
+  if (!name.startsWith("_")) return item.data[name];
+  const entry = item;
+  return entry[name.slice(1)];
+}
+var ExplorerEntryData = class {
+  constructor(item, _root, parents2 = []) {
+    this.item = item;
+    const configuredRoot = (get) => {
+      const value = get(this.item);
+      const workspace = get(configAtom).workspaces[value.workspace];
+      const rootConfig = workspace ? getWorkspace(workspace).roots[value.root] : void 0;
+      return rootConfig ? getRoot(rootConfig) : void 0;
+    };
+    const icon = atom((get) => {
+      const data = configuredRoot(get);
+      return data?.icon ?? LucideFile;
+    });
+    const label = atom((get) => {
+      const data = configuredRoot(get);
+      return data?.label ?? get(this.item).root;
+    });
+    this.root = atom({ icon, label });
+    this.parents = atom(parents2);
+  }
+  item;
+  label = atom((get) => get(this.item).title);
+  hasChildren = atom((get) => get(this.item).hasChildren);
+  canOpen = atom((get) => {
+    const item = get(this.item);
+    if (item.hasChildren) return true;
+    const type = get(configAtom).schema[item.type];
+    return Boolean(type && Type.isContainer(type));
+  });
+  parents;
+  root;
+  icon = atom((get) => {
+    const item = get(this.item);
+    const type = get(configAtom).schema[item.type];
+    return type ? getType(type).icon : void 0;
+  });
+  type = atom((get) => {
+    const item = get(this.item);
+    const type = get(configAtom).schema[item.type];
+    return { label: type ? String(Type.label(type)) : item.type };
+  });
+  fileInfo = atom((get) => {
+    const item = get(this.item);
+    const type = get(configAtom).schema[item.type];
+    return type === MediaFile ? item.data : null;
+  });
+  overviewCells = atom((get) => {
+    const item = get(this.item);
+    const type = get(configAtom).schema[item.type];
+    if (!type) return [];
+    return Object.entries(Type.fields(type)).flatMap(([key, field]) => {
+      const options = Field.options(field);
+      if (options.hidden || options.overview !== true || key === "title")
+        return [];
+      return [
+        { id: key, field, label: Field.label(field), value: item.data[key] }
+      ];
+    }).slice(0, dashboardEntryOverviewColumnCount);
+  });
+};
+var ExplorerEntry = class {
+  constructor(id, value, item, root, parents2 = []) {
+    this.id = id;
+    this.title = value.title;
+    this.hasChildren = value.hasChildren;
+    this.workspace = value.workspace;
+    this.root = value.root;
+    this.locale = value.locale;
+    const data = new ExplorerEntryData(item, root, parents2);
+    this.data = atom({ pending: false, data, error: void 0 });
+  }
+  id;
+  title;
+  hasChildren;
+  workspace;
+  root;
+  locale;
+  data;
+};
+var ExplorerAtoms = class {
+  constructor(location, options, initialLocation) {
+    this.location = location;
+    this.#options = options;
+    this.allowAllWorkspaces = options.allowAllWorkspaces ?? false;
+    const initialSearchScope = this.allowAllWorkspaces ? options.initialSearchScope ?? "workspace" : "workspace";
+    const initialResultMode = options.initialResultMode ?? (options.condition || options.pickChildren ? "matches" : "browse");
+    this.searchScope = atom(initialSearchScope);
+    this.#selectedResultMode = atom(initialResultMode);
+    this.resultMode = atom(
+      (get) => get(this.search).trim() ? "matches" : get(this.#selectedResultMode),
+      (_get, set, resultMode) => set(this.#selectedResultMode, resultMode)
+    );
+    this.#selectedView = atom(options.initialView);
+    this.mode = options.mode ?? "browse";
+    this.hasRowAction = options.onAction !== void 0 || options.enableNavigation === true && options.onConfirm === void 0;
+    this.rootScope = this.mode === "search" ? "workspace" : "current";
+    this.selectionMode = options.selectionMode ?? "single";
+    this.selectionBehavior = options.selectionBehavior ?? "replace";
+    this.showSelectionControls = options.showSelectionControls ?? this.mode !== "search";
+    this.breadcrumbs = options.breadcrumbs ?? false;
+    this.autoSelectFirstItem = options.autoSelectFirstItem ?? this.mode === "search";
+    this.hasSelection = this.selectionMode !== "none";
+    this.hideResultsUntilSearch = options.hideResultsUntilSearch ?? this.mode === "search";
+    this.searchDepth = options.searchDepth ?? (this.mode === "search" ? "all" : "current");
+    this.linkedKeys = new Set(options.initialSelection);
+    this.supportsInlineExpansion = options.nestedNavigation ?? false;
+    this.pickChildren = options.pickChildren ?? false;
+    this.hasCondition = Boolean(options.condition);
+    this.canSearchEverything = atom(
+      (get) => this.allowAllWorkspaces && (this.mode === "search" || this.hasCondition || Boolean(get(this.search).trim()))
+    );
+    this.searchesEverything = atom(
+      (get) => get(this.canSearchEverything) && get(this.resultMode) === "matches" && get(this.searchScope) === "everything"
+    );
+    this.selection = atom(
+      new Set(options.preselect ?? true ? options.initialSelection : [])
+    );
+    this.selectedLocale = options.selectedLocaleAtom ?? atom(initialLocation.locale ?? options.selectedLocale ?? null);
+    if (options.rootData) {
+      const rootData = options.rootData;
+      const value = {
+        icon: atom((get) => get(rootData).icon ?? LucideFile),
+        label: atom((get) => get(rootData).label)
+      };
+      this.root = atom(value);
+    } else {
+      this.root = atom({ icon: atom(LucideFile), label: atom("") });
+    }
+    const treeEntry = (item) => {
+      const value = {
+        id: item.id,
+        title: item.title,
+        path: "",
+        type: item.type,
+        workspace: initialLocation.workspace,
+        root: initialLocation.root ?? "",
+        locale: null,
+        parentId: item.parentId,
+        parents: [],
+        index: "",
+        data: {},
+        hasChildren: item.hasChildren
+      };
+      return new ExplorerEntry(item.id, value, atom(value), this.root);
+    };
+    this.parent = dispense(
+      (location2, locale) => atom((get) => {
+        const parentId = location2.parentId;
+        if (!parentId || !options.treeItems) return void 0;
+        const items = get(options.treeItems(locale, location2));
+        const item = items.find((candidate) => candidate.id === parentId);
+        if (!item) return void 0;
+        const parent = treeEntry(item);
+        const ancestors = new Array();
+        let ancestorId = item.parentId;
+        while (ancestorId) {
+          const ancestor = items.find(
+            (candidate) => candidate.id === ancestorId
+          );
+          if (!ancestor) break;
+          ancestors.unshift(treeEntry(ancestor));
+          ancestorId = ancestor.parentId;
+        }
+        const { data } = get(parent.data);
+        if (data) data.parents = atom(ancestors);
+        return parent;
+      })
+    );
+    const itemsSource = dispense(
+      (locale) => atom(async (get) => {
+        const values = await get(this.#itemData(locale));
+        return values.map((value) => {
+          const parentEntries = value.parentEntries ?? [];
+          const parentItems = parentEntries.map((parent, index) => {
+            const parentValue = {
+              ...parent,
+              path: "",
+              parents: parentEntries.slice(0, index).map((item) => item.id),
+              index: "",
+              data: {},
+              hasChildren: true
+            };
+            return new ExplorerEntry(
+              parent.id,
+              parentValue,
+              atom(parentValue),
+              this.root
+            );
+          });
+          return new ExplorerEntry(
+            value.id,
+            value,
+            atom(value),
+            this.root,
+            parentItems
+          );
+        });
+      })
+    );
+    this.items = dispense(
+      (locale) => unwrap(itemsSource(locale), (previous) => previous ?? [])
+    );
+    this.itemsReady = dispense(
+      (locale) => atom(async (get) => {
+        get(this.items(locale));
+        const items = await get(itemsSource(locale));
+        if (!this.supportsInlineExpansion) return items;
+        const expandedKeys = get(this.expandedKeys);
+        const preloadExpanded = async (entries) => {
+          await Promise.all(
+            entries.map(async (entry) => {
+              if (!expandedKeys.has(entry.id)) return;
+              get(this.children(entry, locale));
+              const children = await get(this.childrenReady(entry, locale));
+              await preloadExpanded(children);
+            })
+          );
+        };
+        await preloadExpanded(items);
+        return items;
+      })
+    );
+    this.pageReady = atom(async (get) => {
+      const locale = get(this.selectedLocale);
+      const location2 = get(this.location);
+      const resultMode = get(this.resultMode);
+      const searchScope = get(this.searchScope);
+      const searchesEverything = get(this.searchesEverything);
+      const view = get(this.view);
+      const isMedia = get(this.isMedia);
+      const requestedRoot = get(this.root);
+      const root = {
+        icon: atom(get(requestedRoot.icon)),
+        label: atom(get(requestedRoot.label))
+      };
+      const itemsPromise = get(this.itemsReady(locale));
+      const needsTree = view === "card" && resultMode === "browse" && !searchesEverything && !this.pickChildren && !options.limitLocations?.length;
+      const treeReady = needsTree ? options.treeReady?.(locale, location2) : void 0;
+      if (treeReady) await get(treeReady);
+      const items = await itemsPromise;
+      return {
+        isMedia,
+        items,
+        locale,
+        location: location2,
+        resultMode,
+        root,
+        searchScope,
+        searchesEverything,
+        view
+      };
+    });
+    this.page = unwrap(this.pageReady, (previous) => previous);
+  }
+  location;
+  allowAllWorkspaces;
+  selectionMode;
+  selectionBehavior;
+  showSelectionControls;
+  breadcrumbs;
+  autoSelectFirstItem;
+  rootScope;
+  hasRowAction;
+  mode;
+  hasSelection;
+  hideResultsUntilSearch;
+  linkedKeys;
+  searchDepth;
+  supportsInlineExpansion;
+  pickChildren;
+  hasCondition;
+  canSearchEverything;
+  searchesEverything;
+  search = atom("");
+  searchScope;
+  resultMode;
+  selection;
+  expandedKeys = atom(/* @__PURE__ */ new Set());
+  sidebarExpandedKeys = atom(/* @__PURE__ */ new Set());
+  #selectedResultMode;
+  #selectedView;
+  #selectedSort = atom();
+  #selectedFilter = atom();
+  selectedLocale;
+  root;
+  parent;
+  itemsReady;
+  items;
+  pageReady;
+  page;
+  #options;
+  showResults = atom((get) => {
+    return !this.hideResultsUntilSearch || Boolean(get(this.search).trim());
+  });
+  isMedia = atom(
+    (get) => Boolean(this.#options.rootData && get(this.#options.rootData).isMediaRoot)
+  );
+  view = atom(
+    (get) => get(this.#selectedView) ?? (get(this.isMedia) ? "card" : "row"),
+    (_get, set, view) => set(this.#selectedView, view)
+  );
+  sort = atom(
+    (get) => get(this.#selectedSort) ?? {
+      sortBy: "index",
+      direction: "asc"
+    },
+    (get, set, sortBy) => {
+      const current = get(this.sort);
+      set(this.#selectedSort, {
+        sortBy,
+        direction: current.sortBy === sortBy && current.direction === "desc" ? "asc" : "desc"
+      });
+    }
+  );
+  filter = atom(
+    (get) => get(this.#selectedFilter),
+    (get, set, filter) => {
+      set(
+        this.#selectedFilter,
+        get(this.#selectedFilter) === filter ? void 0 : filter
+      );
+    }
+  );
+  get limitLocations() {
+    return this.#options.limitLocations;
+  }
+  canUpload = atom((get) => {
+    const location = get(this.location);
+    return get(policyAtom).canUpload({
+      workspace: location.workspace,
+      root: location.root,
+      id: location.parentId
+    });
+  });
+  uploadsInCurrentFolder = atom((get) => {
+    const location = get(this.location);
+    return get(activityAtom).items.filter((activity) => {
+      if (activity.type !== "upload" || activity.status !== "running" || !activity.upload)
+        return false;
+      return activity.upload.workspace === location.workspace && activity.upload.root === location.root && (activity.upload.parentId ?? null) === (location.parentId ?? null);
+    });
+  });
+  upload = atom(null, (get, set, files) => {
+    const location = get(this.location);
+    if (!location.root) return;
+    set(uploadFilesAtom, {
+      files,
+      workspace: location.workspace,
+      root: location.root,
+      parentId: location.parentId
+    });
+  });
+  getItems = atom(null, (_get, _set, keys) => {
+    return [...keys].map(dashboardEntryDragItem);
+  });
+  getDropOperation = atom(
+    null,
+    (_get, _set, target, types, allowedOperations) => {
+      if (target.type !== "item" || !acceptsDashboardEntryDrag(types))
+        return "cancel";
+      return allowedOperations.includes("move") ? "move" : "cancel";
+    }
+  );
+  onItemDrop = atom(
+    null,
+    async (get, _set, event, locale) => {
+      const target = String(event.target.key);
+      const entries = get(this.items(locale));
+      const policy = get(policyAtom);
+      const graph = get(graphAtom);
+      for (const dragItem of event.items) {
+        if (dragItem.kind !== "text" || !dragItem.types || !dragItem.getText)
+          continue;
+        const id = dragItem.types.has(dashboardEntryDragTypes[0]) ? await dragItem.getText(dashboardEntryDragTypes[0]) : await dragItem.getText("text/plain");
+        const entry = entries.find((entry2) => entry2.id === id);
+        if (!entry) continue;
+        const { data } = get(entry.data);
+        if (!data) continue;
+        const item = get(data.item);
+        policy.assert(Permission.Move, item);
+        await graph.move({
+          id,
+          target,
+          targetType: "entry",
+          dropPosition: "on"
+        });
+      }
+    }
+  );
+  onAction = atom(
+    null,
+    (get, set, entry, locale) => {
+      if (this.#options.onAction) {
+        this.#options.onAction(entry);
+        return;
+      }
+      if (this.hasRowAction) {
+        set(routeAtom, {
+          workspace: entry.workspace,
+          root: entry.root,
+          entry: entry.id,
+          locale: locale ?? void 0
+        });
+        return;
+      }
+      const { data } = get(entry.data);
+      if (data && get(data.canOpen)) set(this.openLocation, entry);
+    }
+  );
+  openLocation = atom(null, (_get, set, entry) => {
+    set(this.selectedLocale, entry.locale);
+    set(this.location, {
+      workspace: entry.workspace,
+      root: entry.root,
+      parentId: entry.id,
+      locale: entry.locale ?? void 0
+    });
+  });
+  onConfirm = atom(null, (get) => {
+    const selected = get(this.selection);
+    if (selected !== "all") this.#options.onConfirm?.([...selected].map(String));
+  });
+  isExpanded = dispense(
+    (entry) => atom((get) => get(this.expandedKeys).has(entry.id))
+  );
+  isSelectable = dispense(
+    (entry) => atom((get) => {
+      if (!this.#options.condition) return true;
+      const { data } = get(entry.data);
+      if (!data) return false;
+      const item = get(data.item);
+      return filterChecker(
+        this.#options.condition,
+        (candidate, name) => explorerItemField(candidate, name)
+      )(item);
+    })
+  );
+  childrenReady = dispense(
+    (entry, locale) => atom(async (get) => {
+      get(shaAtom);
+      const { data } = get(entry.data);
+      if (!data || !get(data.hasChildren)) return [];
+      const graph = get(graphAtom);
+      const sort = get(this.sort);
+      const filter = get(this.filter);
+      const entries = await graph.find({
+        workspace: entry.workspace,
+        root: entry.root,
+        parentId: entry.id,
+        locale,
+        filter: void 0,
+        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"
+        },
+        select: {
+          active: Entry.active,
+          createdAt: Entry.createdAt,
+          id: Entry.id,
+          status: Entry.status,
+          title: Entry.title,
+          path: Entry.path,
+          updatedAt: Entry.updatedAt,
+          url: Entry.url,
+          type: Entry.type,
+          workspace: Entry.workspace,
+          root: Entry.root,
+          locale: Entry.locale,
+          parentId: Entry.parentId,
+          parents: Entry.parents,
+          parentEntries: parents({
+            select: {
+              id: Entry.id,
+              title: Entry.title,
+              type: Entry.type,
+              workspace: Entry.workspace,
+              root: Entry.root,
+              locale: Entry.locale,
+              parentId: Entry.parentId
+            }
+          }),
+          index: Entry.index,
+          data: Entry.data
+        }
+      });
+      const policy = get(policyAtom);
+      const readable = entries.filter((candidate) => policy.canRead(candidate));
+      const parentIds = await graph.find({
+        workspace: entry.workspace,
+        root: entry.root,
+        parentId: { in: readable.map((candidate) => candidate.id) },
+        status: "preferDraft",
+        groupBy: Entry.parentId,
+        select: Entry.parentId
+      });
+      const currentParents = get(data.parents);
+      return readable.map((candidate) => {
+        const value = {
+          ...candidate,
+          hasChildren: parentIds.includes(candidate.id)
+        };
+        return new ExplorerEntry(candidate.id, value, atom(value), this.root, [
+          ...currentParents,
+          entry
+        ]);
+      });
+    })
+  );
+  children = dispense(
+    (entry, locale) => unwrap(this.childrenReady(entry, locale), (previous) => previous ?? [])
+  );
+  #itemData = dispense(
+    (locale) => atom(async (get) => {
+      get(shaAtom);
+      const location = get(this.location);
+      const search = get(this.search).trim();
+      const searchesEverything = get(this.searchesEverything);
+      const resultMode = get(this.resultMode);
+      const workspace = searchesEverything ? void 0 : location.workspace;
+      const root = searchesEverything ? void 0 : this.rootScope === "workspace" ? void 0 : location.root;
+      if (!searchesEverything && !location.root && this.rootScope === "current")
+        return [];
+      if (this.hideResultsUntilSearch && !search) return [];
+      const graph = get(graphAtom);
+      const sort = get(this.sort);
+      const selectedSort = get(this.#selectedSort);
+      const filter = get(this.filter);
+      const defaultOrderBy = this.#options.defaultOrderBy ? get(this.#options.defaultOrderBy) : void 0;
+      const flatList = resultMode === "matches";
+      const filterSelectable = flatList;
+      const selectedLocationParentId = !searchesEverything && flatList && !this.pickChildren && location.root && location.parentId ? location.parentId : void 0;
+      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,
+        root,
+        parentId: this.pickChildren ? location.parentId ?? null : flatList ? void 0 : searchesEverything ? null : location.parentId ?? null,
+        locale: searchesEverything ? void 0 : locale,
+        search: search || void 0,
+        filter: filterSelectable ? this.#options.condition : void 0,
+        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"
+        },
+        select: {
+          active: Entry.active,
+          createdAt: Entry.createdAt,
+          id: Entry.id,
+          status: Entry.status,
+          title: Entry.title,
+          path: Entry.path,
+          updatedAt: Entry.updatedAt,
+          url: Entry.url,
+          type: Entry.type,
+          workspace: Entry.workspace,
+          root: Entry.root,
+          locale: Entry.locale,
+          parentId: Entry.parentId,
+          parents: Entry.parents,
+          parentEntries: parents({
+            select: {
+              id: Entry.id,
+              title: Entry.title,
+              type: Entry.type,
+              workspace: Entry.workspace,
+              root: Entry.root,
+              locale: Entry.locale,
+              parentId: Entry.parentId
+            }
+          }),
+          index: Entry.index,
+          data: Entry.data
+        }
+      });
+      const policy = get(policyAtom);
+      const condition = this.#options.condition;
+      const matchesCondition = condition ? filterChecker(
+        condition,
+        (candidate, name) => explorerItemField(candidate, name)
+      ) : void 0;
+      const readable = entries.filter(
+        (entry) => policy.canRead(entry) && (!selectedLocationParentId || entry.parents.includes(selectedLocationParentId)) && (!filterSelectable || !matchesCondition || matchesCondition(entry))
+      );
+      const parentIds = await graph.find({
+        workspace,
+        root,
+        parentId: { in: readable.map((entry) => entry.id) },
+        status: "preferDraft",
+        groupBy: Entry.parentId,
+        select: Entry.parentId
+      });
+      return readable.map((entry) => ({
+        ...entry,
+        hasChildren: parentIds.includes(entry.id)
+      }));
+    })
+  );
+};
+function createExplorerAtoms(initialLocation, options) {
+  const initial = constrainLocation(initialLocation, options.limitLocations);
+  const locationState = atom(initial);
+  const location = atom(
+    (get) => get(locationState),
+    (get, set, update) => {
+      const current = get(locationState);
+      const next = typeof update === "function" ? update(current) : update;
+      set(locationState, constrainLocation(next, options.limitLocations));
+    }
+  );
+  return new ExplorerAtoms(location, options, initial);
+}
+export {
+  ExplorerAtoms,
+  ExplorerEntry,
+  ExplorerEntryData,
+  createExplorerAtoms,
+  dashboardEntryOverviewColumnCount,
+  explorerPageIsPending
+};

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

@@ -0,0 +1,5 @@
+export declare const shaAtom: import("jotai").Atom<Promise<string | undefined>>;
+export declare const entryRevisionAtom: (id: string) => import("jotai").Atom<string | undefined>;
+export declare const syncAtom: import("jotai").WritableAtom<null, [], Promise<string | undefined>> & {
+    init: null;
+};