alinea 2.0.0-preview.9 → 2.0.0-rc2

package/dist/dashboard/atoms/overview.js

@@ -0,0 +1,519 @@
+import {
+  atom
+} from "../../chunks/chunk-CFNRVI3Y.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/overview.ts
+import { Entry } from "alinea/core/Entry";
+import { Expr } from "alinea/core/Expr";
+import { Field } from "alinea/core/Field";
+import { getWorkspace, hasField } from "alinea/core/Internal";
+import {
+  Overview
+} from "alinea/core/Overview";
+import { Root } from "alinea/core/Root";
+import { Schema } from "alinea/core/Schema";
+import { getScope } from "alinea/core/Scope";
+import { Type } from "alinea/core/Type";
+import { isRecord } from "alinea/core/util/Objects";
+import { ScalarField } from "alinea/core/field/ScalarField";
+import { JsonField } from "alinea/field/json/JsonField";
+import { hasAuditMetadata } from "alinea/field/metadata/MetadataAudit";
+import { graphAtom } from "./core.js";
+import { routeAtom } from "./nav.js";
+var builtinColumns = [
+  "type",
+  "updated",
+  "author"
+];
+var overviewFieldColumnLimit = 5;
+var titleColumn = {
+  key: "title",
+  header: "Title",
+  sortBy: Entry.title
+};
+var updatedByName = new Expr({
+  type: "entryField",
+  name: "name",
+  path: ["metadata", "updatedBy"]
+});
+function builtinColumn(key) {
+  switch (key) {
+    case "type":
+      return {
+        key,
+        builtin: key,
+        header: "Type",
+        width: 140,
+        collapsible: true,
+        sortBy: Entry.type
+      };
+    case "updated":
+      return {
+        key,
+        builtin: key,
+        header: "Updated",
+        width: 140,
+        collapsible: true,
+        sortBy: Entry.updatedAt
+      };
+    case "author":
+      return {
+        key,
+        builtin: key,
+        header: "Author",
+        width: "1fr",
+        minWidth: 120,
+        collapsible: true,
+        sortBy: updatedByName
+      };
+  }
+}
+function parentOverview(parent) {
+  if (parent.kind === "root") return parent.data.overview;
+  if (parent.kind === "type") return Type.overview(parent.type);
+  return void 0;
+}
+function parentOrder(parent) {
+  if (parent.kind === "root") return Root.childrenOrder(parent.data);
+  if (parent.kind === "type") return Type.childrenOrder(parent.type);
+  return void 0;
+}
+function parentTypes(config, parent) {
+  const contains = parent.kind === "root" ? parent.data.contains ?? [] : parent.kind === "type" ? Type.contains(parent.type) : [];
+  return Schema.contained(config.schema, contains).filter(
+    (name) => Boolean(config.schema[name])
+  );
+}
+function resolveOverview(config, parent, options = {}) {
+  return resolveOverviewOptions(
+    config,
+    parentOverview(parent),
+    parentTypes(config, parent),
+    parentOrder(parent),
+    options
+  );
+}
+function listedTypes(config, types, children) {
+  const schemaTypes = Object.keys(config.schema);
+  if (children?.length) {
+    const present = new Set(children.map((group) => group.type));
+    return schemaTypes.filter((name) => present.has(name));
+  }
+  if (types.length > 0 || children) return types;
+  return schemaTypes;
+}
+function resolveOverviewOptions(config, overview, types, sort, options = {}) {
+  const typeNames = new Set(Object.keys(config.schema));
+  const { children } = options;
+  const listed = listedTypes(config, types, children);
+  const childTypes = listed.flatMap(
+    (name) => config.schema[name] ? [config.schema[name]] : []
+  );
+  const configured = overview?.columns ? Object.entries(overview.columns).filter(
+    ([key]) => key !== titleColumn.key
+  ) : void 0;
+  const custom = configured ? configured.map(([key, column]) => customColumn(key, column, typeNames)) : fieldColumns(config, listed);
+  const byKey = new Map(custom.map((column) => [column.key, column]));
+  const builtins = overview?.builtins ?? {};
+  const audited = childTypes.some(hasAuditMetadata);
+  const defaults = {
+    type: children ? new Set(children.map((group) => group.type)).size > 1 : Boolean(options.mixed) || listed.length > 1,
+    updated: children ? children.some((group) => group.updatedAt) : audited,
+    author: children ? children.some((group) => group.updatedBy) : audited
+  };
+  const atStart = new Set(
+    (configured ?? []).filter(([, column]) => column.position === "start").map(([key]) => key)
+  );
+  const isBuiltinKey = (key) => builtinColumns.includes(key);
+  const columns = custom.filter(
+    (column) => atStart.has(column.key) && !isBuiltinKey(column.key)
+  );
+  for (const key of builtinColumns) {
+    const replacement = byKey.get(key);
+    if (replacement) {
+      columns.push(replacement);
+      continue;
+    }
+    if (builtins[key] ?? defaults[key]) columns.push(builtinColumn(key));
+  }
+  for (const column of custom)
+    if (!atStart.has(column.key) && !isBuiltinKey(column.key))
+      columns.push(column);
+  return {
+    columns,
+    sorts: overview?.sorts ? Object.entries(overview.sorts).map(
+      ([key, option]) => sortOptionState(key, option)
+    ) : columnSorts(columns),
+    filters: Object.entries(overview?.filters ?? {}).map(
+      ([key, filter]) => filterState(key, filter)
+    ),
+    tabs: Object.entries(overview?.tabs ?? {}).map(([key, tab]) => ({
+      key,
+      label: tab.label,
+      filter: tab.filter
+    })),
+    sort,
+    layout: overview?.layout,
+    thumbnail: overview?.thumbnail ? selection(overview.thumbnail, typeNames) : void 0,
+    actions: overview?.actions ?? [],
+    header: overview?.header,
+    types: listed
+  };
+}
+function selection(select, typeNames) {
+  if (Overview.isSelectByType(select, typeNames)) return { byType: select };
+  return { all: select };
+}
+function sortOptionState(key, option) {
+  return {
+    key,
+    label: option.label,
+    by: (Array.isArray(option.by) ? option.by : [option.by]).map(
+      Overview.sortExpr
+    ),
+    direction: option.direction ?? "asc"
+  };
+}
+function columnSorts(columns) {
+  return [titleColumn, ...columns].flatMap(
+    (column) => column.sortBy ? [
+      {
+        key: column.key,
+        label: column.header,
+        by: [column.sortBy],
+        direction: "asc"
+      }
+    ] : []
+  );
+}
+function filterOptions(options) {
+  return Object.entries(options).map(([key, option]) => ({
+    key,
+    label: option.label,
+    filter: option.filter
+  }));
+}
+function filterState(key, filter) {
+  const base = { key, label: filter.label, multiple: filter.multiple ?? false };
+  const { options } = filter;
+  if (typeof options === "function")
+    return { ...base, options: [], load: options };
+  return { ...base, options: filterOptions(options) };
+}
+function hasFilterLoaders(overview) {
+  return overview.filters.some((filter) => filter.load);
+}
+async function loadFilterOptions(overview, context) {
+  if (!hasFilterLoaders(overview)) return overview;
+  const filters = await Promise.all(
+    overview.filters.map(
+      async ({ load, ...filter }) => load ? { ...filter, options: filterOptions(await load(context)) } : filter
+    )
+  );
+  return { ...overview, filters };
+}
+function customColumn(key, column, typeNames) {
+  const select = column.select === void 0 ? void 0 : selection(column.select, typeNames);
+  return {
+    key,
+    header: column.header,
+    info: column.info,
+    width: column.width ?? "1fr",
+    minWidth: column.minWidth ?? (column.width === void 0 ? 120 : void 0),
+    align: column.align,
+    collapsible: column.collapsible ?? true,
+    select,
+    format: column.format,
+    view: column.view,
+    sortBy: columnSortBy(column, select)
+  };
+}
+function isSortable(value) {
+  if (isRecord(value) && "edge" in value) return value.count === true;
+  if (!Overview.isPlainExpr(value)) return false;
+  if (!hasField(value)) return true;
+  const field = value;
+  return field instanceof ScalarField && !(field instanceof JsonField) && !Array.isArray(Field.initialValue(field));
+}
+function columnSortBy(column, select) {
+  if (column.sortable === false) return void 0;
+  if (column.sortBy) return Overview.sortExpr(column.sortBy);
+  if (!select) return void 0;
+  if (select.all !== void 0)
+    return isSortable(select.all) ? Overview.sortExpr(select.all) : void 0;
+  const cases = Object.entries(select.byType ?? {});
+  if (!cases.every(([, value]) => isSortable(value))) return void 0;
+  return Overview.sortExpr(Object.fromEntries(cases));
+}
+function fieldColumns(config, types) {
+  const columns = /* @__PURE__ */ new Map();
+  for (const typeName of types) {
+    const type = config.schema[typeName];
+    if (!type) continue;
+    for (const [key, field] of Object.entries(Type.fields(type))) {
+      const options = Field.options(field);
+      if (options.hidden || options.overview !== true || key === "title")
+        continue;
+      const column = columns.get(key) ?? {
+        header: Field.label(field),
+        byType: {}
+      };
+      column.byType[typeName] = field;
+      columns.set(key, column);
+    }
+  }
+  return [...columns.entries()].slice(0, overviewFieldColumnLimit).map(([key, column]) => {
+    const byType = column.byType;
+    const select = Object.keys(byType).length === types.length && new Set(Object.values(byType)).size === 1 ? { all: Object.values(byType)[0] } : { byType };
+    return {
+      key,
+      header: column.header,
+      width: "1fr",
+      minWidth: 120,
+      collapsible: true,
+      select,
+      sortBy: Object.values(column.byType).every(isSortable) ? Overview.sortExpr(column.byType) : void 0
+    };
+  });
+}
+function columnProjection(select, typeName) {
+  if (!select) return void 0;
+  if (select.all !== void 0) return select.all;
+  return select.byType?.[typeName];
+}
+function columnField(config, column, typeName) {
+  if (column.format || column.view) return void 0;
+  const projection = columnProjection(column.select, typeName);
+  if (!projection || !isRecord(projection) || !hasField(projection))
+    return void 0;
+  const name = getScope(config).nameOf(projection);
+  if (!name) return void 0;
+  const type = config.schema[typeName];
+  const field = type ? Type.field(type, name) : void 0;
+  return field ? [name, field] : void 0;
+}
+function thumbnailField(config, overview, typeName) {
+  const projection = columnProjection(overview.thumbnail, typeName);
+  if (!projection || !isRecord(projection) || !hasField(projection))
+    return void 0;
+  const name = getScope(config).nameOf(projection);
+  const type = config.schema[typeName];
+  const field = name && type ? Type.field(type, name) : void 0;
+  return name && field ? [name, field] : void 0;
+}
+function pickedSort(overview, sort) {
+  if (!sort) return void 0;
+  const option = overview.sorts.find((option2) => option2.key === sort.column);
+  if (option) return option;
+  return columnSorts(overview.columns).find(
+    (option2) => option2.key === sort.column
+  );
+}
+function overviewOrder(overview, sort) {
+  const picked = pickedSort(overview, sort);
+  if (!picked || !sort) return overview.sort;
+  const orders = picked.by.map(
+    (expr) => sort.direction === "asc" ? { asc: expr } : { desc: expr }
+  );
+  return orders.length === 1 ? orders[0] : orders;
+}
+function sortedColumn(overview, sort) {
+  if (sort && pickedSort(overview, sort)) {
+    const columns = [titleColumn, ...overview.columns];
+    const sortable = columns.some(
+      (column2) => column2.key === sort.column && column2.sortBy
+    );
+    return sortable ? sort : void 0;
+  }
+  const [first] = Array.isArray(overview.sort) ? overview.sort : overview.sort ? [overview.sort] : [];
+  if (!first) return void 0;
+  const expr = first.asc ?? first.desc;
+  const direction = first.asc ? "asc" : "desc";
+  if (expr === titleColumn.sortBy) return { column: titleColumn.key, direction };
+  const column = overview.columns.find((column2) => column2.sortBy === expr);
+  return column ? { column: column.key, direction } : void 0;
+}
+function pickedFilters(overview, selection2) {
+  const picked = {};
+  for (const filter of overview.filters) {
+    const keys = filter.options.filter((option) => selection2[filter.key]?.includes(option.key)).map((option) => option.key);
+    if (keys.length === 0) continue;
+    picked[filter.key] = filter.multiple ? keys : keys.slice(0, 1);
+  }
+  return picked;
+}
+function pickedTab(overview, tab) {
+  return overview.tabs.find((option) => option.key === tab) ?? overview.tabs[0];
+}
+function overviewFilter(overview, selection2, tab) {
+  const picked = pickedFilters(overview, selection2);
+  const tabFilter = pickedTab(overview, tab)?.filter;
+  const conditions = overview.filters.flatMap((filter) => {
+    const options = filter.options.filter(
+      (option) => picked[filter.key]?.includes(option.key)
+    );
+    if (options.length === 0) return [];
+    if (options.length === 1) return [options[0].filter];
+    return [{ or: options.map((option) => option.filter) }];
+  });
+  if (tabFilter) conditions.unshift(tabFilter);
+  if (conditions.length === 0) return void 0;
+  if (conditions.length === 1) return conditions[0];
+  return { and: conditions };
+}
+function overviewEntry(row) {
+  return {
+    id: row.id,
+    type: row.type,
+    title: row.title,
+    path: row.path,
+    url: row.url ?? "",
+    status: row.status ?? "published",
+    locale: row.locale,
+    workspace: row.workspace,
+    root: row.root,
+    parentId: row.parentId
+  };
+}
+function columnLinkIds(config, overview, row) {
+  return overview.columns.flatMap((column) => {
+    const resolved = columnField(config, column, row.type);
+    if (!resolved) return [];
+    const [name, field] = resolved;
+    const label = Field.label(field);
+    return Field.references(field, row.data[name], {
+      path: [name],
+      label,
+      labels: [label]
+    }).map((reference) => reference.targetId);
+  });
+}
+async function loadColumnValues(config, graph, overview, rows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = `${row.type}\0${row.locale ?? ""}`;
+    const group = groups.get(key) ?? [];
+    group.push(row);
+    groups.set(key, group);
+  }
+  const values = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...groups.values()].map(async (group) => {
+      const [{ type, locale }] = group;
+      const select = {};
+      for (const column of overview.columns) {
+        if (column.builtin || columnField(config, column, type)) continue;
+        const projection = columnProjection(column.select, type);
+        if (projection !== void 0) select[column.key] = projection;
+      }
+      if (Object.keys(select).length === 0) return;
+      const found = await graph.find({
+        id: { in: group.map((row) => row.id) },
+        locale,
+        status: "preferDraft",
+        select: { id: Entry.id, values: select }
+      });
+      for (const { id, values: row } of found)
+        values.set(`${id}\0${locale ?? ""}`, row);
+    })
+  );
+  if (values.size === 0) return rows;
+  return rows.map((row) => {
+    const columns = values.get(`${row.id}\0${row.locale ?? ""}`);
+    return columns ? { ...row, columns } : row;
+  });
+}
+async function loadOverviewParent(config, graph, location) {
+  if (location.parentId) {
+    const typeName = await graph.first({
+      id: location.parentId,
+      status: "preferDraft",
+      select: Entry.type
+    });
+    const type = typeName ? config.schema[typeName] : void 0;
+    return type && typeName ? { kind: "type", name: typeName, type } : { kind: "none" };
+  }
+  if (!location.root) return { kind: "none" };
+  const workspace = config.workspaces[location.workspace];
+  const root = workspace ? getWorkspace(workspace).roots[location.root] : void 0;
+  return root && Root.isRoot(root) ? { kind: "root", data: Root.data(root) } : { kind: "none" };
+}
+function linkedEntryId(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value._entry === "string") return value._entry;
+  if (typeof value.entryId === "string") return value.entryId;
+  if (typeof value.id === "string" && typeof value.title === "string")
+    return value.id;
+  return void 0;
+}
+var openEntryAtom = atom(
+  null,
+  async (get, set, id, locale) => {
+    const found = await get(graphAtom).find({
+      id,
+      status: "preferDraft",
+      select: {
+        workspace: Entry.workspace,
+        root: Entry.root,
+        locale: Entry.locale
+      }
+    });
+    const entry = found.find((candidate) => candidate.locale === locale) ?? found.find((candidate) => candidate.locale === null) ?? found[0];
+    if (!entry) return;
+    set(routeAtom, {
+      workspace: entry.workspace,
+      root: entry.root,
+      entry: id,
+      locale: entry.locale ?? void 0
+    });
+  }
+);
+function summarizeRows(rows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const group = groups.get(row.type) ?? {
+      type: row.type,
+      updatedAt: false,
+      updatedBy: false
+    };
+    group.updatedAt ||= hasAuditValue(row, "updatedAt");
+    group.updatedBy ||= hasAuditValue(row, "updatedBy");
+    groups.set(row.type, group);
+  }
+  return [...groups.values()];
+}
+function hasAuditValue(row, key) {
+  const metadata = row.data.metadata;
+  if (!isRecord(metadata)) return false;
+  const value = metadata[key];
+  if (key === "updatedAt") return typeof value === "number";
+  return isRecord(value) && typeof value.name === "string" && value.name !== "";
+}
+export {
+  columnField,
+  columnLinkIds,
+  columnProjection,
+  hasFilterLoaders,
+  linkedEntryId,
+  loadColumnValues,
+  loadFilterOptions,
+  loadOverviewParent,
+  openEntryAtom,
+  overviewEntry,
+  overviewFieldColumnLimit,
+  overviewFilter,
+  overviewOrder,
+  parentOrder,
+  parentOverview,
+  parentTypes,
+  pickedFilters,
+  pickedSort,
+  pickedTab,
+  resolveOverview,
+  resolveOverviewOptions,
+  sortedColumn,
+  summarizeRows,
+  thumbnailField,
+  titleColumn
+};

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

