@xleddyl/nuxt-cms 0.9.3 → 0.10.0

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

@@ -1,4 +1,4 @@
-import type { FieldConfig } from './index.js';
+import type { BlockConfig, FieldConfig } from './index.js';
 export declare const MAX_LAYOUT_ROW_FIELDS = 4;
 export type CmsLayoutRow = string | string[];
 export interface CmsLayoutSectionInput {
@@ -28,6 +28,7 @@ export interface CmsEntrySettings {
 export type CmsSettingsMap = Record<string, CmsEntrySettings>;
 export declare function layoutFromConfig(input: CmsLayoutBlock[] | undefined): CmsFormLayout;
 export declare function resolveFormLayout(fields: Record<string, FieldConfig>, layout: CmsFormLayout | undefined): CmsFormLayout;
+export declare function blockFormLayout(block: Pick<BlockConfig, 'fields' | 'layout'>): CmsFormLayout;
 export declare function defaultListColumns(fields: Record<string, FieldConfig>, list: CmsListInput | undefined, extra?: string[]): string[];
 export declare function resolveListColumns(fields: Record<string, FieldConfig>, saved: string[] | undefined, list: CmsListInput | undefined, extra?: string[]): string[];
 export declare function layoutErrors(at: string, fields: Record<string, FieldConfig>, input: CmsLayoutBlock[] | undefined): string[];

package/dist/runtime/shared/layout.js

@@ -78,6 +78,9 @@ export function resolveFormLayout(fields, layout) {
   }
   return { main };
 }
+export function blockFormLayout(block) {
+  return resolveFormLayout(block.fields, layoutFromConfig(block.layout));
+}
 export function defaultListColumns(fields, list, extra = []) {
   const available = [...Object.keys(fields), ...extra];
   const configured = list?.columns?.filter((key) => available.includes(key));

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

@@ -0,0 +1,48 @@
+import type { CmsConfig, CmsEntry, FieldConfig } from './index.js';
+export declare const LINK_URL_MAX_LENGTH = 2048;
+export declare const LINK_URL_SCHEMES: readonly string[];
+export declare const LINK_TARGET_SEPARATOR = ":";
+export interface CmsLinkValue {
+    url?: string;
+    entry?: string;
+    id?: string;
+    label?: string | Record<string, string>;
+    newTab?: boolean;
+}
+export interface CmsLink {
+    href: string | null;
+    label: string | null;
+    newTab: boolean;
+    external: boolean;
+    entry: string | null;
+    id: string | null;
+}
+export interface CmsLinkTarget {
+    entry: string;
+    id: string;
+}
+export interface CmsLinkReference extends CmsLinkTarget {
+    field: string;
+}
+export type CmsLinkUrlKind = 'absolute' | 'path' | 'anchor';
+export declare function linkUrlKind(url: string): CmsLinkUrlKind | null;
+export declare function linkUrlError(url: unknown): string | null;
+export declare function isExternalLinkUrl(url: string | null | undefined): boolean;
+export declare function isLinkTargetEntry(entry: CmsEntry | null | undefined): boolean;
+export declare function declaredLinkTargets(field: FieldConfig): string[] | null;
+export declare function linkTargetNames(config: CmsConfig, field: FieldConfig): string[];
+export declare function allowsExternalLinks(field: FieldConfig): boolean;
+export declare function linkTargetKey(entry: string, id: string): string;
+export declare function parseLinkTargetKey(key: string): CmsLinkTarget | null;
+export declare function readLinkValue(value: unknown): CmsLinkValue | null;
+export declare function linkTargetOf(value: unknown): CmsLinkTarget | null;
+export declare function linkLabelText(label: unknown, locale: string, defaultLocale: string): string | null;
+export declare function linkLabelTexts(label: unknown): {
+    locale: string | null;
+    text: string;
+}[];
+export declare function pageLinkPath(entry: CmsEntry | undefined, id: string): string | null;
+export declare function linkHref(config: CmsConfig, link: CmsLinkValue | null, locale: string, target?: Record<string, unknown> | null): string | null;
+export declare function resolveCmsLink(config: CmsConfig, value: unknown, locale: string, defaultLocale: string, target?: Record<string, unknown> | null): CmsLink | null;
+export declare function linkReferences(fields: Record<string, FieldConfig>, values: Record<string, unknown>): CmsLinkReference[];
+export declare function linkDisplayText(value: unknown, locale: string, defaultLocale: string, targetTitle?: string | null): string;

package/dist/runtime/shared/links.js

@@ -0,0 +1,155 @@
+import { blockReferenceLabel, walkBlocks } from "./block-paths.js";
+import { contentItemPath, isRoutedContent } from "./content-routes.js";
+export const LINK_URL_MAX_LENGTH = 2048;
+export const LINK_URL_SCHEMES = ["http", "https", "mailto", "tel"];
+export const LINK_TARGET_SEPARATOR = ":";
+const SCHEME = /^([a-z][a-z\d+.-]*):/i;
+const UNSAFE_CHARACTERS = /[\s\u0000-\u001F\u007F]/;
+const TEL_NUMBER = /^\+?[\d().\-/]+$/;
+export function linkUrlKind(url) {
+  if (url.startsWith("#")) return "anchor";
+  if (url.startsWith("/") && !url.startsWith("//") && !url.startsWith("/\\")) return "path";
+  const scheme = SCHEME.exec(url)?.[1]?.toLowerCase();
+  return scheme && LINK_URL_SCHEMES.includes(scheme) ? "absolute" : null;
+}
+export function linkUrlError(url) {
+  if (typeof url !== "string" || !url) return "Enter a URL";
+  if (url.length > LINK_URL_MAX_LENGTH) return "The URL is too long";
+  if (UNSAFE_CHARACTERS.test(url)) return "A URL cannot contain spaces";
+  if (url.startsWith("//") || url.startsWith("/\\") || url.startsWith("\\"))
+    return "Use https:// for links to other sites";
+  if (url.startsWith("/")) return null;
+  if (url.startsWith("#")) return url.length > 1 ? null : "Add an anchor name after #";
+  const scheme = SCHEME.exec(url)?.[1]?.toLowerCase();
+  if (!scheme) return "Use a full URL (https://...), a path starting with / or an #anchor";
+  if (!LINK_URL_SCHEMES.includes(scheme))
+    return `${scheme}: links are not allowed (use http, https, mailto or tel)`;
+  const rest = url.slice(scheme.length + 1);
+  if (scheme === "mailto") return rest ? null : "Add an email address after mailto:";
+  if (scheme === "tel") return TEL_NUMBER.test(rest) ? null : "Add a phone number after tel:";
+  if (!rest.startsWith("//")) return "Invalid URL";
+  try {
+    return new URL(url).hostname ? null : "Invalid URL";
+  } catch {
+    return "Invalid URL";
+  }
+}
+export function isExternalLinkUrl(url) {
+  return !!url && linkUrlKind(url) === "absolute";
+}
+export function isLinkTargetEntry(entry) {
+  return !!entry && (entry.kind === "page" || isRoutedContent(entry));
+}
+export function declaredLinkTargets(field) {
+  const to = field.to;
+  if (!Array.isArray(to)) return null;
+  return to.filter((name) => typeof name === "string");
+}
+export function linkTargetNames(config, field) {
+  const declared = declaredLinkTargets(field);
+  if (declared) return declared.filter((name) => isLinkTargetEntry(config[name]));
+  return Object.entries(config).filter(([, entry]) => isLinkTargetEntry(entry)).map(([name]) => name);
+}
+export function allowsExternalLinks(field) {
+  return field.external !== false;
+}
+export function linkTargetKey(entry, id) {
+  return `${entry}${LINK_TARGET_SEPARATOR}${id}`;
+}
+export function parseLinkTargetKey(key) {
+  const index = key.indexOf(LINK_TARGET_SEPARATOR);
+  if (index <= 0 || index === key.length - 1) return null;
+  return { entry: key.slice(0, index), id: key.slice(index + 1) };
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function readLinkValue(value) {
+  let parsed = value;
+  if (typeof parsed === "string") {
+    const text = parsed.trim();
+    if (!text.startsWith("{")) return text ? { url: text } : null;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return null;
+    }
+  }
+  if (!isRecord(parsed)) return null;
+  const link = {};
+  if (typeof parsed.url === "string" && parsed.url) link.url = parsed.url;
+  if (typeof parsed.entry === "string" && parsed.entry) link.entry = parsed.entry;
+  if (typeof parsed.id === "string" && parsed.id) link.id = parsed.id;
+  if (typeof parsed.label === "string" || isRecord(parsed.label))
+    link.label = parsed.label;
+  if (parsed.newTab === true) link.newTab = true;
+  return link;
+}
+export function linkTargetOf(value) {
+  const link = readLinkValue(value);
+  if (!link?.entry || !link.id || link.url) return null;
+  return { entry: link.entry, id: link.id };
+}
+export function linkLabelText(label, locale, defaultLocale) {
+  if (typeof label === "string") return label || null;
+  if (!isRecord(label)) return null;
+  const pick = (key) => {
+    const text = label[key];
+    return typeof text === "string" && text ? text : null;
+  };
+  return pick(locale) ?? pick(defaultLocale) ?? Object.keys(label).map(pick).find((text) => text !== null) ?? null;
+}
+export function linkLabelTexts(label) {
+  if (typeof label === "string") return label ? [{ locale: null, text: label }] : [];
+  if (!isRecord(label)) return [];
+  return Object.entries(label).filter((pair) => typeof pair[1] === "string" && !!pair[1]).map(([locale, text]) => ({ locale, text }));
+}
+export function pageLinkPath(entry, id) {
+  if (entry?.kind !== "page") return null;
+  return entry.pages?.find((route) => route.key === id)?.path ?? null;
+}
+export function linkHref(config, link, locale, target) {
+  if (!link) return null;
+  if (link.url) return linkUrlError(link.url) ? null : link.url;
+  if (!link.entry || !link.id) return null;
+  const entry = config[link.entry];
+  if (entry?.kind === "page") return pageLinkPath(entry, link.id);
+  if (!target || !isRoutedContent(entry)) return null;
+  return contentItemPath(entry, target, locale);
+}
+export function resolveCmsLink(config, value, locale, defaultLocale, target) {
+  const link = readLinkValue(value);
+  if (!link || !link.url && !(link.entry && link.id)) return null;
+  return {
+    href: linkHref(config, link, locale, target),
+    label: linkLabelText(link.label, locale, defaultLocale),
+    newTab: !!link.newTab,
+    external: isExternalLinkUrl(link.url),
+    entry: link.url ? null : link.entry ?? null,
+    id: link.url ? null : link.id ?? null
+  };
+}
+export function linkReferences(fields, values) {
+  const references = [];
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.type !== "link") continue;
+    const target = linkTargetOf(values[key]);
+    if (target) references.push({ field: key, ...target });
+  }
+  walkBlocks(fields, values, ({ item, block, path }) => {
+    for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
+      if (blockField.type !== "link") continue;
+      const target = linkTargetOf(item[blockFieldKey]);
+      if (target) references.push({ field: blockReferenceLabel(path, blockFieldKey), ...target });
+    }
+  });
+  return references;
+}
+export function linkDisplayText(value, locale, defaultLocale, targetTitle) {
+  const link = readLinkValue(value);
+  if (!link) return "";
+  const label = linkLabelText(link.label, locale, defaultLocale);
+  const target = link.url ?? targetTitle ?? null;
+  if (label && target) return `${label} (${target})`;
+  return label ?? target ?? (link.entry && link.id ? `${link.entry} #${link.id}` : "");
+}

