@xleddyl/nuxt-cms 0.9.4 → 0.10.1

package/dist/runtime/shared/index.js

@@ -1,3 +1,4 @@
+import { MAX_BLOCKS_DEPTH, blockFieldsDeep, mapBlocks } from "./block-paths.js";
 export const MEDIA_TYPES = ["image", "video", "file"];
 const MEDIA_EXTENSIONS = {
   image: [
@@ -120,8 +121,15 @@ export function groupMediaUsage(usage) {
   }
   return [...entries.values()];
 }
-export function mediaUsageGroups(usage, keys) {
-  return [...new Set(keys)].map((key) => ({ key, entries: groupMediaUsage(usage[key] ?? []) })).filter((group) => group.entries.length > 0);
+export function mediaUsageGroups(usage, keys, hidden = {}) {
+  return [...new Set(keys)].map((key) => ({
+    key,
+    entries: groupMediaUsage(usage[key] ?? []),
+    hidden: hidden[key] ?? 0
+  })).filter((group) => group.entries.length > 0 || group.hidden > 0);
+}
+export function otherEntriesLabel(count) {
+  return `${count} other entr${count === 1 ? "y" : "ies"}`;
 }
 export function selectOptions(field) {
   return (field.options ?? []).map(
@@ -148,28 +156,21 @@ export function selectDisplayValue(field, value) {
   if (Array.isArray(value)) return value.map((item) => selectOptionLabel(field, item)).join(", ");
   return selectOptionLabel(field, value);
 }
+export function relationTarget(field) {
+  return typeof field.to === "string" ? field.to : "";
+}
 export function isPrivateField(field) {
   return !!field.private;
 }
 export function isRequiredField(field) {
   return !!field.required && !field.showIf;
 }
-export function fieldConditions(field) {
-  if (!field.showIf) return [];
-  return Array.isArray(field.showIf) ? field.showIf : [field.showIf];
-}
-function matchesCondition(condition, value) {
-  if (condition.in) return condition.in.some((option) => option === value);
-  return condition.eq === value;
-}
-export function isFieldVisible(field, values) {
-  const conditions = fieldConditions(field);
-  if (!conditions.length) return true;
-  return conditions.every((condition) => matchesCondition(condition, values?.[condition.field]));
-}
 export function isTranslatableField(field) {
   return !!field.translatable && (field.type === "text" || field.type === "richtext" || field.type === "media");
 }
+export function isLocalizedLinkField(field) {
+  return field.type === "link" && !!field.translatable && !!field.withLabel;
+}
 export function isTranslatableMediaField(field) {
   return !!field.translatable && field.type === "media";
 }
@@ -285,8 +286,8 @@ export function translatableBlockFieldKeys(block) {
 }
 export function hasTranslatableBlockFields(field) {
   if (field.type !== "blocks") return false;
-  return Object.values(field.blocks ?? {}).some(
-    (block) => Object.values(block.fields).some(isTranslatableField)
+  return blockFieldsDeep(field).some(
+    (blockField) => isTranslatableField(blockField) || isLocalizedLinkField(blockField)
   );
 }
 export function canAddBlock(field, count) {
@@ -300,11 +301,11 @@ 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)]);
-  });
+  return mapBlocks(
+    field,
+    value,
+    (item, block) => isHiddenBlock(item) && !declaresHiddenField(block) ? null : item
+  );
 }
 export function localizeBlock(field, item, locale, defaultLocale) {
   if (!item || typeof item !== "object") return item;
@@ -320,8 +321,11 @@ export function localizeBlock(field, item, locale, defaultLocale) {
   return localized;
 }
 export function localizeBlocks(field, value, locale, defaultLocale) {
-  if (!Array.isArray(value)) return value;
-  return value.map((item) => localizeBlock(field, item, locale, defaultLocale));
+  return mapBlocks(
+    field,
+    value,
+    (item, _block, owner) => localizeBlock(owner, item, locale, defaultLocale)
+  );
 }
 export const CMS_GRAPHQL_BATCH_LIMIT = 20;
 export const MOBILE_MEDIA_SUFFIX = "Mobile";
@@ -389,8 +393,10 @@ export const CONTENT_SYSTEM_FIELDS = [
   "body",
   "seoTitle",
   "seoDescription",
-  "seoImage"
+  "seoImage",
+  "seoNoindex"
 ];
+export const CONTENT_NOINDEX_FIELD = "seoNoindex";
 export const CONTENT_LIST_COLUMNS = ["title", "status", "publishedAt"];
 export function isContentEntry(entry) {
   return entry.kind === "content";
@@ -430,7 +436,12 @@ function contentSystemFields(blocks, labels, translatable) {
       textarea: true,
       ...localized
     },
-    seoImage: { label: label("seoImage", "SEO image"), type: "media", mediaType: "image" }
+    seoImage: { label: label("seoImage", "SEO image"), type: "media", mediaType: "image" },
+    seoNoindex: {
+      label: label("seoNoindex", "Hide from search engines"),
+      type: "boolean",
+      description: "Adds noindex to the page and leaves it out of the sitemap."
+    }
   };
 }
 function normalizeContentEntry(entry, translatable) {
@@ -440,7 +451,7 @@ function normalizeContentEntry(entry, translatable) {
   const extra = Object.fromEntries(
     Object.entries(declared).filter(([key]) => !Object.hasOwn(system, key))
   );
-  const { body, seoTitle, seoDescription, seoImage, ...head } = system;
+  const { body, seoTitle, seoDescription, seoImage, seoNoindex, ...head } = system;
   return Object.assign(entry, {
     declared: {
       fields: Object.keys(declared),
@@ -449,7 +460,7 @@ function normalizeContentEntry(entry, translatable) {
     },
     titleField: CONTENT_TITLE_FIELD,
     drafts: true,
-    fields: { ...head, ...extra, body, seoTitle, seoDescription, seoImage },
+    fields: { ...head, ...extra, body, seoTitle, seoDescription, seoImage, seoNoindex },
     list: entry.list ?? { columns: [...CONTENT_LIST_COLUMNS] }
   });
 }
@@ -460,8 +471,72 @@ export function normalizeContentEntries(config, i18n) {
   }
   return config;
 }
+function boundBlocksField(field, depth, trail) {
+  const blocks = field.blocks;
+  if (!blocks || typeof blocks !== "object") return field;
+  const inner = new Set(trail).add(blocks);
+  let changed = false;
+  const bounded = {};
+  for (const [name, block] of Object.entries(blocks)) {
+    if (!block?.fields || typeof block.fields !== "object") {
+      bounded[name] = block;
+      continue;
+    }
+    let fields = null;
+    let dropped = false;
+    for (const [key, subfield] of Object.entries(block.fields)) {
+      if (subfield?.type !== "blocks" || !subfield.blocks) continue;
+      const cyclic = inner.has(subfield.blocks);
+      if (depth >= MAX_BLOCKS_DEPTH) {
+        if (cyclic) dropped = true;
+        continue;
+      }
+      const next = boundBlocksField(subfield, depth + 1, inner);
+      if (next === subfield) continue;
+      fields ??= { ...block.fields };
+      fields[key] = next;
+    }
+    if (dropped) {
+      changed = true;
+      continue;
+    }
+    if (fields) {
+      changed = true;
+      bounded[name] = { ...block, fields };
+    } else {
+      bounded[name] = block;
+    }
+  }
+  return changed ? { ...field, blocks: bounded } : field;
+}
+function boundFields(fields) {
+  let next = null;
+  for (const [key, field] of Object.entries(fields)) {
+    if (field?.type !== "blocks") continue;
+    const bounded = boundBlocksField(field, 1, /* @__PURE__ */ new Set());
+    if (bounded === field) continue;
+    next ??= { ...fields };
+    next[key] = bounded;
+  }
+  return next ?? fields;
+}
+export function boundBlockNesting(config) {
+  for (const entry of Object.values(config)) {
+    if (!entry?.fields || typeof entry.fields !== "object") continue;
+    entry.fields = boundFields(entry.fields);
+    if (entry.overrides && typeof entry.overrides === "object") {
+      entry.overrides = Object.fromEntries(
+        Object.entries(entry.overrides).map(([path, override]) => [
+          path,
+          override && typeof override === "object" ? boundFields(override) : override
+        ])
+      );
+    }
+  }
+  return config;
+}
 export function normalizeCmsConfig(config, i18n) {
-  return expandMobileMedia(normalizeContentEntries(config, i18n));
+  return boundBlockNesting(expandMobileMedia(normalizeContentEntries(config, i18n)));
 }
 export function slugSourceValue(source, value, defaultLocale) {
   if (value == null) return null;
@@ -478,10 +553,7 @@ export function isScheduledContent(row, now = /* @__PURE__ */ new Date()) {
   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)];
+  return mapBlocks(field, value, (item, block) => {
     if (!block) return item;
     const resolved = { ...item };
     for (const [key, blockField] of Object.entries(block.fields)) {
@@ -586,11 +658,15 @@ export function entryFieldsFor(entry, path) {
 export function typeName(name) {
   return name.replace(/(?:^|_)([a-z0-9])/gi, (_, c) => c.toUpperCase());
 }
-export function blocksFieldTypeName(entryName, fieldKey) {
-  return `${typeName(entryName)}${typeName(fieldKey)}Block`;
+export function blocksTypePrefix(entryName, schemaPath) {
+  const segments = typeof schemaPath === "string" ? schemaPath.split(".") : schemaPath;
+  return `${typeName(entryName)}${segments.map(typeName).join("")}`;
+}
+export function blocksFieldTypeName(entryName, schemaPath) {
+  return `${blocksTypePrefix(entryName, schemaPath)}Block`;
 }
-export function blockTypeName(entryName, fieldKey, blockName) {
-  return `${typeName(entryName)}${typeName(fieldKey)}${typeName(blockName)}`;
+export function blockTypeName(entryName, schemaPath, blockName) {
+  return `${blocksTypePrefix(entryName, schemaPath)}${typeName(blockName)}`;
 }
 export function defineCmsConfig(config) {
   return config;
@@ -598,5 +674,13 @@ export function defineCmsConfig(config) {
 export function defineCmsBlocks(blocks) {
   return blocks;
 }
+export * from "./block-paths.js";
+export * from "./conditions.js";
+export * from "./content-routes.js";
+export * from "./seo.js";
+export * from "./redirects.js";
 export * from "./layout.js";
+export * from "./media-focal.js";
 export * from "./users.js";
+export * from "./preview-links.js";
+export * from "./links.js";

package/dist/runtime/shared/inline-text.d.ts

@@ -0,0 +1,38 @@
+import type { CmsBlockPath } from './block-paths.js';
+import type { FieldConfig } from './index.js';
+export declare const CMS_INLINE_TEXT_MAX_LENGTH = 100000;
+export declare const CMS_INLINE_INPUT_DELAY = 250;
+export interface CmsInlineNode {
+    nodeType: number;
+    nodeName: string;
+    nodeValue: string | null;
+    childNodes: ArrayLike<CmsInlineNode>;
+}
+export interface CmsInlineOverride {
+    path: CmsBlockPath | null;
+    key: string;
+    value: unknown;
+    settled: boolean;
+}
+export declare function isInlineTextField(field: FieldConfig | undefined): field is FieldConfig;
+export declare function isPlainTextContent(node: CmsInlineNode): boolean;
+export declare function editableText(node: CmsInlineNode): string;
+export declare function normalizeInlineText(text: string, multiline: boolean): string;
+export declare function inlineTextLimit(field: FieldConfig | undefined): number | undefined;
+export declare function clampInlineText(text: string, max: number | undefined): string;
+export declare function fitInlineInsertion(text: string, room: number): string;
+export declare function inlineFieldPath(path: CmsBlockPath | null, key: string): string;
+export interface CmsInlineLockOptions {
+    fields: Record<string, FieldConfig> | null;
+    values: Record<string, unknown>;
+    blocksFields: Record<string, FieldConfig>;
+    blocksValues: Record<string, unknown>;
+    locked?: readonly string[];
+}
+export declare function lockedInlineFields(options: CmsInlineLockOptions): string[];
+export declare function matchesInlineValue(text: string, value: unknown): boolean;
+export declare function inlineFieldValue(field: FieldConfig, current: unknown, locale: string, defaultLocale: string, text: string): unknown;
+export declare function applyInlineOverride<T extends Record<string, unknown>>(blocks: readonly T[], item: Record<string, unknown> | null, override: CmsInlineOverride | null): {
+    blocks: T[];
+    item: Record<string, unknown> | null;
+};

package/dist/runtime/shared/inline-text.js

@@ -0,0 +1,85 @@
+import { formatBlockPath, updateBlockAt, walkBlocks } from "./block-paths.js";
+import { decodeTranslatableValue, isFieldVisible, isTranslatableField } from "./index.js";
+export const CMS_INLINE_TEXT_MAX_LENGTH = 1e5;
+export const CMS_INLINE_INPUT_DELAY = 250;
+const TEXT_NODE = 3;
+const ELEMENT_NODE = 1;
+const LINE_TAGS = /* @__PURE__ */ new Set(["DIV", "P", "LI"]);
+export function isInlineTextField(field) {
+  return field?.type === "text";
+}
+export function isPlainTextContent(node) {
+  return Array.from(node.childNodes).every((child) => child.nodeType !== ELEMENT_NODE);
+}
+export function editableText(node) {
+  let text = "";
+  const walk = (parent) => {
+    for (const child of Array.from(parent.childNodes)) {
+      if (child.nodeType === TEXT_NODE) text += child.nodeValue ?? "";
+      else if (child.nodeType !== ELEMENT_NODE) continue;
+      else if (child.nodeName === "BR") text += "\n";
+      else {
+        if (LINE_TAGS.has(child.nodeName) && text && !text.endsWith("\n")) text += "\n";
+        walk(child);
+      }
+    }
+  };
+  walk(node);
+  return text;
+}
+export function normalizeInlineText(text, multiline) {
+  const value = text.replace(/ /g, " ").replace(/\r\n?/g, "\n").replace(/\n$/, "");
+  return multiline ? value : value.replace(/[^\S\n]*\n\s*/g, " ");
+}
+export function inlineTextLimit(field) {
+  return isInlineTextField(field) && typeof field.max === "number" ? field.max : void 0;
+}
+export function clampInlineText(text, max) {
+  return max === void 0 || text.length <= max ? text : text.slice(0, max);
+}
+export function fitInlineInsertion(text, room) {
+  return text.slice(0, Math.max(room, 0));
+}
+export function inlineFieldPath(path, key) {
+  return path ? `${formatBlockPath(path)}.${key}` : key;
+}
+export function lockedInlineFields(options) {
+  const paths = [];
+  for (const [key, field] of Object.entries(options.fields ?? {})) {
+    if (!isInlineTextField(field)) continue;
+    if (options.locked?.includes(key) || !isFieldVisible(field, options.values, options.fields))
+      paths.push(key);
+  }
+  walkBlocks(options.blocksFields, options.blocksValues, ({ item, block, path }) => {
+    for (const [key, field] of Object.entries(block.fields)) {
+      if (isInlineTextField(field) && !isFieldVisible(field, item, block.fields))
+        paths.push(inlineFieldPath(path, key));
+    }
+  });
+  return paths;
+}
+export function matchesInlineValue(text, value) {
+  if (value != null && typeof value !== "string") return false;
+  return text.trim() === (value ?? "").trim();
+}
+export function inlineFieldValue(field, current, locale, defaultLocale, text) {
+  if (!isTranslatableField(field)) return text === "" ? null : text;
+  const translations = decodeTranslatableValue(current, defaultLocale) ?? {};
+  const next = Object.fromEntries(Object.entries(translations).filter(([code]) => code !== locale));
+  if (text !== "") next[locale] = text;
+  return Object.keys(next).length ? next : null;
+}
+export function applyInlineOverride(blocks, item, override) {
+  if (!override) return { blocks: [...blocks], item };
+  if (!override.path)
+    return {
+      blocks: [...blocks],
+      item: item ? { ...item, [override.key]: override.value } : item
+    };
+  const root = String(override.path[0]);
+  const updated = updateBlockAt({ [root]: blocks }, override.path, (block) => ({
+    ...block,
+    [override.key]: override.value
+  }));
+  return { blocks: [...updated[root] ?? []], item };
+}

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

@@ -1,4 +1,4 @@
-import type { FieldConfig } from './index.js';
+import type { BlockConfig, FieldConfig } from './index.js';
 export declare const MAX_LAYOUT_ROW_FIELDS = 4;
 export type CmsLayoutRow = string | string[];
 export interface CmsLayoutSectionInput {
@@ -28,6 +28,7 @@ export interface CmsEntrySettings {
 export type CmsSettingsMap = Record<string, CmsEntrySettings>;
 export declare function layoutFromConfig(input: CmsLayoutBlock[] | undefined): CmsFormLayout;
 export declare function resolveFormLayout(fields: Record<string, FieldConfig>, layout: CmsFormLayout | undefined): CmsFormLayout;
+export declare function blockFormLayout(block: Pick<BlockConfig, 'fields' | 'layout'>): CmsFormLayout;
 export declare function defaultListColumns(fields: Record<string, FieldConfig>, list: CmsListInput | undefined, extra?: string[]): string[];
 export declare function resolveListColumns(fields: Record<string, FieldConfig>, saved: string[] | undefined, list: CmsListInput | undefined, extra?: string[]): string[];
 export declare function layoutErrors(at: string, fields: Record<string, FieldConfig>, input: CmsLayoutBlock[] | undefined): string[];

package/dist/runtime/shared/layout.js

@@ -78,6 +78,9 @@ export function resolveFormLayout(fields, layout) {
   }
   return { main };
 }
+export function blockFormLayout(block) {
+  return resolveFormLayout(block.fields, layoutFromConfig(block.layout));
+}
 export function defaultListColumns(fields, list, extra = []) {
   const available = [...Object.keys(fields), ...extra];
   const configured = list?.columns?.filter((key) => available.includes(key));

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

@@ -0,0 +1,48 @@
+import type { CmsConfig, CmsEntry, FieldConfig } from './index.js';
+export declare const LINK_URL_MAX_LENGTH = 2048;
+export declare const LINK_URL_SCHEMES: readonly string[];
+export declare const LINK_TARGET_SEPARATOR = ":";
+export interface CmsLinkValue {
+    url?: string;
+    entry?: string;
+    id?: string;
+    label?: string | Record<string, string>;
+    newTab?: boolean;
+}
+export interface CmsLink {
+    href: string | null;
+    label: string | null;
+    newTab: boolean;
+    external: boolean;
+    entry: string | null;
+    id: string | null;
+}
+export interface CmsLinkTarget {
+    entry: string;
+    id: string;
+}
+export interface CmsLinkReference extends CmsLinkTarget {
+    field: string;
+}
+export type CmsLinkUrlKind = 'absolute' | 'path' | 'anchor';
+export declare function linkUrlKind(url: string): CmsLinkUrlKind | null;
+export declare function linkUrlError(url: unknown): string | null;
+export declare function isExternalLinkUrl(url: string | null | undefined): boolean;
+export declare function isLinkTargetEntry(entry: CmsEntry | null | undefined): boolean;
+export declare function declaredLinkTargets(field: FieldConfig): string[] | null;
+export declare function linkTargetNames(config: CmsConfig, field: FieldConfig): string[];
+export declare function allowsExternalLinks(field: FieldConfig): boolean;
+export declare function linkTargetKey(entry: string, id: string): string;
+export declare function parseLinkTargetKey(key: string): CmsLinkTarget | null;
+export declare function readLinkValue(value: unknown): CmsLinkValue | null;
+export declare function linkTargetOf(value: unknown): CmsLinkTarget | null;
+export declare function linkLabelText(label: unknown, locale: string, defaultLocale: string): string | null;
+export declare function linkLabelTexts(label: unknown): {
+    locale: string | null;
+    text: string;
+}[];
+export declare function pageLinkPath(entry: CmsEntry | undefined, id: string): string | null;
+export declare function linkHref(config: CmsConfig, link: CmsLinkValue | null, locale: string, target?: Record<string, unknown> | null): string | null;
+export declare function resolveCmsLink(config: CmsConfig, value: unknown, locale: string, defaultLocale: string, target?: Record<string, unknown> | null): CmsLink | null;
+export declare function linkReferences(fields: Record<string, FieldConfig>, values: Record<string, unknown>): CmsLinkReference[];
+export declare function linkDisplayText(value: unknown, locale: string, defaultLocale: string, targetTitle?: string | null): string;

package/dist/runtime/shared/links.js

@@ -0,0 +1,155 @@
+import { blockReferenceLabel, walkBlocks } from "./block-paths.js";
+import { contentItemPath, isRoutedContent } from "./content-routes.js";
+export const LINK_URL_MAX_LENGTH = 2048;
+export const LINK_URL_SCHEMES = ["http", "https", "mailto", "tel"];
+export const LINK_TARGET_SEPARATOR = ":";
+const SCHEME = /^([a-z][a-z\d+.-]*):/i;
+const UNSAFE_CHARACTERS = /[\s\u0000-\u001F\u007F]/;
+const TEL_NUMBER = /^\+?[\d().\-/]+$/;
+export function linkUrlKind(url) {
+  if (url.startsWith("#")) return "anchor";
+  if (url.startsWith("/") && !url.startsWith("//") && !url.startsWith("/\\")) return "path";
+  const scheme = SCHEME.exec(url)?.[1]?.toLowerCase();
+  return scheme && LINK_URL_SCHEMES.includes(scheme) ? "absolute" : null;
+}
+export function linkUrlError(url) {
+  if (typeof url !== "string" || !url) return "Enter a URL";
+  if (url.length > LINK_URL_MAX_LENGTH) return "The URL is too long";
+  if (UNSAFE_CHARACTERS.test(url)) return "A URL cannot contain spaces";
+  if (url.startsWith("//") || url.startsWith("/\\") || url.startsWith("\\"))
+    return "Use https:// for links to other sites";
+  if (url.startsWith("/")) return null;
+  if (url.startsWith("#")) return url.length > 1 ? null : "Add an anchor name after #";
+  const scheme = SCHEME.exec(url)?.[1]?.toLowerCase();
+  if (!scheme) return "Use a full URL (https://...), a path starting with / or an #anchor";
+  if (!LINK_URL_SCHEMES.includes(scheme))
+    return `${scheme}: links are not allowed (use http, https, mailto or tel)`;
+  const rest = url.slice(scheme.length + 1);
+  if (scheme === "mailto") return rest ? null : "Add an email address after mailto:";
+  if (scheme === "tel") return TEL_NUMBER.test(rest) ? null : "Add a phone number after tel:";
+  if (!rest.startsWith("//")) return "Invalid URL";
+  try {
+    return new URL(url).hostname ? null : "Invalid URL";
+  } catch {
+    return "Invalid URL";
+  }
+}
+export function isExternalLinkUrl(url) {
+  return !!url && linkUrlKind(url) === "absolute";
+}
+export function isLinkTargetEntry(entry) {
+  return !!entry && (entry.kind === "page" || isRoutedContent(entry));
+}
+export function declaredLinkTargets(field) {
+  const to = field.to;
+  if (!Array.isArray(to)) return null;
+  return to.filter((name) => typeof name === "string");
+}
+export function linkTargetNames(config, field) {
+  const declared = declaredLinkTargets(field);
+  if (declared) return declared.filter((name) => isLinkTargetEntry(config[name]));
+  return Object.entries(config).filter(([, entry]) => isLinkTargetEntry(entry)).map(([name]) => name);
+}
+export function allowsExternalLinks(field) {
+  return field.external !== false;
+}
+export function linkTargetKey(entry, id) {
+  return `${entry}${LINK_TARGET_SEPARATOR}${id}`;
+}
+export function parseLinkTargetKey(key) {
+  const index = key.indexOf(LINK_TARGET_SEPARATOR);
+  if (index <= 0 || index === key.length - 1) return null;
+  return { entry: key.slice(0, index), id: key.slice(index + 1) };
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function readLinkValue(value) {
+  let parsed = value;
+  if (typeof parsed === "string") {
+    const text = parsed.trim();
+    if (!text.startsWith("{")) return text ? { url: text } : null;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return null;
+    }
+  }
+  if (!isRecord(parsed)) return null;
+  const link = {};
+  if (typeof parsed.url === "string" && parsed.url) link.url = parsed.url;
+  if (typeof parsed.entry === "string" && parsed.entry) link.entry = parsed.entry;
+  if (typeof parsed.id === "string" && parsed.id) link.id = parsed.id;
+  if (typeof parsed.label === "string" || isRecord(parsed.label))
+    link.label = parsed.label;
+  if (parsed.newTab === true) link.newTab = true;
+  return link;
+}
+export function linkTargetOf(value) {
+  const link = readLinkValue(value);
+  if (!link?.entry || !link.id || link.url) return null;
+  return { entry: link.entry, id: link.id };
+}
+export function linkLabelText(label, locale, defaultLocale) {
+  if (typeof label === "string") return label || null;
+  if (!isRecord(label)) return null;
+  const pick = (key) => {
+    const text = label[key];
+    return typeof text === "string" && text ? text : null;
+  };
+  return pick(locale) ?? pick(defaultLocale) ?? Object.keys(label).map(pick).find((text) => text !== null) ?? null;
+}
+export function linkLabelTexts(label) {
+  if (typeof label === "string") return label ? [{ locale: null, text: label }] : [];
+  if (!isRecord(label)) return [];
+  return Object.entries(label).filter((pair) => typeof pair[1] === "string" && !!pair[1]).map(([locale, text]) => ({ locale, text }));
+}
+export function pageLinkPath(entry, id) {
+  if (entry?.kind !== "page") return null;
+  return entry.pages?.find((route) => route.key === id)?.path ?? null;
+}
+export function linkHref(config, link, locale, target) {
+  if (!link) return null;
+  if (link.url) return linkUrlError(link.url) ? null : link.url;
+  if (!link.entry || !link.id) return null;
+  const entry = config[link.entry];
+  if (entry?.kind === "page") return pageLinkPath(entry, link.id);
+  if (!target || !isRoutedContent(entry)) return null;
+  return contentItemPath(entry, target, locale);
+}
+export function resolveCmsLink(config, value, locale, defaultLocale, target) {
+  const link = readLinkValue(value);
+  if (!link || !link.url && !(link.entry && link.id)) return null;
+  return {
+    href: linkHref(config, link, locale, target),
+    label: linkLabelText(link.label, locale, defaultLocale),
+    newTab: !!link.newTab,
+    external: isExternalLinkUrl(link.url),
+    entry: link.url ? null : link.entry ?? null,
+    id: link.url ? null : link.id ?? null
+  };
+}
+export function linkReferences(fields, values) {
+  const references = [];
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.type !== "link") continue;
+    const target = linkTargetOf(values[key]);
+    if (target) references.push({ field: key, ...target });
+  }
+  walkBlocks(fields, values, ({ item, block, path }) => {
+    for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
+      if (blockField.type !== "link") continue;
+      const target = linkTargetOf(item[blockFieldKey]);
+      if (target) references.push({ field: blockReferenceLabel(path, blockFieldKey), ...target });
+    }
+  });
+  return references;
+}
+export function linkDisplayText(value, locale, defaultLocale, targetTitle) {
+  const link = readLinkValue(value);
+  if (!link) return "";
+  const label = linkLabelText(link.label, locale, defaultLocale);
+  const target = link.url ?? targetTitle ?? null;
+  if (label && target) return `${label} (${target})`;
+  return label ?? target ?? (link.entry && link.id ? `${link.entry} #${link.id}` : "");
+}

package/dist/runtime/shared/list-filters.d.ts

@@ -1,7 +1,9 @@
 import type { CmsEntry, SelectOption } from './index.js';
 export declare const LIST_FILTER_PREFIX = "filter.";
+export declare const LIST_SEARCH_PARAM = "q";
 export declare const LIST_FILTER_STATUS = "status";
 export declare const LIST_FILTER_ID_MAX = 256;
+export declare const LIST_IDS_MAX = 1000;
 export type CmsListFilters = Record<string, string>;
 type FilterEntry = Pick<CmsEntry, 'kind' | 'fields' | 'drafts' | 'list'>;
 export declare function listFilterExtras(entry: FilterEntry): string[];

package/dist/runtime/shared/list-filters.js

@@ -1,7 +1,9 @@
 import { isCollectionKind, listFilterKeys, selectOptions } from "./index.js";
 export const LIST_FILTER_PREFIX = "filter.";
+export const LIST_SEARCH_PARAM = "q";
 export const LIST_FILTER_STATUS = "status";
 export const LIST_FILTER_ID_MAX = 256;
+export const LIST_IDS_MAX = 1e3;
 const STATUS_OPTIONS = [
   { value: "draft", label: "Draft" },
   { value: "published", label: "Published" }

package/dist/runtime/shared/media-focal.d.ts

@@ -0,0 +1,30 @@
+export interface CmsFocalPoint {
+    x: number;
+    y: number;
+}
+export interface CmsFocalMedia {
+    focalX?: number | null;
+    focalY?: number | null;
+}
+export declare function isFocalCoordinate(value: unknown): value is number;
+export declare function roundFocalCoordinate(value: number): number;
+export declare function focalPointOf(media: CmsFocalMedia | null | undefined): CmsFocalPoint | null;
+export declare function focalPointIssue(focalX: unknown, focalY: unknown): string | null;
+export declare function focalObjectPosition(media: CmsFocalMedia | null | undefined): string | undefined;
+export declare function imgixFocalModifiers(media: CmsFocalMedia | null | undefined): Record<string, string | number>;
+export interface CmsImageMedia extends CmsFocalMedia {
+    url: string | null;
+    type?: string | null;
+    alt?: string | null;
+    width?: number | null;
+    height?: number | null;
+}
+export interface CmsImageSizeInput {
+    width?: number | string | null;
+    height?: number | string | null;
+}
+export declare function cmsImageSize(media: Pick<CmsImageMedia, 'width' | 'height'> | null | undefined, input?: CmsImageSizeInput): {
+    width: number | undefined;
+    height: number | undefined;
+};
+export declare function isRenderableImage(media: CmsImageMedia | null | undefined): media is CmsImageMedia;