@blokkli/editor 2.0.0-alpha.61 → 2.0.0-alpha.63

package/dist/runtime/editor/helpers/diff/index.d.ts

@@ -21,3 +21,90 @@ export declare function computeDiff(before: string, after: string): string;
  * <ins> rather than wrapping the block tags themselves.
  */
 export declare function computeInsertion(after: string): string;
+/**
+ * One chunk of a field's diff that can be individually accepted or rejected
+ * by the user. A markup field becomes an ordered list of segments; lists
+ * (<ul>/<ol>) become a `list` segment whose children are the individual
+ * <li> atoms.
+ *
+ * Acceptance semantics (see `reassembleValue`):
+ * - matched: accepted → afterHtml, rejected → beforeHtml
+ * - inserted: accepted → keep, rejected → drop
+ * - deleted: accepted → drop (matches after), rejected → restore (matches before)
+ */
+export type AtomicSegment = {
+    kind: 'atomic';
+    id: string;
+    tag: string;
+    openTag: string;
+    closeTag: string;
+    beforeHtml: string;
+    afterHtml: string;
+    changed: boolean;
+    status: 'matched' | 'inserted' | 'deleted';
+};
+export type ListSegment = {
+    kind: 'list';
+    id: string;
+    tag: 'ul' | 'ol';
+    openTag: string;
+    closeTag: string;
+    children: AtomicSegment[];
+};
+export type Segment = AtomicSegment | ListSegment;
+/**
+ * Split a before/after value pair into chunks the user can individually
+ * accept or reject. Returns null when chunk-level approval can't apply:
+ *
+ * - non-markup fields
+ * - either side contains inline-only HTML or stray top-level text
+ *   (`parseBlocks` returns null)
+ * - both sides empty
+ *
+ * Two-level structure: top-level block alignment, then a one-level recurse
+ * into matched <ul>/<ol> blocks whose innerHTML differs. <li> is the leaf.
+ *
+ * Used for both rewrites (word-diff preview) and translations
+ * (insertion-only preview). The difference is at the renderer.
+ */
+export declare function splitIntoSegments(before: string, after: string, fieldType: 'plain' | 'markup'): Segment[] | null;
+/**
+ * True when at least one segment (or list child) actually changes. Use to
+ * skip the approval row for fields where the proposed value already matches
+ * the current value chunk-for-chunk.
+ */
+export declare function segmentsHaveChanges(segments: Segment[]): boolean;
+/**
+ * Render segments as preview HTML with `data-chunk-index` attributes on each
+ * atomic block, so the approval UI can locate each chunk's DOM bounds. The
+ * resulting markup replaces the editable's innerHTML during preview, just
+ * like `computeDiff` / `computeInsertion`.
+ *
+ * `insertionsOnly` matches the existing prop on DiffApproval — translations
+ * render new content as a single <ins> per leaf, rewrites render word-diffs.
+ *
+ * `acceptedById` (optional) makes the preview track per-segment acceptance:
+ * rejected matched segments render their original content with no markers,
+ * rejected insertions render as deletions, rejected deletions render plain.
+ * Defaults to "all accepted" when omitted (initial render).
+ */
+export declare function renderSegmentDiff(segments: Segment[], opts?: {
+    insertionsOnly?: boolean;
+    acceptedById?: Record<string, boolean>;
+}): string;
+/**
+ * Reassemble a field value from segments using per-segment acceptance.
+ * Acceptance defaults to `true` for any unmapped segment id, mirroring the
+ * DiffApproval initial state.
+ *
+ * For `list` segments the wrapper is emitted only when at least one child
+ * survives — accepting a full deletion of every item drops the list itself.
+ */
+export declare function reassembleValue(segments: Segment[], acceptedById: Record<string, boolean>): string;
+/**
+ * Walk a segment list and return every atomic segment in reading order,
+ * including those inside list wrappers. Used by the approval UI for
+ * keyboard nav, selection initialisation, and the rejected-segments
+ * feedback to the agent.
+ */
+export declare function flattenSegments(segments: Segment[]): AtomicSegment[];

