@xleddyl/nuxt-cms 0.9.3 → 0.10.0

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;

package/dist/runtime/shared/graphql-sdl.js

@@ -6,8 +6,10 @@ import {
   isMultiValueField,
   isPrivateField,
   isRequiredField,
+  isRoutedContent,
   isTranslatableField,
   pageAllFields,
+  relationTarget,
   typeName
 } from "./index.js";
 export { blockTypeName, blocksFieldTypeName, typeName };
@@ -32,6 +34,7 @@ function filterScalarFor(field) {
   if (isMultiValueField(field)) return LIST_FILTER;
   switch (field.type) {
     case "json":
+    case "link":
       return null;
     case "blocks":
       return null;
@@ -54,12 +57,13 @@ function filterableKeys(entry) {
 }
 function fieldSdl(config, entryName, key, field) {
   if (field.type === "relation") {
-    const target = typeName(field.to);
+    const target = typeName(relationTarget(field));
     if (field.cardinality === "many-to-many") return `  ${key}: [${target}!]!`;
-    const nonNull = isRequiredField(field) && !config[field.to]?.drafts;
+    const nonNull = isRequiredField(field) && !config[relationTarget(field)]?.drafts;
     return `  ${key}: ${target}${nonNull ? "!" : ""}`;
   }
   if (field.type === "media") return `  ${key}: CmsMedia`;
+  if (field.type === "link") return `  ${key}: CmsLink`;
   if (field.type === "tags" || field.type === "select" && field.multiple)
     return `  ${key}: [String!]!`;
   if (field.type === "blocks")
@@ -69,6 +73,7 @@ function fieldSdl(config, entryName, key, field) {
 function entrySdl(config, name, entry) {
   const lines = ["  id: ID!"];
   if (entry.kind === "page") lines.push(`  ${PAGE_PATH_FIELD}: String!`);
+  if (isRoutedContent(entry)) lines.push("  path: String!", "  paths: [CmsLocalePath!]!");
   for (const [key, field] of Object.entries(entryFields(entry))) {
     if (isPrivateField(field)) continue;
     lines.push(fieldSdl(config, name, key, field));
@@ -79,42 +84,58 @@ function entrySdl(config, name, entry) {
 ${lines.join("\n")}
 }`;
 }
-function blockFieldSdl(field) {
-  return field.type === "media" ? "CmsMedia" : scalarFor(field);
+function blockFieldSdl(name, schemaPath, blockName, key, field) {
+  if (field.type === "media") return "CmsMedia";
+  if (field.type === "link") return "CmsLink";
+  if (field.type === "blocks")
+    return `[${blocksFieldTypeName(name, [...schemaPath, blockName, key])}!]`;
+  return scalarFor(field);
 }
-function sharedBlockFieldsSdl(field) {
-  const blocks = Object.values(field.blocks ?? {});
+function sharedBlockFieldsSdl(name, schemaPath, field) {
+  const blocks = Object.entries(field.blocks ?? {});
   const first = blocks[0];
   if (!first) return [];
   const lines = [];
-  for (const key of Object.keys(first.fields)) {
-    const rendered = blocks.map((block) => block.fields[key]);
-    if (rendered.some((blockField) => !blockField)) continue;
-    const types = rendered.map((blockField) => blockFieldSdl(blockField));
+  for (const key of Object.keys(first[1].fields)) {
+    if (blocks.some(([, block]) => !block.fields[key])) continue;
+    const types = blocks.map(
+      ([blockName, block]) => blockFieldSdl(name, schemaPath, blockName, key, block.fields[key])
+    );
     if (types.some((type) => type !== types[0])) continue;
     lines.push(`  ${key}: ${types[0]}`);
   }
   return lines;
 }
-function blocksSdl(name, key, field) {
+function blocksSdl(name, schemaPath, field) {
   const blocks = Object.entries(field.blocks ?? {});
   if (!blocks.length) return [];
-  const interfaceName = blocksFieldTypeName(name, key);
-  const shared = ["  type: String!", ...sharedBlockFieldsSdl(field)];
+  const interfaceName = blocksFieldTypeName(name, schemaPath);
+  const shared = ["  type: String!", ...sharedBlockFieldsSdl(name, schemaPath, field)];
   const defs = [`interface ${interfaceName} {
 ${shared.join("\n")}
 }`];
+  const nested = [];
   for (const [blockName, block] of blocks) {
     const lines = ["  type: String!"];
     for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
-      lines.push(`  ${blockFieldKey}: ${blockFieldSdl(blockField)}`);
+      lines.push(
+        `  ${blockFieldKey}: ${blockFieldSdl(
+          name,
+          schemaPath,
+          blockName,
+          blockFieldKey,
+          blockField
+        )}`
+      );
+      if (blockField.type === "blocks")
+        nested.push(...blocksSdl(name, [...schemaPath, blockName, blockFieldKey], blockField));
     }
-    const gqlType = blockTypeName(name, key, blockName);
+    const gqlType = blockTypeName(name, schemaPath, blockName);
     defs.push(`type ${gqlType} implements ${interfaceName} {
 ${lines.join("\n")}
 }`);
   }
-  return defs;
+  return [...defs, ...nested];
 }
 function filterSdl(name, entry) {
   const gqlType = typeName(name);
@@ -147,17 +168,22 @@ const COMMON_SDL = [
   isEmpty: Boolean
 }`,
   "enum CmsMediaType {\n  image\n  video\n  file\n}",
-  "type CmsMedia {\n  key: String!\n  url: String\n  type: CmsMediaType!\n  alt: String\n  folder: String\n  mime: String\n  size: Int\n  width: Int\n  height: Int\n}"
+  "type CmsMedia {\n  key: String!\n  url: String\n  type: CmsMediaType!\n  alt: String\n  folder: String\n  mime: String\n  size: Int\n  width: Int\n  height: Int\n  focalX: Float\n  focalY: Float\n}",
+  "type CmsLink {\n  href: String\n  label: String\n  newTab: Boolean!\n  external: Boolean!\n  entry: String\n  id: String\n}",
+  "type CmsSite {\n  name: String\n  titleTemplate: String\n  description: String\n  image: CmsMedia\n  hidden: Boolean!\n}"
 ];
+export const SITE_QUERY_FIELD = "cmsSite";
 export function renderGraphqlSdl(config) {
-  const queryLines = [];
+  const queryLines = [`  ${SITE_QUERY_FIELD}(locale: String): CmsSite!`];
   const types = [];
+  if (Object.values(config).some(isRoutedContent))
+    types.push("type CmsLocalePath {\n  locale: String!\n  path: String!\n}");
   for (const [name, entry] of Object.entries(config)) {
     const gqlType = typeName(name);
     types.push(entrySdl(config, name, entry));
     for (const [key, field] of Object.entries(entryFields(entry))) {
       if (field.type === "blocks" && !isPrivateField(field))
-        types.push(...blocksSdl(name, key, field));
+        types.push(...blocksSdl(name, [key], field));
     }
     if (entry.kind === "single") {
       queryLines.push(`  ${name}(locale: String): ${gqlType}`);
@@ -176,12 +202,10 @@ export function renderGraphqlSdl(config) {
     queryLines.push(`  ${name}Count(filters: ${gqlType}Filters): Int!`);
     if (entry.kind === "content")
       queryLines.push(`  ${name}BySlug(slug: String!, locale: String): ${gqlType}`);
+    if (isRoutedContent(entry))
+      queryLines.push(`  ${name}ByPath(path: String!, locale: String): ${gqlType}`);
   }
-  return [
-    ...COMMON_SDL,
-    ...types,
-    `type Query {
-${queryLines.length ? queryLines.join("\n") : "  _empty: Boolean"}
-}`
-  ].join("\n\n");
+  return [...COMMON_SDL, ...types, `type Query {
+${queryLines.join("\n")}
+}`].join("\n\n");
 }

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

@@ -0,0 +1,27 @@
+export declare const CMS_HISTORY_MAX = 100;
+export declare const CMS_HISTORY_DELAY = 400;
+export interface CmsHistoryStatus {
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export interface CmsHistoryOptions<S = number | null> {
+    state: () => Record<string, unknown>;
+    selected: () => S;
+    restore: (state: Record<string, unknown>, selected: S) => void;
+    omit?: readonly string[];
+    max?: number;
+    delay?: number;
+    onUpdate?: (status: CmsHistoryStatus) => void;
+}
+export declare function createCmsHistory<S = number | null>(options: CmsHistoryOptions<S>): {
+    change: (key?: string, hold?: boolean) => void;
+    release: () => void;
+    observe: () => void;
+    undo: () => boolean;
+    redo: () => boolean;
+    reset: () => void;
+    flush: () => void;
+    dispose: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+};

package/dist/runtime/shared/history.js

@@ -0,0 +1,123 @@
+export const CMS_HISTORY_MAX = 100;
+export const CMS_HISTORY_DELAY = 400;
+export function createCmsHistory(options) {
+  const max = options.max ?? CMS_HISTORY_MAX;
+  const delay = options.delay ?? CMS_HISTORY_DELAY;
+  const omitted = new Set(options.omit ?? []);
+  const status = { canUndo: false, canRedo: false };
+  let entries = [];
+  let index = 0;
+  let intent = null;
+  let timer;
+  function serialize() {
+    const state = options.state();
+    return JSON.stringify(
+      Object.fromEntries(Object.entries(state).filter(([key]) => !omitted.has(key)))
+    );
+  }
+  function refresh() {
+    const pending = !!intent && serialize() !== entries[index].json;
+    const canUndo = index > 0 || pending;
+    const canRedo = !pending && index < entries.length - 1;
+    if (canUndo === status.canUndo && canRedo === status.canRedo) return;
+    status.canUndo = canUndo;
+    status.canRedo = canRedo;
+    options.onUpdate?.({ ...status });
+  }
+  function clearTimer() {
+    if (timer === void 0) return;
+    clearTimeout(timer);
+    timer = void 0;
+  }
+  function reset() {
+    clearTimer();
+    intent = null;
+    const selected = options.selected();
+    entries = [{ json: serialize(), selected, before: selected }];
+    index = 0;
+    refresh();
+  }
+  function flush() {
+    clearTimer();
+    const current = intent;
+    intent = null;
+    if (!current) return;
+    const json = serialize();
+    if (json !== entries[index].json) {
+      entries = entries.slice(0, index + 1);
+      entries.push({ json, selected: options.selected(), before: current.before });
+      if (entries.length > max + 1) entries = entries.slice(entries.length - max - 1);
+      index = entries.length - 1;
+    }
+    refresh();
+  }
+  function change(key, hold = false) {
+    const coalesce = key ?? null;
+    if (intent && (coalesce === null || intent.key !== coalesce)) flush();
+    if (!intent) intent = { key: coalesce, before: options.selected(), held: false };
+    if (hold && coalesce !== null) {
+      intent.held = true;
+      clearTimer();
+    }
+  }
+  function release() {
+    if (intent?.held) flush();
+  }
+  function observe() {
+    const json = serialize();
+    const entry = entries[index];
+    if (json === entry.json) {
+      if (intent && timer === void 0 && !intent.held) intent = null;
+      refresh();
+      return;
+    }
+    if (!intent) {
+      entry.json = json;
+      return;
+    }
+    if (intent.key === null) {
+      flush();
+      return;
+    }
+    if (intent.held) {
+      refresh();
+      return;
+    }
+    clearTimer();
+    timer = setTimeout(flush, delay);
+    refresh();
+  }
+  function apply(entry, selected) {
+    const values = JSON.parse(entry.json);
+    options.restore({ ...options.state(), ...values }, selected);
+    refresh();
+  }
+  function undo() {
+    flush();
+    if (index === 0) return false;
+    const from = entries[index];
+    index--;
+    apply(entries[index], from.before);
+    return true;
+  }
+  function redo() {
+    flush();
+    if (index >= entries.length - 1) return false;
+    index++;
+    apply(entries[index], entries[index].selected);
+    return true;
+  }
+  reset();
+  return {
+    change,
+    release,
+    observe,
+    undo,
+    redo,
+    reset,
+    flush,
+    dispose: clearTimer,
+    canUndo: () => status.canUndo,
+    canRedo: () => status.canRedo
+  };
+}

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

@@ -0,0 +1,45 @@
+import type { H3Event } from 'h3';
+import type { CmsEntryKind } from './index.js';
+import type { CmsUserRole } from './users.js';
+export declare const CMS_ENTRY_CHANGE_HOOK = "cms:entry:change";
+export declare const CMS_MEDIA_CHANGE_HOOK = "cms:media:change";
+export declare const CMS_ENTRY_ACTIONS: readonly ["create", "update", "delete", "publish", "unpublish", "import"];
+export declare const CMS_MEDIA_ACTIONS: readonly ["upload", "update", "move", "delete", "folder-create", "folder-rename", "folder-delete"];
+export type CmsEntryAction = (typeof CMS_ENTRY_ACTIONS)[number];
+export type CmsMediaAction = (typeof CMS_MEDIA_ACTIONS)[number];
+export type CmsEntryStatus = 'draft' | 'published';
+export interface CmsHookUser {
+    id: string | null;
+    email: string;
+    name: string | null;
+    role: CmsUserRole;
+}
+export interface CmsEntryChange {
+    entry: string;
+    kind: CmsEntryKind;
+    action: CmsEntryAction;
+    ids: string[];
+    path: string | null;
+    status: CmsEntryStatus | null;
+    item: Record<string, unknown> | null;
+    user: CmsHookUser;
+    at: string;
+}
+export interface CmsMediaChange {
+    action: CmsMediaAction;
+    keys: string[];
+    folder: string | null;
+    from: string | null;
+    user: CmsHookUser;
+    at: string;
+}
+export interface CmsHookContext {
+    event: H3Event;
+}
+export interface CmsRuntimeHooks {
+    [CMS_ENTRY_CHANGE_HOOK]: (change: CmsEntryChange, context: CmsHookContext) => void | Promise<void>;
+    [CMS_MEDIA_CHANGE_HOOK]: (change: CmsMediaChange, context: CmsHookContext) => void | Promise<void>;
+}
+export type CmsHookName = keyof CmsRuntimeHooks;
+export declare function entryStatus(value: unknown): CmsEntryStatus | null;
+export declare function entryWriteAction(created: boolean, previous: CmsEntryStatus | null, next: CmsEntryStatus | null): CmsEntryAction;

package/dist/runtime/shared/hooks.js

@@ -0,0 +1,28 @@
+export const CMS_ENTRY_CHANGE_HOOK = "cms:entry:change";
+export const CMS_MEDIA_CHANGE_HOOK = "cms:media:change";
+export const CMS_ENTRY_ACTIONS = [
+  "create",
+  "update",
+  "delete",
+  "publish",
+  "unpublish",
+  "import"
+];
+export const CMS_MEDIA_ACTIONS = [
+  "upload",
+  "update",
+  "move",
+  "delete",
+  "folder-create",
+  "folder-rename",
+  "folder-delete"
+];
+export function entryStatus(value) {
+  return value === "draft" || value === "published" ? value : null;
+}
+export function entryWriteAction(created, previous, next) {
+  if (created) return "create";
+  if (previous !== "published" && next === "published") return "publish";
+  if (previous === "published" && next === "draft") return "unpublish";
+  return "update";
+}