@xleddyl/nuxt-cms 0.9.4 → 0.10.1

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

@@ -1,3 +1,4 @@
+import type { CmsBlockPath } from './block-paths.js';
 import type { CmsConfig, CmsEntryKind } from './index.js';
 export declare const CMS_SEARCH_MIN_LENGTH = 2;
 export declare const CMS_SEARCH_MAX_LENGTH = 200;
@@ -35,8 +36,12 @@ export interface CmsSearchFocus {
     field?: string;
     locale?: string | null;
     block?: number | null;
+    blockPath?: CmsBlockPath | null;
     tab?: string;
 }
+export type CmsSearchLinkFocus = Omit<CmsSearchFocus, 'block' | 'blockPath'> & {
+    block?: number | string | null;
+};
 export declare function normalizeSearchQuery(value: string): string;
 export declare function isSearchableQuery(value: string): boolean;
 export declare function searchLikePattern(term: string): string;
@@ -44,7 +49,17 @@ 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 const CMS_TAB_QUERY = "tab";
+export declare function cmsSearchLink(path: string, focus?: CmsSearchLinkFocus): string;
+export declare const CMS_ENTRY_ROUTE_KEY = "entry";
+export declare const CMS_ENTRY_TAB_ROUTE_KEY = "entrytab";
+export declare const CMS_ENTRY_FOCUS_KEYS: readonly ["field", "locale", "block"];
+export declare function cmsHashLink(path: string, entries: Record<string, string | number | null | undefined>): string;
+export declare function cmsPageKey(route: {
+    path: string;
+    query: Record<string, unknown>;
+}, omit?: string[]): string;
+export declare function cmsEntryLink(collection: string, id: string, focus?: CmsSearchLinkFocus): string;
 export declare function readSearchFocus(query: Record<string, unknown>): CmsSearchFocus | null;
 export declare function searchCmsLabels(config: CmsConfig, query: string, limit?: number): {
     hits: CmsSearchHit[];

package/dist/runtime/shared/search.js

@@ -1,3 +1,4 @@
+import { parseBlockPath } from "./block-paths.js";
 import { entryTabs, fieldTab, pageAllFields, pageRoutes } from "./index.js";
 export const CMS_SEARCH_MIN_LENGTH = 2;
 export const CMS_SEARCH_MAX_LENGTH = 200;
@@ -57,29 +58,58 @@ export function searchSnippet(text, term) {
 export function searchFieldPath(...labels) {
   return labels.join(CMS_SEARCH_PATH_SEPARATOR);
 }
+export const CMS_TAB_QUERY = "tab";
 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);
+  if (focus.tab) params.set(CMS_TAB_QUERY, focus.tab);
   const query = params.toString();
   return query ? `${path}?${query}` : path;
 }
+export const CMS_ENTRY_ROUTE_KEY = "entry";
+export const CMS_ENTRY_TAB_ROUTE_KEY = "entrytab";
+export const CMS_ENTRY_FOCUS_KEYS = ["field", "locale", "block"];
+function escapeHashValue(value) {
+  return value.replace(/[%&]/g, (char) => char === "%" ? "%25" : "%26");
+}
+export function cmsHashLink(path, entries) {
+  const text = Object.entries(entries).filter(([, value]) => value != null && value !== "").map(([key, value]) => `${key}/${escapeHashValue(String(value))}`).join("&");
+  return text ? `${path}#${text}` : path;
+}
+export function cmsPageKey(route, omit = []) {
+  const query = Object.fromEntries(
+    Object.entries(route.query).filter(([key]) => !omit.includes(key))
+  );
+  return `${route.path}${JSON.stringify(query)}`;
+}
+export function cmsEntryLink(collection, id, focus = {}) {
+  return cmsHashLink(`/cms/${collection}`, {
+    [CMS_ENTRY_ROUTE_KEY]: id,
+    field: focus.field,
+    locale: focus.locale,
+    block: focus.block,
+    [CMS_ENTRY_TAB_ROUTE_KEY]: focus.tab
+  });
+}
 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);
