@xleddyl/nuxt-cms 0.9.4 → 0.10.1

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
+};

package/dist/runtime/shared/field-options.d.ts

@@ -0,0 +1,21 @@
+import type { CmsI18n, FieldConfig } from './index.js';
+export declare const DEFAULT_TODAY = "today";
+export declare const DEFAULT_NOW = "now";
+export declare const DEFAULT_FIELD_TYPES: string[];
+export declare const UNIQUE_FIELD_TYPES: string[];
+export declare const IMMUTABLE_FIELD_TYPES: string[];
+export interface FieldDefaultOptions {
+    now?: Date;
+    local?: boolean;
+}
+export declare function hasFieldDefault(field: FieldConfig): boolean;
+export declare function resolveFieldDefault(field: FieldConfig, i18n: Pick<CmsI18n, 'locales' | 'defaultLocale'>, options?: FieldDefaultOptions): unknown;
+export declare function entryDefaults(fields: Record<string, FieldConfig>, i18n: Pick<CmsI18n, 'locales' | 'defaultLocale'>, options?: FieldDefaultOptions): Record<string, unknown>;
+export declare function withEntryDefaults(fields: Record<string, FieldConfig>, values: Record<string, unknown>, i18n: Pick<CmsI18n, 'locales' | 'defaultLocale'>, options?: FieldDefaultOptions): Record<string, unknown>;
+export declare function isUniqueValueField(field: FieldConfig): boolean;
+export declare function isCaseInsensitiveUnique(field: Pick<FieldConfig, 'type'>): boolean;
+export declare function uniqueCompareValue<T>(field: Pick<FieldConfig, 'type'>, value: T): T | string;
+export declare function isImmutableField(field: FieldConfig): boolean;
+export declare function immutableFieldKeys(fields: Record<string, FieldConfig>): string[];
+export declare function lockedFieldKeys(fields: Record<string, FieldConfig>, saved: Record<string, unknown> | null | undefined): string[];
+export declare function changedImmutableKeys(fields: Record<string, FieldConfig>, saved: Record<string, unknown> | null | undefined, next: Record<string, unknown>): string[];

package/dist/runtime/shared/field-options.js

@@ -0,0 +1,90 @@
+import { isTranslatableField } from "./index.js";
+export const DEFAULT_TODAY = "today";
+export const DEFAULT_NOW = "now";
+export const DEFAULT_FIELD_TYPES = [
+  "text",
+  "richtext",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "email",
+  "select",
+  "tags"
+];
+export const UNIQUE_FIELD_TYPES = ["text", "email", "number"];
+export const IMMUTABLE_FIELD_TYPES = [
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "email",
+  "slug",
+  "select",
+  "relation"
+];
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function todayOf(now, local) {
+  if (!local) return now.toISOString().slice(0, 10);
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+export function hasFieldDefault(field) {
+  return field.default !== void 0 && DEFAULT_FIELD_TYPES.includes(field.type);
+}
+export function resolveFieldDefault(field, i18n, options = {}) {
+  const value = field.default;
+  if (value === void 0 || value === null) return null;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  if (field.type === "date" && value === DEFAULT_TODAY) return todayOf(now, !!options.local);
+  if (field.type === "datetime" && value === DEFAULT_NOW) return now.toISOString();
+  if (Array.isArray(value)) return [...value];
+  if (isTranslatableField(field) && i18n.locales.length) return { [i18n.defaultLocale]: value };
+  return value;
+}
+export function entryDefaults(fields, i18n, options = {}) {
+  return Object.fromEntries(
+    Object.entries(fields).filter(([, field]) => hasFieldDefault(field)).map(([key, field]) => [key, resolveFieldDefault(field, i18n, options)])
+  );
+}
+export function withEntryDefaults(fields, values, i18n, options = {}) {
+  const filled = { ...values };
+  for (const [key, value] of Object.entries(entryDefaults(fields, i18n, options))) {
+    if (!Object.hasOwn(filled, key)) filled[key] = value;
+  }
+  return filled;
+}
+export function isUniqueValueField(field) {
+  return !!field.unique && UNIQUE_FIELD_TYPES.includes(field.type) && !isTranslatableField(field);
+}
+export function isCaseInsensitiveUnique(field) {
+  return field.type === "email";
+}
+export function uniqueCompareValue(field, value) {
+  return isCaseInsensitiveUnique(field) && typeof value === "string" ? value.toLowerCase() : value;
+}
+export function isImmutableField(field) {
+  return !!field.immutable && IMMUTABLE_FIELD_TYPES.includes(field.type) && !isTranslatableField(field) && !(field.type === "relation" && field.cardinality === "many-to-many");
+}
+export function immutableFieldKeys(fields) {
+  return Object.keys(fields).filter((key) => isImmutableField(fields[key]));
+}
+function isBlank(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return !value.trim();
+  return Array.isArray(value) && !value.length;
+}
+export function lockedFieldKeys(fields, saved) {
+  if (!saved) return [];
+  return immutableFieldKeys(fields).filter((key) => !isBlank(saved[key]));
+}
+function comparable(value) {
+  return JSON.stringify(isBlank(value) ? null : value);
+}
+export function changedImmutableKeys(fields, saved, next) {
+  return lockedFieldKeys(fields, saved).filter(
+    (key) => Object.hasOwn(next, key) && comparable(saved[key]) !== comparable(next[key])
+  );
+}

package/dist/runtime/shared/graphql-sdl.d.ts

@@ -2,4 +2,5 @@ import type { CmsConfig } from './index.js';
 import { blockTypeName, blocksFieldTypeName, typeName } from './index.js';
 export { blockTypeName, blocksFieldTypeName, typeName };
 export declare const LIST_FILTER = "StringListFilter";
+export declare const SITE_QUERY_FIELD = "cmsSite";
 export declare function renderGraphqlSdl(config: CmsConfig): string;