@xleddyl/nuxt-cms 0.2.1 → 0.2.3

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/timestamps.d.ts

@@ -0,0 +1,4 @@
+export declare const SQLITE_ISO_FORMAT = "%Y-%m-%dT%H:%M:%fZ";
+export declare function nowTimestamp(): string;
+export declare function normalizeTimestamp<T>(value: T): T | string;
+export declare function normalizeTimestampFields<T extends Record<string, unknown>>(row: T, keys?: readonly string[]): T;

package/dist/runtime/shared/timestamps.js

@@ -0,0 +1,24 @@
+export const SQLITE_ISO_FORMAT = "%Y-%m-%dT%H:%M:%fZ";
+export function nowTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+const TIMESTAMP_PATTERN = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.(\d+))?(Z|[+-]\d{2}(?::?\d{2})?)?$/;
+export function normalizeTimestamp(value) {
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? value : value.toISOString();
+  if (typeof value !== "string") return value;
+  const match = TIMESTAMP_PATTERN.exec(value.trim());
+  if (!match) return value;
+  const [, date, time, fraction = "", zone] = match;
+  const millis = fraction.padEnd(3, "0").slice(0, 3);
+  const utc = `${date}T${time}.${millis}Z`;
+  if (!zone || zone === "Z") return utc;
+  const offset = zone.length === 3 ? `${zone}:00` : zone.includes(":") ? zone : `${zone.slice(0, 3)}:${zone.slice(3)}`;
+  const parsed = /* @__PURE__ */ new Date(`${date}T${time}.${millis}${offset}`);
+  return Number.isNaN(parsed.getTime()) ? value : parsed.toISOString();
+}
+export function normalizeTimestampFields(row, keys = ["createdAt", "updatedAt"]) {
+  for (const key of keys) {
+    if (Object.hasOwn(row, key)) row[key] = normalizeTimestamp(row[key]);
+  }
+  return row;
+}

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.1",
+  "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)",