@xleddyl/nuxt-cms 0.2.2 → 0.3.0

package/dist/runtime/shared/search.js

@@ -0,0 +1,207 @@
+import { entryTabs, fieldTab, pageAllFields, pageRoutes } from "./index.js";
+export const CMS_SEARCH_MIN_LENGTH = 2;
+export const CMS_SEARCH_MAX_LENGTH = 200;
+export const CMS_SEARCH_LABEL_LIMIT = 20;
+export const CMS_SEARCH_VALUE_LIMIT = 50;
+export const CMS_SEARCH_ROWS_PER_ENTRY = 10;
+export const CMS_SEARCH_HITS_PER_ROW = 5;
+export const CMS_SEARCH_PATH_SEPARATOR = " \u203A ";
+const SNIPPET_BEFORE = 40;
+const SNIPPET_AFTER = 90;
+const ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " "
+};
+export function normalizeSearchQuery(value) {
+  return value.replace(/\s+/g, " ").trim().slice(0, CMS_SEARCH_MAX_LENGTH);
+}
+export function isSearchableQuery(value) {
+  return normalizeSearchQuery(value).length >= CMS_SEARCH_MIN_LENGTH;
+}
+export function searchLikePattern(term) {
+  return `%${term.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
+}
+export function decodeHtmlEntities(value) {
+  return value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (entity, code) => {
+    if (code[0] === "#") {
+      const point = code[1] === "x" || code[1] === "X" ? Number.parseInt(code.slice(2), 16) : Number.parseInt(code.slice(1), 10);
+      return Number.isFinite(point) && point > 0 && point <= 1114111 ? String.fromCodePoint(point) : entity;
+    }
+    return ENTITIES[code.toLowerCase()] ?? entity;
+  });
+}
+export function stripMarkup(html) {
+  return decodeHtmlEntities(
+    html.replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, " ").replace(/<\/?(p|div|li|ul|ol|h[1-6]|blockquote|pre|br|hr|tr|td|th)\b[^>]*>/gi, " ").replace(/<[^>]*>/g, "")
+  );
+}
+export function searchSnippet(text, term) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  const needle = normalizeSearchQuery(term).toLowerCase();
+  if (!needle) return null;
+  const index = normalized.toLowerCase().indexOf(needle);
+  if (index === -1) return null;
+  const end = index + needle.length;
+  const from = Math.max(0, index - SNIPPET_BEFORE);
+  const to = Math.min(normalized.length, end + SNIPPET_AFTER);
+  return {
+    before: `${from > 0 ? "\u2026" : ""}${normalized.slice(from, index).trimStart()}`,
+    match: normalized.slice(index, end),
+    after: `${normalized.slice(end, to).trimEnd()}${to < normalized.length ? "\u2026" : ""}`
+  };
+}
+export function searchFieldPath(...labels) {
+  return labels.join(CMS_SEARCH_PATH_SEPARATOR);
+}
+export function cmsSearchLink(path, focus = {}) {
+  const params = new URLSearchParams();
+  if (focus.field) params.set("field", focus.field);
+  if (focus.locale) params.set("locale", focus.locale);
+  if (focus.block != null) params.set("block", String(focus.block));
+  if (focus.tab) params.set("tab", focus.tab);
+  const query = params.toString();
+  return query ? `${path}?${query}` : path;
+}
+export function readSearchFocus(query) {
+  const text = (value) => {
+    const first = Array.isArray(value) ? value[0] : value;
+    return typeof first === "string" && first ? first : void 0;
+  };
+  const field = text(query.field);
+  const tab = text(query.tab);
+  if (!field && !tab) return null;
+  const block = Number.parseInt(text(query.block) ?? "", 10);
+  return {
+    ...field ? { field } : {},
+    ...tab ? { tab } : {},
+    locale: text(query.locale) ?? null,
+    block: Number.isInteger(block) && block >= 0 ? block : null
+  };
+}
+function entryPath(name) {
+  return `/cms/${name}`;
+}
+function fieldLink(name, entry, key, overridePaths) {
+  if (entry.kind === "single") {
+    return { to: cmsSearchLink(entryPath(name), { field: key }), id: null, title: null };
+  }
+  if (entry.kind === "page" && !Object.hasOwn(entry.fields, key) && overridePaths.length === 1) {
+    const route = pageRoutes(entry).find((candidate) => candidate.path === overridePaths[0]);
+    if (route) {
+      return {
+        to: cmsSearchLink(`${entryPath(name)}/${route.key}`, { field: key }),
+        id: route.key,
+        title: route.label
+      };
+    }
+  }
+  return { to: entryPath(name), id: null, title: null };
+}
+function overridePathsOf(entry, key) {
+  return Object.entries(entry.overrides ?? {}).filter(([, fields]) => !!fields[key]).map(([path]) => path);
+}
+function blockCandidates(key, field, link) {
+  const candidates = [];
+  for (const block of Object.values(field.blocks ?? {})) {
+    candidates.push({
+      type: "block",
+      ...link,
+      field: key,
+      fieldLabel: searchFieldPath(field.label, block.label),
+      texts: [block.label]
+    });
+    for (const blockField of Object.values(block.fields)) {
+      candidates.push({
+        type: "field",
+        ...link,
+        field: key,
+        fieldLabel: searchFieldPath(field.label, block.label, blockField.label),
+        texts: [blockField.label]
+      });
+    }
+  }
+  return candidates;
+}
+function labelCandidates(name, entry) {
+  const candidates = [
+    { type: "entry", texts: [entry.label], to: entryPath(name) }
+  ];
+  if (entry.kind === "page") {
+    for (const route of pageRoutes(entry)) {
+      candidates.push({
+        type: "page",
+        id: route.key,
+        title: route.label,
+        texts: [route.label, route.path],
+        to: `${entryPath(name)}/${route.key}`
+      });
+    }
+  }
+  for (const tab of entryTabs(entry)) {
+    candidates.push({
+      type: "tab",
+      fieldLabel: tab.label,
+      texts: [tab.label],
+      to: entry.kind === "single" ? cmsSearchLink(entryPath(name), { tab: tab.id }) : entryPath(name)
+    });
+  }
+  const fields = entry.kind === "page" ? pageAllFields(entry) : entry.fields;
+  const tabs = entryTabs(entry);
+  for (const [key, field] of Object.entries(fields)) {
+    const link = fieldLink(name, entry, key, overridePathsOf(entry, key));
+    candidates.push({
+      type: "field",
+      ...link,
+      field: key,
+      fieldLabel: tabs.length ? searchFieldPath(
+        tabs.find((tab) => tab.id === fieldTab(field, tabs))?.label ?? "",
+        field.label
+      ) : field.label,
+      texts: [field.label]
+    });
+    if (field.type === "blocks") candidates.push(...blockCandidates(key, field, link));
+  }
+  return candidates;
+}
+export function searchCmsLabels(config, query, limit = CMS_SEARCH_LABEL_LIMIT) {
+  const term = normalizeSearchQuery(query);
+  if (term.length < CMS_SEARCH_MIN_LENGTH) return { hits: [], truncated: false };
+  const needle = term.toLowerCase();
+  const scored = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [name, entry] of Object.entries(config)) {
+    for (const candidate of labelCandidates(name, entry)) {
+      const text = candidate.texts.find((value) => value.toLowerCase().includes(needle));
+      if (!text) continue;
+      const snippet = searchSnippet(text, term);
+      if (!snippet) continue;
+      const identity = [candidate.type, name, candidate.fieldLabel ?? "", candidate.to].join(
+        "\0"
+      );
+      if (seen.has(identity)) continue;
+      seen.add(identity);
+      scored.push({
+        score: text.toLowerCase().startsWith(needle) ? 0 : 1,
+        hit: {
+          type: candidate.type,
+          collection: name,
+          entryLabel: entry.label,
+          kind: entry.kind,
+          id: candidate.id ?? null,
+          title: candidate.title ?? null,
+          field: candidate.field ?? null,
+          fieldLabel: candidate.fieldLabel ?? null,
+          locale: null,
+          snippet,
+          to: candidate.to
+        }
+      });
+    }
+  }
+  const sorted = scored.map((item, index) => ({ ...item, index })).sort((a, b) => a.score - b.score || a.index - b.index).map((item) => item.hit);
+  return { hits: sorted.slice(0, limit), truncated: sorted.length > limit };
+}

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.3.0",
   "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)",
@@ -124,6 +124,6 @@
     "test:docker": "vitest run --config test/docker/vitest.config.ts",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
     "format": "prettier --write \"**/*.{ts,tsx,js,jsx,md,html,json,sql,vue}\" --log-level error",
-    "release": "sh -c 'changelogen --release --no-github ${1:+--$1} && git push origin main --follow-tags' --"
+    "release": "node scripts/release.mjs"
   }
 }