@xleddyl/nuxt-cms 0.2.2 → 0.3.0

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

@@ -0,0 +1,52 @@
+import type { CmsConfig, CmsEntryKind } from './index.js';
+export declare const CMS_SEARCH_MIN_LENGTH = 2;
+export declare const CMS_SEARCH_MAX_LENGTH = 200;
+export declare const CMS_SEARCH_LABEL_LIMIT = 20;
+export declare const CMS_SEARCH_VALUE_LIMIT = 50;
+export declare const CMS_SEARCH_ROWS_PER_ENTRY = 10;
+export declare const CMS_SEARCH_HITS_PER_ROW = 5;
+export declare const CMS_SEARCH_PATH_SEPARATOR = " \u203A ";
+export type CmsSearchHitType = 'entry' | 'page' | 'tab' | 'field' | 'block' | 'value' | 'media';
+export type CmsSearchKind = CmsEntryKind | 'media';
+export interface CmsSearchSnippet {
+    before: string;
+    match: string;
+    after: string;
+}
+export interface CmsSearchHit {
+    type: CmsSearchHitType;
+    collection: string | null;
+    entryLabel: string;
+    kind: CmsSearchKind;
+    id: string | null;
+    title: string | null;
+    field: string | null;
+    fieldLabel: string | null;
+    locale: string | null;
+    snippet: CmsSearchSnippet;
+    to: string;
+}
+export interface CmsSearchResponse {
+    query: string;
+    hits: CmsSearchHit[];
+    truncated: boolean;
+}
+export interface CmsSearchFocus {
+    field?: string;
+    locale?: string | null;
+    block?: number | null;
+    tab?: string;
+}
+export declare function normalizeSearchQuery(value: string): string;
+export declare function isSearchableQuery(value: string): boolean;
+export declare function searchLikePattern(term: string): string;
+export declare function decodeHtmlEntities(value: string): string;
+export declare function stripMarkup(html: string): string;
+export declare function searchSnippet(text: string, term: string): CmsSearchSnippet | null;
+export declare function searchFieldPath(...labels: string[]): string;
+export declare function cmsSearchLink(path: string, focus?: CmsSearchFocus): string;
+export declare function readSearchFocus(query: Record<string, unknown>): CmsSearchFocus | null;
+export declare function searchCmsLabels(config: CmsConfig, query: string, limit?: number): {
+    hits: CmsSearchHit[];
+    truncated: boolean;
+};