@xleddyl/nuxt-cms 0.9.4 → 0.10.1

package/dist/runtime/shared/translations.js

@@ -0,0 +1,123 @@
+import { isFieldVisible } from "./conditions.js";
+import {
+  decodeTranslatableValue,
+  entryFieldsFor,
+  hasTranslatableBlockFields,
+  isCollectionKind,
+  isLocalizedLinkField,
+  isTranslatableField
+} from "./index.js";
+import { stripMarkup } from "./search.js";
+export const TRANSLATIONS_COLUMN = "_translations";
+export function isTranslationFilled(field, value) {
+  if (typeof value !== "string") return false;
+  return (field.type === "richtext" ? stripMarkup(value) : value).trim() !== "";
+}
+export function hasTranslatableContent(fields) {
+  return Object.values(fields).some(
+    (field) => isTranslatableField(field) || isLocalizedLinkField(field) || hasTranslatableBlockFields(field)
+  );
+}
+export function entryHasTranslations(entry) {
+  return hasTranslatableContent(entryFieldsFor(entry));
+}
+export function hasTranslationsColumn(entry, i18n) {
+  return i18n.locales.length > 1 && isCollectionKind(entry) && !Object.hasOwn(entry.fields, TRANSLATIONS_COLUMN) && hasTranslatableContent(entry.fields);
+}
+function visitBlocks(field, value, defaultLocale, visit) {
+  if (!Array.isArray(value)) return void 0;
+  let changed = false;
+  const items = value.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+    const block = field.blocks?.[String(item.type)];
+    if (!block) return item;
+    const next = visitTranslations(block.fields, item, defaultLocale, visit);
+    if (next !== item) changed = true;
+    return next;
+  });
+  return changed ? items : void 0;
+}
+function visitLinkLabel(field, value, defaultLocale, visit) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const { label, ...rest } = value;
+  const translations = typeof label === "string" ? { [defaultLocale]: label } : label && typeof label === "object" && !Array.isArray(label) ? label : null;
+  const next = visit(field, translations);
+  if (next === void 0) return void 0;
+  return next && Object.keys(next).length ? { ...rest, label: next } : rest;
+}
+function visitTranslations(fields, values, defaultLocale, visit, keys) {
+  let next = null;
+  for (const key of keys ?? Object.keys(fields)) {
+    const field = Object.hasOwn(fields, key) ? fields[key] : void 0;
+    if (!field || !isFieldVisible(field, values, fields)) continue;
+    const replaced = isTranslatableField(field) ? visit(field, decodeTranslatableValue(values[key], defaultLocale)) : isLocalizedLinkField(field) ? visitLinkLabel(field, values[key], defaultLocale, visit) : field.type === "blocks" ? visitBlocks(field, values[key], defaultLocale, visit) : void 0;
+    if (replaced === void 0) continue;
+    next ??= { ...values };
+    next[key] = replaced;
+  }
+  return next ?? values;
+}
+function translationState(filled, total) {
+  if (filled >= total) return "complete";
+  return filled ? "partial" : "missing";
+}
+export function translationProgress(fields, values, i18n, keys) {
+  const slots = [];
+  visitTranslations(
+    fields,
+    values ?? {},
+    i18n.defaultLocale,
+    (field, translations) => {
+      if (translations) slots.push({ field, translations });
+      return void 0;
+    },
+    keys
+  );
+  const sources = slots.filter(
+    ({ field, translations }) => isTranslationFilled(field, translations[i18n.defaultLocale])
+  );
+  const total = sources.length;
+  return Object.fromEntries(
+    i18n.locales.map((locale) => {
+      const filled = sources.filter(
+        ({ field, translations }) => isTranslationFilled(field, translations[locale])
+      ).length;
+      const written = slots.filter(
+        ({ field, translations }) => isTranslationFilled(field, translations[locale])
+      ).length;
+      return [locale, { filled, total, values: written, state: translationState(filled, total) }];
+    })
+  );
+}
+export function translationSummary(progress) {
+  if (!progress?.total) return "Nothing to translate yet";
+  const noun = progress.total === 1 ? "value" : "values";
+  return `${progress.filled} of ${progress.total} ${noun} translated`;
+}
+export function copyTranslations(fields, values, i18n, { from, to, overwrite = false }) {
+  let count = 0;
+  if (from === to) return { values, count };
+  const next = visitTranslations(fields, values, i18n.defaultLocale, (field, translations) => {
+    const source = translations?.[from];
+    if (!translations || !isTranslationFilled(field, source)) return void 0;
+    const target = translations[to];
+    if (target === source) return void 0;
+    if (!overwrite && isTranslationFilled(field, target)) return void 0;
+    count++;
+    return { ...translations, [to]: source };
+  });
+  return { values: next, count };
+}
+export function clearTranslations(fields, values, i18n, locale) {
+  let count = 0;
+  if (locale === i18n.defaultLocale) return { values, count };
+  const next = visitTranslations(fields, values, i18n.defaultLocale, (field, translations) => {
+    if (!translations || !Object.hasOwn(translations, locale)) return void 0;
+    if (isTranslationFilled(field, translations[locale])) count++;
+    const rest = Object.fromEntries(
+      Object.entries(translations).filter(([code]) => code !== locale)
+    );
+    return Object.keys(rest).length ? rest : null;
+  });
+  return { values: next, count };
+}

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

