@aduptive/strapi-blockscene 2.0.0-alpha.14 → 2.0.0-alpha.15

package/dist/server.cjs

@@ -4,6 +4,223 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 
+// server/text-template.js
+var require_text_template = __commonJS({
+  "server/text-template.js"(exports2, module2) {
+    "use strict";
+    var CUSTOM_FIELD = "plugin::blockscene.text-template";
+    var TAGS = ["h1", "h2", "h3", "h4", "h5", "h6", "p"];
+    var ROLES = ["eyebrow", "title", "description", "body"];
+    var MODIFIERS = ["uppercase", "lowercase", "underline"];
+    var ID = /^[a-z][a-z0-9_-]{0,47}$/;
+    var TOKEN = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
+    var MAX_ENTRIES = 24;
+    var MAX_TEXT = 5e4;
+    var BINDING = /^[a-z][a-z0-9_-]*(?:::[a-z][a-z0-9_-]*)?(?:\.[A-Za-z_][A-Za-z0-9_-]*)+$/;
+    var plain = (value) => value && typeof value === "object" && !Array.isArray(value);
+    var codePoints = (value) => [...String(value || "")].length;
+    var cleanLineBreaks = (value) => String(value || "").replace(/\r\n?/g, "\n");
+    function templateError(message) {
+      const error = new Error(message);
+      error.name = "ValidationError";
+      throw error;
+    }
+    function validateTemplate(value) {
+      if (!Array.isArray(value) || value.length > MAX_ENTRIES) templateError(`Text template must contain at most ${MAX_ENTRIES} entries`);
+      const ids = /* @__PURE__ */ new Set();
+      return value.map((raw, index) => {
+        if (!plain(raw)) templateError(`Text template entry ${index + 1} must be an object`);
+        const allowed = ["id", "label", "role", "tag", "token", "modifiers", "required", "allowBreaks", "softLines", "maxChars", "demo"];
+        for (const key of Object.keys(raw)) if (!allowed.includes(key)) templateError(`Unknown text template option "${key}"`);
+        if (typeof raw.id !== "string" || !ID.test(raw.id) || ids.has(raw.id)) templateError(`Invalid or duplicate text template id "${raw.id}"`);
+        ids.add(raw.id);
+        if (typeof raw.label !== "string" || !raw.label.trim() || raw.label.length > 80) templateError(`Invalid label for text template entry "${raw.id}"`);
+        if (!ROLES.includes(raw.role)) templateError(`Invalid role for text template entry "${raw.id}"`);
+        if (!TAGS.includes(raw.tag)) templateError(`Invalid Tag HTML for text template entry "${raw.id}"`);
+        if (raw.token !== void 0 && (typeof raw.token !== "string" || raw.token && !TOKEN.test(raw.token))) templateError(`Invalid style token for text template entry "${raw.id}"`);
+        if (!Array.isArray(raw.modifiers) || raw.modifiers.some((item) => !MODIFIERS.includes(item)) || new Set(raw.modifiers).size !== raw.modifiers.length || raw.modifiers.includes("uppercase") && raw.modifiers.includes("lowercase")) templateError(`Invalid modifiers for text template entry "${raw.id}"`);
+        if (typeof raw.required !== "boolean" || typeof raw.allowBreaks !== "boolean") templateError(`Invalid rules for text template entry "${raw.id}"`);
+        if (raw.softLines !== void 0 && (!Number.isInteger(raw.softLines) || raw.softLines < 1 || raw.softLines > 20)) templateError(`Invalid line guidance for text template entry "${raw.id}"`);
+        if (raw.maxChars !== void 0 && (!Number.isInteger(raw.maxChars) || raw.maxChars < 1 || raw.maxChars > MAX_TEXT)) templateError(`Invalid character limit for text template entry "${raw.id}"`);
+        if (typeof raw.demo !== "string" || codePoints(raw.demo) > MAX_TEXT) templateError(`Invalid demo text for text template entry "${raw.id}"`);
+        if (!raw.allowBreaks && /[\r\n]/.test(raw.demo)) templateError(`Demo text for "${raw.id}" cannot contain line breaks`);
+        if (raw.maxChars && codePoints(raw.demo) > raw.maxChars) templateError(`Demo text for "${raw.id}" exceeds its character limit`);
+        return {
+          id: raw.id,
+          label: raw.label.trim(),
+          role: raw.role,
+          tag: raw.tag,
+          token: raw.token || "",
+          modifiers: [...raw.modifiers],
+          required: raw.required,
+          allowBreaks: raw.allowBreaks,
+          ...raw.softLines && { softLines: raw.softLines },
+          ...raw.maxChars && { maxChars: raw.maxChars },
+          demo: cleanLineBreaks(raw.demo)
+        };
+      });
+    }
+    function normalizeValue(value) {
+      if (value == null) return { version: 1, values: {} };
+      if (!plain(value) || value.version !== 1 || !plain(value.values)) templateError("Text template value must be { version: 1, values: { ... } }");
+      if (Object.keys(value.values).length > 100) templateError("Text template value has too many entries");
+      const values = {};
+      for (const [id, text] of Object.entries(value.values)) {
+        if (!ID.test(id) || typeof text !== "string" || codePoints(text) > MAX_TEXT) templateError(`Invalid text template value for "${id}"`);
+        values[id] = cleanLineBreaks(text);
+      }
+      return { version: 1, values };
+    }
+    function validateValue(template, value) {
+      const entries = validateTemplate(template);
+      const normalized = normalizeValue(value);
+      const errors = [];
+      for (const entry of entries) {
+        const text = normalized.values[entry.id] || "";
+        if (entry.required && !text.trim()) errors.push({ id: entry.id, code: "required", message: `${entry.label} is required` });
+        if (!entry.allowBreaks && /\n/.test(text)) errors.push({ id: entry.id, code: "lineBreak", message: `${entry.label} does not allow line breaks` });
+        if (entry.maxChars && codePoints(text) > entry.maxChars) errors.push({ id: entry.id, code: "maxChars", message: `${entry.label} exceeds ${entry.maxChars} characters` });
+      }
+      return { value: normalized, errors };
+    }
+    function demoValue(template) {
+      return { version: 1, values: Object.fromEntries(validateTemplate(template).map((entry) => [entry.id, entry.demo])) };
+    }
+    function renderTextTemplate(template, value) {
+      const entries = validateTemplate(template);
+      const normalized = normalizeValue(value);
+      return entries.flatMap((entry) => {
+        const text = normalized.values[entry.id] || "";
+        if (!text.trim()) return [];
+        return [{ id: entry.id, tag: entry.tag, text, lines: text.split("\n"), className: textTemplateClassName(entry) }];
+      });
+    }
+    function textTemplateClassName(entry) {
+      if (!plain(entry) || entry.token && !TOKEN.test(entry.token) || !Array.isArray(entry.modifiers) || entry.modifiers.some((item) => !MODIFIERS.includes(item))) return "";
+      return [entry.token, ...entry.modifiers].filter(Boolean).join(" ");
+    }
+    function renderTextTemplateElement(part, createElement) {
+      if (!plain(part) || !TAGS.includes(part.tag) || typeof part.text !== "string" || typeof createElement !== "function") templateError("Invalid projected text template part");
+      const children = part.text.split("\n").flatMap((line, index) => index ? [createElement("br", { key: `${part.id}-break-${index}` }), line] : [line]);
+      return createElement(part.tag, { key: part.id, className: part.className || void 0 }, ...children);
+    }
+    function binding(uid, name) {
+      return `${uid}.${name}`;
+    }
+    function isTextTemplateBinding(value) {
+      return typeof value === "string" && BINDING.test(value);
+    }
+    function resolveBinding(attribute, contentTypeUID, name) {
+      const explicit = attribute?.options?.blockscene?.textTemplate || attribute?.pluginOptions?.blockscene?.textTemplate;
+      if (isTextTemplateBinding(explicit)) return explicit;
+      return typeof contentTypeUID === "string" && contentTypeUID ? binding(contentTypeUID, String(name || "").split(".").pop()) : "";
+    }
+    function createEntryId(entries, values, nonce) {
+      const used = /* @__PURE__ */ new Set([...entries.map((entry) => entry.id), ...Object.keys(values || {})]);
+      const safe = String(nonce || "").toLowerCase().replace(/[^a-z0-9]/g, "").slice(0, 32);
+      const base = `text-${safe || Date.now().toString(36)}`;
+      let id = base, suffix = 2;
+      while (used.has(id)) id = `${base}-${suffix++}`;
+      return id;
+    }
+    function applyTextChange(entry, current, next, { composing = false, compositionStart = current } = {}) {
+      const value = entry.allowBreaks ? cleanLineBreaks(next) : String(next || "").replace(/[\r\n]+/g, " ");
+      const previous = String(compositionStart ?? current ?? "");
+      const exceeds = entry.maxChars && codePoints(value) > entry.maxChars;
+      const recoverable = codePoints(previous) > entry.maxChars && codePoints(value) <= codePoints(previous);
+      if (exceeds && !composing && !recoverable) return { accepted: false, value: previous, code: "maxChars" };
+      return { accepted: true, value };
+    }
+    function mergePartialDocument2(stored, patch) {
+      return { ...plain(stored) ? stored : {}, ...plain(patch) ? patch : {} };
+    }
+    function draftReadPlan2(localized, { documentId, locale } = {}, populate = {}, defaultLocale) {
+      const common = { status: "draft", ...Object.keys(populate).length && { populate } };
+      if (localized && locale === "*") return { many: true, query: { filters: { documentId }, locale: "*", ...common } };
+      return { many: false, query: { documentId, ...localized && { locale: locale || defaultLocale }, ...common } };
+    }
+    async function validateBulkUpdates2(query, where, populate, patch, validate) {
+      const entries = await query.findMany({ where: where || {}, ...Object.keys(populate || {}).length && { populate } });
+      for (const entry of entries) validate(mergePartialDocument2(entry, patch));
+      return entries.length;
+    }
+    function isTextTemplate(attr) {
+      return attr?.customField === CUSTOM_FIELD;
+    }
+    function textTemplateBindings(schemas2) {
+      const bindings = /* @__PURE__ */ new Set();
+      for (const [uid, schema] of Object.entries(schemas2 || {})) {
+        for (const [name, attribute] of Object.entries(schema?.attributes || {})) {
+          if (!isTextTemplate(attribute)) continue;
+          const key = resolveBinding(attribute, uid, name);
+          if (key) bindings.add(key);
+        }
+      }
+      return bindings;
+    }
+    function validateDocument2(schemas2, uid, data, templates, path = []) {
+      if (!plain(data)) return [];
+      const schema = schemas2?.[uid];
+      if (!schema) return [];
+      const errors = [];
+      for (const [name, attr] of Object.entries(schema.attributes || {})) {
+        const here = [...path, name];
+        if (isTextTemplate(attr)) {
+          const template = templates?.[resolveBinding(attr, uid, name)];
+          if (!template) continue;
+          let result;
+          try {
+            result = validateValue(template, data[name]);
+          } catch (error) {
+            errors.push({ path: here, code: "invalid", message: error.message });
+            continue;
+          }
+          errors.push(...result.errors.map((error) => ({ ...error, path: [...here, error.id] })));
+        } else if (!(name in data)) continue;
+        else if (attr?.type === "component") {
+          const list = attr.repeatable ? data[name] : [data[name]];
+          if (Array.isArray(list)) list.forEach((item, index) => errors.push(...validateDocument2(schemas2, attr.component, item, templates, attr.repeatable ? [...here, index] : here)));
+        } else if (attr?.type === "dynamiczone" && Array.isArray(data[name])) {
+          data[name].forEach((item, index) => errors.push(...validateDocument2(schemas2, item?.__component, item, templates, [...here, index])));
+        }
+      }
+      return errors;
+    }
+    function textTemplatePopulate2(schemas2, uid, templates) {
+      const active = new Set(Object.keys(templates || {}));
+      const walk = (schemaUid, seen = /* @__PURE__ */ new Set()) => {
+        if (seen.has(schemaUid)) return { configured: false, populate: {} };
+        const next = new Set(seen).add(schemaUid);
+        let configured = false;
+        const populate = {};
+        for (const [name, attr] of Object.entries(schemas2?.[schemaUid]?.attributes || {})) {
+          if (isTextTemplate(attr) && active.has(resolveBinding(attr, schemaUid, name))) configured = true;
+          else if (attr?.type === "component") {
+            const child = walk(attr.component, next);
+            if (child.configured) {
+              populate[name] = Object.keys(child.populate).length ? { populate: child.populate } : true;
+              configured = true;
+            }
+          } else if (attr?.type === "dynamiczone") {
+            const children = (attr.components || []).map((component) => [component, walk(component, next)]).filter(([, child]) => child.configured);
+            if (children.length) {
+              populate[name] = { on: Object.fromEntries(children.map(([component, child]) => [
+                component,
+                Object.keys(child.populate).length ? { populate: child.populate } : {}
+              ])) };
+              configured = true;
+            }
+          }
+        }
+        return { configured, populate };
+      };
+      const result = walk(uid);
+      return result.configured ? result.populate : null;
+    }
+    module2.exports = { CUSTOM_FIELD, TAGS, ROLES, MODIFIERS, MAX_ENTRIES, codePoints, validateTemplate, normalizeValue, validateValue, demoValue, renderTextTemplate, renderTextTemplateElement, textTemplateClassName, binding, isTextTemplateBinding, resolveBinding, createEntryId, applyTextChange, mergePartialDocument: mergePartialDocument2, draftReadPlan: draftReadPlan2, validateBulkUpdates: validateBulkUpdates2, isTextTemplate, textTemplateBindings, validateDocument: validateDocument2, textTemplatePopulate: textTemplatePopulate2 };
+  }
+});
+
 // server/groups.js
 var require_groups = __commonJS({
   "server/groups.js"(exports2, module2) {
@@ -163,6 +380,7 @@ var require_groups = __commonJS({
 var require_settings = __commonJS({
   "server/settings.js"(exports2, module2) {
     "use strict";
+    var { validateTemplate, isTextTemplateBinding, textTemplateBindings } = require_text_template();
     var PLUGIN2 = "blockscene";
     var TEMPLATES2 = ["generic", "banner", "cards", "imageText", "faq", "none"];
     var INITIAL_STATES = ["closed", "open", "remember"];
@@ -203,6 +421,8 @@ var require_settings = __commonJS({
       // Per content type (only the ones with a Dynamic Zone): { enabled: false } turns the plugin off there;
       // previewMode overrides editor.previewMode as the mode the edit view opens in. Absent means the global behaviour.
       contentTypes: {},
+      // Developer-owned templates for plugin::blockscene.text-template fields, keyed by "schema.uid.attribute".
+      textTemplates: {},
       // Version history (Strapi 5, see README "Version history"): off until turned on. contentTypes: 'all' (every api:: type)
       // or a list of uids. Snapshots are kept retentionDays and at most maxSnapshots per document; events eventDays; deleted
       // documents stay in the trash trashDays (fixed per document when it is deleted).
@@ -270,7 +490,7 @@ var require_settings = __commonJS({
       const name = `${uid.split(".").pop()} ${displayName}`.toLowerCase();
       return GUESSES.find(([, pattern]) => pattern.test(name))?.[0] || "text";
     }
-    function facetsOf(uid, schema, schemas = {}) {
+    function facetsOf(uid, schema, schemas2 = {}) {
       const facets = /* @__PURE__ */ new Set();
       const read = (attributes, nested) => {
         for (const attr of Object.values(attributes || {})) {
@@ -283,7 +503,7 @@ var require_settings = __commonJS({
           else if (attr?.type === "relation") facets.add("dynamic");
           else if (attr?.type === "component") {
             if (attr.repeatable) facets.add("list");
-            if (!nested) read(schemas[attr.component]?.attributes, true);
+            if (!nested) read(schemas2[attr.component]?.attributes, true);
           }
         }
       };
@@ -340,7 +560,7 @@ var require_settings = __commonJS({
         groups: safeGroups2(config.groups, config.componentUids)
       };
     }
-    function validateSettings2(input, componentUids2, contentTypeUids2 = [], historyTypes = null, schemas = null) {
+    function validateSettings2(input, componentUids2, contentTypeUids2 = [], historyTypes = null, schemas2 = null) {
       const types = typeMap(contentTypeUids2);
       if (!input || typeof input !== "object" || Array.isArray(input)) fail2("Settings must be an object");
       if (JSON.stringify(input).length > 64 * 1024) fail2("Settings payload too large");
@@ -380,7 +600,7 @@ var require_settings = __commonJS({
             if (typeof entry.showRowThumbnail !== "boolean") fail2(`Invalid row thumbnail setting for "${uid}"`);
             clean.showRowThumbnail = entry.showRowThumbnail;
           } else if (key === "layout") {
-            if (!validLayout(entry.layout, schemas && (schemas[uid]?.attributes || {}))) fail2(`Invalid layout for "${uid}": columnsField (and mobileColumnsField) must name a number, string or numeric enumeration attribute of the component; maxColumns 1 to 12`);
+            if (!validLayout(entry.layout, schemas2 && (schemas2[uid]?.attributes || {}))) fail2(`Invalid layout for "${uid}": columnsField (and mobileColumnsField) must name a number, string or numeric enumeration attribute of the component; maxColumns 1 to 12`);
             clean.layout = structuredClone(entry.layout);
           } else fail2(`Unknown component setting "${key}"`);
         }
@@ -397,6 +617,17 @@ var require_settings = __commonJS({
         }
         if (Object.keys(entry).length) out.contentTypes[uid] = { ...structuredClone(entry), ...entry.previewDevices && { previewDevices: cleanDevices(entry.previewDevices) } };
       }
+      const textTemplates = input.textTemplates || {};
+      if (!plain(textTemplates) || Object.keys(textTemplates).length > 200) fail2("textTemplates must be an object with at most 200 field bindings");
+      const bindings = schemas2 ? textTemplateBindings(schemas2) : null;
+      for (const [key, entries] of Object.entries(textTemplates)) {
+        if (!isTextTemplateBinding(key) || bindings && !bindings.has(key)) fail2(`Unknown text template field "${key}"`);
+        try {
+          out.textTemplates[key] = validateTemplate(entries);
+        } catch (error) {
+          fail2(`${key}: ${error.message}`);
+        }
+      }
       const history = input.history || {};
       if (typeof history !== "object" || Array.isArray(history)) fail2("history must be an object");
       for (const [key, value] of Object.entries(history)) {
@@ -407,8 +638,9 @@ var require_settings = __commonJS({
       if (out.history.eventDays < out.history.retentionDays) fail2("history.eventDays must be at least history.retentionDays");
       return out;
     }
-    function mergeSaved2(saved, componentUids2, contentTypeUids2 = [], historyTypes = null, schemas = null) {
+    function mergeSaved2(saved, componentUids2, contentTypeUids2 = [], historyTypes = null, schemas2 = null) {
       const types = typeMap(contentTypeUids2);
+      const templateBindings = schemas2 ? textTemplateBindings(schemas2) : null;
       const out = structuredClone(DEFAULTS2);
       if (!saved || typeof saved !== "object") return out;
       for (const key of Object.keys(DEFAULTS2.palette)) if (COLOR.test(String(saved.palette?.[key]))) out.palette[key] = saved.palette[key];
@@ -438,7 +670,7 @@ var require_settings = __commonJS({
           if (!clean.tags.length) delete clean.tags;
         }
         if ("showRowThumbnail" in clean && typeof clean.showRowThumbnail !== "boolean") delete clean.showRowThumbnail;
-        if ("layout" in clean && !validLayout(clean.layout, schemas && (schemas[uid]?.attributes || {}))) delete clean.layout;
+        if ("layout" in clean && !validLayout(clean.layout, schemas2 && (schemas2[uid]?.attributes || {}))) delete clean.layout;
         if (Object.keys(clean).length) out.components[uid] = clean;
       }
       for (const [uid, entry] of Object.entries(saved.contentTypes || {})) {
@@ -447,6 +679,14 @@ var require_settings = __commonJS({
         const clean = Object.fromEntries(Object.entries(entry).map(([key, value]) => [key, fix(key, value)]).filter(([key, value]) => TYPE_KEYS[key]?.(value, types[uid])));
         if (Object.keys(clean).length) out.contentTypes[uid] = clean;
       }
+      for (const [key, entries] of Object.entries(saved.textTemplates || {})) {
+        if (!isTextTemplateBinding(key) || templateBindings && !templateBindings.has(key)) continue;
+        try {
+          out.textTemplates[key] = validateTemplate(entries);
+        } catch (error) {
+          if (error?.name !== "ValidationError") throw error;
+        }
+      }
       for (const key of Object.keys(HISTORY_KEYS)) {
         let value = saved.history?.[key];
         if (key === "contentTypes" && Array.isArray(value)) value = value.filter((uid) => HISTORY_KEYS.contentTypes([uid], historyTypes));
@@ -455,7 +695,7 @@ var require_settings = __commonJS({
       out.history.eventDays = Math.max(out.history.eventDays, out.history.retentionDays);
       return out;
     }
-    var ENTRY_KEYS = ["components", "contentTypes"];
+    var ENTRY_KEYS = ["components", "contentTypes", "textTemplates"];
     var UNSET_WHEN_EMPTY = ["previewUrl", "blockPreviewUrl"];
     var withoutEmpty = (editor) => Object.fromEntries(Object.entries(editor).filter(([key, value]) => !(UNSET_WHEN_EMPTY.includes(key) && value === "")));
     function layer2(base, saved) {
@@ -478,7 +718,7 @@ var require_settings = __commonJS({
     var LOCALE = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
     var plain = (value) => value && typeof value === "object" && !Array.isArray(value);
     var fieldText = (value, max) => typeof value === "string" ? value.trim() !== "" && value.length <= max : plain(value) && Object.keys(value).length > 0 && Object.keys(value).length <= 30 && Object.entries(value).every(([locale, text2]) => LOCALE.test(locale) && fieldText(text2, max));
-    function validateFields2(input, schemas = {}, stale = []) {
+    function validateFields2(input, schemas2 = {}, stale = []) {
       if (input === null || input === void 0) return {};
       if (!plain(input)) fail2("fields must be an object");
       if (JSON.stringify(input).length > 256 * 1024) fail2("fields config too large");
@@ -491,7 +731,7 @@ var require_settings = __commonJS({
             if (!(key in FIELD_TEXT)) fail2(`Unknown field setting "${key}" of "${uid}.${name}"`);
             if (!fieldText(value, FIELD_TEXT[key])) fail2(`Invalid ${key} of "${uid}.${name}": a string of 1 to ${FIELD_TEXT[key]} characters, or { "<locale>": string }`);
           }
-          if (!schemas[uid]?.includes(name)) {
+          if (!schemas2[uid]?.includes(name)) {
             stale.push(`${uid}.${name}`);
             continue;
           }
@@ -506,7 +746,7 @@ var require_settings = __commonJS({
     var localize = (holder, key, source, locale, text2) => {
       holder[key] = { ...plain(holder[key]) ? holder[key] : { en: holder[key] ?? source }, [locale]: text2 };
     };
-    function schemaMetadata2(schemas = {}, translations = null, notes = []) {
+    function schemaMetadata2(schemas2 = {}, translations = null, notes = []) {
       const blocks = {}, fields = {};
       const own = (holder, where) => {
         const value = holder?.pluginOptions?.blockscene;
@@ -514,7 +754,7 @@ var require_settings = __commonJS({
         notes.push(`${where}: pluginOptions.blockscene must be an object`);
         return {};
       };
-      for (const [uid, schema] of Object.entries(schemas)) {
+      for (const [uid, schema] of Object.entries(schemas2)) {
         if (!uid.includes("::")) {
           const block = {};
           for (const [key, value] of Object.entries(own(schema, uid))) {
@@ -546,10 +786,10 @@ var require_settings = __commonJS({
           continue;
         }
         for (const [key, text2] of Object.entries(entries)) {
-          const uid = Object.keys(schemas).find((uid2) => key === uid2 || key.startsWith(`${uid2}.`));
+          const uid = Object.keys(schemas2).find((uid2) => key === uid2 || key.startsWith(`${uid2}.`));
           const [name, part = "label", extra] = uid ? key.slice(uid.length + 1).split(".") : [];
           const block = uid && !uid.includes("::");
-          const target = block && key === uid ? [blocks[uid] ||= {}, "label", schemas[uid]?.info?.displayName || uid, 80] : block && key === `${uid}.description` ? [blocks[uid] ||= {}, "description", null, 300] : uid && Object.hasOwn(schemas[uid]?.attributes || {}, name) && Object.hasOwn(FIELD_TEXT, part) && extra === void 0 ? [null, part, null, FIELD_TEXT[part]] : null;
+          const target = block && key === uid ? [blocks[uid] ||= {}, "label", schemas2[uid]?.info?.displayName || uid, 80] : block && key === `${uid}.description` ? [blocks[uid] ||= {}, "description", null, 300] : uid && Object.hasOwn(schemas2[uid]?.attributes || {}, name) && Object.hasOwn(FIELD_TEXT, part) && extra === void 0 ? [null, part, null, FIELD_TEXT[part]] : null;
           if (!target) {
             stale.push(`${locale} "${key}"`);
             continue;
@@ -588,7 +828,7 @@ var require_settings = __commonJS({
       blocks: Array.isArray,
       enumeration: (value, attr) => (attr.enum || []).includes(value)
     };
-    function variantValues(values, schema, schemas, path, skipped) {
+    function variantValues(values, schema, schemas2, path, skipped) {
       if (!plain(values)) throw new Error(`${path} must be an object`);
       const out = {};
       for (const [name, value] of Object.entries(values)) {
@@ -600,22 +840,22 @@ var require_settings = __commonJS({
           continue;
         }
         if (attr.type === "component") {
-          const nested = schemas[attr.component], max = Math.min(attr.max ?? Infinity, VARIANT.items);
+          const nested = schemas2[attr.component], max = Math.min(attr.max ?? Infinity, VARIANT.items);
           if (!nested) throw new Error(`${at}: unknown component "${attr.component}"`);
-          if (!attr.repeatable) out[name] = value === null ? null : variantValues(value, nested, schemas, at, skipped);
+          if (!attr.repeatable) out[name] = value === null ? null : variantValues(value, nested, schemas2, at, skipped);
           else if (!Array.isArray(value) || value.length > max) throw new Error(`${at} must be a list of at most ${max} items`);
-          else out[name] = value.map((item, index) => variantValues(item, nested, schemas, `${at}[${index}]`, skipped));
+          else out[name] = value.map((item, index) => variantValues(item, nested, schemas2, `${at}[${index}]`, skipped));
         } else if (value === null || SCALARS[attr.type]?.(value, attr)) out[name] = structuredClone(value);
         else throw new Error(`${at}: ${SCALARS[attr.type] ? `not a valid ${attr.type}` : `${attr.type} values are not supported`}`);
       }
       return out;
     }
-    function validateVariants2(config, schemas = {}, notes = []) {
+    function validateVariants2(config, schemas2 = {}, notes = []) {
       const out = {};
       let total = 0;
       for (const [uid, entry] of Object.entries(plain(config) ? config : {})) {
         if (!plain(entry) || entry.variants === void 0) continue;
-        if (!schemas[uid]) {
+        if (!schemas2[uid]) {
           notes.push(`${uid}: unknown component`);
           continue;
         }
@@ -631,7 +871,7 @@ var require_settings = __commonJS({
             if (!text(variant.id) || !VARIANT.id.test(variant.id) || ids.has(variant.id)) throw new Error('id must be 1 to 40 lowercase letters, digits, "-" or "_", unique per component');
             if (!fieldText(variant.label, 60)) throw new Error('label must be a string of 1 to 60 characters, or { "<locale>": string }');
             const skipped = [];
-            const values = variantValues(variant.values ?? {}, schemas[uid], schemas, "values", skipped);
+            const values = variantValues(variant.values ?? {}, schemas2[uid], schemas2, "values", skipped);
             const size = JSON.stringify(values).length;
             if (size > VARIANT.bytes) throw new Error(`values over ${VARIANT.bytes / 1024} KB`);
             if (total + size > VARIANT.total) throw new Error(`all variants together over ${VARIANT.total / 1024} KB`);
@@ -646,7 +886,7 @@ var require_settings = __commonJS({
       }
       return out;
     }
-    function requiredProblems(schema, values, schemas, path, media, problems) {
+    function requiredProblems(schema, values, schemas2, path, media, problems) {
       for (const [field, attr] of Object.entries(schema?.attributes || {})) {
         const at = `${path}.${field}`;
         const supplied = Object.hasOwn(values, field);
@@ -656,7 +896,7 @@ var require_settings = __commonJS({
           continue;
         }
         if (attr.type === "component") {
-          const nested = schemas[attr.component];
+          const nested = schemas2[attr.component];
           if (!nested) {
             problems.push(`${at}: unknown component "${attr.component}"`);
             continue;
@@ -665,16 +905,16 @@ var require_settings = __commonJS({
             const minimum = Math.max(attr.min ?? 0, attr.required ? 1 : 0);
             const items = supplied ? value : Array.from({ length: minimum }, () => ({}));
             if (!Array.isArray(items) || items.length < minimum) problems.push(`${at} requires at least ${minimum} item${minimum === 1 ? "" : "s"}`);
-            else items.forEach((item, index) => requiredProblems(nested, item, schemas, `${at}[${index}]`, media, problems));
+            else items.forEach((item, index) => requiredProblems(nested, item, schemas2, `${at}[${index}]`, media, problems));
           } else if (supplied && value === null) {
             if (attr.required) problems.push(`${at} is required`);
-          } else if (supplied || attr.required) requiredProblems(nested, supplied ? value : {}, schemas, at, media, problems);
+          } else if (supplied || attr.required) requiredProblems(nested, supplied ? value : {}, schemas2, at, media, problems);
           continue;
         }
         if (attr.required && (value === void 0 || value === null || value === "")) problems.push(`${at} is required`);
       }
     }
-    function validateKits2(input, contentTypes = {}, schemas = {}, groups = null, notes = []) {
+    function validateKits2(input, contentTypes = {}, schemas2 = {}, groups = null, notes = []) {
       if (input === null || input === void 0) return {};
       if (!plain(input) || JSON.stringify(input).length > 256 * 1024) {
         notes.push("expected an object up to 256 KB");
@@ -710,18 +950,18 @@ var require_settings = __commonJS({
                 const row = rows[index];
                 if (!plain(row) || !text(row.__component)) throw new Error(`${zoneName}[${index}] must have __component`);
                 const component = row.__component;
-                if (!zone.components?.includes(component) || !schemas[component]) throw new Error(`${zoneName}[${index}]: component "${component}" is not allowed`);
+                if (!zone.components?.includes(component) || !schemas2[component]) throw new Error(`${zoneName}[${index}]: component "${component}" is not allowed`);
                 const skipped = [];
-                const values = variantValues(row, schemas[component], schemas, `${zoneName}[${index}]`, skipped);
+                const values = variantValues(row, schemas2[component], schemas2, `${zoneName}[${index}]`, skipped);
                 if (skipped.length) notes.push(`${name}: media and relation values are not inserted (${skipped.slice(0, 5).join(", ")}${skipped.length > 5 ? ", ..." : ""})`);
                 const media = [], required = [];
-                requiredProblems(schemas[component], values, schemas, `${zoneName}[${index}]`, media, required);
+                requiredProblems(schemas2[component], values, schemas2, `${zoneName}[${index}]`, media, required);
                 if (required.length) throw new Error(required.slice(0, 5).join("; "));
                 if (media.length) notes.push(`${name}: required media or relations must be completed before publishing (${media.slice(0, 5).join(", ")}${media.length > 5 ? ", ..." : ""})`);
                 clean.push({ __component: component, values });
                 const close = groups?.[component];
                 if (close) {
-                  if (!zone.components?.includes(close) || !schemas[close]) throw new Error(`${zoneName}[${index}]: close component "${close}" is not allowed`);
+                  if (!zone.components?.includes(close) || !schemas2[close]) throw new Error(`${zoneName}[${index}]: close component "${close}" is not allowed`);
                   clean.push({ __component: close, values: {} });
                 }
               }
@@ -1838,6 +2078,7 @@ var { safeGroups, validateGroups, invalidComponents, layoutFields } = require_gr
 var { hiddenName, injectHidden, hideFromBuilder, registerHiddenStrip } = require_hidden();
 var { CRON, covers, eventContentType, historyService, historyController, registerHistory, registerPurge } = require_history();
 var { trashContentType, trashService, trashController } = require_trash();
+var { validateDocument, textTemplatePopulate, mergePartialDocument, draftReadPlan, validateBulkUpdates } = require_text_template();
 var STRAPI5 = true;
 var withHidden = [];
 var store = (strapi) => strapi.store({ type: "plugin", name: PLUGIN });
@@ -1853,6 +2094,7 @@ async function readSettings(strapi) {
   return legacy;
 }
 var componentUids = (strapi) => Object.keys(strapi.components || {});
+var schemas = (strapi) => ({ ...strapi.contentTypes || {}, ...strapi.components || {} });
 var findMedia = (strapi, id) => strapi.db.query("plugin::upload.file").findOne({ where: { id }, select: ["id", "url", "mime", "name"] });
 async function resolveMedia(strapi, settings) {
   const resolved = {};
@@ -1968,6 +2210,63 @@ function registerZoneGuards(strapi) {
     }
   });
 }
+function registerTextTemplateGuard(strapi) {
+  const check = (uid, data, templates) => {
+    const errors = validateDocument(schemas(strapi), uid, data, templates);
+    if (errors.length) fail("Text template content is invalid.", { plugin: PLUGIN, errors: errors.map((error) => ({ ...error, name: "ValidationError" })) });
+  };
+  if (strapi.documents?.use) {
+    const defaultLocale = async () => {
+      try {
+        return await strapi.plugin("i18n")?.service("locales")?.getDefaultLocale?.();
+      } catch {
+        return void 0;
+      }
+    };
+    strapi.documents.use(async (ctx, next) => {
+      const { action, params = {} } = ctx;
+      if (!ctx.uid || !["create", "update", "publish"].includes(action)) return next();
+      const templates = (await strapi.plugin(PLUGIN).service("settings").get()).textTemplates;
+      const populate = textTemplatePopulate(schemas(strapi), ctx.uid, templates);
+      if (!populate) return next();
+      if (action === "create") {
+        check(ctx.uid, params.data || {}, templates);
+        return next();
+      }
+      const localized = Boolean(strapi.getModel(ctx.uid)?.pluginOptions?.i18n?.localized);
+      const plan = draftReadPlan(localized, params, populate, await defaultLocale());
+      const stored = plan.many ? await strapi.documents(ctx.uid).findMany(plan.query) : [await strapi.documents(ctx.uid).findOne(plan.query)];
+      for (const entry of stored) check(ctx.uid, action === "update" ? mergePartialDocument(entry, params.data) : entry || {}, templates);
+      return next();
+    });
+    return;
+  }
+  strapi.db.lifecycles.subscribe({
+    beforeCreate: async (event) => {
+      const templates = (await strapi.plugin(PLUGIN).service("settings").get()).textTemplates;
+      check(event.model.uid, event.params?.data || {}, templates);
+    },
+    beforeUpdate: async (event) => {
+      const templates = (await strapi.plugin(PLUGIN).service("settings").get()).textTemplates;
+      const populate = textTemplatePopulate(schemas(strapi), event.model.uid, templates);
+      if (!populate) return;
+      const stored = await strapi.db.query(event.model.uid).findOne({ where: event.params?.where || {}, ...Object.keys(populate).length && { populate } });
+      check(event.model.uid, mergePartialDocument(stored, event.params?.data), templates);
+    },
+    beforeUpdateMany: async (event) => {
+      const templates = (await strapi.plugin(PLUGIN).service("settings").get()).textTemplates;
+      const populate = textTemplatePopulate(schemas(strapi), event.model.uid, templates);
+      if (!populate) return;
+      await validateBulkUpdates(
+        strapi.db.query(event.model.uid),
+        event.params?.where,
+        populate,
+        event.params?.data,
+        (entry) => check(event.model.uid, entry, templates)
+      );
+    }
+  });
+}
 module.exports = {
   config: {
     default: {
@@ -2000,6 +2299,7 @@ module.exports = {
   },
   // Before the database schema sync, so the column exists. A name the host already uses with another type is skipped.
   register({ strapi }) {
+    strapi.customFields.register({ name: "text-template", plugin: PLUGIN, type: "json", inputSize: { default: 12, isResizable: true } });
     const plugin = strapi.plugin(PLUGIN);
     const name = hiddenName(plugin.config("hiddenAttribute"));
     withHidden = [];
@@ -2027,6 +2327,7 @@ module.exports = {
     strapi.plugin(PLUGIN).service("settings").variants();
     strapi.plugin(PLUGIN).service("settings").kits();
     registerZoneGuards(strapi);
+    registerTextTemplateGuard(strapi);
     registerHiddenStrip(strapi, hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")), strapi.plugin(PLUGIN));
     if (withHidden.length) hideFromBuilder(typeof strapi.get === "function" ? strapi.get("services") : strapi.container.get("services"), withHidden, hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")));
     if (STRAPI5) {
@@ -2046,7 +2347,7 @@ module.exports = {
       const code = strapi.plugin(PLUGIN).config("settings");
       project = null;
       if (code) try {
-        project = validateSettings(code, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
+        project = validateSettings(code, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), schemas(strapi));
       } catch (error) {
         strapi.log?.warn(`[${PLUGIN}] "settings" config ignored: ${error.message}. Using the built-in defaults under the saved settings.`);
       }
@@ -2063,11 +2364,11 @@ module.exports = {
     let fields;
     const fieldTexts = () => {
       if (fields !== void 0) return fields;
-      const schemas = Object.fromEntries(Object.entries({ ...strapi.contentTypes, ...strapi.components }).map(([uid, schema]) => [uid, Object.keys(schema?.attributes || {})]));
+      const schemas2 = Object.fromEntries(Object.entries({ ...strapi.contentTypes, ...strapi.components }).map(([uid, schema]) => [uid, Object.keys(schema?.attributes || {})]));
       const stale = [];
       let code = {};
       try {
-        code = validateFields(strapi.plugin(PLUGIN).config("fields"), schemas, stale);
+        code = validateFields(strapi.plugin(PLUGIN).config("fields"), schemas2, stale);
       } catch (error) {
         strapi.log?.warn(`[${PLUGIN}] "fields" config ignored: ${error.message}. Field labels fall back to the schema metadata and the Content Manager's own.`);
       }
@@ -2092,7 +2393,7 @@ module.exports = {
       for (const note of notes) strapi.log?.warn(`[${PLUGIN}] starter kits: ${note}.`);
       return kits;
     };
-    const get = async () => mergeSaved(layer(projectDefaults(), await readSettings(strapi)), componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
+    const get = async () => mergeSaved(layer(projectDefaults(), await readSettings(strapi)), componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), schemas(strapi));
     return {
       projectDefaults,
       get,
@@ -2101,7 +2402,7 @@ module.exports = {
       variants: insertVariants,
       kits: starterKits,
       async set(value) {
-        const next = validateSettings(value, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
+        const next = validateSettings(value, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), schemas(strapi));
         for (const [uid, entry] of Object.entries(next.components)) {
           if (entry.mediaId && !await findMedia(strapi, entry.mediaId).catch(() => null)) fail(`Media for "${uid}" does not exist`);
         }
@@ -2154,6 +2455,7 @@ module.exports = {
           kits: plugin.service("settings").kits(),
           palette: settings.palette,
           contentTypes: settings.contentTypes,
+          textTemplates: settings.textTemplates,
           hiddenAttribute: hidden,
           fields: plugin.service("settings").fields(),
           types,