@@ -0,0 +1,112 @@
+import type { Config } from 'alinea/core/Config';
+import type { EntryReference } from 'alinea/core/db/EntryReference';
+import type { EntryFields } from 'alinea/core/EntryFields';
+import type { Filter } from 'alinea/core/Filter';
+import type { Policy } from 'alinea/core/Role';
+import { type Atom, type PrimitiveAtom } from 'jotai';
+import { type EntryReferenceWithSource } from './entry.js';
+import type { ExplorerItemData, ExplorerLimitLocation } from './explorer.js';
+/** Deleting removes the entries, archiving unpublishes them until restored */
+export type RemoveAction = 'delete' | 'archive';
+/** An entry that is about to be removed, in the locale it is shown in */
+export interface RemoveSubject {
+    id: string;
+    title: string;
+    type: string;
+    workspace: string;
+    root: string;
+    /** Null for entries without languages */
+    locale: string | null;
+    parents: Array<string>;
+    hasChildren: boolean;
+}
+/** A translation that is removed, a null locale removes every version */
+export interface Removal {
+    id: string;
+    locale: string | null;
+}
+/** An entry that is removed with the translation of its parent */
+export interface RemovedDescendant extends Removal {
+    subjectId: string;
+}
+/** The public URL of a removed translation of a page */
+export interface RemovedUrl extends Removal {
+    url: string;
+}
+/** The page the URLs of the removed pages redirect to */
+export interface RedirectTarget {
+    id: string;
+    title: string;
+    url: string;
+    /** The languages of its versions, null for an entry without languages */
+    locales: Array<string | null>;
+}
+/** Which languages of the entries are removed and the links that will break */
+export interface RemovePlan {
+    subjects: Array<RemoveSubject>;
+    /** The languages of a single entry the user can pick to delete, undefined
+     * for a batch */
+    locales?: Array<string>;
+    /** The picked languages, the shown language at first */
+    selectedLocales: PrimitiveAtom<Array<string>>;
+    removals: Atom<Array<Removal>>;
+    /** The versions linking to the removed translations and their contents,
+     * that are not removed themselves */
+    references: Atom<Array<EntryReferenceWithSource>>;
+    /** How many entries the user can not read link to them, their titles stay
+     * hidden */
+    hiddenSources: Atom<number>;
+    /** Every removed translation is published and can be archived instead */
+    archivable: Atom<boolean>;
+    /** The public URLs of the removed translations of pages */
+    urls: Atom<Array<RemovedUrl>>;
+    /** The page the editor picked to redirect the URLs to */
+    redirect: PrimitiveAtom<RedirectTarget | undefined>;
+    /** The URLs the redirect target has no version for, they don't redirect */
+    unredirected: Atom<Array<RemovedUrl>>;
+}
+export interface RemovePlanOptions {
+    subjects: Array<RemoveSubject>;
+    locales?: Array<string>;
+    references?: Array<EntryReferenceWithSource>;
+    /** Links from versions the user can not read */
+    hidden?: Array<EntryReference>;
+    descendants?: Array<RemovedDescendant>;
+    /** The translations that can be archived */
+    archivable?: Array<Removal>;
+    /** The public URLs of the subjects, in each of their languages */
+    urls?: Array<RemovedUrl>;
+}
+/**
+ * Entries without languages are removed entirely, the others in the picked
+ * languages or, in a batch, the language they are shown in.
+ */
+export declare function createRemovePlan({ subjects, locales, references, hidden, descendants, archivable, urls }: RemovePlanOptions): RemovePlan;
+export interface RedirectPicker {
+    /** The entries of the types that hold URL aliases */
+    condition: Filter<EntryFields>;
+    /** The roots of the workspace of the removed entries */
+    locations: Array<ExplorerLimitLocation>;
+    /** Entries that are not removed and the user may add an alias to */
+    canSelect(item: ExplorerItemData): boolean;
+}
+/** Which pages the URLs of the removed entries can redirect to */
+export declare function redirectPicker(config: Config, policy: Policy, subjects: Array<RemoveSubject>): RedirectPicker;
+/** Loads the page the editor picked to redirect the URLs to */
+export declare const loadRedirectTargetAtom: import("jotai").WritableAtom<null, [id: string, locale: string | null], Promise<RedirectTarget | undefined>> & {
+    init: null;
+};
+/** Loads the references to the entries before the remove dialog opens */
+export declare const loadRemovePlanAtom: import("jotai").WritableAtom<null, [subjects: RemoveSubject[], locales?: string[] | undefined], Promise<RemovePlan>> & {
+    init: null;
+};
+/** Removes the translations and redirects their URLs in one commit */
+export declare const deleteEntriesAtom: import("jotai").WritableAtom<null, [plan: RemovePlan], Promise<void>> & {
+    init: null;
+};
+/** Archives the translations the plan would delete */
+export declare const archiveEntriesAtom: import("jotai").WritableAtom<null, [plan: RemovePlan], Promise<void>> & {
+    init: null;
+};
+/** Archive without asking first, until the browser session ends */
+export declare const archiveDirectlyAtom: import("jotai").WritableAtom<boolean, [boolean | typeof import("jotai/utils").RESET | ((prev: boolean) => boolean | typeof import("jotai/utils").RESET)], void>;