@xleddyl/nuxt-cms 0.2.2 → 0.2.3

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

@@ -2,7 +2,7 @@ import type { PgTable } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 import type { CmsLayoutBlock, CmsListInput } from './layout.js';
 export type CmsTable = SQLiteTable | PgTable;
-export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'email' | 'slug' | 'select' | 'json' | 'media' | 'relation' | 'blocks';
+export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'slug' | 'select' | 'json' | 'media' | 'relation' | 'blocks';
 export interface CmsI18n {
     locales: string[];
     defaultLocale: string;
@@ -76,6 +76,9 @@ export interface MediaUsageGroup {
 export declare function mediaUsageGroups(usage: Record<string, MediaUsage[]>, keys: string[]): MediaUsageGroup[];
 export interface BlockConfig {
     label: string;
+    component?: string;
+    icon?: string;
+    description?: string;
     fields: Record<string, FieldConfig>;
 }
 export type ConditionValue = string | number | boolean;
@@ -129,10 +132,14 @@ export declare function isMultiSelect(field: FieldConfig): boolean;
 export declare function translatableFieldKeys(entry: EntryLike): string[];
 export declare function translatableBlockFieldKeys(block: BlockConfig): string[];
 export declare function hasTranslatableBlockFields(field: FieldConfig): boolean;
+export declare const BLOCK_HIDDEN_KEY = "hidden";
+export declare function declaresHiddenField(block: BlockConfig | undefined): boolean;
+export declare function isHiddenBlock(item: unknown): boolean;
+export declare function publicBlocks(field: FieldConfig, value: unknown): unknown;
 export declare function localizeBlock(field: FieldConfig, item: unknown, locale: string, defaultLocale: string): unknown;
 export declare function localizeBlocks(field: FieldConfig, value: unknown, locale: string, defaultLocale: string): unknown;
 export declare const CMS_GRAPHQL_BATCH_LIMIT = 20;
-export type CmsEntryKind = 'collection' | 'single' | 'page';
+export type CmsEntryKind = 'collection' | 'single' | 'page' | 'content';
 export interface CmsPageRoute {
     path: string;
     key: string;
@@ -158,10 +165,35 @@ export interface CmsEntry {
     icon?: string;
     layout?: CmsLayoutBlock[];
     list?: CmsListInput;
+    blocks?: Record<string, BlockConfig>;
+    preview?: CmsPreviewOptions;
+    declared?: CmsContentDeclared;
+}
+export interface CmsPreviewOptions {
+    component?: string;
+}
+export interface CmsContentDeclared {
+    fields: string[];
+    titleField?: unknown;
+    drafts?: unknown;
 }
 export declare const MOBILE_MEDIA_SUFFIX = "Mobile";
 export declare function mobileMediaKey(key: string): string;
 export declare function expandMobileMedia<T extends Record<string, unknown>>(config: T): T;
+export declare const CONTENT_TITLE_FIELD = "title";
+export declare const CONTENT_SLUG_FIELD = "slug";
+export declare const CONTENT_PUBLISHED_AT_FIELD = "publishedAt";
+export declare const CONTENT_BODY_FIELD = "body";
+export declare const CONTENT_SYSTEM_FIELDS: readonly ["title", "slug", "publishedAt", "excerpt", "cover", "body", "seoTitle", "seoDescription", "seoImage"];
+export type CmsContentSystemField = (typeof CONTENT_SYSTEM_FIELDS)[number];
+export declare const CONTENT_LIST_COLUMNS: string[];
+export declare function isContentEntry(entry: Pick<CmsEntry, 'kind'>): boolean;
+export declare function isCollectionKind(entry: Pick<CmsEntry, 'kind'>): boolean;
+export declare function normalizeContentEntries<T extends Record<string, unknown>>(config: T, i18n?: Pick<CmsI18n, 'locales'>): T;
+export declare function normalizeCmsConfig<T extends Record<string, unknown>>(config: T, i18n?: Pick<CmsI18n, 'locales'>): T;
+export declare function slugSourceValue(source: FieldConfig | undefined, value: unknown, defaultLocale: string): string | null;
+export declare function isScheduledContent(row: Record<string, unknown> | null | undefined, now?: Date): boolean;
+export declare function resolveBlocksMedia(field: FieldConfig, value: unknown, resolve: (key: string) => unknown): unknown;
 export declare function entryTabs(entry: Pick<CmsEntry, 'tabs'>): CmsTab[];
 export declare function fieldTab(field: FieldConfig, tabs: CmsTab[]): string | undefined;
 export declare function fieldsByTab(fields: Record<string, FieldConfig>, tabs: CmsTab[]): Record<string, Record<string, FieldConfig>>;
@@ -214,6 +246,9 @@ export interface BooleanFieldInput extends FieldInputBase {
 export interface DateFieldInput extends FieldInputBase {
     type: 'date';
 }
+export interface DateTimeFieldInput extends FieldInputBase {
+    type: 'datetime';
+}
 export interface EmailFieldInput extends FieldInputBase {
     type: 'email';
 }
@@ -243,16 +278,19 @@ export interface RelationFieldInput extends FieldInputBase {
     onDelete?: 'set null' | 'cascade' | 'restrict';
 }
 type BlockField<T> = Omit<T, 'private' | 'showIf' | 'tab'>;
-export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'>;
+export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<DateTimeFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'>;
 export interface BlockInput {
     label: string;
+    component?: string;
+    icon?: string;
+    description?: string;
     fields: Record<string, BlockFieldInput>;
 }
 export interface BlocksFieldInput extends FieldInputBase {
     type: 'blocks';
     blocks: Record<string, BlockInput>;
 }
-export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
+export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | DateTimeFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
 interface CmsEntryInputBase {
     id: string;
     label: string;
@@ -283,8 +321,24 @@ export interface CmsPageInput extends CmsEntryInputBase {
     overrides?: Record<string, Record<string, CmsFieldInput | null>>;
     columns?: string[];
 }
-export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput;
+export interface CmsContentInput {
+    id: string;
+    label: string;
+    kind: 'content';
+    icon?: string;
+    blocks: Record<string, BlockInput>;
+    fields?: Record<string, CmsFieldInput>;
+    labels?: Partial<Record<CmsContentSystemField, string>>;
+    tabs?: CmsTab[];
+    layout?: CmsLayoutBlock[];
+    list?: CmsListInput;
+    preview?: CmsPreviewOptions;
+    titleField?: never;
+    drafts?: never;
+}
+export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput | CmsContentInput;
 export type CmsConfigInput = Record<string, CmsEntryInput>;
 export declare function defineCmsConfig<T extends CmsConfigInput>(config: T): T;
+export declare function defineCmsBlocks<T extends Record<string, BlockInput>>(blocks: T): T;
 export * from './layout.js';
 export * from './users.js';

package/dist/runtime/shared/index.js

@@ -219,6 +219,20 @@ export function hasTranslatableBlockFields(field) {
     (block) => Object.values(block.fields).some(isTranslatableField)
   );
 }
+export const BLOCK_HIDDEN_KEY = "hidden";
+export function declaresHiddenField(block) {
+  return !!block && Object.hasOwn(block.fields, BLOCK_HIDDEN_KEY);
+}
+export function isHiddenBlock(item) {
+  return !!item && typeof item === "object" && item.hidden === true;
+}
+export function publicBlocks(field, value) {
+  if (!Array.isArray(value)) return value;
+  return value.filter((item) => {
+    if (!isHiddenBlock(item)) return true;
+    return declaresHiddenField(field.blocks?.[String(item.type)]);
+  });
+}
 export function localizeBlock(field, item, locale, defaultLocale) {
   if (!item || typeof item !== "object") return item;
   const block = field.blocks?.[String(item.type)];
@@ -289,6 +303,122 @@ export function expandMobileMedia(config) {
   }
   return config;
 }
+export const CONTENT_TITLE_FIELD = "title";
+export const CONTENT_SLUG_FIELD = "slug";
+export const CONTENT_PUBLISHED_AT_FIELD = "publishedAt";
+export const CONTENT_BODY_FIELD = "body";
+export const CONTENT_SYSTEM_FIELDS = [
+  "title",
+  "slug",
+  "publishedAt",
+  "excerpt",
+  "cover",
+  "body",
+  "seoTitle",
+  "seoDescription",
+  "seoImage"
+];
+export const CONTENT_LIST_COLUMNS = ["title", "status", "publishedAt"];
+export function isContentEntry(entry) {
+  return entry.kind === "content";
+}
+export function isCollectionKind(entry) {
+  return entry.kind === "collection" || entry.kind === "content";
+}
+function contentSystemFields(blocks, labels, translatable) {
+  const label = (key, fallback) => labels[key] || fallback;
+  const localized = translatable ? { translatable: true } : {};
+  return {
+    title: { label: label("title", "Title"), type: "text", required: true, ...localized },
+    slug: {
+      label: label("slug", "Slug"),
+      type: "slug",
+      from: CONTENT_TITLE_FIELD,
+      required: true,
+      description: "Filled from the title in the default language."
+    },
+    publishedAt: {
+      label: label("publishedAt", "Published at"),
+      type: "datetime",
+      description: "Empty means now when you publish. A future date schedules the item."
+    },
+    excerpt: {
+      label: label("excerpt", "Excerpt"),
+      type: "text",
+      textarea: true,
+      ...localized
+    },
+    cover: { label: label("cover", "Cover"), type: "media", mediaType: "image" },
+    body: { label: label("body", "Body"), type: "blocks", blocks },
+    seoTitle: { label: label("seoTitle", "SEO title"), type: "text", ...localized },
+    seoDescription: {
+      label: label("seoDescription", "SEO description"),
+      type: "text",
+      textarea: true,
+      ...localized
+    },
+    seoImage: { label: label("seoImage", "SEO image"), type: "media", mediaType: "image" }
+  };
+}
+function normalizeContentEntry(entry, translatable) {
+  if (entry.declared) return entry;
+  const declared = entry.fields ?? {};
+  const system = contentSystemFields(entry.blocks ?? {}, entry.labels ?? {}, translatable);
+  const extra = Object.fromEntries(
+    Object.entries(declared).filter(([key]) => !Object.hasOwn(system, key))
+  );
+  const { body, seoTitle, seoDescription, seoImage, ...head } = system;
+  return Object.assign(entry, {
+    declared: {
+      fields: Object.keys(declared),
+      ...entry.titleField !== void 0 ? { titleField: entry.titleField } : {},
+      ...entry.drafts !== void 0 ? { drafts: entry.drafts } : {}
+    },
+    titleField: CONTENT_TITLE_FIELD,
+    drafts: true,
+    fields: { ...head, ...extra, body, seoTitle, seoDescription, seoImage },
+    list: entry.list ?? { columns: [...CONTENT_LIST_COLUMNS] }
+  });
+}
+export function normalizeContentEntries(config, i18n) {
+  const translatable = !!i18n?.locales.length;
+  for (const entry of Object.values(config)) {
+    if (entry?.kind === "content") normalizeContentEntry(entry, translatable);
+  }
+  return config;
+}
+export function normalizeCmsConfig(config, i18n) {
+  return expandMobileMedia(normalizeContentEntries(config, i18n));
+}
+export function slugSourceValue(source, value, defaultLocale) {
+  if (value == null) return null;
+  if (source && isTranslatableField(source) && typeof value === "object") {
+    return value[defaultLocale] ?? null;
+  }
+  return typeof value === "string" ? value : null;
+}
+export function isScheduledContent(row, now = /* @__PURE__ */ new Date()) {
+  if (!row || row.status !== "published") return false;
+  const at = row[CONTENT_PUBLISHED_AT_FIELD];
+  if (typeof at !== "string" || !at) return false;
+  const time = new Date(at).getTime();
+  return !Number.isNaN(time) && time > now.getTime();
+}
+export function resolveBlocksMedia(field, value, resolve) {
+  if (!Array.isArray(value)) return value;
+  return value.map((item) => {
+    if (!item || typeof item !== "object") return item;
+    const block = field.blocks?.[String(item.type)];
+    if (!block) return item;
+    const resolved = { ...item };
+    for (const [key, blockField] of Object.entries(block.fields)) {
+      if (blockField.type !== "media") continue;
+      const media = resolved[key];
+      resolved[key] = typeof media === "string" && media ? resolve(media) ?? null : null;
+    }
+    return resolved;
+  });
+}
 export function entryTabs(entry) {
   return entry.tabs?.length ? entry.tabs : [];
 }
@@ -392,5 +522,8 @@ export function blockTypeName(entryName, fieldKey, blockName) {
 export function defineCmsConfig(config) {
   return config;
 }
+export function defineCmsBlocks(blocks) {
+  return blocks;
+}
 export * from "./layout.js";
 export * from "./users.js";

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

@@ -0,0 +1,85 @@
+import type { BlockConfig, FieldConfig, MediaItem, MediaType } from './index.js';
+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[];
+export type CmsBlockValue = Record<string, unknown>;
+export interface CmsPreviewMedia {
+    key: string;
+    url: string | null;
+    type: MediaType;
+    alt: string | null;
+    folder: string | null;
+    mime: string | null;
+    size: number | null;
+    width: number | null;
+    height: number | null;
+}
+export interface CmsPreviewState {
+    entry: string;
+    field: string;
+    locale: string;
+    blocks: CmsBlockValue[];
+    item: Record<string, unknown> | null;
+    media: Record<string, CmsPreviewMedia>;
+    selected: number | null;
+}
+export type CmsPreviewHostMessage = {
+    type: 'render';
+    state: CmsPreviewState;
+};
+export type CmsPreviewFrameMessage = {
+    type: 'ready';
+} | {
+    type: 'select';
+    index: number | null;
+    focus?: boolean;
+} | {
+    type: 'insert';
+    index: number;
+} | {
+    type: 'move';
+    from: number;
+    to: number;
+    focus?: boolean;
+} | {
+    type: 'duplicate';
+    index: number;
+} | {
+    type: 'toggle-hidden';
+    index: number;
+} | {
+    type: 'remove';
+    index: number;
+};
+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 parseFrameMessage(data: unknown): CmsPreviewFrameMessage | null;
+export declare function parseHostMessage(data: unknown): CmsPreviewHostMessage | null;
+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 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 {
+    index: number;
+    top: number;
+    bottom: 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 blockSummary(block: BlockConfig | undefined, item: CmsBlockValue, locale: string, defaultLocale: string, max?: number): string;

package/dist/runtime/shared/preview.js

@@ -0,0 +1,219 @@
+import {
+  BLOCK_HIDDEN_KEY,
+  declaresHiddenField,
+  decodeTranslatableValue,
+  isHiddenBlock,
+  isPrivateField,
+  isTranslatableField,
+  isTranslatableMediaField,
+  localizeBlocks,
+  mediaPublicUrl,
+  mediaTypeForKey,
+  pickTranslatedMedia,
+  resolveBlocksMedia
+} from "./index.js";
+export const CMS_PREVIEW_CHANNEL = "nuxt-cms:preview";
+export const DEFAULT_CMS_PREVIEW_PATH = "/cms/preview";
+const RESERVED_ADMIN_SEGMENTS = /* @__PURE__ */ new Set(["login", "media"]);
+export function previewPathErrors(path, entryNames) {
+  const match = /^\/cms\/([a-z0-9][a-z0-9-]*)$/.exec(path);
+  if (!match)
+    return [
+      `preview.path '${path}' must be a single lowercase segment under /cms, like '${DEFAULT_CMS_PREVIEW_PATH}'`
+    ];
+  const segment = match[1];
+  if (RESERVED_ADMIN_SEGMENTS.has(segment) || entryNames.includes(segment))
+    return [`preview.path '${path}' clashes with an admin route, pick another segment`];
+  return [];
+}
+export function previewEnvelope(message) {
+  return { ...message, channel: CMS_PREVIEW_CHANNEL };
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isIndex(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function envelope(data) {
+  if (!isRecord(data) || data.channel !== CMS_PREVIEW_CHANNEL) return null;
+  return typeof data.type === "string" ? data : null;
+}
+export function parseFrameMessage(data) {
+  const message = envelope(data);
+  if (!message) return null;
+  const focus = message.focus === true ? { focus: true } : {};
+  switch (message.type) {
+    case "ready":
+      return { type: "ready" };
+    case "select":
+      return message.index === null || isIndex(message.index) ? { type: "select", index: message.index, ...focus } : null;
+    case "move":
+      return isIndex(message.from) && isIndex(message.to) ? { type: "move", from: message.from, to: message.to, ...focus } : null;
+    case "insert":
+    case "duplicate":
+    case "toggle-hidden":
+    case "remove":
+      return isIndex(message.index) ? { type: message.type, index: message.index } : null;
+    default:
+      return null;
+  }
+}
+export function parseHostMessage(data) {
+  const message = envelope(data);
+  if (!message || message.type !== "render" || !isRecord(message.state)) return null;
+  const state = message.state;
+  if (typeof state.entry !== "string" || typeof state.field !== "string") return null;
+  if (typeof state.locale !== "string" || !Array.isArray(state.blocks)) return null;
+  if (state.item !== null && !isRecord(state.item)) return null;
+  if (!isRecord(state.media)) return null;
+  if (state.selected !== null && !isIndex(state.selected)) return null;
+  return {
+    type: "render",
+    state: {
+      entry: state.entry,
+      field: state.field,
+      locale: state.locale,
+      blocks: state.blocks.filter(isRecord),
+      item: state.item,
+      media: state.media,
+      selected: state.selected
+    }
+  };
+}
+export function isTrustedPreviewEvent(event, origin, source) {
+  return !!source && event.origin === origin && event.source === source;
+}
+function clamp(index, length) {
+  return Math.min(Math.max(index, 0), length);
+}
+export function emptyBlock(type, block) {
+  return { type, ...Object.fromEntries(Object.keys(block.fields).map((key) => [key, null])) };
+}
+export function insertBlock(list, index, item) {
+  const next = [...list];
+  next.splice(clamp(index, list.length), 0, item);
+  return next;
+}
+export function moveBlock(list, from, to) {
+  if (from === to || from < 0 || from >= list.length || to < 0 || to >= list.length)
+    return [...list];
+  const next = [...list];
+  const [item] = next.splice(from, 1);
+  next.splice(to, 0, item);
+  return next;
+}
+export function duplicateBlock(list, index) {
+  const item = list[index];
+  if (!item) return [...list];
+  return insertBlock(list, index + 1, JSON.parse(JSON.stringify(item)));
+}
+export function removeBlock(list, index) {
+  return list.filter((_, i) => i !== index);
+}
+export function canHideBlock(block) {
+  return !!block && !declaresHiddenField(block);
+}
+export function toggleBlockHidden(list, index, block) {
+  const item = list[index];
+  if (!item || !canHideBlock(block)) return [...list];
+  const { [BLOCK_HIDDEN_KEY]: _hidden, ...rest } = item;
+  const updated = isHiddenBlock(item) ? rest : { ...rest, [BLOCK_HIDDEN_KEY]: true };
+  return list.map((current, i) => i === index ? updated : current);
+}
+export function selectionAfterMove(selected, from, to) {
+  if (selected === null) return null;
+  if (selected === from) return to;
+  if (from < selected && to >= selected) return selected - 1;
+  if (from > selected && to <= selected) return selected + 1;
+  return selected;
+}
+export function selectionAfterRemove(selected, index) {
+  if (selected === null || selected === index) return null;
+  return selected > index ? selected - 1 : selected;
+}
+export function moveTargetForInsertion(from, insertAt) {
+  return insertAt > from ? insertAt - 1 : insertAt;
+}
+export function insertionIndex(blocks, y, total) {
+  for (const block of blocks) {
+    if (y < (block.top + block.bottom) / 2) return block.index;
+  }
+  const last = blocks[blocks.length - 1];
+  return last ? last.index + 1 : total;
+}
+function pushMediaKeys(keys, field, value) {
+  if (field.type !== "media" || value == null) return;
+  const values = typeof value === "object" ? Object.values(value) : [value];
+  for (const key of values) if (typeof key === "string" && key) keys.add(key);
+}
+export function collectMediaKeys(fields, values) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const [key, field] of Object.entries(fields)) {
+    const value = values?.[key];
+    if (field.type === "media") {
+      pushMediaKeys(keys, field, value);
+      continue;
+    }
+    if (field.type !== "blocks" || !Array.isArray(value)) continue;
+    for (const item of value) {
+      if (!isRecord(item)) continue;
+      const block = field.blocks?.[String(item.type)];
+      for (const [blockKey, blockField] of Object.entries(block?.fields ?? {}))
+        pushMediaKeys(keys, blockField, item[blockKey]);
+    }
+  }
+  return [...keys];
+}
+export function previewMedia(key, item, baseUrl) {
+  return {
+    key,
+    url: item?.url ?? mediaPublicUrl(baseUrl, key),
+    type: item?.type ?? mediaTypeForKey(key),
+    alt: item?.alt ?? null,
+    folder: item?.folder ?? null,
+    mime: item?.mime ?? null,
+    size: item?.size ?? null,
+    width: item?.width ?? null,
+    height: item?.height ?? null
+  };
+}
+export function previewBlocks(field, value, locale, defaultLocale, media) {
+  if (!Array.isArray(value)) return [];
+  const localized = localizeBlocks(field, value, locale, defaultLocale);
+  return resolveBlocksMedia(field, localized, (key) => media[key] ?? null);
+}
+export function previewItem(fields, values, locale, defaultLocale, media) {
+  const item = {};
+  for (const [key, field] of Object.entries(fields)) {
+    if (isPrivateField(field)) continue;
+    const value = values[key] ?? null;
+    if (field.type === "blocks") {
+      item[key] = previewBlocks(field, value, locale, defaultLocale, media);
+    } else if (field.type === "media") {
+      const mediaKey = isTranslatableMediaField(field) ? pickTranslatedMedia(
+        decodeTranslatableValue(value, defaultLocale),
+        locale,
+        defaultLocale
+      ) : value;
+      item[key] = typeof mediaKey === "string" && mediaKey ? media[mediaKey] ?? null : null;
+    } else if (isTranslatableField(field)) {
+      const translations = decodeTranslatableValue(value, defaultLocale);
+      item[key] = translations?.[locale] ?? translations?.[defaultLocale] ?? null;
+    } else {
+      item[key] = value;
+    }
+  }
+  return item;
+}
+export function blockSummary(block, item, locale, defaultLocale, max = 80) {
+  for (const [key, field] of Object.entries(block?.fields ?? {})) {
+    if (field.type !== "text" && field.type !== "richtext") continue;
+    const raw = item[key];
+    const translations = isRecord(raw) ? raw : null;
+    const value = typeof raw === "string" ? raw : translations?.[locale] || translations?.[defaultLocale] || "";
+    const text = value.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+    if (text) return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+  }
+  return "";
+}

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

@@ -4,11 +4,13 @@ export declare const objectKeySchema: z.ZodString;
 export interface ValidationMessages {
     required: string;
     invalidDate: string;
+    invalidDateTime: string;
     invalidEmail: string;
     invalidSlug: string;
     unknownLocale: string;
     requiredLocale: (locale: string) => string;
 }
+export declare function datetimeSchema(message: string): z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
 export declare function buildEntrySchema(entry: Pick<CmsEntry, 'fields'> & {
     drafts?: boolean;
 }, i18n: CmsI18n, messages?: Partial<ValidationMessages>): z.ZodObject<{

package/dist/runtime/shared/validation.js

@@ -1,14 +1,22 @@
 import { z } from "zod";
-import { isFieldVisible, isTranslatableField } from "./index.js";
+import { BLOCK_HIDDEN_KEY, declaresHiddenField, isFieldVisible, isTranslatableField } from "./index.js";
 export const objectKeySchema = z.string().min(1).max(1024).refine((k) => !k.includes("..") && !k.startsWith("/"), "Invalid object key");
 const DEFAULT_MESSAGES = {
   required: "Required field",
   invalidDate: "Invalid date (yyyy-mm-dd)",
+  invalidDateTime: "Invalid date and time (ISO 8601 with a time zone)",
   invalidEmail: "Invalid email",
   invalidSlug: "Invalid slug (lowercase letters, numbers, dashes)",
   unknownLocale: "Unknown locale key",
   requiredLocale: (locale) => `Required field (locale '${locale}')`
 };
+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(
+    (value) => DATETIME_PATTERN.test(value) && !Number.isNaN(new Date(value).getTime()),
+    message
+  ).transform((value) => new Date(value).toISOString());
+}
 function scalarSchema(field, m) {
   switch (field.type) {
     case "number":
@@ -19,6 +27,8 @@ function scalarSchema(field, m) {
       return z.string().min(1);
     case "date":
       return z.string().regex(/^\d{4}-\d{2}-\d{2}$/, m.invalidDate);
+    case "datetime":
+      return datetimeSchema(m.invalidDateTime);
     case "email":
       return z.email(m.invalidEmail);
     case "slug":
@@ -37,7 +47,9 @@ function optionalize(field, base, m) {
 }
 function translatableSchema(field, i18n, m) {
   const { locales, defaultLocale } = i18n;
-  const record = z.record(z.string(), field.type === "media" ? objectKeySchema : z.string()).refine((v) => Object.keys(v).every((k) => locales.includes(k)), m.unknownLocale);
+  const record = z.record(z.string(), field.type === "media" ? objectKeySchema : z.string(), {
+    error: (issue) => issue.input == null ? m.required : void 0
+  }).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) {
@@ -49,6 +61,7 @@ function blocksSchema(field, i18n, m) {
   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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xleddyl/nuxt-cms",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Lightweight CMS that ships with your Nuxt app: runs on the Nitro server, content types defined in code, /cms admin panel, GraphQL API, SQLite or Postgres. No external CMS needed!",
   "license": "MIT",
   "author": "Edoardo Alberti (https://github.com/xleddyl)",