alinea 2.0.0-preview.11 → 2.0.0-preview.13

package/dist/core/db/EntryValidationError.js

@@ -1,23 +0,0 @@
-import "../../chunks/chunk-CQ52GEHY.js";
-
-// src/core/db/EntryValidationError.ts
-import { ErrorCode, HttpError } from "../HttpError.js";
-import {
-  formatValidationErrors
-} from "../Validation.js";
-var EntryValidationError = class extends HttpError {
-  constructor(info) {
-    const entry = info.title ? `"${info.title}" (${info.entryId})` : `entry ${info.entryId}`;
-    super(
-      ErrorCode.UnprocessableEntity,
-      `Cannot publish ${entry}, fix these fields first:
-${formatValidationErrors(info.errors)}`
-    );
-    this.info = info;
-  }
-  info;
-  name = "EntryValidationError";
-};
-export {
-  EntryValidationError
-};

package/dist/dashboard/app/DeleteDialog.d.ts

@@ -1,11 +0,0 @@
-import type { DeletePlan } from 'alinea/dashboard/atoms/delete';
-export interface DeleteDialogProps {
-    /** What to delete, loaded before it opens, closed when undefined */
-    plan: DeletePlan | undefined;
-    onClose(): void;
-    onConfirm(plan: DeletePlan): Promise<void>;
-    /** Archives the entries instead, offered when all of them can be */
-    onArchive?(plan: DeletePlan): Promise<void>;
-}
-/** Confirms deleting entries, warning about the links that will break */
-export declare function DeleteDialog({ plan, onClose, onConfirm, onArchive }: DeleteDialogProps): import("react").JSX.Element;

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