+  const tab = text(query[CMS_TAB_QUERY]);
   if (!field && !tab) return null;
-  const block = Number.parseInt(text(query.block) ?? "", 10);
+  const blockText = text(query.block);
+  const block = Number.parseInt(blockText ?? "", 10);
+  const blockPath = field && blockText ? parseBlockPath(`${field}.${blockText}`) : null;
   return {
     ...field ? { field } : {},
     ...tab ? { tab } : {},
     locale: text(query.locale) ?? null,
-    block: Number.isInteger(block) && block >= 0 ? block : null
+    block: Number.isInteger(block) && block >= 0 ? block : null,
+    blockPath: blockPath && blockPath.length % 2 === 0 ? blockPath : null
   };
 }
 function entryPath(name) {
@@ -104,14 +134,14 @@ function fieldLink(name, entry, key, overridePaths) {
 function overridePathsOf(entry, key) {
   return Object.entries(entry.overrides ?? {}).filter(([, fields]) => !!fields[key]).map(([path]) => path);
 }
-function blockCandidates(key, field, link) {
+function blockCandidates(key, field, link, labels = [field.label]) {
   const candidates = [];
   for (const block of Object.values(field.blocks ?? {})) {
     candidates.push({
       type: "block",
       ...link,
       field: key,
-      fieldLabel: searchFieldPath(field.label, block.label),
+      fieldLabel: searchFieldPath(...labels, block.label),
       texts: [block.label]
     });
     for (const blockField of Object.values(block.fields)) {
@@ -119,9 +149,13 @@ function blockCandidates(key, field, link) {
         type: "field",
         ...link,
         field: key,
-        fieldLabel: searchFieldPath(field.label, block.label, blockField.label),
+        fieldLabel: searchFieldPath(...labels, block.label, blockField.label),
         texts: [blockField.label]
       });
+      if (blockField.type === "blocks")
+        candidates.push(
+          ...blockCandidates(key, blockField, link, [...labels, block.label, blockField.label])
+        );
     }
   }
   return candidates;

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

@@ -0,0 +1,167 @@
+import type { CmsLocalePath } from './content-routes.js';
+export declare const CMS_SITE_SETTINGS_KEY = "cms:site";
+export declare const DEFAULT_TITLE_TEMPLATE = "%s | %siteName";
+export declare const TITLE_PLACEHOLDER = "%s";
+export declare const SITE_NAME_PLACEHOLDER = "%siteName";
+export declare const SITEMAP_PATH = "/sitemap.xml";
+export declare const ROBOTS_PATH = "/robots.txt";
+export declare const SITEMAP_MAX_URLS = 50000;
+export declare const SEO_ADMIN_PREFIX = "/cms";
+export declare const HIDDEN_SITE_ROBOTS = "noindex, nofollow";
+export declare const SITE_TEXT_LIMITS: {
+    readonly name: 200;
+    readonly titleTemplate: 200;
+    readonly description: 1000;
+};
+export declare const SITEMAP_CONFLICT_MODULES: string[];
+export declare const ROBOTS_CONFLICT_MODULES: string[];
+export type CmsLocaleText = Record<string, string> | null;
+export interface CmsSiteSettings {
+    name: CmsLocaleText;
+    titleTemplate: string | null;
+    description: CmsLocaleText;
+    image: string | null;
+    hidden: boolean;
+}
+export declare const EMPTY_SITE_SETTINGS: CmsSiteSettings;
+export declare function coerceSiteSettings(value: unknown): CmsSiteSettings;
+export interface CmsSeoMedia {
+    url: string | null;
+    type?: string | null;
+    alt?: string | null;
+    width?: number | null;
+    height?: number | null;
+    mime?: string | null;
+}
+export interface CmsSite {
+    name: string | null;
+    titleTemplate: string | null;
+    description: string | null;
+    image: CmsSeoMedia | null;
+    hidden: boolean;
+}
+export interface CmsSeoSource {
+    title?: string | null;
+    seoTitle?: string | null;
+    description?: string | null;
+    excerpt?: string | null;
+    seoDescription?: string | null;
+    cover?: CmsSeoMedia | null;
+    seoImage?: CmsSeoMedia | null;
+    seoNoindex?: boolean | null;
+    path?: string | null;
+    paths?: readonly CmsLocalePath[] | null;
+    publishedAt?: string | null;
+    updatedAt?: string | null;
+}
+export type CmsSeoType = 'website' | 'article';
+export interface CmsSeoOverrides {
+    title?: string | null;
+    description?: string | null;
+    image?: string | CmsSeoMedia | null;
+    path?: string | null;
+    alternates?: readonly CmsLocalePath[] | null;
+    noindex?: boolean | null;
+    type?: CmsSeoType;
+    titleTemplate?: string | false | null;
+}
+export interface CmsSeoContext {
+    siteUrl: string;
+    path: string;
+    defaultLocale: string;
+}
+export interface CmsSeoAlternate {
+    hreflang: string;
+    href: string;
+}
+export interface CmsSeoImage {
+    url: string;
+    alt: string | null;
+    width: number | null;
+    height: number | null;
+    type: string | null;
+}
+export interface CmsSeoMeta {
+    title: string;
+    pageTitle: string | null;
+    description: string | null;
+    canonical: string;
+    image: CmsSeoImage | null;
+    robots: string | null;
+    alternates: CmsSeoAlternate[];
+    type: CmsSeoType;
+    siteName: string | null;
+    publishedTime: string | null;
+    modifiedTime: string | null;
+}
+export declare function localeText(value: CmsLocaleText | undefined, locale: string, defaultLocale: string): string | null;
+export declare function normalizeSiteUrl(url: string | null | undefined): string;
+export declare function isAbsoluteUrl(value: string): boolean;
+export declare function absoluteUrl(siteUrl: string, pathOrUrl: string): string;
+export declare function applyTitleTemplate(template: string | null | undefined, title: string | null | undefined, siteName: string | null | undefined): string;
+export declare function titleTemplateErrors(template: string): string[];
+export declare function plainText(value: string | null | undefined): string | null;
+export declare function seoAlternates(paths: readonly CmsLocalePath[] | null | undefined, siteUrl: string, defaultLocale: string): CmsSeoAlternate[];
+export declare function resolveSeoMeta(source: CmsSeoSource | null | undefined, site: CmsSite | null | undefined, context: CmsSeoContext, overrides?: CmsSeoOverrides): CmsSeoMeta;
+export interface SitemapUrl {
+    loc: string;
+    lastmod?: string | null;
+    alternates?: CmsSeoAlternate[];
+}
+export declare function escapeXml(value: string): string;
+export declare const SITEMAP_URLSET_OPEN = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\" xmlns:xhtml=\"http://www.w3.org/1999/xhtml\">\n";
+export declare const SITEMAP_URLSET_CLOSE = "</urlset>\n";
+export declare function renderSitemapUrl(url: SitemapUrl): string;
+export declare function renderSitemap(urls: readonly SitemapUrl[]): string;
+export declare function renderSitemapIndex(locs: readonly string[]): string;
+export declare function sitemapUrlsForPaths(paths: readonly CmsLocalePath[], siteUrl: string, defaultLocale: string, lastmod: string | null): SitemapUrl[];
+export declare function isAdminPath(path: string): boolean;
+export declare function hiddenSiteHeaderApplies(path: string): boolean;
+export declare function sitemapLastmod(value: unknown): string | null;
+export declare function pageSitemapUrls(paths: readonly string[], rows: readonly Record<string, unknown>[], siteUrl: string): SitemapUrl[];
+export interface SitemapSourceSize {
+    source: string;
+    count: number;
+    urlsPerItem: number;
+}
+export interface SitemapChunk {
+    source: string;
+    offset: number;
+    limit: number;
+}
+export declare function sitemapUrlCount(sizes: readonly SitemapSourceSize[]): number;
+export declare function planSitemapChunks(sizes: readonly SitemapSourceSize[], maxUrls?: number): SitemapChunk[];
+export declare function sitemapPartUrl(siteUrl: string, part: number): string;
+export interface RobotsOptions {
+    hidden: boolean;
+    sitemapUrl: string | null;
+}
+export declare function renderRobotsTxt(options: RobotsOptions): string;
+export interface CmsSeoModuleOptions {
+    sitemap?: boolean;
+    robots?: boolean;
+}
+export interface CmsSiteModuleOptions {
+    url?: string;
+    trustForwardedHost?: boolean;
+}
+export declare const SEO_ROUTE_CACHE_CONTROL = "public, max-age=600, s-maxage=600";
+export declare const SEO_ROUTE_PRIVATE_CACHE_CONTROL = "private, no-store";
+export declare function seoRouteCacheControl(configuredSiteUrl: string | null | undefined): string;
+export declare function isForwardedHostTrusted(value: unknown): boolean;
+export declare function missingSiteUrlWarning(routes: {
+    sitemap: boolean;
+    robots: boolean;
+}): string | null;
+export declare function siteUrlErrors(url: unknown, at?: string): string[];
+export declare function seoOptionErrors(seo: unknown, site: unknown): string[];
+export interface SeoConflicts {
+    sitemap: string[];
+    robots: string[];
+}
+export interface ResolvedSeoSwitches {
+    sitemap: boolean;
+    robots: boolean;
+    warnings: string[];
+}
+export declare function resolveSeoSwitches(seo: CmsSeoModuleOptions | undefined, conflicts: SeoConflicts): ResolvedSeoSwitches;

package/dist/runtime/shared/seo.js

@@ -0,0 +1,335 @@
+import { normalizeTimestamp } from "./timestamps.js";
+export const CMS_SITE_SETTINGS_KEY = "cms:site";
+export const DEFAULT_TITLE_TEMPLATE = "%s | %siteName";
+export const TITLE_PLACEHOLDER = "%s";
+export const SITE_NAME_PLACEHOLDER = "%siteName";
+export const SITEMAP_PATH = "/sitemap.xml";
+export const ROBOTS_PATH = "/robots.txt";
+export const SITEMAP_MAX_URLS = 5e4;
+export const SEO_ADMIN_PREFIX = "/cms";
+export const HIDDEN_SITE_ROBOTS = "noindex, nofollow";
+export const SITE_TEXT_LIMITS = { name: 200, titleTemplate: 200, description: 1e3 };
+export const SITEMAP_CONFLICT_MODULES = ["@nuxtjs/sitemap", "nuxt-simple-sitemap"];
+export const ROBOTS_CONFLICT_MODULES = ["@nuxtjs/robots", "nuxt-simple-robots"];
+export const EMPTY_SITE_SETTINGS = {
+  name: null,
+  titleTemplate: null,
+  description: null,
+  image: null,
+  hidden: false
+};
+function coerceLocaleText(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const entries = Object.entries(value).filter(
+    (entry) => typeof entry[1] === "string" && !!entry[1].trim()
+  );
+  return entries.length ? Object.fromEntries(entries) : null;
+}
+export function coerceSiteSettings(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { ...EMPTY_SITE_SETTINGS };
+  const raw = value;
+  return {
+    name: coerceLocaleText(raw.name),
+    titleTemplate: typeof raw.titleTemplate === "string" && raw.titleTemplate.trim() ? raw.titleTemplate : null,
+    description: coerceLocaleText(raw.description),
+    image: typeof raw.image === "string" && raw.image ? raw.image : null,
+    hidden: raw.hidden === true
+  };
+}
+export function localeText(value, locale, defaultLocale) {
+  if (!value) return null;
+  const pick = (candidate) => typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+  return pick(value[locale]) ?? pick(value[defaultLocale]) ?? Object.values(value).map(pick).find(Boolean) ?? null;
+}
+export function normalizeSiteUrl(url) {
+  return (url ?? "").trim().replace(/\/+$/, "");
+}
+export function isAbsoluteUrl(value) {
+  return /^[a-z][a-z\d+.-]*:/i.test(value) || value.startsWith("//");
+}
+export function absoluteUrl(siteUrl, pathOrUrl) {
+  if (isAbsoluteUrl(pathOrUrl)) return pathOrUrl;
+  const base = normalizeSiteUrl(siteUrl);
+  const path = pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`;
+  return `${base}${path}`;
+}
+function hasTitlePlaceholder(template) {
+  return template.split(SITE_NAME_PLACEHOLDER).join("").includes(TITLE_PLACEHOLDER);
+}
+export function applyTitleTemplate(template, title, siteName) {
+  const page = title?.trim() || "";
+  const site = siteName?.trim() || "";
+  if (!page) return site;
+  const pattern = template?.trim() || (site ? DEFAULT_TITLE_TEMPLATE : TITLE_PLACEHOLDER);
+  if (!hasTitlePlaceholder(pattern)) return page;
+  if (pattern.includes(SITE_NAME_PLACEHOLDER) && !site) return page;
+  if (site && page === site) return page;
+  return pattern.split(SITE_NAME_PLACEHOLDER).map((part) => part.split(TITLE_PLACEHOLDER).join(page)).join(site);
+}
+export function titleTemplateErrors(template) {
+  return hasTitlePlaceholder(template) ? [] : [`The title template needs ${TITLE_PLACEHOLDER} where the page title goes`];
+}
+const ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  "#39": "'"
+};
+export function plainText(value) {
+  if (typeof value !== "string") return null;
+  const text = value.replace(/<[^>]*>/g, " ").replace(/&(amp|lt|gt|quot|apos|nbsp|#39);/g, (_, name) => ENTITIES[name] ?? "").replace(/\s+/g, " ").trim();
+  return text || null;
+}
+export function seoAlternates(paths, siteUrl, defaultLocale) {
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const { locale, path } of paths ?? []) {
+    if (locale && path && !byLocale.has(locale)) byLocale.set(locale, path);
+  }
+  if (new Set(byLocale.values()).size < 2) return [];
+  const links = [...byLocale].map(([locale, path]) => ({
+    hreflang: locale,
+    href: absoluteUrl(siteUrl, path)
+  }));
+  const fallback = byLocale.get(defaultLocale) ?? byLocale.values().next().value;
+  links.push({ hreflang: "x-default", href: absoluteUrl(siteUrl, fallback) });
+  return links;
+}
+function cleanText(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function seoImageOf(media, siteUrl) {
+  if (!media?.url) return null;
+  if (media.type && media.type !== "image") return null;
+  return {
+    url: absoluteUrl(siteUrl, media.url),
+    alt: media.alt ?? null,
+    width: media.width ?? null,
+    height: media.height ?? null,
+    type: media.mime ?? null
+  };
+}
+function pickImage(candidates, siteUrl) {
+  for (const candidate of candidates) {
+    const image = typeof candidate === "string" ? seoImageOf({ url: candidate }, siteUrl) : seoImageOf(candidate, siteUrl);
+    if (image) return image;
+  }
+  return null;
+}
+export function resolveSeoMeta(source, site, context, overrides = {}) {
+  const item = source ?? {};
+  const siteName = cleanText(site?.name);
+  const pageTitle = cleanText(overrides.title) ?? cleanText(item.seoTitle) ?? cleanText(item.title) ?? null;
+  const template = overrides.titleTemplate === false ? TITLE_PLACEHOLDER : cleanText(overrides.titleTemplate) ?? cleanText(site?.titleTemplate);
+  const description = plainText(overrides.description) ?? plainText(item.seoDescription) ?? plainText(item.excerpt) ?? plainText(item.description) ?? plainText(site?.description);
+  const path = cleanText(overrides.path) ?? cleanText(item.path) ?? context.path;
+  const hidden = !!site?.hidden;
+  const noindex = overrides.noindex ?? item.seoNoindex ?? false;
+  return {
+    title: applyTitleTemplate(template, pageTitle, siteName),
+    pageTitle,
+    description,
+    canonical: absoluteUrl(context.siteUrl, path.replace(/[?#].*$/, "") || "/"),
+    image: pickImage(
+      overrides.image !== void 0 ? [overrides.image] : [item.seoImage, item.cover, site?.image],
+      context.siteUrl
+    ),
+    robots: hidden ? HIDDEN_SITE_ROBOTS : noindex ? "noindex" : null,
+    alternates: seoAlternates(
+      overrides.alternates ?? item.paths,
+      context.siteUrl,
+      context.defaultLocale
+    ),
+    type: overrides.type ?? (item.publishedAt ? "article" : "website"),
+    siteName,
+    publishedTime: cleanText(item.publishedAt),
+    modifiedTime: cleanText(item.updatedAt)
+  };
+}
+export function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+export const SITEMAP_URLSET_OPEN = '<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">\n';
+export const SITEMAP_URLSET_CLOSE = "</urlset>\n";
+export function renderSitemapUrl(url) {
+  const lines = ["  <url>", `    <loc>${escapeXml(url.loc)}</loc>`];
+  if (url.lastmod) lines.push(`    <lastmod>${escapeXml(url.lastmod)}</lastmod>`);
+  for (const alternate of url.alternates ?? []) {
+    lines.push(
+      `    <xhtml:link rel="alternate" hreflang="${escapeXml(
+        alternate.hreflang
+      )}" href="${escapeXml(alternate.href)}"/>`
+    );
+  }
+  lines.push("  </url>");
+  return `${lines.join("\n")}
+`;
+}
+export function renderSitemap(urls) {
+  return `${SITEMAP_URLSET_OPEN}${urls.map(renderSitemapUrl).join("")}${SITEMAP_URLSET_CLOSE}`;
+}
+export function renderSitemapIndex(locs) {
+  const items = locs.map((loc) => `  <sitemap>
+    <loc>${escapeXml(loc)}</loc>
+  </sitemap>
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${items.join(
+    ""
+  )}</sitemapindex>
+`;
+}
+export function sitemapUrlsForPaths(paths, siteUrl, defaultLocale, lastmod) {
+  const alternates = seoAlternates(paths, siteUrl, defaultLocale);
+  const seen = /* @__PURE__ */ new Set();
+  const urls = [];
+  for (const { path } of paths) {
+    if (!path || seen.has(path) || isAdminPath(path)) continue;
+    seen.add(path);
+    urls.push({
+      loc: absoluteUrl(siteUrl, path),
+      lastmod,
+      ...alternates.length ? { alternates } : {}
+    });
+  }
+  return urls;
+}
+export function isAdminPath(path) {
+  return path === SEO_ADMIN_PREFIX || path.startsWith(`${SEO_ADMIN_PREFIX}/`);
+}
+const ROBOTS_HEADER_SKIPPED_PREFIXES = ["/_nuxt/", "/__nuxt"];
+export function hiddenSiteHeaderApplies(path) {
+  const bare = path.replace(/[?#].*$/, "");
+  return !isAdminPath(bare) && !ROBOTS_HEADER_SKIPPED_PREFIXES.some((prefix) => bare.startsWith(prefix));
+}
+export function sitemapLastmod(value) {
+  const normalized = normalizeTimestamp(value);
+  return typeof normalized === "string" && normalized ? normalized : null;
+}
+export function pageSitemapUrls(paths, rows, siteUrl) {
+  const byPath = new Map(rows.map((row) => [row.path, row]));
+  const urls = [];
+  for (const path of paths) {
+    if (!path.startsWith("/") || /[[\]:*]/.test(path) || isAdminPath(path)) continue;
+    const row = byPath.get(path);
+    if (row?.seoNoindex === true) continue;
+    urls.push({ loc: absoluteUrl(siteUrl, path), lastmod: sitemapLastmod(row?.updatedAt) });
+  }
+  return urls;
+}
+export function sitemapUrlCount(sizes) {
+  return sizes.reduce((total, size) => total + size.count * Math.max(1, size.urlsPerItem), 0);
+}
+export function planSitemapChunks(sizes, maxUrls = SITEMAP_MAX_URLS) {
+  const chunks = [];
+  for (const { source, count, urlsPerItem } of sizes) {
+    const perChunk = Math.max(1, Math.floor(maxUrls / Math.max(1, urlsPerItem)));
+    for (let offset = 0; offset < count; offset += perChunk) {
+      chunks.push({ source, offset, limit: Math.min(perChunk, count - offset) });
+    }
+  }
+  return chunks;
+}
+export function sitemapPartUrl(siteUrl, part) {
+  return absoluteUrl(siteUrl, `${SITEMAP_PATH}?part=${part}`);
+}
+export function renderRobotsTxt(options) {
+  const lines = ["User-agent: *", `Disallow: ${SEO_ADMIN_PREFIX}/`];
+  if (!options.hidden && options.sitemapUrl) lines.push("", `Sitemap: ${options.sitemapUrl}`);
+  return `${lines.join("\n")}
+`;
+}
+const SEO_OPTION_KEYS = ["sitemap", "robots"];
+const SITE_OPTION_KEYS = ["url", "trustForwardedHost"];
+export const SEO_ROUTE_CACHE_CONTROL = "public, max-age=600, s-maxage=600";
+export const SEO_ROUTE_PRIVATE_CACHE_CONTROL = "private, no-store";
+export function seoRouteCacheControl(configuredSiteUrl) {
+  return configuredSiteUrl ? SEO_ROUTE_CACHE_CONTROL : SEO_ROUTE_PRIVATE_CACHE_CONTROL;
+}
+export function isForwardedHostTrusted(value) {
+  return value === true || value === "true" || value === 1 || value === "1";
+}
+export function missingSiteUrlWarning(routes) {
+  const served = [
+    routes.sitemap ? "/sitemap.xml" : null,
+    routes.robots ? "/robots.txt" : null
+  ].filter((path) => !!path);
+  if (!served.length) return null;
+  return `[nuxt-cms] ${served.join(" and ")} ${served.length > 1 ? "are" : "is"} served but no site URL is set: set cms.site.url (or NUXT_PUBLIC_SITE_URL), otherwise the URLs come from the request host and the responses are sent with Cache-Control: private, no-store.`;
+}
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function siteUrlErrors(url, at = "cms.site.url") {
+  if (typeof url !== "string") return [`${at} must be a string`];
+  if (!url.trim()) return [];
+  let parsed;
+  try {
+    parsed = new URL(url.trim());
+  } catch {
+    return [`${at} must be an absolute URL like https://example.com, got '${url}'`];
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+    return [`${at} must use http or https, got '${url}'`];
+  if (parsed.search || parsed.hash || url.includes("?") || url.includes("#"))
+    return [`${at} cannot hold a query or a hash, got '${url}'`];
+  if (parsed.username || parsed.password) return [`${at} cannot hold credentials`];
+  return [];
+}
+export function seoOptionErrors(seo, site) {
+  const errors = [];
+  if (seo !== void 0) {
+    if (!isPlainObject(seo)) {
+      errors.push("cms.seo must be an object like { sitemap: true, robots: true }");
+    } else {
+      for (const [key, value] of Object.entries(seo)) {
+        if (!SEO_OPTION_KEYS.includes(key))
+          errors.push(`cms.seo.${key} is not an option (use ${SEO_OPTION_KEYS.join(", ")})`);
+        else if (value !== void 0 && typeof value !== "boolean")
+          errors.push(`cms.seo.${key} must be true or false`);
+      }
+    }
+  }
+  if (site !== void 0) {
+    if (!isPlainObject(site)) {
+      errors.push("cms.site must be an object like { url: 'https://example.com' }");
+    } else {
+      for (const [key, value] of Object.entries(site)) {
+        if (!SITE_OPTION_KEYS.includes(key))
+          errors.push(`cms.site.${key} is not an option (use ${SITE_OPTION_KEYS.join(", ")})`);
+        else if (key === "trustForwardedHost") {
+          if (value !== void 0 && typeof value !== "boolean")
+            errors.push("cms.site.trustForwardedHost must be true or false");
+        } else if (value !== void 0) errors.push(...siteUrlErrors(value));
+      }
+    }
+  }
+  return errors;
+}
+function resolveSwitch(key, option, conflicts, route) {
+  if (option === false) return { enabled: false, warning: null };
+  if (!conflicts.length) return { enabled: true, warning: null };
+  const found = conflicts.join(", ");
+  if (option === true)
+    return {
+      enabled: true,
+      warning: `[nuxt-cms] cms.seo.${key} is on but ${found} also serves ${route}; only one of them answers. Set cms.seo.${key} to false to keep the other one.`
+    };
+  return {
+    enabled: false,
+    warning: `[nuxt-cms] ${found} found, so the cms ${route} is off. Set cms.seo.${key} to true or false to silence this.`
+  };
+}
+export function resolveSeoSwitches(seo, conflicts) {
+  const sitemap = resolveSwitch("sitemap", seo?.sitemap, conflicts.sitemap, SITEMAP_PATH);
+  const robots = resolveSwitch("robots", seo?.robots, conflicts.robots, ROBOTS_PATH);
+  return {
+    sitemap: sitemap.enabled,
+    robots: robots.enabled,
+    warnings: [sitemap.warning, robots.warning].filter((warning) => !!warning)
+  };
+}

package/dist/runtime/shared/transfer.js

@@ -136,7 +136,8 @@ export function csvCellValue(field, text) {
     return { error: "Not a boolean (true or false)" };
   }
   if (field.type === "tags" && !text.trim().startsWith("[")) return { value: text.split(",") };
-  if (field.type === "json" || isStringListField(field)) {
+  if (field.type === "link" && !text.trim().startsWith("{")) return { value: { url: text.trim() } };
+  if (field.type === "json" || field.type === "link" || isStringListField(field)) {
     try {
       return { value: JSON.parse(text) };
     } catch {

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

@@ -0,0 +1,29 @@
+import type { CmsEntry, CmsI18n, FieldConfig } from './index.js';
+export declare const TRANSLATIONS_COLUMN = "_translations";
+export type TranslationState = 'complete' | 'partial' | 'missing';
+export interface TranslationLocaleProgress {
+    filled: number;
+    total: number;
+    values: number;
+    state: TranslationState;
+}
+export type TranslationProgress = Record<string, TranslationLocaleProgress>;
+export interface TranslationChange {
+    values: Record<string, unknown>;
+    count: number;
+}
+type Values = Record<string, unknown>;
+export declare function isTranslationFilled(field: FieldConfig, value: unknown): boolean;
+export declare function hasTranslatableContent(fields: Record<string, FieldConfig>): boolean;
+export declare function entryHasTranslations(entry: Pick<CmsEntry, 'fields'> & Partial<Pick<CmsEntry, 'kind' | 'overrides'>>): boolean;
+export declare function hasTranslationsColumn(entry: Pick<CmsEntry, 'kind' | 'fields'>, i18n: Pick<CmsI18n, 'locales'>): boolean;
+export declare function translationProgress(fields: Record<string, FieldConfig>, values: Values | null | undefined, i18n: CmsI18n, keys?: readonly string[]): TranslationProgress;
+export declare function translationSummary(progress: TranslationLocaleProgress | undefined): string;
+export interface TranslationCopyOptions {
+    from: string;
+    to: string;
+    overwrite?: boolean;
+}
+export declare function copyTranslations(fields: Record<string, FieldConfig>, values: Values, i18n: CmsI18n, { from, to, overwrite }: TranslationCopyOptions): TranslationChange;
+export declare function clearTranslations(fields: Record<string, FieldConfig>, values: Values, i18n: CmsI18n, locale: string): TranslationChange;
+export {};