@xleddyl/nuxt-cms 0.9.3 → 0.10.0

package/dist/runtime/shared/clipboard.js

@@ -0,0 +1,206 @@
+import {
+  BLOCK_HIDDEN_KEY,
+  allowsExternalLinks,
+  declaredLinkTargets,
+  declaresHiddenField,
+  isTranslatableField,
+  linkUrlError,
+  selectOptionValues
+} from "./index.js";
+import { CMS_CLIPBOARD_MAX_LENGTH } from "./preview.js";
+import { objectKeySchema } from "./validation.js";
+export const CMS_CLIPBOARD_KIND = "blocks";
+export const CMS_CLIPBOARD_VERSION = 1;
+export const CMS_CLIPBOARD_MAX_ITEMS = 200;
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isBlockItem(value) {
+  return isRecord(value) && typeof value.type === "string" && value.type !== "";
+}
+export function clipboardText(items) {
+  const payload = {
+    nuxtCms: CMS_CLIPBOARD_KIND,
+    version: CMS_CLIPBOARD_VERSION,
+    items: items.map((item) => ({ ...item }))
+  };
+  return JSON.stringify(payload);
+}
+export function parseClipboardText(text) {
+  if (typeof text !== "string" || text.length > CMS_CLIPBOARD_MAX_LENGTH) return null;
+  if (!text.trimStart().startsWith("{")) return null;
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isRecord(data) || data.nuxtCms !== CMS_CLIPBOARD_KIND) return null;
+  if (data.version !== CMS_CLIPBOARD_VERSION || !Array.isArray(data.items)) return null;
+  const items = data.items.filter(isBlockItem).slice(0, CMS_CLIPBOARD_MAX_ITEMS);
+  return items.length ? items : null;
+}
+function isMediaKey(value) {
+  return objectKeySchema.safeParse(value).success;
+}
+function localizedShape(raw, i18n, accepts) {
+  if (typeof raw === "string") return raw && accepts(raw) ? { [i18n.defaultLocale]: raw } : null;
+  if (!isRecord(raw)) return null;
+  const entries = Object.entries(raw).filter(
+    (pair) => i18n.locales.includes(pair[0]) && accepts(pair[1])
+  );
+  return entries.length ? Object.fromEntries(entries) : null;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function plainShape(field, raw, i18n) {
+  if (field.type === "json" || field.type === "link" || !isRecord(raw)) return raw;
+  const value = raw[i18n.defaultLocale];
+  if (typeof value === "string") return value;
+  return Object.values(raw).find((entry) => typeof entry === "string") ?? null;
+}
+function trimmedText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function linkLabelShape(field, raw, i18n) {
+  if (!field.withLabel || raw == null) return void 0;
+  if (field.translatable && i18n.locales.length) {
+    const label = localizedShape(raw, i18n, isString);
+    if (!label) return void 0;
+    const kept = Object.entries(label).map(([locale, text2]) => [locale, text2.trim()]).filter(([, text2]) => !!text2);
+    return kept.length ? Object.fromEntries(kept) : void 0;
+  }
+  const text = trimmedText(plainShape({ ...field, type: "text" }, raw, i18n));
+  return text || void 0;
+}
+function linkShape(field, raw, i18n) {
+  if (!isRecord(raw)) return null;
+  const url = trimmedText(raw.url);
+  const entry = trimmedText(raw.entry);
+  const id = trimmedText(raw.id);
+  const label = linkLabelShape(field, raw.label, i18n);
+  const extra = {
+    ...label !== void 0 ? { label } : {},
+    ...raw.newTab === true ? { newTab: true } : {}
+  };
+  if (url && !entry && !id) {
+    if (!allowsExternalLinks(field) || linkUrlError(url)) return null;
+    return { url, ...extra };
+  }
+  if (url || !entry || !id) return null;
+  const targets = declaredLinkTargets(field);
+  if (targets && !targets.includes(entry)) return null;
+  return { entry, id, ...extra };
+}
+function scalarShape(field, raw) {
+  if (raw === void 0 || raw === null) return null;
+  switch (field.type) {
+    case "json":
+      return raw;
+    case "number":
+      return typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+    case "boolean":
+      return typeof raw === "boolean" ? raw : null;
+    case "media":
+      return isMediaKey(raw) ? raw : null;
+    case "select": {
+      const options = selectOptionValues(field);
+      if (field.multiple) {
+        if (!Array.isArray(raw)) return null;
+        const values = [...new Set(raw.filter((value) => options.includes(value)))];
+        return values.length ? values : null;
+      }
+      return typeof raw === "string" && options.includes(raw) ? raw : null;
+    }
+    case "tags": {
+      if (!Array.isArray(raw)) return null;
+      const values = raw.filter(isString);
+      return values.length ? values : null;
+    }
+    default:
+      return typeof raw === "string" ? raw : null;
+  }
+}
+export function pastedFieldValue(field, raw, i18n) {
+  if (field.type === "blocks") {
+    if (!Array.isArray(raw)) return null;
+    const { list } = pasteBlocks([], 0, raw.filter(isBlockItem), field, i18n);
+    return list.length ? list : null;
+  }
+  if (field.type === "link") return linkShape(field, raw, i18n);
+  if (isTranslatableField(field) && i18n.locales.length > 0)
+    return localizedShape(raw, i18n, field.type === "media" ? isMediaKey : isString);
+  return scalarShape(field, plainShape(field, raw, i18n));
+}
+export function pastedBlock(type, block, item, i18n) {
+  const value = { type };
+  for (const [key, field] of Object.entries(block.fields))
+    value[key] = pastedFieldValue(field, item[key], i18n);
+  if (!declaresHiddenField(block) && item[BLOCK_HIDDEN_KEY] === true)
+    value[BLOCK_HIDDEN_KEY] = true;
+  return value;
+}
+export function pasteBlocks(list, at, items, field, i18n) {
+  const blocks = field.blocks ?? {};
+  const unknown = [];
+  const allowed = [];
+  for (const item of items) {
+    const type = String(item.type);
+    if (Object.hasOwn(blocks, type)) allowed.push(item);
+    else unknown.push(type);
+  }
+  const room = field.max === void 0 ? allowed.length : Math.max(field.max - list.length, 0);
+  const kept = allowed.slice(0, room);
+  const index = Math.min(Math.max(at, 0), list.length);
+  const next = [...list];
+  next.splice(
+    index,
+    0,
+    ...kept.map((item) => pastedBlock(String(item.type), blocks[String(item.type)], item, i18n))
+  );
+  return {
+    list: next,
+    at: index,
+    pasted: kept.length,
+    unknown,
+    overflow: allowed.length - kept.length
+  };
+}
+export function pasteableCount(items, field) {
+  const blocks = field.blocks ?? {};
+  return (items ?? []).filter((item) => Object.hasOwn(blocks, String(item.type))).length;
+}
+function blockCount(count) {
+  return `${count} ${count === 1 ? "block" : "blocks"}`;
+}
+export function skippedText(result, field) {
+  const parts = [];
+  if (result.unknown.length) {
+    const types = [...new Set(result.unknown)].join(", ");
+    parts.push(
+      `${blockCount(result.unknown.length)} skipped, not available in this field: ${types}.`
+    );
+  }
+  if (result.overflow) {
+    const max = field.max ?? 0;
+    parts.push(
+      `${blockCount(result.overflow)} skipped, this field holds at most ${blockCount(max)}.`
+    );
+  }
+  return parts.length ? parts.join(" ") : void 0;
+}
+export function copyNotice(count, cut = false) {
+  const what = count === 1 ? "Block" : blockCount(count);
+  return { title: `${what} ${cut ? "cut" : "copied"}` };
+}
+export function pasteNotice(result, field) {
+  if (!result) return { title: "Nothing to paste", description: "Copy or cut a block first." };
+  const description = skippedText(result, field);
+  if (!result.pasted) return { title: "Nothing pasted", description, color: "error" };
+  return {
+    title: `${result.pasted === 1 ? "Block" : blockCount(result.pasted)} pasted`,
+    description,
+    color: description ? void 0 : "success"
+  };
+}

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

@@ -0,0 +1,36 @@
+import type { FieldConfig, FieldType } from './index.js';
+export type ConditionValue = string | number | boolean;
+export interface FieldCondition {
+    field: string;
+    eq?: ConditionValue;
+    neq?: ConditionValue;
+    in?: readonly ConditionValue[];
+    notIn?: readonly ConditionValue[];
+    gt?: number | string;
+    gte?: number | string;
+    lt?: number | string;
+    lte?: number | string;
+    empty?: boolean;
+    has?: string;
+}
+export interface AllCondition {
+    all: readonly ShowIfCondition[];
+}
+export interface AnyCondition {
+    any: readonly ShowIfCondition[];
+}
+export interface NotCondition {
+    not: ShowIfCondition;
+}
+export type ShowIfCondition = FieldCondition | AllCondition | AnyCondition | NotCondition;
+export type CmsShowIf = ShowIfCondition | readonly ShowIfCondition[];
+export declare const CONDITION_OPERATORS: readonly ["eq", "neq", "in", "notIn", "gt", "gte", "lt", "lte", "empty", "has"];
+export type ConditionOperator = (typeof CONDITION_OPERATORS)[number];
+export declare const CONDITION_GROUPS: readonly ["all", "any", "not"];
+export type ConditionScope = Record<string, Pick<FieldConfig, 'type'>> | null | undefined;
+type Values = Record<string, unknown> | null | undefined;
+export declare function fieldConditions(field: FieldConfig): ShowIfCondition[];
+export declare function isEmptyConditionValue(value: unknown, type?: FieldType): boolean;
+export declare function matchesShowIf(condition: ShowIfCondition, values: Values, scope?: ConditionScope): boolean;
+export declare function isFieldVisible(field: FieldConfig, values: Values, scope?: ConditionScope): boolean;
+export {};

package/dist/runtime/shared/conditions.js

@@ -0,0 +1,100 @@
+export const CONDITION_OPERATORS = [
+  "eq",
+  "neq",
+  "in",
+  "notIn",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "empty",
+  "has"
+];
+export const CONDITION_GROUPS = ["all", "any", "not"];
+function isConditionList(value) {
+  return Array.isArray(value);
+}
+export function fieldConditions(field) {
+  const showIf = field.showIf;
+  if (!showIf) return [];
+  return isConditionList(showIf) ? [...showIf] : [showIf];
+}
+function isEmptyLinkTarget(link) {
+  return isEmptyConditionValue(link.url) && (isEmptyConditionValue(link.entry) || isEmptyConditionValue(link.id));
+}
+export function isEmptyConditionValue(value, type) {
+  if (value == null) return true;
+  if (typeof value === "string") return !value.trim();
+  if (Array.isArray(value)) return !value.length;
+  if (typeof value === "object") {
+    if (type === "json") return !Object.keys(value).length;
+    if (type === "link") return isEmptyLinkTarget(value);
+    return Object.values(value).every((entry) => isEmptyConditionValue(entry));
+  }
+  return false;
+}
+function timeOf(value) {
+  const time = new Date(value).getTime();
+  return Number.isNaN(time) ? null : time;
+}
+function compareValues(value, expected, type) {
+  if (typeof value === "number" && typeof expected === "number") return value - expected;
+  if (typeof value !== "string" || typeof expected !== "string" || !value) return null;
+  if (type === "datetime") {
+    const a = timeOf(value);
+    const b = timeOf(expected);
+    return a === null || b === null ? null : a - b;
+  }
+  return value < expected ? -1 : value > expected ? 1 : 0;
+}
+function sameValue(value, expected, type) {
+  if (type === "datetime") return compareValues(value, expected, type) === 0;
+  return value === expected;
+}
+function sameItem(item, expected, type) {
+  if (type === "tags" && typeof item === "string" && typeof expected === "string")
+    return item.trim().toLowerCase() === expected.trim().toLowerCase();
+  return item === expected;
+}
+function ordered(test) {
+  return (value, expected, type) => {
+    const diff = compareValues(value, expected, type);
+    return diff !== null && test(diff);
+  };
+}
+const OPERATORS = {
+  eq: sameValue,
+  neq: (value, expected, type) => !sameValue(value, expected, type),
+  in: (value, expected, type) => Array.isArray(expected) && expected.some((option) => sameValue(value, option, type)),
+  notIn: (value, expected, type) => Array.isArray(expected) && !expected.some((option) => sameValue(value, option, type)),
+  gt: ordered((diff) => diff > 0),
+  gte: ordered((diff) => diff >= 0),
+  lt: ordered((diff) => diff < 0),
+  lte: ordered((diff) => diff <= 0),
+  empty: (value, expected, type) => isEmptyConditionValue(value, type) === expected,
+  has: (value, expected, type) => Array.isArray(value) && value.some((item) => sameItem(item, expected, type))
+};
+function matchesFieldCondition(condition, values, scope) {
+  const value = values?.[condition.field];
+  const type = scope?.[condition.field]?.type;
+  let matched = false;
+  for (const operator of CONDITION_OPERATORS) {
+    const expected = condition[operator];
+    if (expected === void 0) continue;
+    if (!OPERATORS[operator](value, expected, type)) return false;
+    matched = true;
+  }
+  return matched;
+}
+export function matchesShowIf(condition, values, scope) {
+  if (!condition || typeof condition !== "object") return false;
+  if ("all" in condition)
+    return isConditionList(condition.all) && condition.all.every((c) => matchesShowIf(c, values, scope));
+  if ("any" in condition)
+    return isConditionList(condition.any) && condition.any.some((c) => matchesShowIf(c, values, scope));
+  if ("not" in condition) return !matchesShowIf(condition.not, values, scope);
+  return matchesFieldCondition(condition, values, scope);
+}
+export function isFieldVisible(field, values, scope) {
+  return fieldConditions(field).every((condition) => matchesShowIf(condition, values, scope));
+}

package/dist/runtime/shared/content-routes.d.ts

@@ -0,0 +1,42 @@
+import type { CmsConfig, CmsEntry, CmsI18n } from './index.js';
+export declare const CONTENT_ROUTE_FIELDS: readonly string[];
+export declare const CONTENT_ROUTE_PARAMS: readonly ["slug", "id", "year", "month", "day"];
+export type CmsContentRouteParam = (typeof CONTENT_ROUTE_PARAMS)[number];
+export type CmsContentRoute = string | Readonly<Record<string, string>>;
+export type CmsContentRouteParams = Partial<Record<CmsContentRouteParam, string>>;
+export type CmsContentRouteItem = Readonly<Record<string, unknown>>;
+export interface CmsLocalePath {
+    locale: string;
+    path: string;
+}
+export interface CmsContentPathMatch {
+    entry: string;
+    pattern: string;
+    params: CmsContentRouteParams;
+}
+type RouteSegment = {
+    param: CmsContentRouteParam;
+} | {
+    text: string;
+};
+type RoutedEntry = Pick<CmsEntry, 'kind' | 'route'>;
+export declare function contentRouteSegments(pattern: string): RouteSegment[];
+export declare function contentRouteErrors(pattern: unknown): string[];
+export declare function contentRouteShape(pattern: string): string;
+export declare function compareContentRoutes(a: string, b: string): number;
+export declare function contentRouteLocales(i18n: Pick<CmsI18n, 'locales' | 'defaultLocale'>): string[];
+export declare function contentRoutePattern(route: CmsContentRoute | null | undefined, locale: string): string | null;
+export declare function contentRoutePatterns(route: CmsContentRoute | null | undefined): string[];
+export declare function isRoutedContent(entry: RoutedEntry | null | undefined): boolean;
+export declare function contentRouteValues(item: CmsContentRouteItem): CmsContentRouteParams;
+export declare function buildContentPath(pattern: string, item: CmsContentRouteItem): string | null;
+export declare function contentItemPath(entry: RoutedEntry, item: CmsContentRouteItem, locale: string): string | null;
+export declare function contentItemPaths(entry: RoutedEntry, item: CmsContentRouteItem, locales: readonly string[]): CmsLocalePath[];
+export declare function normalizeContentPath(path: string): string;
+export declare function matchContentPattern(pattern: string, path: string): CmsContentRouteParams | null;
+export declare function contentPathParamsMatch(params: CmsContentRouteParams, item: CmsContentRouteItem): boolean;
+export declare function matchContentPath(config: CmsConfig, path: string, locale: string): CmsContentPathMatch[];
+export declare function routedContentNames(config: CmsConfig): string[];
+export declare function contentRouteConfigErrors(at: string, route: unknown, i18n: Pick<CmsI18n, 'locales'>): string[];
+export declare function contentRouteClashErrors(config: CmsConfig): string[];
+export {};

package/dist/runtime/shared/content-routes.js

@@ -0,0 +1,237 @@
+export const CONTENT_ROUTE_FIELDS = ["path", "paths"];
+export const CONTENT_ROUTE_PARAMS = ["slug", "id", "year", "month", "day"];
+const PARAM_SEGMENT = /^\[([^\]]*)\]$/;
+const FORBIDDEN_CHARACTERS = /[?#\s\\]/;
+const RESERVED_PREFIX = "cms";
+const PARAM_VALUES = {
+  slug: /^.+$/,
+  id: /^.+$/,
+  year: /^\d{4}$/,
+  month: /^\d{2}$/,
+  day: /^\d{2}$/
+};
+const DATE_PARAMS = ["year", "month", "day"];
+function isRouteParam(name) {
+  return CONTENT_ROUTE_PARAMS.includes(name);
+}
+export function contentRouteSegments(pattern) {
+  return pattern.split("/").filter(Boolean).map((segment) => {
+    const name = PARAM_SEGMENT.exec(segment)?.[1];
+    return name && isRouteParam(name) ? { param: name } : { text: segment };
+  });
+}
+export function contentRouteErrors(pattern) {
+  if (typeof pattern !== "string" || !pattern) return ["must be a non-empty string"];
+  if (!pattern.startsWith("/")) return [`'${pattern}' must start with /`];
+  if (FORBIDDEN_CHARACTERS.test(pattern))
+    return [`'${pattern}' cannot hold spaces, backslashes, ? or #`];
+  const segments = pattern.slice(1).split("/");
+  if (segments.some((segment) => !segment))
+    return [`'${pattern}' has an empty segment or a trailing slash`];
+  const errors = [];
+  if (segments[0] === RESERVED_PREFIX)
+    errors.push(`'${pattern}' is under /${RESERVED_PREFIX}, which belongs to the admin`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const segment of segments) {
+    const name = PARAM_SEGMENT.exec(segment)?.[1];
+    if (name === void 0) {
+      if (/[[\]]/.test(segment))
+        errors.push(`'${pattern}': a placeholder must fill a whole segment ('${segment}')`);
+      continue;
+    }
+    if (!isRouteParam(name)) {
+      errors.push(
+        `'${pattern}': unknown placeholder [${name}] (use ${CONTENT_ROUTE_PARAMS.map(
+          (param) => `[${param}]`
+        ).join(", ")})`
+      );
+    } else if (seen.has(name)) {
+      errors.push(`'${pattern}': placeholder [${name}] is used twice`);
+    }
+    seen.add(name);
+  }
+  if (!seen.has("slug") && !seen.has("id"))
+    errors.push(`'${pattern}' needs a [slug] or [id] placeholder`);
+  return errors;
+}
+export function contentRouteShape(pattern) {
+  const shape = contentRouteSegments(pattern).map((segment) => {
+    if ("text" in segment) return segment.text;
+    if (segment.param === "year") return "[yyyy]";
+    if (DATE_PARAMS.includes(segment.param)) return "[nn]";
+    return "[*]";
+  });
+  return `/${shape.join("/")}`;
+}
+function routeRank(pattern) {
+  const segments = contentRouteSegments(pattern);
+  const statics = segments.filter((segment) => "text" in segment).length;
+  const dates = segments.filter(
+    (segment) => "param" in segment && DATE_PARAMS.includes(segment.param)
+  ).length;
+  return [statics, dates, segments.length];
+}
+export function compareContentRoutes(a, b) {
+  const left = routeRank(a);
+  const right = routeRank(b);
+  return right[0] - left[0] || right[1] - left[1] || right[2] - left[2] || a.localeCompare(b);
+}
+export function contentRouteLocales(i18n) {
+  return i18n.locales.length ? [...i18n.locales] : [i18n.defaultLocale];
+}
+export function contentRoutePattern(route, locale) {
+  if (!route) return null;
+  if (typeof route === "string") return route;
+  return route[locale] ?? null;
+}
+export function contentRoutePatterns(route) {
+  if (!route) return [];
+  return typeof route === "string" ? [route] : [...new Set(Object.values(route))];
+}
+export function isRoutedContent(entry) {
+  return entry?.kind === "content" && !!entry.route;
+}
+function datePart(value, part) {
+  if (typeof value !== "string" || !value) return void 0;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return void 0;
+  if (part === "year") return String(date.getUTCFullYear()).padStart(4, "0");
+  const number = part === "month" ? date.getUTCMonth() + 1 : date.getUTCDate();
+  return String(number).padStart(2, "0");
+}
+function textValue(value) {
+  if (typeof value === "number") return String(value);
+  return typeof value === "string" && value ? value : void 0;
+}
+export function contentRouteValues(item) {
+  const values = {};
+  const slug = textValue(item.slug);
+  const id = textValue(item.id);
+  if (slug) values.slug = slug;
+  if (id) values.id = id;
+  for (const part of ["year", "month", "day"]) {
+    const value = datePart(item.publishedAt, part);
+    if (value) values[part] = value;
+  }
+  return values;
+}
+export function buildContentPath(pattern, item) {
+  const values = contentRouteValues(item);
+  const parts = [];
+  for (const segment of contentRouteSegments(pattern)) {
+    if ("text" in segment) {
+      parts.push(segment.text);
+      continue;
+    }
+    const value = values[segment.param];
+    if (!value) return null;
+    parts.push(encodeURIComponent(value));
+  }
+  return `/${parts.join("/")}`;
+}
+export function contentItemPath(entry, item, locale) {
+  if (!isRoutedContent(entry)) return null;
+  const pattern = contentRoutePattern(entry.route, locale);
+  return pattern ? buildContentPath(pattern, item) : null;
+}
+export function contentItemPaths(entry, item, locales) {
+  const paths = [];
+  for (const locale of locales) {
+    const path = contentItemPath(entry, item, locale);
+    if (path) paths.push({ locale, path });
+  }
+  return paths;
+}
+export function normalizeContentPath(path) {
+  const bare = path.replace(/[?#].*$/, "");
+  const segments = bare.split("/").filter(Boolean);
+  return `/${segments.join("/")}`;
+}
+function decodeSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return null;
+  }
+}
+export function matchContentPattern(pattern, path) {
+  const segments = contentRouteSegments(pattern);
+  const parts = normalizeContentPath(path).split("/").filter(Boolean);
+  if (parts.length !== segments.length) return null;
+  const params = {};
+  for (const [index, segment] of segments.entries()) {
+    const part = decodeSegment(parts[index]);
+    if (part === null) return null;
+    if ("text" in segment) {
+      if (part !== segment.text) return null;
+      continue;
+    }
+    if (!PARAM_VALUES[segment.param].test(part)) return null;
+    params[segment.param] = part;
+  }
+  return params;
+}
+export function contentPathParamsMatch(params, item) {
+  const values = contentRouteValues(item);
+  return Object.entries(params).every(
+    ([param, value]) => values[param] === value
+  );
+}
+export function matchContentPath(config, path, locale) {
+  const matches = [];
+  for (const [name, entry] of Object.entries(config)) {
+    if (!isRoutedContent(entry)) continue;
+    const pattern = contentRoutePattern(entry.route, locale);
+    if (!pattern) continue;
+    const params = matchContentPattern(pattern, path);
+    if (params) matches.push({ entry: name, pattern, params });
+  }
+  return matches.sort((a, b) => compareContentRoutes(a.pattern, b.pattern));
+}
+function mostSpecificRoute(entry) {
+  return contentRoutePatterns(entry.route).sort(compareContentRoutes)[0] ?? "";
+}
+export function routedContentNames(config) {
+  return Object.entries(config).filter(([, entry]) => isRoutedContent(entry)).sort(([, a], [, b]) => compareContentRoutes(mostSpecificRoute(a), mostSpecificRoute(b))).map(([name]) => name);
+}
+export function contentRouteConfigErrors(at, route, i18n) {
+  if (typeof route === "string") return contentRouteErrors(route).map((e) => `${at}: route ${e}`);
+  if (!route || typeof route !== "object" || Array.isArray(route))
+    return [`${at}: route must be a path pattern or a map of locale to path pattern`];
+  const { locales } = i18n;
+  if (!locales.length)
+    return [`${at}: a per-locale route needs cms.i18n locales, use a single pattern instead`];
+  const errors = [];
+  const map = route;
+  for (const [locale, pattern] of Object.entries(map)) {
+    if (!locales.includes(locale))
+      errors.push(`${at}: route names the unknown locale '${locale}'`);
+    errors.push(...contentRouteErrors(pattern).map((e) => `${at}: route.${locale} ${e}`));
+  }
+  const missing = locales.filter((locale) => !Object.hasOwn(map, locale));
+  if (missing.length)
+    errors.push(`${at}: route has no pattern for the locale(s) ${missing.join(", ")}`);
+  return errors;
+}
+export function contentRouteClashErrors(config) {
+  const errors = [];
+  const owners = /* @__PURE__ */ new Map();
+  for (const [name, entry] of Object.entries(config)) {
+    if (!isRoutedContent(entry)) continue;
+    const patterns = contentRoutePatterns(entry.route).filter(
+      (pattern) => !contentRouteErrors(pattern).length
+    );
+    for (const shape of new Set(patterns.map(contentRouteShape))) {
+      const pattern = patterns.find((candidate) => contentRouteShape(candidate) === shape);
+      const owner = owners.get(shape);
+      if (owner) {
+        errors.push(
+          `cms.config entry '${name}': route '${pattern}' matches the same paths as '${owner.pattern}' of entry '${owner.entry}'`
+        );
+      } else {
+        owners.set(shape, { entry: name, pattern });
+      }
+    }
+  }
+  return errors;
+}

package/dist/runtime/shared/duplicate.js

@@ -1,10 +1,11 @@
+import { isUniqueValueField } from "./field-options.js";
 import { CONTENT_PUBLISHED_AT_FIELD, isCollectionKind, isTranslatableField } from "./index.js";
 export const DUPLICATE_TITLE_SUFFIX = " (copy)";
 const DUPLICATE_TOKEN_LENGTH = 4;
 const DUPLICATE_TOKEN_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
 const COPIED_SLUG = new RegExp(`-copy-[a-z0-9]{${DUPLICATE_TOKEN_LENGTH}}$`);
 export function isUniqueField(field) {
-  return field.type === "slug" || field.type === "relation" && field.cardinality === "one-to-one";
+  return field.type === "slug" || field.type === "relation" && field.cardinality === "one-to-one" || isUniqueValueField(field);
 }
 export function uniqueFieldKeys(entry) {
   return Object.keys(entry.fields).filter((key) => isUniqueField(entry.fields[key]));

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

@@ -0,0 +1,18 @@
+export declare const CMS_EDITOR_PANES: {
+    readonly left: {
+        readonly min: 260;
+        readonly max: 440;
+        readonly initial: 288;
+    };
+    readonly right: {
+        readonly min: 300;
+        readonly max: 560;
+        readonly initial: 360;
+    };
+};
+export declare const CMS_PREVIEW_DEVICE_WIDTHS: {
+    readonly desktop: null;
+    readonly tablet: 768;
+    readonly mobile: 390;
+};
+export type CmsPreviewDevice = keyof typeof CMS_PREVIEW_DEVICE_WIDTHS;

package/dist/runtime/shared/editor-layout.js

@@ -0,0 +1,9 @@
+export const CMS_EDITOR_PANES = {
+  left: { min: 260, max: 440, initial: 288 },
+  right: { min: 300, max: 560, initial: 360 }
+};
+export const CMS_PREVIEW_DEVICE_WIDTHS = {
+  desktop: null,
+  tablet: 768,
+  mobile: 390
+};