package/dist/runtime/shared/list-filters.d.ts

@@ -1,7 +1,9 @@
 import type { CmsEntry, SelectOption } from './index.js';
 export declare const LIST_FILTER_PREFIX = "filter.";
+export declare const LIST_SEARCH_PARAM = "q";
 export declare const LIST_FILTER_STATUS = "status";
 export declare const LIST_FILTER_ID_MAX = 256;
+export declare const LIST_IDS_MAX = 1000;
 export type CmsListFilters = Record<string, string>;
 type FilterEntry = Pick<CmsEntry, 'kind' | 'fields' | 'drafts' | 'list'>;
 export declare function listFilterExtras(entry: FilterEntry): string[];

package/dist/runtime/shared/list-filters.js

@@ -1,7 +1,9 @@
 import { isCollectionKind, listFilterKeys, selectOptions } from "./index.js";
 export const LIST_FILTER_PREFIX = "filter.";
+export const LIST_SEARCH_PARAM = "q";
 export const LIST_FILTER_STATUS = "status";
 export const LIST_FILTER_ID_MAX = 256;
+export const LIST_IDS_MAX = 1e3;
 const STATUS_OPTIONS = [
   { value: "draft", label: "Draft" },
   { value: "published", label: "Published" }

package/dist/runtime/shared/media-focal.d.ts

@@ -0,0 +1,30 @@
+export interface CmsFocalPoint {
+    x: number;
+    y: number;
+}
+export interface CmsFocalMedia {
+    focalX?: number | null;
+    focalY?: number | null;
+}
+export declare function isFocalCoordinate(value: unknown): value is number;
+export declare function roundFocalCoordinate(value: number): number;
+export declare function focalPointOf(media: CmsFocalMedia | null | undefined): CmsFocalPoint | null;
+export declare function focalPointIssue(focalX: unknown, focalY: unknown): string | null;
+export declare function focalObjectPosition(media: CmsFocalMedia | null | undefined): string | undefined;
+export declare function imgixFocalModifiers(media: CmsFocalMedia | null | undefined): Record<string, string | number>;
+export interface CmsImageMedia extends CmsFocalMedia {
+    url: string | null;
+    type?: string | null;
+    alt?: string | null;
+    width?: number | null;
+    height?: number | null;
+}
+export interface CmsImageSizeInput {
+    width?: number | string | null;
+    height?: number | string | null;
+}
+export declare function cmsImageSize(media: Pick<CmsImageMedia, 'width' | 'height'> | null | undefined, input?: CmsImageSizeInput): {
+    width: number | undefined;
+    height: number | undefined;
+};
+export declare function isRenderableImage(media: CmsImageMedia | null | undefined): media is CmsImageMedia;

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[];