package/dist/runtime/editor/helpers/diff/index.js

@@ -234,3 +234,259 @@ export function computeInsertion(after) {
   }
   return `<ins>${after}</ins>`;
 }
+function parseListItems(html) {
+  const container = document.createElement("div");
+  container.innerHTML = html;
+  const items = [];
+  for (const child of container.childNodes) {
+    if (child.nodeType === Node.ELEMENT_NODE) {
+      const el = child;
+      const tag = el.tagName.toLowerCase();
+      if (tag !== "li") return null;
+      let openTag = `<${tag}`;
+      for (const attr of el.attributes) {
+        openTag += ` ${attr.name}="${attr.value}"`;
+      }
+      openTag += ">";
+      items.push({ tag, innerHTML: el.innerHTML, openTag });
+    } else if (child.nodeType === Node.TEXT_NODE && child.textContent?.trim()) {
+      return null;
+    }
+  }
+  return items;
+}
+function alignListItems(before, after) {
+  const m = before.length;
+  const n = after.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => Array(n + 1).fill(0)
+  );
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (before[i2 - 1].innerHTML === after[j2 - 1].innerHTML) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const ops = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (before[i - 1].innerHTML === after[j - 1].innerHTML) {
+      ops.push({
+        type: "unchanged",
+        before: before[i - 1],
+        after: after[j - 1]
+      });
+      i--;
+      j--;
+    } else if (dp[i - 1][j] >= dp[i][j - 1]) {
+      ops.push({ type: "before", block: before[i - 1] });
+      i--;
+    } else {
+      ops.push({ type: "after", block: after[j - 1] });
+      j--;
+    }
+  }
+  while (i > 0) {
+    ops.push({ type: "before", block: before[i - 1] });
+    i--;
+  }
+  while (j > 0) {
+    ops.push({ type: "after", block: after[j - 1] });
+    j--;
+  }
+  ops.reverse();
+  const entries = [];
+  let k = 0;
+  while (k < ops.length) {
+    const op = ops[k];
+    if (op.type === "unchanged") {
+      entries.push({ type: "match", before: op.before, after: op.after });
+      k++;
+      continue;
+    }
+    const befores = [];
+    const afters = [];
+    while (k < ops.length && ops[k].type !== "unchanged") {
+      const r = ops[k];
+      if (r.type === "before") befores.push(r.block);
+      else if (r.type === "after") afters.push(r.block);
+      k++;
+    }
+    const pairCount = Math.min(befores.length, afters.length);
+    for (let p = 0; p < pairCount; p++) {
+      entries.push({ type: "match", before: befores[p], after: afters[p] });
+    }
+    for (let p = pairCount; p < befores.length; p++) {
+      entries.push({ type: "delete", before: befores[p] });
+    }
+    for (let p = pairCount; p < afters.length; p++) {
+      entries.push({ type: "insert", after: afters[p] });
+    }
+  }
+  return entries;
+}
+function atomicFromAlignment(entry, id) {
+  if (entry.type === "match") {
+    return {
+      kind: "atomic",
+      id,
+      tag: entry.after.tag,
+      openTag: entry.after.openTag,
+      closeTag: `</${entry.after.tag}>`,
+      beforeHtml: entry.before.innerHTML,
+      afterHtml: entry.after.innerHTML,
+      changed: entry.before.innerHTML !== entry.after.innerHTML,
+      status: "matched"
+    };
+  }
+  if (entry.type === "delete") {
+    return {
+      kind: "atomic",
+      id,
+      tag: entry.before.tag,
+      openTag: entry.before.openTag,
+      closeTag: `</${entry.before.tag}>`,
+      beforeHtml: entry.before.innerHTML,
+      afterHtml: "",
+      changed: true,
+      status: "deleted"
+    };
+  }
+  return {
+    kind: "atomic",
+    id,
+    tag: entry.after.tag,
+    openTag: entry.after.openTag,
+    closeTag: `</${entry.after.tag}>`,
+    beforeHtml: "",
+    afterHtml: entry.after.innerHTML,
+    changed: true,
+    status: "inserted"
+  };
+}
+export function splitIntoSegments(before, after, fieldType) {
+  if (fieldType !== "markup") return null;
+  const beforeBlocks = parseBlocks(before);
+  const afterBlocks = parseBlocks(after);
+  if (!beforeBlocks || !afterBlocks) return null;
+  if (beforeBlocks.length === 0 && afterBlocks.length === 0) return null;
+  const alignment = alignBlocks(beforeBlocks, afterBlocks);
+  const segments = [];
+  alignment.forEach((entry, index) => {
+    const id = String(index);
+    if (entry.type === "match" && (entry.after.tag === "ul" || entry.after.tag === "ol") && entry.before.innerHTML !== entry.after.innerHTML) {
+      const beforeItems = parseListItems(entry.before.innerHTML);
+      const afterItems = parseListItems(entry.after.innerHTML);
+      if (beforeItems && afterItems) {
+        const childAlignment = alignListItems(beforeItems, afterItems);
+        const children = childAlignment.map(
+          (childEntry, childIndex) => atomicFromAlignment(childEntry, `${id}/${childIndex}`)
+        );
+        segments.push({
+          kind: "list",
+          id,
+          tag: entry.after.tag,
+          openTag: entry.after.openTag,
+          closeTag: `</${entry.after.tag}>`,
+          children
+        });
+        return;
+      }
+    }
+    segments.push(atomicFromAlignment(entry, id));
+  });
+  return segments;
+}
+export function segmentsHaveChanges(segments) {
+  return segments.some(
+    (seg) => seg.kind === "list" ? seg.children.some(
+      (c) => c.status !== "matched" || c.beforeHtml !== c.afterHtml
+    ) : seg.status !== "matched" || seg.beforeHtml !== seg.afterHtml
+  );
+}
+function injectAttribute(openTag, name, value) {
+  return openTag.slice(0, -1) + ` ${name}="${value}">`;
+}
+function renderAtomicDiffMarkup(seg, opts) {
+  const open = injectAttribute(seg.openTag, "data-chunk-index", seg.id);
+  const accepted = opts.acceptedById?.[seg.id] !== false;
+  if (seg.status === "inserted") {
+    if (!accepted) {
+      return `${open}<del>${seg.afterHtml}</del>${seg.closeTag}`;
+    }
+    return `${open}<ins>${seg.afterHtml}</ins>${seg.closeTag}`;
+  }
+  if (seg.status === "deleted") {
+    if (!accepted) {
+      return `${open}${seg.beforeHtml}${seg.closeTag}`;
+    }
+    return `${open}<del>${seg.beforeHtml}</del>${seg.closeTag}`;
+  }
+  if (!accepted) {
+    return `${open}${seg.beforeHtml}${seg.closeTag}`;
+  }
+  if (opts.insertionsOnly) {
+    return `${open}<ins>${seg.afterHtml}</ins>${seg.closeTag}`;
+  }
+  if (seg.beforeHtml === seg.afterHtml) {
+    return `${open}${seg.afterHtml}${seg.closeTag}`;
+  }
+  const innerDiff = diff(seg.beforeHtml, seg.afterHtml);
+  return `${open}${cleanupDiffMods(innerDiff)}${seg.closeTag}`;
+}
+export function renderSegmentDiff(segments, opts = {}) {
+  const parts = [];
+  for (const seg of segments) {
+    if (seg.kind === "list") {
+      const childParts = seg.children.map(
+        (c) => renderAtomicDiffMarkup(c, opts)
+      );
+      parts.push(`${seg.openTag}${childParts.join("")}${seg.closeTag}`);
+    } else {
+      parts.push(renderAtomicDiffMarkup(seg, opts));
+    }
+  }
+  return parts.join("");
+}
+export function reassembleValue(segments, acceptedById) {
+  const isAccepted = (id) => acceptedById[id] !== false;
+  const renderAtomic = (seg) => {
+    const accepted = isAccepted(seg.id);
+    if (seg.status === "matched") {
+      return seg.openTag + (accepted ? seg.afterHtml : seg.beforeHtml) + seg.closeTag;
+    }
+    if (seg.status === "inserted") {
+      return accepted ? seg.openTag + seg.afterHtml + seg.closeTag : "";
+    }
+    return accepted ? "" : seg.openTag + seg.beforeHtml + seg.closeTag;
+  };
+  const parts = [];
+  for (const seg of segments) {
+    if (seg.kind === "list") {
+      const childParts = seg.children.map(renderAtomic).filter((p) => p);
+      if (childParts.length > 0) {
+        parts.push(`${seg.openTag}${childParts.join("")}${seg.closeTag}`);
+      }
+    } else {
+      const out = renderAtomic(seg);
+      if (out) parts.push(out);
+    }
+  }
+  return parts.join("");
+}
+export function flattenSegments(segments) {
+  const out = [];
+  for (const seg of segments) {
+    if (seg.kind === "list") {
+      out.push(...seg.children);
+    } else {
+      out.push(seg);
+    }
+  }
+  return out;
+}

