@xleddyl/nuxt-cms 0.9.3 → 0.10.0

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

@@ -1,8 +1,10 @@
 import type { PgTable } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { CmsShowIf } from './conditions.js';
+import type { CmsContentRoute } from './content-routes.js';
 import type { CmsLayoutBlock, CmsListInput } from './layout.js';
 export type CmsTable = SQLiteTable | PgTable;
-export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'slug' | 'select' | 'tags' | 'json' | 'media' | 'relation' | 'blocks';
+export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'slug' | 'select' | 'tags' | 'json' | 'media' | 'relation' | 'link' | 'blocks';
 export interface CmsI18n {
     locales: string[];
     defaultLocale: string;
@@ -42,6 +44,8 @@ export interface MediaItem {
     size: number | null;
     width: number | null;
     height: number | null;
+    focalX: number | null;
+    focalY: number | null;
     createdAt: string | null;
     type: MediaType;
     url: string | null;
@@ -52,10 +56,11 @@ export interface MediaSourceInfo {
     root: string;
     builtAt: string | null;
 }
+export type MediaUsageKind = CmsEntryKind | 'site';
 export interface MediaUsage {
     collection: string;
     label: string;
-    kind: CmsEntryKind;
+    kind: MediaUsageKind;
     id: string | null;
     title: string | null;
     field: string;
@@ -63,23 +68,32 @@ export interface MediaUsage {
 export interface MediaUsageEntry {
     collection: string;
     label: string;
-    kind: CmsEntryKind;
+    kind: MediaUsageKind;
     id: string | null;
     title: string | null;
     fields: string[];
 }
 export declare function groupMediaUsage(usage: MediaUsage[]): MediaUsageEntry[];
+export interface MediaUsageReport {
+    usage: Record<string, MediaUsage[]>;
+    hidden: Record<string, number>;
+}
 export interface MediaUsageGroup {
     key: string;
     entries: MediaUsageEntry[];
+    hidden: number;
 }
-export declare function mediaUsageGroups(usage: Record<string, MediaUsage[]>, keys: string[]): MediaUsageGroup[];
+export declare function mediaUsageGroups(usage: Record<string, MediaUsage[]>, keys: string[], hidden?: Record<string, number>): MediaUsageGroup[];
+export declare function otherEntriesLabel(count: number): string;
 export interface BlockConfig {
     label: string;
     component?: string;
     icon?: string;
     description?: string;
+    group?: string;
+    tags?: readonly string[];
     fields: Record<string, FieldConfig>;
+    layout?: CmsLayoutBlock[];
     validate?: CmsBlockValidate;
 }
 export type CmsValidationLevel = 'error' | 'warning';
@@ -95,6 +109,7 @@ export interface CmsValidateContext {
 }
 export interface CmsBlockValidateContext extends CmsValidateContext {
     index: number;
+    blockPath: string;
 }
 export type CmsValidateResult = readonly CmsValidationIssue[] | null | undefined | void;
 export type CmsValidate = (values: Record<string, unknown>, context: CmsValidateContext) => CmsValidateResult;
@@ -118,12 +133,6 @@ export declare function selectOptionValues(field: Pick<FieldConfig, 'options'>):
 export declare function selectOptionLabel(field: Pick<FieldConfig, 'options'>, value: unknown): string;
 export declare function selectValuesMatching(field: Pick<FieldConfig, 'options'>, term: string): string[];
 export declare function selectDisplayValue(field: Pick<FieldConfig, 'options'>, value: unknown): string;
-export type ConditionValue = string | number | boolean;
-export interface FieldCondition {
-    field: string;
-    eq?: ConditionValue;
-    in?: ConditionValue[];
-}
 export interface CmsTab {
     id: string;
     label: string;
@@ -136,6 +145,9 @@ export interface FieldConfig {
     tab?: string;
     required?: boolean;
     private?: boolean;
+    default?: unknown;
+    unique?: boolean;
+    immutable?: boolean;
     textarea?: boolean;
     integer?: boolean;
     translatable?: boolean;
@@ -150,16 +162,18 @@ export interface FieldConfig {
     accept?: string[];
     mobile?: boolean;
     mobileOf?: string;
-    to?: string;
+    to?: string | readonly string[];
+    external?: boolean;
+    withLabel?: boolean;
     cardinality?: 'many-to-one' | 'one-to-one' | 'many-to-many';
     onDelete?: 'set null' | 'cascade' | 'restrict';
-    showIf?: FieldCondition | FieldCondition[];
+    showIf?: CmsShowIf;
 }
+export declare function relationTarget(field: Pick<FieldConfig, 'to'>): string;
 export declare function isPrivateField(field: FieldConfig): boolean;
 export declare function isRequiredField(field: FieldConfig): boolean;
-export declare function fieldConditions(field: FieldConfig): FieldCondition[];
-export declare function isFieldVisible(field: FieldConfig, values: Record<string, unknown> | null | undefined): boolean;
 export declare function isTranslatableField(field: FieldConfig): boolean;
+export declare function isLocalizedLinkField(field: FieldConfig): boolean;
 export declare function isTranslatableMediaField(field: FieldConfig): boolean;
 export declare function defaultLocaleValue(value: unknown, defaultLocale: string): string | null;
 export declare function decodeTranslatableValue(value: unknown, defaultLocale: string): Record<string, string> | null;
@@ -215,6 +229,7 @@ export interface CmsEntry {
     list?: CmsListInput;
     blocks?: Record<string, BlockConfig>;
     preview?: CmsPreviewOptions;
+    route?: CmsContentRoute;
     declared?: CmsContentDeclared;
     validate?: CmsValidate;
 }
@@ -233,12 +248,14 @@ export declare const CONTENT_TITLE_FIELD = "title";
 export declare const CONTENT_SLUG_FIELD = "slug";
 export declare const CONTENT_PUBLISHED_AT_FIELD = "publishedAt";
 export declare const CONTENT_BODY_FIELD = "body";
-export declare const CONTENT_SYSTEM_FIELDS: readonly ["title", "slug", "publishedAt", "excerpt", "cover", "body", "seoTitle", "seoDescription", "seoImage"];
+export declare const CONTENT_SYSTEM_FIELDS: readonly ["title", "slug", "publishedAt", "excerpt", "cover", "body", "seoTitle", "seoDescription", "seoImage", "seoNoindex"];
+export declare const CONTENT_NOINDEX_FIELD = "seoNoindex";
 export type CmsContentSystemField = (typeof CONTENT_SYSTEM_FIELDS)[number];
 export declare const CONTENT_LIST_COLUMNS: string[];
 export declare function isContentEntry(entry: Pick<CmsEntry, 'kind'>): boolean;
 export declare function isCollectionKind(entry: Pick<CmsEntry, 'kind'>): boolean;
 export declare function normalizeContentEntries<T extends Record<string, unknown>>(config: T, i18n?: Pick<CmsI18n, 'locales'>): T;
+export declare function boundBlockNesting<T extends Record<string, unknown>>(config: T): T;
 export declare function normalizeCmsConfig<T extends Record<string, unknown>>(config: T, i18n?: Pick<CmsI18n, 'locales'>): T;
 export declare function slugSourceValue(source: FieldConfig | undefined, value: unknown, defaultLocale: string): string | null;
 export declare function isScheduledContent(row: Record<string, unknown> | null | undefined, now?: Date): boolean;
@@ -265,8 +282,9 @@ export declare function pageMediaTableName(name: string): string;
 type EntryLike = Pick<CmsEntry, 'fields'> & Partial<Pick<CmsEntry, 'kind' | 'overrides'>>;
 export declare function entryFieldsFor(entry: EntryLike, path?: string): Record<string, FieldConfig>;
 export declare function typeName(name: string): string;
-export declare function blocksFieldTypeName(entryName: string, fieldKey: string): string;
-export declare function blockTypeName(entryName: string, fieldKey: string, blockName: string): string;
+export declare function blocksTypePrefix(entryName: string, schemaPath: string | readonly string[]): string;
+export declare function blocksFieldTypeName(entryName: string, schemaPath: string | readonly string[]): string;
+export declare function blockTypeName(entryName: string, schemaPath: string | readonly string[], blockName: string): string;
 interface FieldInputBase {
     label: string;
     description?: string;
@@ -274,46 +292,70 @@ interface FieldInputBase {
     required?: boolean;
     private?: boolean;
     tab?: string;
-    showIf?: FieldCondition | FieldCondition[];
+    showIf?: CmsShowIf;
 }
 export interface TextFieldInput extends FieldInputBase {
     type: 'text';
     textarea?: boolean;
     translatable?: boolean;
+    default?: string;
+    min?: number;
+    max?: number;
+    unique?: boolean;
+    immutable?: boolean;
 }
 export interface RichtextFieldInput extends FieldInputBase {
     type: 'richtext';
     translatable?: boolean;
+    default?: string;
 }
 export interface NumberFieldInput extends FieldInputBase {
     type: 'number';
     integer?: boolean;
+    default?: number;
+    min?: number;
+    max?: number;
+    unique?: boolean;
+    immutable?: boolean;
 }
 export interface BooleanFieldInput extends FieldInputBase {
     type: 'boolean';
+    default?: boolean;
+    immutable?: boolean;
 }
 export interface DateFieldInput extends FieldInputBase {
     type: 'date';
+    default?: 'today' | (string & {});
+    immutable?: boolean;
 }
 export interface DateTimeFieldInput extends FieldInputBase {
     type: 'datetime';
+    default?: 'now' | (string & {});
+    immutable?: boolean;
 }
 export interface EmailFieldInput extends FieldInputBase {
     type: 'email';
+    default?: string;
+    unique?: boolean;
+    immutable?: boolean;
 }
 export interface SlugFieldInput extends FieldInputBase {
     type: 'slug';
     from: string;
+    immutable?: boolean;
 }
 export interface SelectFieldInput extends FieldInputBase {
     type: 'select';
     options: readonly SelectOptionInput[];
     multiple?: boolean;
+    default?: string | readonly string[];
+    immutable?: boolean;
 }
 export interface TagsFieldInput extends FieldInputBase {
     type: 'tags';
     max?: number;
     suggestions?: boolean;
+    default?: readonly string[];
 }
 export interface JsonFieldInput extends FieldInputBase {
     type: 'json';
@@ -330,15 +372,32 @@ export interface RelationFieldInput extends FieldInputBase {
     to: string;
     cardinality?: 'many-to-one' | 'one-to-one' | 'many-to-many';
     onDelete?: 'set null' | 'cascade' | 'restrict';
+    immutable?: boolean;
+}
+export interface LinkFieldInput extends FieldInputBase {
+    type: 'link';
+    to?: readonly string[];
+    external?: boolean;
+    withLabel?: boolean;
+    translatable?: boolean;
 }
-type BlockField<T> = Omit<T, 'private' | 'showIf' | 'tab'>;
-export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<DateTimeFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'>;
+type BlockField<T> = Omit<T, 'private' | 'tab' | 'default' | 'unique' | 'immutable'>;
+export interface NestedBlocksFieldInput extends Omit<FieldInputBase, 'private' | 'tab'> {
+    type: 'blocks';
+    blocks: Record<string, BlockInput>;
+    min?: number;
+    max?: number;
+}
+export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<DateTimeFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | BlockField<LinkFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'> | NestedBlocksFieldInput;
 export interface BlockInput {
     label: string;
     component?: string;
     icon?: string;
     description?: string;
+    group?: string;
+    tags?: readonly string[];
     fields: Record<string, BlockFieldInput>;
+    layout?: CmsLayoutBlock[];
     validate?: CmsBlockValidate;
 }
 export interface BlocksFieldInput extends FieldInputBase {
@@ -347,7 +406,7 @@ export interface BlocksFieldInput extends FieldInputBase {
     min?: number;
     max?: number;
 }
-export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | DateTimeFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | TagsFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
+export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | DateTimeFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | TagsFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | LinkFieldInput | BlocksFieldInput;
 interface CmsEntryInputBase {
     id: string;
     label: string;
@@ -391,6 +450,7 @@ export interface CmsContentInput {
     layout?: CmsLayoutBlock[];
     list?: CmsListInput;
     preview?: CmsPreviewOptions;
+    route?: string | Readonly<Record<string, string>>;
     validate?: CmsValidate;
     titleField?: never;
     drafts?: never;
@@ -399,5 +459,14 @@ export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput |
 export type CmsConfigInput = Record<string, CmsEntryInput>;
 export declare function defineCmsConfig<T extends CmsConfigInput>(config: T): T;
 export declare function defineCmsBlocks<T extends Record<string, BlockInput>>(blocks: T): T;
+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';
+export type { CmsAccess, CmsRole, CmsRoleInput, CmsRoleOption, CmsRoles, CmsRolesInput, } from './roles.js';

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