@@ -1,68 +0,0 @@
-import type { EntryReference } from 'alinea/core/db/EntryReference';
-import { type Atom, type PrimitiveAtom } from 'jotai';
-import { type EntryReferenceWithSource } from './entry.js';
-/** An entry that is about to be deleted, in the locale it is shown in */
-export interface DeleteSubject {
-    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 DeleteRemoval {
-    id: string;
-    locale: string | null;
-}
-/** An entry that is deleted with the translation of its parent */
-export interface DeleteDescendant extends DeleteRemoval {
-    subjectId: string;
-}
-/** Which languages of the entries are deleted and the links that will break */
-export interface DeletePlan {
-    subjects: Array<DeleteSubject>;
-    /** 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<DeleteRemoval>>;
-    /** 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>;
-}
-export interface DeletePlanOptions {
-    subjects: Array<DeleteSubject>;
-    locales?: Array<string>;
-    references?: Array<EntryReferenceWithSource>;
-    /** Links from versions the user can not read */
-    hidden?: Array<EntryReference>;
-    descendants?: Array<DeleteDescendant>;
-    /** The translations that can be archived */
-    archivable?: Array<DeleteRemoval>;
-}
-/**
- * Entries without languages are deleted entirely, the others in the picked
- * languages or, in a batch, the language they are shown in.
- */
-export declare function createDeletePlan({ subjects, locales, references, hidden, descendants, archivable }: DeletePlanOptions): DeletePlan;
-/** Loads the references to the entries before the delete dialog opens */
-export declare const loadDeletePlanAtom: import("jotai").WritableAtom<null, [subjects: DeleteSubject[], locales?: string[] | undefined], Promise<DeletePlan>> & {
-    init: null;
-};
-export declare const deleteEntriesAtom: import("jotai").WritableAtom<null, [plan: DeletePlan], Promise<void>> & {
-    init: null;
-};
-/** Archives the translations the plan would delete */
-export declare const archiveEntriesAtom: import("jotai").WritableAtom<null, [plan: DeletePlan], Promise<void>> & {
-    init: null;
-};

package/dist/dashboard/atoms/delete.js

@@ -1,143 +0,0 @@
-import {
-  atom
-} from "../../chunks/chunk-CFNRVI3Y.js";
-import "../../chunks/chunk-CQ52GEHY.js";
-
-// src/dashboard/atoms/delete.ts
-import { Entry } from "alinea/core/Entry";
-import { MediaFile } from "alinea/core/media/MediaTypes";
-import { configAtom, graphAtom } from "./core.js";
-import { loadIncomingReferences } from "./entry.js";
-import { policyAtom } from "./user.js";
-function createDeletePlan({
-  subjects,
-  locales,
-  references = [],
-  hidden = [],
-  descendants = [],
-  archivable = []
-}) {
-  const shown = subjects[0]?.locale;
-  const selectedLocales = atom(
-    shown && locales?.includes(shown) ? [shown] : Array()
-  );
-  const removals = atom((get) => {
-    const selected = get(selectedLocales);
-    return subjects.flatMap(({ id, locale }) => {
-      if (locale === null || !locales) return [{ id, locale }];
-      return selected.map((locale2) => ({ id, locale: locale2 }));
-    });
-  });
-  const removed = atom(
-    (get) => get(removals).flatMap((removal) => [
-      removal,
-      ...descendants.filter(
-        ({ subjectId, locale }) => subjectId === removal.id && locale === removal.locale
-      )
-    ])
-  );
-  const breaks = (reference, removed2) => !removed2.some(
-    ({ id, locale }) => id === reference.sourceId && locale === reference.sourceLocale
-  ) && // References hold the language of the linking entry: links from an
-  // entry without languages can point to any language
-  removed2.some(
-    ({ id, locale }) => id === reference.targetId && (locale === null || reference.sourceLocale === null || locale === reference.sourceLocale)
-  );
-  return {
-    subjects,
-    locales,
-    selectedLocales,
-    removals,
-    references: atom((get) => {
-      const current = get(removed);
-      return references.filter(({ reference }) => breaks(reference, current));
-    }),
-    hiddenSources: atom((get) => {
-      const current = get(removed);
-      const sources = hidden.filter((reference) => breaks(reference, current)).map((reference) => reference.sourceId);
-      return new Set(sources).size;
-    }),
-    archivable: atom((get) => {
-      const current = get(removals);
-      return current.length > 0 && current.every(
-        ({ id, locale }) => archivable.some((item) => item.id === id && item.locale === locale)
-      );
-    })
-  };
-}
-var loadDeletePlanAtom = atom(
-  null,
-  async (get, _set, subjects, locales) => {
-    const config = get(configAtom);
-    const policy = get(policyAtom);
-    const [first] = subjects;
-    const versions = await get(graphAtom).find({
-      id: { in: subjects.map((subject) => subject.id) },
-      status: "all",
-      select: {
-        id: Entry.id,
-        locale: Entry.locale,
-        status: Entry.status,
-        active: Entry.active,
-        descendants: {
-          edge: "children",
-          // The deepest level queried, queries are sent as JSON
-          depth: 999,
-          status: "all",
-          select: Entry.id
-        }
-      }
-    });
-    const descendants = versions.flatMap(
-      (version) => version.descendants.map((id) => ({
-        id,
-        locale: version.locale,
-        subjectId: version.id
-      }))
-    );
-    const archivable = versions.flatMap(({ id, locale, status, active }) => {
-      const subject = subjects.find((subject2) => subject2.id === id);
-      if (!subject || !active || status !== "published") return [];
-      if (config.schema[subject.type] === MediaFile) return [];
-      if (!policy.canArchive({ ...subject, locale })) return [];
-      return [{ id, locale }];
-    });
-    const targetIds = new Set(
-      subjects.map((subject) => subject.id).concat(descendants.map((d) => d.id))
-    );
-    const { references, hidden } = await loadIncomingReferences(
-      get,
-      Array.from(targetIds)
-    );
-    return createDeletePlan({
-      subjects,
-      locales: locales?.filter((locale) => policy.canDelete({ ...first, locale })),
-      references,
-      hidden,
-      descendants,
-      archivable
-    });
-  }
-);
-var deleteEntriesAtom = atom(
-  null,
-  async (get, _set, plan) => {
-    await get(graphAtom).mutate(
-      get(plan.removals).map((removal) => ({ op: "remove", ...removal }))
-    );
-  }
-);
-var archiveEntriesAtom = atom(
-  null,
-  async (get, _set, plan) => {
-    await get(graphAtom).mutate(
-      get(plan.removals).map((removal) => ({ op: "archive", ...removal }))
-    );
-  }
-);
-export {
-  archiveEntriesAtom,
-  createDeletePlan,
-  deleteEntriesAtom,
-  loadDeletePlanAtom
-};

package/dist/chunks/{chunk-MOWR65LM.js → chunk-PYDOMKJZ.js}

@@ -34,77 +34,6 @@ import {
   sql
 } from "./chunk-ETBQTP2S.js";
 
-// node_modules/rado/dist/core/Constraint.js
-var UniqueConstraint = class _UniqueConstraint {
-  [internalData];
-  constructor(data) {
-    this[internalData] = data;
-  }
-  on(...columns) {
-    const fields = columns.map(getField);
-    return new _UniqueConstraint({ ...getData(this), fields });
-  }
-  nullsNotDistinct() {
-    return new _UniqueConstraint({ ...getData(this), nullsNotDistinct: true });
-  }
-  get [internalConstraint]() {
-    const { fields, nullsNotDistinct } = getData(this);
-    return sql.join([
-      sql`unique`,
-      nullsNotDistinct ? sql`nulls not distinct` : void 0,
-      sql`(${sql.join(
-        fields.map((field) => sql.identifier(field.fieldName)),
-        sql`, `
-      )})`
-    ]);
-  }
-};
-var PrimaryKeyConstraint = class {
-  constructor(data) {
-    this.data = data;
-    this[internalData] = data;
-  }
-  data;
-  [internalData];
-  get [internalConstraint]() {
-    const { fields } = getData(this);
-    return sql`primary key (${sql.join(
-      fields.map((field) => sql.identifier(field.fieldName)),
-      sql`, `
-    )})`;
-  }
-};
-function primaryKey(...args) {
-  if (args.length === 1 && "columns" in args[0])
-    return new PrimaryKeyConstraint({
-      name: args[0].name,
-      fields: args[0].columns.map(getField)
-    });
-  return new PrimaryKeyConstraint({ fields: args.map(getField) });
-}
-var ForeignKeyConstraint = class _ForeignKeyConstraint {
-  [internalData];
-  constructor(data) {
-    this[internalData] = data;
-  }
-  references(...fields) {
-    return new _ForeignKeyConstraint({
-      ...getData(this),
-      references: fields.map(getField)
-    });
-  }
-  get [internalConstraint]() {
-    const { fields, references } = getData(this);
-    return sql`foreign key (${sql.join(
-      fields.map((field) => sql.identifier(field.fieldName)),
-      sql`, `
-    )}) references ${sql.identifier(references[0].targetName)} (${sql.join(
-      references.map((field) => sql.identifier(field.fieldName)),
-      sql`, `
-    )})`;
-  }
-};
-
 // node_modules/rado/dist/core/Column.js
 function formatType(kind, args) {
   return args.length === 0 ? sql.unsafe(kind) : sql`${sql.unsafe(kind)}(${sql.join(args.map(sql.inline), sql`, `)})`;
@@ -241,6 +170,77 @@ function formatColumn(column2) {
   );
 }
 
+// node_modules/rado/dist/core/Constraint.js
+var UniqueConstraint = class _UniqueConstraint {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  on(...columns) {
+    const fields = columns.map(getField);
+    return new _UniqueConstraint({ ...getData(this), fields });
+  }
+  nullsNotDistinct() {
+    return new _UniqueConstraint({ ...getData(this), nullsNotDistinct: true });
+  }
+  get [internalConstraint]() {
+    const { fields, nullsNotDistinct } = getData(this);
+    return sql.join([
+      sql`unique`,
+      nullsNotDistinct ? sql`nulls not distinct` : void 0,
+      sql`(${sql.join(
+        fields.map((field) => sql.identifier(field.fieldName)),
+        sql`, `
+      )})`
+    ]);
+  }
+};
+var PrimaryKeyConstraint = class {
+  constructor(data) {
+    this.data = data;
+    this[internalData] = data;
+  }
+  data;
+  [internalData];
+  get [internalConstraint]() {
+    const { fields } = getData(this);
+    return sql`primary key (${sql.join(
+      fields.map((field) => sql.identifier(field.fieldName)),
+      sql`, `
+    )})`;
+  }
+};
+function primaryKey(...args) {
+  if (args.length === 1 && "columns" in args[0])
+    return new PrimaryKeyConstraint({
+      name: args[0].name,
+      fields: args[0].columns.map(getField)
+    });
+  return new PrimaryKeyConstraint({ fields: args.map(getField) });
+}
+var ForeignKeyConstraint = class _ForeignKeyConstraint {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  references(...fields) {
+    return new _ForeignKeyConstraint({
+      ...getData(this),
+      references: fields.map(getField)
+    });
+  }
+  get [internalConstraint]() {
+    const { fields, references } = getData(this);
+    return sql`foreign key (${sql.join(
+      fields.map((field) => sql.identifier(field.fieldName)),
+      sql`, `
+    )}) references ${sql.identifier(references[0].targetName)} (${sql.join(
+      references.map((field) => sql.identifier(field.fieldName)),
+      sql`, `
+    )})`;
+  }
+};
+
 // node_modules/rado/dist/postgres/columns.js
 function parsePgArrayValue(input2) {
   if (!input2.startsWith("{") || !input2.endsWith("}")) return [input2];