package/dist/runtime/editor/helpers/injections.d.ts

@@ -0,0 +1,11 @@
+import type { InjectionKey, Ref } from 'vue';
+/**
+ * A ref to the nearest popup host element (provided by `<PopupHost>`).
+ *
+ * Descendants that render floating menus (e.g. the chart editor's color
+ * picker) inject this and teleport their content into the host. This lets
+ * the menu escape any `overflow: hidden`/`overflow: auto` clipping ancestor
+ * while staying inside the popup host's stacking context. When no host is
+ * provided, descendants fall back to inline rendering.
+ */
+export declare const INJECT_POPUP_HOST: InjectionKey<Ref<HTMLElement | null>>;

package/dist/runtime/editor/helpers/injections.js

@@ -0,0 +1 @@
+export const INJECT_POPUP_HOST = Symbol("blokkli_popup_host");

package/dist/runtime/editor/plugins/Sidebar/Detached/index.d.vue.ts

@@ -34,8 +34,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
         width: number;
         height: number;
     };
-    minHeight: number;
     minWidth: number;
+    minHeight: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/editor/plugins/Sidebar/Detached/index.vue.d.ts

@@ -34,8 +34,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
         width: number;
         height: number;
     };
-    minHeight: number;
     minWidth: number;
+    minHeight: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/editor/plugins/Sidebar/index.d.vue.ts

