@xleddyl/nuxt-cms 0.9.4 → 0.10.0

package/dist/runtime/shared/media-focal.js

@@ -0,0 +1,52 @@
+const FOCAL_PRECISION = 1e4;
+export function isFocalCoordinate(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+export function roundFocalCoordinate(value) {
+  return Math.round(Math.min(1, Math.max(0, value)) * FOCAL_PRECISION) / FOCAL_PRECISION;
+}
+export function focalPointOf(media) {
+  if (!media) return null;
+  const { focalX, focalY } = media;
+  if (!isFocalCoordinate(focalX) || !isFocalCoordinate(focalY)) return null;
+  return { x: focalX, y: focalY };
+}
+export function focalPointIssue(focalX, focalY) {
+  const unset = (value) => value === null || value === void 0;
+  if (unset(focalX) && unset(focalY)) return null;
+  if (unset(focalX) || unset(focalY)) return "focalX and focalY must be set together";
+  if (!isFocalCoordinate(focalX) || !isFocalCoordinate(focalY))
+    return "focalX and focalY must be numbers from 0 to 1";
+  return null;
+}
+function percent(value) {
+  return `${Math.round(value * 1e4) / 100}%`;
+}
+export function focalObjectPosition(media) {
+  const point = focalPointOf(media);
+  return point ? `${percent(point.x)} ${percent(point.y)}` : void 0;
+}
+export function imgixFocalModifiers(media) {
+  const point = focalPointOf(media);
+  if (!point) return {};
+  return { crop: "focalpoint", focalPointXPosition: point.x, focalPointYPosition: point.y };
+}
+function toPixels(value) {
+  if (value === null || value === void 0 || value === "") return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+export function cmsImageSize(media, input = {}) {
+  const naturalWidth = toPixels(media?.width);
+  const naturalHeight = toPixels(media?.height);
+  const width = toPixels(input.width);
+  const height = toPixels(input.height);
+  const ratio = naturalWidth && naturalHeight ? naturalWidth / naturalHeight : void 0;
+  if (width && height) return { width, height };
+  if (width) return { width, height: ratio ? Math.round(width / ratio) : void 0 };
+  if (height) return { width: ratio ? Math.round(height * ratio) : void 0, height };
+  return { width: naturalWidth, height: naturalHeight };
+}
+export function isRenderableImage(media) {
+  return !!media?.url && (media.type === void 0 || media.type === null || media.type === "image");
+}

package/dist/runtime/shared/migrations-dir.d.ts

@@ -1 +1,15 @@
 export declare function migrationsDirFor(root: string, driver: string): string;
+export interface CmsUniqueTextColumn {
+    table: string;
+    column: string;
+}
+export type CmsMigrationDialect = 'sqlite' | 'turso' | 'postgresql';
+export declare function blankUniqueValuesToNull(sql: string, columns: readonly CmsUniqueTextColumn[], dialect: CmsMigrationDialect): string;
+export declare function migrationSqlFiles(dir: string): string[];
+export declare function fixNewMigrations(dir: string, before: readonly string[], columns: readonly CmsUniqueTextColumn[], dialect: CmsMigrationDialect): string[];
+export declare const MIGRATION_FIXES_FILE = "migration-fixes.json";
+export interface CmsMigrationFixes {
+    dialect: CmsMigrationDialect;
+    out: string;
+    uniqueTextColumns: CmsUniqueTextColumn[];
+}

package/dist/runtime/shared/migrations-dir.js

@@ -1,5 +1,5 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 const MIGRATIONS_ROOT = "server/db/migrations";
 export function migrationsDirFor(root, driver) {
   if (driver === "postgres") return resolve(root, `${MIGRATIONS_ROOT}/postgres`);
@@ -7,3 +7,49 @@ export function migrationsDirFor(root, driver) {
   if (driver !== "sqlite" && existsSync(perDriver)) return perDriver;
   return resolve(root, `${MIGRATIONS_ROOT}/sqlite`);
 }
+const STATEMENT_BREAKPOINT = "--> statement-breakpoint";
+const SQLITE_UNIQUE_INDEX = /^CREATE UNIQUE INDEX [`"]?[\w]+[`"]? ON [`"]?(\w+)[`"]? \([`"]?(\w+)[`"]?\)/i;
+const POSTGRES_UNIQUE_CONSTRAINT = /^ALTER TABLE "(?:\w+"\.")?(\w+)" ADD CONSTRAINT "\w+" UNIQUE(?: NULLS NOT DISTINCT)?\("(\w+)"\)/i;
+function uniqueTarget(statement) {
+  const match = SQLITE_UNIQUE_INDEX.exec(statement) ?? POSTGRES_UNIQUE_CONSTRAINT.exec(statement);
+  return match ? { table: match[1], column: match[2] } : null;
+}
+function blankToNullStatement(target, dialect) {
+  const quote = dialect === "postgresql" ? '"' : "`";
+  const table = `${quote}${target.table}${quote}`;
+  const column = `${quote}${target.column}${quote}`;
+  return `UPDATE ${table} SET ${column} = NULL WHERE trim(${column}) = '';`;
+}
+export function blankUniqueValuesToNull(sql, columns, dialect) {
+  const out = [];
+  for (const part of sql.split(STATEMENT_BREAKPOINT)) {
+    const target = uniqueTarget(part.trim());
+    const listed = columns.some(
+      (column) => column.table === target?.table && column.column === target?.column
+    );
+    if (target && listed) {
+      const leading = /^\s*/.exec(part)[0];
+      out.push(`${leading}${blankToNullStatement(target, dialect)}`, `
+${part.trimStart()}`);
+    } else out.push(part);
+  }
+  return out.join(STATEMENT_BREAKPOINT);
+}
+export function migrationSqlFiles(dir) {
+  return existsSync(dir) ? readdirSync(dir).filter((file) => file.endsWith(".sql")) : [];
+}
+export function fixNewMigrations(dir, before, columns, dialect) {
+  const fixed = [];
+  if (!columns.length) return fixed;
+  for (const file of migrationSqlFiles(dir)) {
+    if (before.includes(file)) continue;
+    const path = join(dir, file);
+    const sql = readFileSync(path, "utf8");
+    const next = blankUniqueValuesToNull(sql, columns, dialect);
+    if (next === sql) continue;
+    writeFileSync(path, next);
+    fixed.push(file);
+  }
+  return fixed;
+}
+export const MIGRATION_FIXES_FILE = "migration-fixes.json";

package/dist/runtime/shared/presets.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import type { CmsI18n, FieldConfig } from './index.js';
+import type { CmsClipboardNotice, CmsPasteResult } from './clipboard.js';
+import type { CmsBlockValue } from './preview.js';
+export declare const CMS_PRESET_KEY_PREFIX = "cms:presets:";
+export declare const CMS_PRESET_NAME_MAX = 80;
+export declare const CMS_PRESET_DESCRIPTION_MAX = 300;
+export declare const CMS_PRESET_MAX_ITEMS = 100;
+export declare const CMS_PRESET_MAX_BYTES = 1000000;
+export declare const CMS_PRESET_MAX_COUNT = 500;
+export type CmsPresetAction = 'use' | 'manage';
+export declare function presetPermission(action: CmsPresetAction, entry: string): string;
+export interface CmsBlockPreset {
+    id: string;
+    name: string;
+    description?: string;
+    source: string;
+    types: string[];
+    signatures?: Record<string, string>;
+    items: CmsBlockValue[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const presetCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const presetUpdateSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export interface CmsPresetDetails {
+    name: string;
+    description?: string;
+}
+export type CmsPresetCreate = z.infer<typeof presetCreateSchema>;
+export type CmsPresetUpdate = z.infer<typeof presetUpdateSchema>;
+export declare function presetKey(id: string): string;
+export declare function presetTypes(items: readonly CmsBlockValue[]): string[];
+export declare function presetFits(preset: Pick<CmsBlockPreset, 'types' | 'signatures' | 'source'>, field: Pick<FieldConfig, 'blocks'>, source: string): boolean;
+export declare function presetSourceEntry(preset: Pick<CmsBlockPreset, 'source'>): string;
+export declare function presetReadable(preset: Pick<CmsBlockPreset, 'source'>, canRead: (permission: string) => boolean): boolean;
+export declare function parseStoredPreset(raw: string): CmsBlockPreset | null;
+export declare function sortPresets(presets: readonly CmsBlockPreset[]): CmsBlockPreset[];
+export type CmsPresetBuild = {
+    preset: CmsBlockPreset;
+} | {
+    error: string;
+};
+export declare function buildPreset(input: CmsPresetCreate, field: Pick<FieldConfig, 'blocks'>, i18n: CmsI18n, meta: {
+    id: string;
+    source: string;
+    now: string;
+}): CmsPresetBuild;
+export declare function renamePreset(preset: CmsBlockPreset, input: CmsPresetUpdate, now: string): CmsBlockPreset;
+export declare function presetBlockCount(count: number): string;
+export declare function presetInsertNotice(result: CmsPasteResult, field: Pick<FieldConfig, 'max'>, preset: Pick<CmsBlockPreset, 'name'>): CmsClipboardNotice;
+export declare const CMS_PRESET_PICKER_GROUP = "Presets";
+export declare const CMS_PRESET_ICON = "bookmark";
+export interface CmsPresetPickerItem {
+    id: string;
+    label: string;
+    description: string;
+    keywords: string[];
+}
+export declare function presetPickerItem(preset: CmsBlockPreset): CmsPresetPickerItem;

package/dist/runtime/shared/presets.js

@@ -0,0 +1,127 @@
+import { z } from "zod";
+import { pasteBlocks, skippedText } from "./clipboard.js";
+import { blockSignature, blockSignatures } from "./block-signature.js";
+export const CMS_PRESET_KEY_PREFIX = "cms:presets:";
+export const CMS_PRESET_NAME_MAX = 80;
+export const CMS_PRESET_DESCRIPTION_MAX = 300;
+export const CMS_PRESET_MAX_ITEMS = 100;
+export const CMS_PRESET_MAX_BYTES = 1e6;
+export const CMS_PRESET_MAX_COUNT = 500;
+export function presetPermission(action, entry) {
+  return action === "use" ? `${entry}.update` : "settings.manage";
+}
+const name = z.string().trim().min(1, "Give the preset a name").max(CMS_PRESET_NAME_MAX);
+const description = z.string().trim().max(CMS_PRESET_DESCRIPTION_MAX);
+const item = z.record(z.string(), z.unknown()).refine(
+  (value) => typeof value.type === "string" && value.type !== "",
+  "Every block needs a type"
+);
+export const presetCreateSchema = z.object({
+  name,
+  description: description.optional(),
+  items: z.array(item).min(1, "A preset needs at least one block").max(CMS_PRESET_MAX_ITEMS)
+}).strict();
+export const presetUpdateSchema = z.object({ name, description: description.optional() }).strict();
+const storedSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  source: z.string(),
+  types: z.array(z.string()),
+  signatures: z.record(z.string(), z.string()).optional(),
+  items: z.array(z.record(z.string(), z.unknown())),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+export function presetKey(id) {
+  return `${CMS_PRESET_KEY_PREFIX}${id}`;
+}
+export function presetTypes(items) {
+  return [...new Set(items.map((value) => String(value.type)))].sort();
+}
+export function presetFits(preset, field, source) {
+  const blocks = field.blocks ?? {};
+  if (!preset.types.length || !preset.types.every((type) => Object.hasOwn(blocks, type)))
+    return false;
+  const signatures = preset.signatures;
+  if (!signatures) return preset.source === source;
+  return preset.types.every(
+    (type) => Object.hasOwn(signatures, type) && signatures[type] === blockSignature(blocks[type])
+  );
+}
+export function presetSourceEntry(preset) {
+  return preset.source.split(".")[0] ?? "";
+}
+export function presetReadable(preset, canRead) {
+  const entry = presetSourceEntry(preset);
+  return !!entry && canRead(`${entry}.read`);
+}
+export function parseStoredPreset(raw) {
+  try {
+    const parsed = storedSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) return null;
+    const { description: text, ...rest } = parsed.data;
+    return { ...rest, ...text ? { description: text } : {} };
+  } catch {
+    return null;
+  }
+}
+export function sortPresets(presets) {
+  return [...presets].sort(
+    (a, b) => a.name.localeCompare(b.name, void 0, { sensitivity: "base" }) || a.createdAt.localeCompare(b.createdAt)
+  );
+}
+export function buildPreset(input, field, i18n, meta) {
+  const result = pasteBlocks([], 0, input.items, { blocks: field.blocks }, i18n);
+  if (result.unknown.length)
+    return {
+      error: `Not a block of this field: ${[...new Set(result.unknown)].join(", ")}`
+    };
+  const types = presetTypes(result.list);
+  const preset = {
+    id: meta.id,
+    name: input.name,
+    ...input.description ? { description: input.description } : {},
+    source: meta.source,
+    types,
+    signatures: blockSignatures(field.blocks, types),
+    items: result.list,
+    createdAt: meta.now,
+    updatedAt: meta.now
+  };
+  if (JSON.stringify(preset).length > CMS_PRESET_MAX_BYTES)
+    return { error: "The preset is too large" };
+  return { preset };
+}
+export function renamePreset(preset, input, now) {
+  const { description: _description, ...rest } = preset;
+  return {
+    ...rest,
+    name: input.name,
+    ...input.description ? { description: input.description } : {},
+    updatedAt: now
+  };
+}
+export function presetBlockCount(count) {
+  return `${count} ${count === 1 ? "block" : "blocks"}`;
+}
+export function presetInsertNotice(result, field, preset) {
+  const description2 = skippedText(result, field);
+  if (!result.pasted) return { title: "Nothing inserted", description: description2, color: "error" };
+  return {
+    title: `${preset.name} inserted`,
+    description: description2 ?? presetBlockCount(result.pasted),
+    color: description2 ? void 0 : "success"
+  };
+}
+export const CMS_PRESET_PICKER_GROUP = "Presets";
+export const CMS_PRESET_ICON = "bookmark";
+export function presetPickerItem(preset) {
+  const count = presetBlockCount(preset.items.length);
+  return {
+    id: preset.id,
+    label: preset.name,
+    description: preset.description ? `${count} \xB7 ${preset.description}` : count,
+    keywords: [CMS_PRESET_PICKER_GROUP, ...preset.types]
+  };
+}

package/dist/runtime/shared/preview-links.d.ts

@@ -0,0 +1,64 @@
+export declare const PREVIEW_QUERY_PARAM = "cms-preview";
+export declare const PREVIEW_HEADER = "x-cms-preview";
+export declare const PREVIEW_TOKEN_BYTES = 32;
+export declare const PREVIEW_RESPONSE_HEADERS: {
+    readonly 'cache-control': "private, no-store";
+    readonly 'x-robots-tag': "noindex, nofollow";
+    readonly 'referrer-policy': "same-origin";
+};
+export declare const PREVIEW_LINK_DURATIONS: readonly [{
+    readonly value: "1h";
+    readonly label: "1 hour";
+    readonly ms: 3600000;
+}, {
+    readonly value: "1d";
+    readonly label: "1 day";
+    readonly ms: number;
+}, {
+    readonly value: "7d";
+    readonly label: "7 days";
+    readonly ms: number;
+}, {
+    readonly value: "30d";
+    readonly label: "30 days";
+    readonly ms: number;
+}];
+export type CmsPreviewLinkDuration = (typeof PREVIEW_LINK_DURATIONS)[number]['value'];
+export declare const DEFAULT_PREVIEW_LINK_DURATION: CmsPreviewLinkDuration;
+export interface CmsPreviewLink {
+    id: string;
+    entry: string;
+    itemId: string;
+    locale: string | null;
+    path: string;
+    createdBy: string | null;
+    createdAt: string;
+    expiresAt: string;
+}
+export interface CmsCreatedPreviewLink {
+    link: CmsPreviewLink;
+    url: string;
+}
+export interface CmsPreviewGrant {
+    entry: string;
+    itemId: string;
+    expiresAt: string;
+}
+export interface CmsPreviewMode {
+    entry: string;
+    id: string;
+    expiresAt: string;
+}
+export interface CmsPreviewLinkState {
+    expiresAt: string;
+    revokedAt: string | null;
+}
+export declare function isPreviewToken(value: unknown): value is string;
+export declare function previewTokenFrom(value: unknown): string | null;
+export declare function hasPreviewQuery(path: string): boolean;
+export declare function isPreviewLinkDuration(value: unknown): value is CmsPreviewLinkDuration;
+export declare function previewLinkExpiry(duration: CmsPreviewLinkDuration, now?: Date): string;
+export declare function isPreviewLinkActive(link: CmsPreviewLinkState, now?: Date): boolean;
+export declare function previewGrantAllows(grant: CmsPreviewGrant | null | undefined, entry: string, itemId?: string): boolean;
+export declare function previewLinkUrl(path: string, token: string): string;
+export declare function previewBannerErrors(banner: unknown): string[];

package/dist/runtime/shared/preview-links.js

@@ -0,0 +1,54 @@
+export const PREVIEW_QUERY_PARAM = "cms-preview";
+export const PREVIEW_HEADER = "x-cms-preview";
+export const PREVIEW_TOKEN_BYTES = 32;
+export const PREVIEW_RESPONSE_HEADERS = {
+  "cache-control": "private, no-store",
+  "x-robots-tag": "noindex, nofollow",
+  "referrer-policy": "same-origin"
+};
+const HOUR_MS = 36e5;
+export const PREVIEW_LINK_DURATIONS = [
+  { value: "1h", label: "1 hour", ms: HOUR_MS },
+  { value: "1d", label: "1 day", ms: 24 * HOUR_MS },
+  { value: "7d", label: "7 days", ms: 7 * 24 * HOUR_MS },
+  { value: "30d", label: "30 days", ms: 30 * 24 * HOUR_MS }
+];
+export const DEFAULT_PREVIEW_LINK_DURATION = "1d";
+const TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+export function isPreviewToken(value) {
+  return typeof value === "string" && TOKEN_PATTERN.test(value);
+}
+export function previewTokenFrom(value) {
+  const candidate = Array.isArray(value) ? value[0] : value;
+  return isPreviewToken(candidate) ? candidate : null;
+}
+export function hasPreviewQuery(path) {
+  const query = path.replace(/#.*$/s, "").split("?").slice(1).join("?");
+  return query.split("&").some((part) => part.split("=")[0] === PREVIEW_QUERY_PARAM);
+}
+export function isPreviewLinkDuration(value) {
+  return PREVIEW_LINK_DURATIONS.some((duration) => duration.value === value);
+}
+export function previewLinkExpiry(duration, now = /* @__PURE__ */ new Date()) {
+  const ms = PREVIEW_LINK_DURATIONS.find((option) => option.value === duration).ms;
+  return new Date(now.getTime() + ms).toISOString();
+}
+export function isPreviewLinkActive(link, now = /* @__PURE__ */ new Date()) {
+  if (link.revokedAt) return false;
+  const expires = Date.parse(link.expiresAt);
+  return Number.isFinite(expires) && expires > now.getTime();
+}
+export function previewGrantAllows(grant, entry, itemId) {
+  if (!grant || grant.entry !== entry) return false;
+  return itemId === void 0 || grant.itemId === itemId;
+}
+export function previewLinkUrl(path, token) {
+  const [base = "", hash] = path.split(/#(.*)/s);
+  const separator = base.includes("?") ? "&" : "?";
+  const url = `${base}${separator}${PREVIEW_QUERY_PARAM}=${token}`;
+  return hash === void 0 ? url : `${url}#${hash}`;
+}
+export function previewBannerErrors(banner) {
+  if (banner === void 0 || typeof banner === "boolean") return [];
+  return [`preview.banner must be a boolean, got ${JSON.stringify(banner)}`];
+}

package/dist/runtime/shared/preview.d.ts

@@ -1,4 +1,6 @@
-import type { BlockConfig, FieldConfig, MediaItem, MediaType } from './index.js';
+import type { BlockConfig, CmsLink, FieldConfig, MediaItem, MediaType } from './index.js';
+import type { CmsBlockPath } from './block-paths.js';
+export type CmsPreviewLinkResolver = (value: unknown) => CmsLink | null;
 export declare const CMS_PREVIEW_CHANNEL = "nuxt-cms:preview";
 export declare const DEFAULT_CMS_PREVIEW_PATH = "/cms/preview";
 export declare function previewPathErrors(path: string, entryNames: string[]): string[];
@@ -13,7 +15,11 @@ export interface CmsPreviewMedia {
     size: number | null;
     width: number | null;
     height: number | null;
+    focalX: number | null;
+    focalY: number | null;
 }
+export type CmsPreviewTheme = 'system' | 'light' | 'dark';
+export declare function readPreviewTheme(value: unknown): CmsPreviewTheme;
 export interface CmsPreviewState {
     entry: string;
     field: string;
@@ -21,65 +27,162 @@ export interface CmsPreviewState {
     blocks: CmsBlockValue[];
     item: Record<string, unknown> | null;
     media: Record<string, CmsPreviewMedia>;
-    selected: number | null;
+    selected: CmsBlockPath | null;
+    editable: boolean;
+    lockedFields: string[];
+    theme: CmsPreviewTheme;
 }
 export type CmsPreviewHostMessage = {
     type: 'render';
     state: CmsPreviewState;
+} | {
+    type: 'highlight';
+    path: CmsBlockPath | null;
+} | {
+    type: 'reveal';
+    path: CmsBlockPath;
 };
 export type CmsPreviewFrameMessage = {
     type: 'ready';
 } | {
     type: 'select';
-    index: number | null;
+    path: CmsBlockPath | null;
     focus?: boolean;
+} | {
+    type: 'hover';
+    path: CmsBlockPath | null;
 } | {
     type: 'insert';
-    index: number;
+    path: CmsBlockPath;
 } | {
     type: 'move';
-    from: number;
-    to: number;
+    from: CmsBlockPath;
+    to: CmsBlockPath;
     focus?: boolean;
 } | {
     type: 'duplicate';
-    index: number;
+    path: CmsBlockPath;
 } | {
     type: 'toggle-hidden';
-    index: number;
+    path: CmsBlockPath;
 } | {
     type: 'remove';
-    index: number;
+    path: CmsBlockPath;
+} | {
+    type: 'copy';
+    path: CmsBlockPath;
+} | {
+    type: 'cut';
+    path: CmsBlockPath;
+} | {
+    type: 'paste';
+    path: CmsBlockPath;
+    text?: string;
+} | {
+    type: 'focus-field';
+    path: CmsBlockPath | null;
+    key: string;
+} | {
+    type: 'field-input';
+    path: CmsBlockPath | null;
+    key: string;
+    locale: string;
+    value: string;
+    commit?: boolean;
+} | {
+    type: 'undo';
+} | {
+    type: 'redo';
+} | {
+    type: 'save';
 };
+export declare const CMS_CLIPBOARD_MAX_LENGTH = 2000000;
 export type CmsPreviewEnvelope<T> = T & {
     channel: typeof CMS_PREVIEW_CHANNEL;
 };
 export declare function previewEnvelope<T extends {
     type: string;
 }>(message: T): CmsPreviewEnvelope<T>;
+export declare function isFieldKey(value: unknown): value is string;
+export declare function readMessagePath(value: unknown): CmsBlockPath | null;
 export declare function parseFrameMessage(data: unknown): CmsPreviewFrameMessage | null;
 export declare function parseHostMessage(data: unknown): CmsPreviewHostMessage | null;
+export interface CmsFieldTarget {
+    path: CmsBlockPath | null;
+    key: string;
+}
+export declare function previewFieldConfig(target: CmsFieldTarget, blocksFields: Record<string, FieldConfig>, blocksValues: Record<string, unknown>, entryFields: Record<string, FieldConfig> | null | undefined, blocksKey: string): FieldConfig | undefined;
+export type CmsEditorShortcut = 'undo' | 'redo' | 'save' | 'remove' | 'duplicate' | 'move-up' | 'move-down' | 'insert-after' | 'insert-before' | 'deselect';
+export interface CmsShortcutKey {
+    key: string;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+}
+export interface CmsShortcutTarget {
+    editable: boolean;
+    interactive: boolean;
+    selected: boolean;
+}
+export declare function isApplePlatform(platform: string): boolean;
+export declare function editorShortcut(event: CmsShortcutKey, apple: boolean): CmsEditorShortcut | null;
+export declare function shortcutApplies(action: CmsEditorShortcut, target: CmsShortcutTarget): boolean;
+export type CmsClipboardAction = 'copy' | 'cut' | 'paste';
+export interface CmsClipboardTarget {
+    editable: boolean;
+    interactive: boolean;
+    textSelected: boolean;
+    selected: boolean;
+}
+export declare function clipboardActionApplies(action: CmsClipboardAction, target: CmsClipboardTarget): boolean;
 export declare function isTrustedPreviewEvent(event: {
     origin: string;
     source: unknown;
 }, origin: string, source: unknown): boolean;
 export declare function emptyBlock(type: string, block: BlockConfig): CmsBlockValue;
-export declare function insertBlock(list: readonly CmsBlockValue[], index: number, item: CmsBlockValue): CmsBlockValue[];
-export declare function moveBlock(list: readonly CmsBlockValue[], from: number, to: number): CmsBlockValue[];
-export declare function duplicateBlock(list: readonly CmsBlockValue[], index: number): CmsBlockValue[];
-export declare function removeBlock(list: readonly CmsBlockValue[], index: number): CmsBlockValue[];
+export declare function duplicateBlockAt(values: Record<string, unknown>, path: CmsBlockPath): Record<string, unknown>;
 export declare function canHideBlock(block: BlockConfig | undefined): boolean;
-export declare function toggleBlockHidden(list: readonly CmsBlockValue[], index: number, block: BlockConfig | undefined): CmsBlockValue[];
-export declare function selectionAfterMove(selected: number | null, from: number, to: number): number | null;
-export declare function selectionAfterRemove(selected: number | null, index: number): number | null;
-export declare function moveTargetForInsertion(from: number, insertAt: number): number;
-export declare function insertionIndex(blocks: readonly {
+export declare function toggleBlockHiddenAt(values: Record<string, unknown>, path: CmsBlockPath, block: BlockConfig | undefined): Record<string, unknown>;
+export declare function canMoveBlock(fields: Record<string, FieldConfig>, values: Record<string, unknown>, from: CmsBlockPath, toList: CmsBlockPath): boolean;
+export interface CmsDropBox {
     index: number;
     top: number;
     bottom: number;
-}[], y: number, total: number): number;
+    left: number;
+    right: number;
+}
+export declare function isHorizontalList(boxes: readonly CmsDropBox[]): boolean;
+export declare function insertionIndex(boxes: readonly CmsDropBox[], point: {
+    x: number;
+    y: number;
+}, total: number): number;
 export declare function collectMediaKeys(fields: Record<string, FieldConfig>, values: Record<string, unknown> | null | undefined): string[];
 export declare function previewMedia(key: string, item: MediaItem | undefined, baseUrl: string | null | undefined): CmsPreviewMedia;
-export declare function previewBlocks(field: FieldConfig, value: unknown, locale: string, defaultLocale: string, media: Record<string, CmsPreviewMedia>): CmsBlockValue[];
-export declare function previewItem(fields: Record<string, FieldConfig>, values: Record<string, unknown>, locale: string, defaultLocale: string, media: Record<string, CmsPreviewMedia>): Record<string, unknown>;
+export declare function previewBlocks(field: FieldConfig, value: unknown, locale: string, defaultLocale: string, media: Record<string, CmsPreviewMedia>, resolveLink?: CmsPreviewLinkResolver): CmsBlockValue[];
+export declare function previewItem(fields: Record<string, FieldConfig>, values: Record<string, unknown>, locale: string, defaultLocale: string, media: Record<string, CmsPreviewMedia>, resolveLink?: CmsPreviewLinkResolver): Record<string, unknown>;
 export declare function blockSummary(block: BlockConfig | undefined, item: CmsBlockValue, locale: string, defaultLocale: string, max?: number): string;
+export declare function blockErrorPaths(errors: Record<string, string | undefined | null>, fieldKey: string): Set<string>;
+export declare function firstBlockError(errors: Record<string, string | undefined | null>, fieldKey: string): {
+    path: CmsBlockPath;
+    key?: string;
+} | null;
+export declare function editorIssueKeys(fields: Record<string, FieldConfig>, values: Record<string, unknown>, path: readonly unknown[], fieldKey: string): string[];
+export interface CmsBlockTreeVisit {
+    path: CmsBlockPath;
+    item: CmsBlockValue;
+    block: BlockConfig | undefined;
+    field: FieldConfig;
+}
+export declare function blockTreeVisits(fields: Record<string, FieldConfig>, values: Record<string, unknown> | null | undefined, prefix?: CmsBlockPath): CmsBlockTreeVisit[];
+export interface CmsBlockIdSnapshot<T> {
+    items: Map<CmsBlockValue, T>;
+    lists: Map<string, {
+        items: CmsBlockValue[];
+        ids: T[];
+    }>;
+}
+export declare function stableBlockTreeIds<T>(visits: readonly CmsBlockTreeVisit[], previous: CmsBlockIdSnapshot<T> | null, createId: () => T): {
+    ids: Map<string, T>;
+    snapshot: CmsBlockIdSnapshot<T>;
+};