@@ -1,4 +1,4 @@
-export type CmsUserRole = 'superadmin' | 'admin';
+export type CmsUserRole = 'superadmin' | 'admin' | (string & {});
 export interface CmsSessionUser {
     id?: string;
     email: string;

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

@@ -1,6 +1,13 @@
 import { z } from 'zod';
-import type { CmsEntry, CmsI18n, CmsValidationLevel, FieldConfig } from './index.js';
+import type { CmsConfig, CmsEntry, CmsI18n, CmsValidationLevel, FieldConfig } from './index.js';
 export declare const objectKeySchema: z.ZodString;
+export declare const mediaUpdateSchema: z.ZodObject<{
+    key: z.ZodString;
+    alt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    focalX: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    focalY: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
 export interface ValidationMessages {
     required: string;
     invalidDate: string;
@@ -12,10 +19,24 @@ export interface ValidationMessages {
     minBlocks: (min: number) => string;
     maxBlocks: (max: number) => string;
     maxTags: (max: number) => string;
+    minValue: (min: number) => string;
+    maxValue: (max: number) => string;
+    minLength: (min: number) => string;
+    maxLength: (max: number) => string;
+    unique: string;
+    immutable: string;
+    linkTarget: string;
+    linkUrlAndTarget: string;
+    linkExternal: string;
+    linkEntry: (entry: string) => string;
+    linkUnknownPage: string;
+    invalidLinkLabel: string;
 }
+export declare function validationMessages(messages?: Partial<ValidationMessages>): ValidationMessages;
 export declare function datetimeSchema(message: string): z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
 export declare function blocksCountMessage(field: Pick<FieldConfig, 'min' | 'max'>, count: number, messages?: Partial<ValidationMessages>): string | null;
 export declare function tagsCountMessage(field: Pick<FieldConfig, 'max'>, count: number, messages?: Partial<ValidationMessages>): string | null;
+export declare function valueBoundsMessage(field: Pick<FieldConfig, 'type' | 'min' | 'max'>, value: unknown, messages?: Partial<ValidationMessages>): string | null;
 export interface EntryValidationIssue {
     path: (string | number)[];
     message: string;
@@ -27,6 +48,7 @@ export declare function entryValidationWarnings(entry: ValidatedEntry, values: R
 export declare function buildEntrySchema(entry: ValidatedEntry & {
     drafts?: boolean;
     path?: string;
+    config?: CmsConfig;
 }, i18n: CmsI18n, messages?: Partial<ValidationMessages>): z.ZodObject<{
     [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
 }, z.core.$strip>;

package/dist/runtime/shared/validation.js

@@ -2,12 +2,31 @@ import { z } from "zod";
 import {
   BLOCK_HIDDEN_KEY,
   declaresHiddenField,
+  focalPointIssue,
+  allowsExternalLinks,
+  declaredLinkTargets,
   isFieldVisible,
   isTranslatableField,
+  linkTargetNames,
+  linkUrlError,
   normalizeTags,
-  selectOptionValues
+  pageLinkPath,
+  formatBlockPath,
+  selectOptionValues,
+  walkBlocks
 } from "./index.js";
 export const objectKeySchema = z.string().min(1).max(1024).refine((k) => !k.includes("..") && !k.startsWith("/"), "Invalid object key");
+const focalCoordinateSchema = z.number().min(0).max(1).nullish();
+export const mediaUpdateSchema = z.object({
+  key: objectKeySchema,
+  alt: z.string().max(1024).nullish(),
+  folder: z.string().max(255).nullish(),
+  focalX: focalCoordinateSchema,
+  focalY: focalCoordinateSchema
+}).superRefine((body, ctx) => {
+  const message = focalPointIssue(body.focalX, body.focalY);
+  if (message) ctx.addIssue({ code: "custom", message, path: ["focalX"] });
+});
 const DEFAULT_MESSAGES = {
   required: "Required field",
   invalidDate: "Invalid date (yyyy-mm-dd)",
@@ -18,8 +37,23 @@ const DEFAULT_MESSAGES = {
   requiredLocale: (locale) => `Required field (locale '${locale}')`,
   minBlocks: (min) => `Add at least ${min} ${min === 1 ? "block" : "blocks"}`,
   maxBlocks: (max) => `Add at most ${max} ${max === 1 ? "block" : "blocks"}`,
-  maxTags: (max) => `Add at most ${max} ${max === 1 ? "tag" : "tags"}`
+  maxTags: (max) => `Add at most ${max} ${max === 1 ? "tag" : "tags"}`,
+  minValue: (min) => `Must be at least ${min}`,
+  maxValue: (max) => `Must be at most ${max}`,
+  minLength: (min) => `Use at least ${min} ${min === 1 ? "character" : "characters"}`,
+  maxLength: (max) => `Use at most ${max} ${max === 1 ? "character" : "characters"}`,
+  unique: "This value is already used by another entry",
+  immutable: "This value cannot be changed once saved",
+  linkTarget: "Choose a page or enter a URL",
+  linkUrlAndTarget: "A link has either a URL or a target, not both",
+  linkExternal: "This link cannot point to an external URL",
+  linkEntry: (entry) => `This link cannot point to '${entry}'`,
+  linkUnknownPage: "Unknown page",
+  invalidLinkLabel: "Invalid link text"
 };
+export function validationMessages(messages) {
+  return { ...DEFAULT_MESSAGES, ...messages };
+}
 const DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
 export function datetimeSchema(message) {
   return z.string().trim().refine(
@@ -50,7 +84,8 @@ function scalarSchema(field, m) {
     case "json":
       return z.unknown();
     default:
-      return field.required ? z.string().trim().min(1, m.required) : z.string();
+      if (field.required) return z.string().trim().min(1, m.required);
+      return field.unique ? z.string().transform((value) => value.trim() ? value : null) : z.string();
   }
 }
 function optionalize(field, base, m) {
@@ -64,26 +99,101 @@ function translatableSchema(field, i18n, m) {
   }).refine((v) => Object.keys(v).every((k) => locales.includes(k)), m.unknownLocale);
   return field.required ? record.refine((v) => !!v[defaultLocale]?.trim(), m.requiredLocale(defaultLocale)) : record.nullish().transform((v) => v ?? null);
 }
-function blockFieldSchema(blockField, i18n, m) {
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function trimmed(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function linkLabelValue(field, raw, i18n, m) {
+  if (!field.withLabel || raw == null) return {};
+  if (field.translatable && i18n.locales.length) {
+    const entries = isRecord(raw) ? Object.entries(raw) : typeof raw === "string" ? [[i18n.defaultLocale, raw]] : null;
+    if (!entries) return { error: m.invalidLinkLabel };
+    if (entries.some(([locale]) => !i18n.locales.includes(locale)))
+      return { error: m.unknownLocale };
+    const label2 = Object.fromEntries(
+      entries.map(([locale, text]) => [locale, trimmed(text)]).filter(([, text]) => !!text)
+    );
+    return Object.keys(label2).length ? { label: label2 } : {};
+  }
+  if (typeof raw !== "string") return { error: m.invalidLinkLabel };
+  const label = raw.trim();
+  return label ? { label } : {};
+}
+function linkSchema(field, i18n, m, config) {
+  const targets = config ? linkTargetNames(config, field) : declaredLinkTargets(field);
+  const parse = z.unknown().nullish().transform((input, ctx) => {
+    const fail = (message) => {
+      ctx.addIssue({ code: "custom", message });
+      return z.NEVER;
+    };
+    if (input == null) return null;
+    if (!isRecord(input)) return fail(m.linkTarget);
+    const url = trimmed(input.url);
+    const entry = trimmed(input.entry);
+    const id = trimmed(input.id);
+    const { label, error } = linkLabelValue(field, input.label, i18n, m);
+    if (error) return fail(error);
+    if (url && (entry || id)) return fail(m.linkUrlAndTarget);
+    const extra = {
+      ...label !== void 0 ? { label } : {},
+      ...input.newTab === true ? { newTab: true } : {}
+    };
+    if (url) {
+      if (!allowsExternalLinks(field)) return fail(m.linkExternal);
+      const urlError = linkUrlError(url);
+      if (urlError) return fail(urlError);
+      return { url, ...extra };
+    }
+    if (!entry && !id) return label !== void 0 ? fail(m.linkTarget) : null;
+    if (!entry || !id) return fail(m.linkTarget);
+    if (targets && !targets.includes(entry)) return fail(m.linkEntry(entry));
+    const target = config?.[entry];
+    if (target?.kind === "page" && !pageLinkPath(target, id)) return fail(m.linkUnknownPage);
+    return { entry, id, ...extra };
+  });
+  if (!field.required) return parse;
+  return parse.refine((value) => value !== null, m.required);
+}
+function blockFieldSchema(blockField, i18n, m, config) {
+  if (blockField.type === "link") return linkSchema(blockField, i18n, m, config);
+  if (blockField.type === "blocks") return blocksFieldSchema(blockField, i18n, m, config);
   if (isTranslatableField(blockField) && i18n.locales.length)
-    return translatableSchema(blockField, i18n, m);
-  return optionalize(blockField, scalarSchema(blockField, m), m);
+    return withValueBounds(blockField, translatableSchema(blockField, i18n, m), m);
+  return withValueBounds(blockField, optionalize(blockField, scalarSchema(blockField, m), m), m);
+}
+function blockVariantSchema(type, block, i18n, m, config) {
+  const variant = z.object({
+    type: z.literal(type),
+    ...declaresHiddenField(block) ? {} : { [BLOCK_HIDDEN_KEY]: z.boolean().optional() },
+    ...Object.fromEntries(
+      Object.entries(block.fields).map(([key, blockField]) => [
+        key,
+        blockFieldSchema(unconditional(blockField), i18n, m, config)
+      ])
+    )
+  });
+  const conditional = conditionalFields(block.fields);
+  if (!conditional.length) return variant;
+  return variant.superRefine((item, ctx) => {
+    for (const issue of conditionalIssues(conditional, item, block.fields, i18n, m))
+      ctx.addIssue({ code: "custom", ...issue });
+  });
 }
-function blocksSchema(field, i18n, m) {
+function blocksSchema(field, i18n, m, config) {
   const variants = Object.entries(field.blocks ?? {}).map(
-    ([type, block]) => z.object({
-      type: z.literal(type),
-      ...declaresHiddenField(block) ? {} : { [BLOCK_HIDDEN_KEY]: z.boolean().optional() },
-      ...Object.fromEntries(
-        Object.entries(block.fields).map(([key, blockField]) => [
-          key,
-          blockFieldSchema(blockField, i18n, m)
-        ])
-      )
-    })
+    ([type, block]) => blockVariantSchema(type, block, i18n, m, config)
   );
   return z.array(z.discriminatedUnion("type", variants));
 }
+function blocksFieldSchema(declared, i18n, m, config) {
+  const field = unconditional(declared);
+  const list = blocksSchema(field, i18n, m, config);
+  const base = field.required ? list.min(1, m.required) : list;
+  const bounded = declared.showIf ? base : boundedBlocks(base, field, m);
+  return field.required ? bounded : bounded.nullish().transform((v) => v ?? null);
+}
 export function blocksCountMessage(field, count, messages) {
   const m = { ...DEFAULT_MESSAGES, ...messages };
   if (field.max !== void 0 && count > field.max) return m.maxBlocks(field.max);
@@ -95,8 +205,61 @@ export function tagsCountMessage(field, count, messages) {
   if (field.max !== void 0 && count > field.max) return m.maxTags(field.max);
   return null;
 }
-function countMessage(field, count, m) {
-  return field.type === "tags" ? tagsCountMessage(field, count, m) : blocksCountMessage(field, count, m);
+export function valueBoundsMessage(field, value, messages) {
+  const m = { ...DEFAULT_MESSAGES, ...messages };
+  if (field.type === "number" && typeof value === "number") {
+    if (field.min !== void 0 && value < field.min) return m.minValue(field.min);
+    if (field.max !== void 0 && value > field.max) return m.maxValue(field.max);
+    return null;
+  }
+  if (field.type !== "text") return null;
+  const texts = typeof value === "string" ? [value] : value && typeof value === "object" ? Object.values(value).filter((text) => typeof text === "string") : [];
+  for (const text of texts) {
+    const length = text.trim() ? text.length : 0;
+    if (!length) continue;
+    if (field.min !== void 0 && length < field.min) return m.minLength(field.min);
+    if (field.max !== void 0 && length > field.max) return m.maxLength(field.max);
+  }
+  return null;
+}
+function boundsMessage(field, value, m) {
+  if (field.type === "tags")
+    return Array.isArray(value) ? tagsCountMessage(field, value.length, m) : null;
+  if (field.type === "blocks")
+    return Array.isArray(value) ? blocksCountMessage(field, value.length, m) : null;
+  return valueBoundsMessage(field, value, m);
+}
+function hasValueBounds(field) {
+  return (field.type === "number" || field.type === "text") && (field.min !== void 0 || field.max !== void 0);
+}
+function withValueBounds(field, schema, m) {
+  if (field.showIf || !hasValueBounds(field)) return schema;
+  return schema.superRefine((value, ctx) => {
+    const message = valueBoundsMessage(field, value, m);
+    if (message) ctx.addIssue({ code: "custom", message });
+  });
+}
+function unconditional(field) {
+  return field.showIf ? { ...field, required: false } : field;
+}
+function conditionalFields(fields) {
+  return Object.entries(fields).filter(
+    ([, field]) => !!field.showIf && (!!field.required || field.min !== void 0 || field.max !== void 0)
+  );
+}
+function conditionalIssues(conditional, values, scope, i18n, m) {
+  const issues = [];
+  for (const [key, field] of conditional) {
+    if (!isFieldVisible(field, values, scope)) continue;
+    const value = values[key];
+    if (field.required && isEmptyValue(field, value, i18n.defaultLocale)) {
+      issues.push({ path: [key], message: m.required });
+      continue;
+    }
+    const message = boundsMessage(field, value, m);
+    if (message) issues.push({ path: [key], message });
+  }
+  return issues;
 }
 function tagsSchema(field, bounded, m) {
   return z.array(z.string()).nullish().transform((value) => normalizeTags(value ?? [])).superRefine((tags, ctx) => {
@@ -118,12 +281,16 @@ function hookIssues(result) {
     (issue) => !!issue && typeof issue === "object" && typeof issue.message === "string"
   );
 }
-function hasValidateHooks(entry) {
-  if (entry.validate) return true;
-  return Object.values(entry.fields).some(
-    (field) => field.type === "blocks" && Object.values(field.blocks ?? {}).some((block) => block.validate)
+function hasBlockValidateHooks(fields) {
+  return Object.values(fields).some(
+    (field) => field.type === "blocks" && Object.values(field.blocks ?? {}).some(
+      (block) => !!block.validate || hasBlockValidateHooks(block.fields)
+    )
   );
 }
+function hasValidateHooks(entry) {
+  return !!entry.validate || hasBlockValidateHooks(entry.fields);
+}
 export function entryValidationIssues(entry, values, i18n, path) {
   const context = {
     locales: i18n.locales,
@@ -140,23 +307,18 @@ export function entryValidationIssues(entry, values, i18n, path) {
       });
     }
   }
-  for (const [key, field] of Object.entries(entry.fields)) {
-    const list = values[key];
-    if (field.type !== "blocks" || !Array.isArray(list)) continue;
-    list.forEach((item, index) => {
-      if (!item || typeof item !== "object") return;
-      const block = field.blocks?.[String(item.type)];
-      if (!block?.validate) return;
-      const result = block.validate(item, { ...context, index });
-      for (const issue of hookIssues(result)) {
-        issues.push({
-          path: issue.field ? [key, index, issue.field] : [key, index],
-          message: issue.message,
-          level: issue.level === "warning" ? "warning" : "error"
-        });
-      }
-    });
-  }
+  walkBlocks(entry.fields, values, ({ item, block, path: path2, index }) => {
+    if (!block.validate) return;
+    for (const issue of hookIssues(
+      block.validate(item, { ...context, index, blockPath: formatBlockPath(path2) })
+    )) {
+      issues.push({
+        path: issue.field ? [...path2, issue.field] : [...path2],
+        message: issue.message,
+        level: issue.level === "warning" ? "warning" : "error"
+      });
+    }
+  });
   return issues;
 }
 export function entryValidationWarnings(entry, values, i18n, path) {
@@ -178,13 +340,9 @@ function isEmptyValue(field, value, defaultLocale) {
 export function buildEntrySchema(entry, i18n, messages) {
   const m = { ...DEFAULT_MESSAGES, ...messages };
   const shape = {};
-  const conditional = [];
-  const conditionalBounds = [];
+  const conditional = conditionalFields(entry.fields);
   for (const [key, declared] of Object.entries(entry.fields)) {
-    const field = declared.showIf ? { ...declared, required: false } : declared;
-    if (declared.showIf && declared.required) conditional.push([key, declared]);
-    if (declared.showIf && (declared.type === "blocks" || declared.type === "tags") && (declared.min !== void 0 || declared.max !== void 0))
-      conditionalBounds.push([key, declared]);
+    const field = unconditional(declared);
     if (field.type === "relation" && field.cardinality === "many-to-many") {
       const list = z.array(z.string().min(1));
       shape[key] = field.required ? list.min(1, m.required) : list.nullish().transform((v) => v ?? []);
@@ -199,15 +357,16 @@ export function buildEntrySchema(entry, i18n, messages) {
       shape[key] = tagsSchema(field, !declared.showIf, m);
       continue;
     }
+    if (field.type === "link") {
+      shape[key] = linkSchema(field, i18n, m, entry.config);
+      continue;
+    }
     if (field.type === "blocks") {
-      const list = blocksSchema(field, i18n, m);
-      const base = field.required ? list.min(1, m.required) : list;
-      const bounded = declared.showIf ? base : boundedBlocks(base, field, m);
-      shape[key] = field.required ? bounded : bounded.nullish().transform((v) => v ?? null);
+      shape[key] = blocksFieldSchema(declared, i18n, m, entry.config);
       continue;
     }
     if (isTranslatableField(field) && i18n.locales.length) {
-      shape[key] = translatableSchema(field, i18n, m);
+      shape[key] = withValueBounds(declared, translatableSchema(field, i18n, m), m);
       continue;
     }
     if (field.type === "json") {
@@ -215,27 +374,18 @@ export function buildEntrySchema(entry, i18n, messages) {
       shape[key] = field.required ? json.refine((v) => v !== void 0 && v !== null, m.required) : json.nullish().transform((v) => v ?? null);
       continue;
     }
-    shape[key] = optionalize(field, scalarSchema(field, m), m);
+    shape[key] = withValueBounds(declared, optionalize(field, scalarSchema(field, m), m), m);
   }
   if (entry.drafts) {
     shape.status = z.enum(["draft", "published"]).nullish().transform((v) => v ?? void 0);
   }
   const schema = z.object(shape);
   const hooks = hasValidateHooks(entry);
-  if (!conditional.length && !conditionalBounds.length && !hooks) return schema;
+  if (!conditional.length && !hooks) return schema;
   return schema.superRefine((parsed, ctx) => {
     const values = parsed;
-    for (const [key, field] of conditional) {
-      if (!isFieldVisible(field, values)) continue;
-      if (!isEmptyValue(field, values[key], i18n.defaultLocale)) continue;
-      ctx.addIssue({ code: "custom", path: [key], message: m.required });
-    }
-    for (const [key, field] of conditionalBounds) {
-      const list = values[key];
-      if (!isFieldVisible(field, values) || !Array.isArray(list)) continue;
-      const message = countMessage(field, list.length, m);
-      if (message) ctx.addIssue({ code: "custom", path: [key], message });
-    }
+    for (const issue of conditionalIssues(conditional, values, entry.fields, i18n, m))
+      ctx.addIssue({ code: "custom", ...issue });
     if (!hooks) return;
     for (const issue of entryValidationIssues(entry, values, i18n, entry.path)) {
       if (issue.level === "error")

package/dist/runtime/webhooks.d.ts

@@ -0,0 +1,33 @@
+import type { CmsEntryAction, CmsEntryStatus, CmsMediaAction, CmsEntryChange, CmsMediaChange } from './shared/hooks.js';
+import type { CmsEntryKind } from './shared/index.js';
+export type { CmsEntryAction, CmsEntryChange, CmsEntryKind, CmsEntryStatus, CmsMediaAction, CmsMediaChange, };
+export declare const CMS_WEBHOOK_SIGNATURE_HEADER = "x-cms-signature";
+export declare const CMS_WEBHOOK_EVENT_HEADER = "x-cms-event";
+export declare const CMS_WEBHOOK_DELIVERY_HEADER = "x-cms-delivery";
+export declare const CMS_WEBHOOK_TOLERANCE_SECONDS = 300;
+export type CmsWebhookEvent = `entry:${CmsEntryAction}` | `media:${CmsMediaAction}`;
+export interface CmsWebhookEntryPayload {
+    event: `entry:${CmsEntryAction}`;
+    action: CmsEntryAction;
+    entry: string;
+    kind: CmsEntryKind;
+    ids: string[];
+    path: string | null;
+    status: CmsEntryStatus | null;
+    at: string;
+}
+export interface CmsWebhookMediaPayload {
+    event: `media:${CmsMediaAction}`;
+    action: CmsMediaAction;
+    keys: string[];
+    folder: string | null;
+    from: string | null;
+    at: string;
+}
+export type CmsWebhookPayload = CmsWebhookEntryPayload | CmsWebhookMediaPayload;
+export declare function signCmsWebhook(body: string, secret: string, timestamp?: number): Promise<string>;
+export declare function parseCmsWebhookSignature(header: string): {
+    timestamp: number;
+    signatures: string[];
+} | null;
+export declare function verifyCmsWebhook(input: Request | string, header: string | null | undefined, secret: string, toleranceSeconds?: number): Promise<CmsWebhookPayload | null>;

package/dist/runtime/webhooks.js

@@ -0,0 +1,57 @@
+export const CMS_WEBHOOK_SIGNATURE_HEADER = "x-cms-signature";
+export const CMS_WEBHOOK_EVENT_HEADER = "x-cms-event";
+export const CMS_WEBHOOK_DELIVERY_HEADER = "x-cms-delivery";
+export const CMS_WEBHOOK_TOLERANCE_SECONDS = 300;
+const encoder = new TextEncoder();
+function toHex(buffer) {
+  return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function hmacHex(secret, message) {
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return toHex(await globalThis.crypto.subtle.sign("HMAC", key, encoder.encode(message)));
+}
+function safeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let index = 0; index < a.length; index++) diff |= a.charCodeAt(index) ^ b.charCodeAt(index);
+  return diff === 0;
+}
+export async function signCmsWebhook(body, secret, timestamp = Math.floor(Date.now() / 1e3)) {
+  return `t=${timestamp},v1=${await hmacHex(secret, `${timestamp}.${body}`)}`;
+}
+export function parseCmsWebhookSignature(header) {
+  let timestamp = null;
+  const signatures = [];
+  for (const part of header.split(",")) {
+    const separator = part.indexOf("=");
+    if (separator < 0) continue;
+    const key = part.slice(0, separator).trim();
+    const value = part.slice(separator + 1).trim();
+    if (key === "t" && /^\d+$/.test(value)) timestamp = Number(value);
+    if (key === "v1" && /^[0-9a-f]{64}$/.test(value)) signatures.push(value);
+  }
+  return timestamp === null || !signatures.length ? null : { timestamp, signatures };
+}
+export async function verifyCmsWebhook(input, header, secret, toleranceSeconds = CMS_WEBHOOK_TOLERANCE_SECONDS) {
+  if (!secret) return null;
+  const signatureHeader = header ?? (typeof input === "string" ? null : input.headers.get(CMS_WEBHOOK_SIGNATURE_HEADER));
+  if (!signatureHeader) return null;
+  const parsed = parseCmsWebhookSignature(signatureHeader);
+  if (!parsed) return null;
+  if (Math.abs(Math.floor(Date.now() / 1e3) - parsed.timestamp) > toleranceSeconds) return null;
+  const body = typeof input === "string" ? input : await input.text();
+  const expected = await hmacHex(secret, `${parsed.timestamp}.${body}`);
+  if (!parsed.signatures.some((signature) => safeEqual(signature, expected))) return null;
+  try {
+    const payload = JSON.parse(body);
+    return payload && typeof payload === "object" ? payload : null;
+  } catch {
+    return null;
+  }
+}

package/dist/types.d.mts

@@ -1,3 +1,7 @@
+export { type CmsRoleInput, type CmsRolesInput } from '../dist/runtime/shared/roles.js'
+
+export { type CmsEntryAction, type CmsEntryChange, type CmsEntryStatus, type CmsHookContext, type CmsHookUser, type CmsMediaAction, type CmsMediaChange } from '../dist/runtime/shared/hooks.js'
+
 export { default } from './module.mjs'
 
-export { type ModuleOptions, type ModuleOptionsDatabase, type ModuleOptionsMedia } from './module.mjs'
+export { type CmsWebhookEventFilter, type ModuleOptions, type ModuleOptionsDatabase, type ModuleOptionsMedia, type ModuleOptionsWebhook } from './module.mjs'