@@ -200,9 +200,9 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
         width: number;
         height: number;
     };
-    minHeight: number;
-    minWidth: number;
     tourText: string;
+    minWidth: number;
+    minHeight: number;
     region: SidebarRegion;
     tooltipTitle: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {

package/dist/runtime/editor/plugins/Sidebar/index.vue.d.ts

@@ -200,9 +200,9 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
         width: number;
         height: number;
     };
-    minHeight: number;
-    minWidth: number;
     tourText: string;
+    minWidth: number;
+    minHeight: number;
     region: SidebarRegion;
     tooltipTitle: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {

package/dist/runtime/editor/providers/analyze.js

@@ -1,12 +1,15 @@
 import { ref } from "#imports";
 import { AnalyzerContext } from "../features/analyze/analyzers/helpers/Context.js";
 import { normalizeToArray } from "../features/analyze/analyzers/helpers/normalizeArray.js";
+import { validationsAnalyzer } from "../features/analyze/analyzers/defaults/validations.js";
+const DEFAULT_ANALYZERS = [validationsAnalyzer];
 export default function analyzeProvider(adapters, state, ui, context, $t, readability) {
   const analyzers = ref([]);
   const isInitialized = ref(false);
   let initPromise = null;
   async function doInit() {
     const fetched = await adapters.getAggregated("getAnalyzers");
+    const all = [...DEFAULT_ANALYZERS, ...fetched];
     const initCtx = new AnalyzerContext(
       context.value.language,
       ui.interfaceLanguage.value,
@@ -17,13 +20,13 @@ export default function analyzeProvider(adapters, state, ui, context, $t, readab
       readability
     );
     await Promise.all(
-      fetched.map(async (analyzer) => {
+      all.map(async (analyzer) => {
         if (analyzer.init) {
           await analyzer.init(initCtx);
         }
       })
     );
-    analyzers.value = fetched;
+    analyzers.value = all;
     isInitialized.value = true;
   }
   function ensureInitialized() {

package/dist/runtime/editor/providers/config.d.ts

@@ -1,8 +1,10 @@
 import { type ComputedRef } from '#imports';
-import type { ColorOption } from '../types/config.js';
+import type { ColorOption } from '#blokkli/types/colors';
 export type ConfigProvider = {
     colorOptions: ComputedRef<ColorOption[]>;
     getColorOption: (id: string) => ColorOption | undefined;
     getColorHex: (id: string) => string;
+    isColorEnabled: (id: string) => boolean;
+    canonicalColorId: (option: ColorOption) => string;
 };
 export default function (): ConfigProvider;

package/dist/runtime/editor/providers/config.js

@@ -1,18 +1,49 @@
-import { computed } from "#imports";
+import { computed, useAppConfig } from "#imports";
 import { colorOptions as moduleColorOptions } from "#blokkli-build/editor-config";
+import {
+  canonicalColorId,
+  findColorOption,
+  isColorIdValid
+} from "#blokkli/helpers/colors";
+import { useBlokkliRuntimeConfig } from "../../composables/useBlokkliRuntimeConfig.js";
 export default function() {
-  const colorOptions = computed(
-    () => Object.entries(moduleColorOptions).map(([id, entry]) => ({
-      id,
-      hex: entry.hex,
-      label: entry.label
-    }))
-  );
-  function getColorOption(id) {
-    return colorOptions.value.find((c) => c.id === id);
-  }
-  function getColorHex(id) {
-    return getColorOption(id)?.hex || "#888888";
-  }
-  return { colorOptions, getColorOption, getColorHex };
+  const appConfig = useAppConfig();
+  const { resolveColorHex } = useBlokkliRuntimeConfig();
+  const colorOptions = computed(() => {
+    const overrides = appConfig.blokkli?.colorOptions ?? {};
+    const result = [];
+    for (const [id, entry] of Object.entries(moduleColorOptions)) {
+      if (overrides[id] === null) continue;
+      if ("shades" in entry) {
+        const shades = [];
+        for (const [shadeId, declaredHex] of Object.entries(entry.shades)) {
+          const value = overrides[`${id}.${shadeId}`];
+          if (value === null) continue;
+          shades.push({
+            id: shadeId,
+            hex: typeof value === "string" ? value : declaredHex,
+            isMain: shadeId === entry.mainShade
+          });
+        }
+        if (shades.length === 0) continue;
+        const main = shades.find((s) => s.isMain) ?? shades[0];
+        result.push({ id, hex: main.hex, label: entry.label, shades });
+      } else {
+        const value = overrides[id];
+        result.push({
+          id,
+          hex: typeof value === "string" ? value : entry.hex,
+          label: entry.label
+        });
+      }
+    }
+    return result;
+  });
+  return {
+    colorOptions,
+    getColorOption: (id) => findColorOption(id, colorOptions.value),
+    getColorHex: resolveColorHex,
+    isColorEnabled: (id) => isColorIdValid(id, colorOptions.value),
+    canonicalColorId
+  };
 }

package/dist/runtime/editor/providers/state.d.ts

@@ -95,6 +95,19 @@ export type StateProvider = {
      * @returns True if successful, false if failed
      */
     mutateWithLoadingState: MutateWithLoadingStateFunction;
+    /**
+     * Apply the raw state returned by a mutation as the current editor state.
+     *
+     * Use this when a caller has invoked an adapter mutation directly (bypassing
+     * {@link mutateWithLoadingState}) and wants to push the response's `state`
+     * payload into the editor without an extra round-trip. The caller is
+     * responsible for only invoking this when the response belongs to the
+     * current edit state.
+     *
+     * @param rawState - The `state` field from a {@link MutationResponseLike}
+     *   response, or `null`/`undefined` to no-op.
+     */
+    applyMutationState: (rawState: unknown) => void;
     /**
      * Current edit mode.
      *

package/dist/runtime/editor/providers/state.js

@@ -370,6 +370,12 @@ export default async function(eventBus, adapter, context, $t, providerKey, permi
   function setOverrideState(state) {
     setContext(state, true);
   }
+  function applyMutationState(rawState) {
+    if (!rawState) {
+      return;
+    }
+    setContext(adapter.mapState(rawState));
+  }
   function clearOverrideState() {
     if (!_mappedState) {
       throw new Error("Missing previous state.");
@@ -391,6 +397,7 @@ export default async function(eventBus, adapter, context, $t, providerKey, permi
     violations,
     currentMutationIndex,
     mutateWithLoadingState,
+    applyMutationState,
     editMode,
     canEdit,
     isLoading: readonly(isLoading),

package/dist/runtime/editor/translations/de.json

@@ -291,6 +291,9 @@
   "analyzerReadabiliyOkTitle": "Text könnte einfacher sein",
   "analyzerReadabiliyShorterSentences": "Verwenden Sie kürzere Sätze und einfachere Formulierungen.",
   "analyzerReadabiliyTitle": "Probleme bei Lesbarkeit",
+  "analyzerValidationsDescription": "Validierungsfehler für den aktuellen Stand der Seite.",
+  "analyzerValidationsLabel": "Validierungen",
+  "analyzerValidationsPassDescription": "Keine Validierungsfehler für den aktuellen Stand der Seite.",
   "arrowLeft": "Pfeil links",
   "arrowRight": "Pfeil rechts",
   "artboard": "Vorschau",
@@ -534,6 +537,7 @@
   "deleteConversation": "Konversation löschen",
   "deleteError": "Das Element konnte nicht entfernt werden.",
   "deleteNoPermission": "Löschen aufgrund fehlender Berechtigung nicht möglich.",
+  "deleted": "gelöscht",
   "description": "Beschreibung",
   "diffBefore": "Vorher",
   "diffModeInline": "Hervorgehoben",
@@ -672,6 +676,7 @@
   "libraryPlaceDialogTitle": "Block aus Bibliothek hinzufügen",
   "link": "Link",
   "loading": "Wird geladen",
+  "mainColor": "Hauptfarbe",
   "manageSchedule": "Planung verwalten",
   "manageScheduling": "Planung verwalten",
   "maskTourText": "Wechseln Sie zwischen Anzeigen und Verbergen nicht bearbeitbarer Teile der Seite.",
@@ -764,6 +769,8 @@
   "publishSuccess": "Änderungen erfolgreich publiziert.",
   "publishSuccessfullyPublished": "Erfolgreich veröffentlicht",
   "publishSuccessfullySaved": "Erfolgreich gespeichert",
+  "publishValidationErrorsDescription": "Beheben Sie die folgenden Probleme und publizieren Sie erneut.",
+  "publishValidationErrorsTitle": "Publikation nicht möglich: Validierungsfehler",
   "publishWillBePublished": "Wird publiziert",
   "publishWillBeScheduled": "Wird geplant",
   "qrCode": "QR-Code",
@@ -929,10 +936,6 @@
   "translationsTranslateNoTexts": "Keine übersetzbaren Texte auf dieser Seite gefunden.",
   "undo": "Rückgängig",
   "unexpectedMutationError": "Ein unerwarteter Fehler ist aufgetreten",
-  "userDeleted": "[gelöscht]",
-  "validationsNoneFound": "Keine Validierungsfehler gefunden.",
-  "validationsToolbarLabel": "Validierungen",
-  "validationsTourText": "Zeigt Validierungsfehler für Inhalte auf der aktuellen Seite an.",
   "video": "Video",
   "viewBannerReviewText": "Sie können Kommentare ansehen und hinzufügen, aber keine Inhalte bearbeiten.",
   "viewBannerReviewTitle": "Sie befinden sich im Review-Modus.",

package/dist/runtime/editor/translations/fr.json

@@ -94,6 +94,7 @@
   "commentsMarkAsUnresolved": "Marquer comme non résolu",
   "commentsShowResolved": "Afficher les résolus",
   "deleteError": "L'élément n'a pas pu être supprimé.",
+  "deleted": "supprimé",
   "duplicate": "Dupliquer",
   "duplicateError": "Les éléments n'ont pas pu être dupliqués.",
   "edit": "Modifier",
@@ -163,8 +164,5 @@
   "settingsDialogTitle": "Paramètres",
   "settingsMenuDescription": "Paramètres personnels pour l’éditeur",
   "structureToolbarLabel": "Structure",
-  "translationsBatchTranslateMenuDescription": "Traduire tous les éléments",
-  "userDeleted": "[supprimé]",
-  "validationsNoneFound": "Aucune erreur de validation trouvée.",
-  "validationsToolbarLabel": "Validations"
+  "translationsBatchTranslateMenuDescription": "Traduire tous les éléments"
 }

package/dist/runtime/editor/translations/gsw_CH.json

@@ -291,6 +291,9 @@
   "analyzerReadabiliyOkTitle": "Teggscht chönnt eifacher si",
   "analyzerReadabiliyShorterSentences": "Bruch chürzeri Sätz und eifacheri Formulierige.",
   "analyzerReadabiliyTitle": "Läsbarkeitsproblem im Teggscht",
+  "analyzerValidationsDescription": "Validierungsfehler für den aktuellen Stand der Seite.",
+  "analyzerValidationsLabel": "Validierungen",
+  "analyzerValidationsPassDescription": "Keine Validierungsfehler für den aktuellen Stand der Seite.",
   "arrowLeft": "Pfeil links",
   "arrowRight": "Pfeil rechts",
   "artboard": "Zeichenflächi",
@@ -534,6 +537,7 @@
   "deleteConversation": "Konversation löschen",
   "deleteError": "Dr Block het nid chönne glöscht wärde.",
   "deleteNoPermission": "Lösche ufgrund fählender Berächtigung nid möglich.",
+  "deleted": "glöscht",
   "description": "Beschreibung",
   "diffBefore": "Vorhär",
   "diffModeInline": "Inline",
@@ -672,6 +676,7 @@
   "libraryPlaceDialogTitle": "Block us dr Bibliothek drzuefüege",
   "link": "Link",
   "loading": "Wird geladen",
+  "mainColor": "Hauptfarbe",
   "manageSchedule": "Planung verwalte...",
   "manageScheduling": "Planung verwalten",
   "maskTourText": "Wächsle zwüsche Aazeige oder Verstecke vo nid-bearbeitbare Teile vo dr Sitte.",
@@ -764,6 +769,8 @@
   "publishSuccess": "Änderige erfolgriich publiziert.",
   "publishSuccessfullyPublished": "Erfolgriich veröffentlicht",
   "publishSuccessfullySaved": "Erfolgriich gspeicheret",
+  "publishValidationErrorsDescription": "Beheben Sie die folgenden Probleme und publizieren Sie erneut.",
+  "publishValidationErrorsTitle": "Publikation nicht möglich: Validierungsfehler",
   "publishWillBePublished": "Würd publiziert",
   "publishWillBeScheduled": "Würd plant",
   "qrCode": "QR-Code",
@@ -929,10 +936,6 @@
   "translationsTranslateNoTexts": "Keine übersetzbaren Texte auf dieser Seite gefunden.",
   "undo": "Rückgängig",
   "unexpectedMutationError": "Es isch e unerwartete Fähler ufträte.",
-  "userDeleted": "[glöscht]",
-  "validationsNoneFound": "Keini Validierigsfähler gfunde.",
-  "validationsToolbarLabel": "Validierige",
-  "validationsTourText": "Lueg Validierigsfähler für Inhalt oder Struktur uf dr aktuälle Sitte aa.",
   "video": "Video",
   "viewBannerReviewText": "Du chasch Kommentär aaluege und drzuefüege, aber kän Inhalt bearbeite.",
   "viewBannerReviewTitle": "Du bisch im Review-Modus.",