@aduptive/strapi-blockscene 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/server.cjs

@@ -106,7 +106,41 @@ var require_groups = __commonJS({
       const [, end] = groupRange(rows, start, g);
       return [...rows.slice(0, start), ...rows.slice(end + 1)];
     }
-    module2.exports = { safeGroups: safeGroups2, validateGroups: validateGroups2, groupRange, groupRows, topLevelRanges, moveGroup, removeGroup, blockKey, isOpener, isClose };
+    var MAX_COLUMNS = 12;
+    var parseColumns = (value) => {
+      const n = typeof value === "number" ? value : typeof value === "string" && /^\s*\d{1,3}\s*$/.test(value) ? Number(value) : NaN;
+      return Number.isInteger(n) && n >= 1 ? n : null;
+    };
+    var columnsAttribute = (attr) => Boolean(attr) && typeof attr === "object" && !attr.private && (["integer", "biginteger", "float", "decimal", "string"].includes(attr.type) || attr.type === "enumeration" && Array.isArray(attr.enum) && attr.enum.length > 0 && attr.enum.every((value) => parseColumns(value) !== null));
+    var layoutFields2 = (schema) => Object.entries(schema?.attributes || {}).filter(([, attr]) => columnsAttribute(attr)).map(([name]) => name);
+    function validLayout(value, attributes) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+      if (!Object.keys(value).every((key) => ["columnsField", "mobileColumnsField", "maxColumns"].includes(key))) return false;
+      const field = (name) => typeof name === "string" && /^[A-Za-z_][\w-]{0,63}$/.test(name) && (!attributes || columnsAttribute(attributes[name]));
+      return field(value.columnsField) && (value.mobileColumnsField === void 0 || field(value.mobileColumnsField)) && (value.maxColumns === void 0 || Number.isInteger(value.maxColumns) && value.maxColumns >= 1 && value.maxColumns <= MAX_COLUMNS);
+    }
+    function layoutColumns(row, layout, schema) {
+      const max = layout.maxColumns || MAX_COLUMNS;
+      const read = (name) => Math.min(max, parseColumns(row?.[name]) ?? parseColumns(schema?.attributes?.[name]?.default) ?? 1);
+      return { desktop: read(layout.columnsField), mobile: layout.mobileColumnsField ? read(layout.mobileColumnsField) : null };
+    }
+    module2.exports = {
+      safeGroups: safeGroups2,
+      validateGroups: validateGroups2,
+      groupRange,
+      groupRows,
+      topLevelRanges,
+      moveGroup,
+      removeGroup,
+      blockKey,
+      isOpener,
+      isClose,
+      MAX_COLUMNS,
+      parseColumns,
+      layoutFields: layoutFields2,
+      validLayout,
+      layoutColumns
+    };
   }
 });
 
@@ -237,7 +271,7 @@ var require_settings = __commonJS({
       return [...facets];
     }
     var safeUrl2 = (value) => typeof value === "string" && (/^\/(?!\/)/.test(value) || /^https?:\/\//.test(value)) ? value : void 0;
-    var { safeGroups: safeGroups2 } = require_groups();
+    var { safeGroups: safeGroups2, validLayout } = require_groups();
     var safeVersion = (value) => typeof value === "string" && /^[\w.-]{1,32}$/.test(value) ? value : void 0;
     var fail2 = (message, details) => {
       let ValidationError;
@@ -268,6 +302,7 @@ var require_settings = __commonJS({
       }
       for (const [uid, schema] of Object.entries(config.schemas || {})) {
         const entry = entries[uid] ||= {};
+        for (const [key, value] of Object.entries(config.blocks?.[uid] || {})) if (entry[key] === void 0) entry[key] = value;
         entry.facets = facetsOf(uid, schema, config.schemas);
         entry.typology ||= guessTypology(uid, schema?.info?.displayName);
         entry.tags ||= [];
@@ -282,7 +317,7 @@ var require_settings = __commonJS({
         groups: safeGroups2(config.groups, config.componentUids)
       };
     }
-    function validateSettings2(input, componentUids2, contentTypeUids2 = [], historyTypes = null) {
+    function validateSettings2(input, componentUids2, contentTypeUids2 = [], historyTypes = null, schemas = 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");
@@ -318,6 +353,9 @@ var require_settings = __commonJS({
           } else if (key === "mediaId") {
             if (!Number.isInteger(entry.mediaId) || entry.mediaId <= 0) fail2(`Invalid media for "${uid}"`);
             clean.mediaId = entry.mediaId;
+          } 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`);
+            clean.layout = structuredClone(entry.layout);
           } else fail2(`Unknown component setting "${key}"`);
         }
         if (Object.keys(clean).length) out.components[uid] = clean;
@@ -343,7 +381,7 @@ 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) {
+    function mergeSaved2(saved, componentUids2, contentTypeUids2 = [], historyTypes = null, schemas = null) {
       const types = typeMap(contentTypeUids2);
       const out = structuredClone(DEFAULTS2);
       if (!saved || typeof saved !== "object") return out;
@@ -373,6 +411,7 @@ var require_settings = __commonJS({
           clean.tags = cleanTags(clean.tags);
           if (!clean.tags.length) delete clean.tags;
         }
+        if ("layout" in clean && !validLayout(clean.layout, schemas && (schemas[uid]?.attributes || {}))) delete clean.layout;
         if (Object.keys(clean).length) out.components[uid] = clean;
       }
       for (const [uid, entry] of Object.entries(saved.contentTypes || {})) {
@@ -411,7 +450,7 @@ var require_settings = __commonJS({
     var FIELD_TEXT = { label: 80, description: 300, placeholder: 120, help: 500 };
     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, text]) => LOCALE.test(locale) && fieldText(text, max));
+    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 = []) {
       if (input === null || input === void 0) return {};
       if (!plain(input)) fail2("fields must be an object");
@@ -435,6 +474,151 @@ var require_settings = __commonJS({
       }
       return out;
     }
+    var str = (max) => (value) => typeof value === "string" && value.trim() !== "" && value.length <= max;
+    var BLOCK_META = { label: str(80), typology: (value) => TYPOLOGIES2.includes(value), tags: validTags, keywords: str(500), image: (value) => safeUrl2(value) !== void 0 };
+    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 = []) {
+      const blocks = {}, fields = {};
+      const own = (holder, where) => {
+        const value = holder?.pluginOptions?.blockscene;
+        if (value === void 0 || plain(value)) return value || {};
+        notes.push(`${where}: pluginOptions.blockscene must be an object`);
+        return {};
+      };
+      for (const [uid, schema] of Object.entries(schemas)) {
+        if (!uid.includes("::")) {
+          const block = {};
+          for (const [key, value] of Object.entries(own(schema, uid))) {
+            if (!Object.hasOwn(BLOCK_META, key)) notes.push(`${uid}: unknown key "${key}"`);
+            else if (!BLOCK_META[key](value)) notes.push(`${uid}: invalid ${key}`);
+            else block[key] = key === "tags" ? cleanTags(value) : value;
+          }
+          if (typeof schema?.info?.description === "string" && schema.info.description.trim()) block.description = schema.info.description;
+          if (Object.keys(block).length) blocks[uid] = block;
+        }
+        for (const [name, attr] of Object.entries(schema?.attributes || {})) {
+          const texts = {};
+          for (const [key, value] of Object.entries(own(attr, `${uid}.${name}`))) {
+            if (!Object.hasOwn(FIELD_TEXT, key)) notes.push(`${uid}.${name}: unknown key "${key}"`);
+            else if (!str(FIELD_TEXT[key])(value)) notes.push(`${uid}.${name}: ${key} must be a string of 1 to ${FIELD_TEXT[key]} characters`);
+            else texts[key] = value;
+          }
+          if (Object.keys(texts).length) (fields[uid] ||= {})[name] = texts;
+        }
+      }
+      if (translations != null && !plain(translations)) {
+        notes.push('translations must be { "<locale>": { "<key>": text } }');
+        translations = null;
+      }
+      const stale = [];
+      for (const [locale, entries] of Object.entries(translations || {})) {
+        if (!LOCALE.test(locale) || !plain(entries) || JSON.stringify(entries).length > 256 * 1024) {
+          notes.push(`translations "${locale}" ignored: expected a locale code with a flat { "<key>": text } map under 256 KB`);
+          continue;
+        }
+        for (const [key, text2] of Object.entries(entries)) {
+          const uid = Object.keys(schemas).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;
+          if (!target) {
+            stale.push(`${locale} "${key}"`);
+            continue;
+          }
+          const [holder, field, source, max] = target;
+          if (!str(max)(text2)) {
+            notes.push(`translations ${locale} "${key}": a string of 1 to ${max} characters`);
+            continue;
+          }
+          localize(holder || ((fields[uid] ||= {})[name] ||= {}), field, source, locale, text2);
+        }
+      }
+      if (stale.length) notes.push(`translation keys naming no block or field were skipped: ${stale.slice(0, 20).join(", ")}${stale.length > 20 ? ` and ${stale.length - 20} more` : ""}`);
+      return { blocks, fields };
+    }
+    var VARIANT = { id: /^[a-z0-9][a-z0-9_-]{0,39}$/, perComponent: 12, bytes: 16 * 1024, total: 256 * 1024, items: 100 };
+    var text = (value) => typeof value === "string";
+    var finite = (value) => typeof value === "number" && Number.isFinite(value);
+    var SCALARS = {
+      string: text,
+      text,
+      richtext: text,
+      email: text,
+      uid: text,
+      date: text,
+      datetime: text,
+      time: text,
+      timestamp: text,
+      integer: Number.isInteger,
+      biginteger: (value) => Number.isInteger(value) || text(value) && /^-?\d{1,19}$/.test(value),
+      float: finite,
+      decimal: finite,
+      boolean: (value) => typeof value === "boolean",
+      json: () => true,
+      customField: () => true,
+      blocks: Array.isArray,
+      enumeration: (value, attr) => (attr.enum || []).includes(value)
+    };
+    function variantValues(values, schema, schemas, path, skipped) {
+      if (!plain(values)) throw new Error(`${path} must be an object`);
+      const out = {};
+      for (const [name, value] of Object.entries(values)) {
+        if (name === "id" || name === "__component") continue;
+        const attr = schema.attributes?.[name], at = `${path}.${name}`;
+        if (!attr) throw new Error(`${at} is not an attribute of the component`);
+        if (attr.type === "media" || attr.type === "relation") {
+          skipped.push(at);
+          continue;
+        }
+        if (attr.type === "component") {
+          const nested = schemas[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);
+          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 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 = []) {
+      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]) {
+          notes.push(`${uid}: unknown component`);
+          continue;
+        }
+        if (!Array.isArray(entry.variants) || entry.variants.length > VARIANT.perComponent) {
+          notes.push(`${uid}: variants must be a list of at most ${VARIANT.perComponent}`);
+          continue;
+        }
+        const ids = /* @__PURE__ */ new Set();
+        entry.variants.forEach((variant, index) => {
+          const name = `${uid} variant "${variant?.id ?? index}"`;
+          try {
+            if (!plain(variant) || Object.keys(variant).some((key) => !["id", "label", "values"].includes(key))) throw new Error("expected { id, label, values }");
+            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 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`);
+            if (skipped.length) notes.push(`${name}: media and relation values are not inserted (${skipped.slice(0, 5).join(", ")}${skipped.length > 5 ? ", ..." : ""})`);
+            ids.add(variant.id);
+            total += size;
+            (out[uid] ||= []).push({ id: variant.id, label: structuredClone(variant.label), values });
+          } catch (error) {
+            notes.push(`${name} ignored: ${error.message}`);
+          }
+        });
+      }
+      return out;
+    }
     var PREFS = { starred: 200, recent: 20 };
     function validatePrefs2(input, componentUids2) {
       if (!input || typeof input !== "object" || Array.isArray(input)) fail2("Preferences must be an object");
@@ -447,7 +631,7 @@ var require_settings = __commonJS({
       return out;
     }
     var mergePrefs2 = (saved, componentUids2) => Object.fromEntries(Object.entries(PREFS).map(([key, max]) => [key, Array.isArray(saved?.[key]) ? [...new Set(saved[key].filter((uid) => componentUids2.includes(uid)))].slice(0, max) : []]));
-    module2.exports = { PLUGIN: PLUGIN2, HIDDEN_MODES, TEMPLATES: TEMPLATES2, TYPOLOGIES: TYPOLOGIES2, guessTypology, facetsOf, validatePrefs: validatePrefs2, mergePrefs: mergePrefs2, ICONS, DEFAULTS: DEFAULTS2, catalog: catalog2, validateSettings: validateSettings2, validateFields: validateFields2, mergeSaved: mergeSaved2, layer: layer2, overrides: overrides2, safeUrl: safeUrl2, fail: fail2 };
+    module2.exports = { PLUGIN: PLUGIN2, HIDDEN_MODES, TEMPLATES: TEMPLATES2, TYPOLOGIES: TYPOLOGIES2, guessTypology, facetsOf, validatePrefs: validatePrefs2, mergePrefs: mergePrefs2, ICONS, DEFAULTS: DEFAULTS2, catalog: catalog2, validateSettings: validateSettings2, validateFields: validateFields2, validateVariants: validateVariants2, schemaMetadata: schemaMetadata2, mergeSaved: mergeSaved2, layer: layer2, overrides: overrides2, safeUrl: safeUrl2, fail: fail2 };
   }
 });
 
@@ -475,6 +659,22 @@ var require_hidden = __commonJS({
       }
       return { added, skipped };
     }
+    function hideFromBuilder2(services, uids, name) {
+      const has = new Set(uids);
+      const drop = (attributes) => Array.isArray(attributes) ? attributes.filter((attr) => attr?.name !== name) : attributes && typeof attributes === "object" ? Object.fromEntries(Object.entries(attributes).filter(([key]) => key !== name)) : attributes;
+      const extend = (uid, wrap) => {
+        if (services?.get?.(uid)) services.extend(uid, wrap);
+      };
+      extend("plugin::content-type-builder.components", (service) => ({ ...service, formatComponent(component, ...rest) {
+        const out = service.formatComponent(component, ...rest);
+        return has.has(component?.uid) && out?.schema ? { ...out, schema: { ...out.schema, attributes: drop(out.schema.attributes) } } : out;
+      } }));
+      extend("plugin::content-type-builder.schema", (service) => ({ ...service, async getSchema(...args) {
+        const out = await service.getSchema(...args);
+        for (const uid of has) if (out?.components?.[uid]) out.components[uid] = { ...out.components[uid], attributes: drop(out.components[uid].attributes) };
+        return out;
+      } }));
+    }
     function stripHidden(data, schema, schemaOf, name, depth = 0) {
       if (!data || typeof data !== "object" || !schema || depth > 20) return data;
       if (Array.isArray(data)) {
@@ -533,7 +733,7 @@ var require_hidden = __commonJS({
         }
       }));
     }
-    module2.exports = { DEFAULT_NAME, hiddenName: hiddenName2, zoneComponents, injectHidden: injectHidden2, stripHidden, registerHiddenStrip: registerHiddenStrip2 };
+    module2.exports = { DEFAULT_NAME, hiddenName: hiddenName2, zoneComponents, injectHidden: injectHidden2, hideFromBuilder: hideFromBuilder2, stripHidden, registerHiddenStrip: registerHiddenStrip2 };
   }
 });
 
@@ -1485,12 +1685,13 @@ var require_history = __commonJS({
 });
 
 // server/index.js
-var { PLUGIN, TEMPLATES, TYPOLOGIES, DEFAULTS, catalog, validateSettings, validateFields, mergeSaved, layer, overrides, validatePrefs, mergePrefs, safeUrl, fail } = require_settings();
-var { safeGroups, validateGroups } = require_groups();
-var { hiddenName, injectHidden, registerHiddenStrip } = require_hidden();
+var { PLUGIN, TEMPLATES, TYPOLOGIES, DEFAULTS, catalog, validateSettings, validateFields, validateVariants, schemaMetadata, mergeSaved, layer, overrides, validatePrefs, mergePrefs, safeUrl, fail } = require_settings();
+var { safeGroups, validateGroups, layoutFields } = require_groups();
+var { hiddenName, injectHidden, hideFromBuilder, registerHiddenStrip } = require_hidden();
 var { CRON, covers, eventContentType, historyService, historyController, registerHistory, registerPurge } = require_history();
 var { trashContentType, trashService, trashController } = require_trash();
 var STRAPI5 = true;
+var withHidden = [];
 var store = (strapi) => strapi.store({ type: "plugin", name: PLUGIN });
 var LEGACY_PLUGIN = "block-picker";
 async function readSettings(strapi) {
@@ -1611,6 +1812,9 @@ module.exports = {
       settings: null,
       // Edit view field texts from code (never stored): { uid: { attribute: { label, description, placeholder } } }. See README "Field labels".
       fields: null,
+      // Other languages for the schema metadata (pluginOptions.blockscene, info.description), one flat map per locale:
+      // { 'pt-BR': require('./blockscene/pt-BR.json') }. See README "Describing blocks and fields in the schema".
+      translations: null,
       // "Hide on the site": boolean attribute added to every Dynamic Zone component (a DB column); false adds nothing.
       hiddenAttribute: "bsHidden"
     },
@@ -1620,9 +1824,11 @@ module.exports = {
   register({ strapi }) {
     const plugin = strapi.plugin(PLUGIN);
     const name = hiddenName(plugin.config("hiddenAttribute"));
+    withHidden = [];
     if (name === null) strapi.log.warn(`[${PLUGIN}] "hiddenAttribute" config ignored: expected a name like "bsHidden" or false. Hiding blocks is off.`);
     if (!name) return;
-    const { skipped } = injectHidden(strapi.components, strapi.contentTypes, name);
+    const { added, skipped } = injectHidden(strapi.components, strapi.contentTypes, name);
+    withHidden = added;
     if (skipped.length) strapi.log.warn(`[${PLUGIN}] "${name}" already exists with another type on ${skipped.join(", ")}; those blocks cannot be hidden.`);
   },
   async bootstrap({ strapi }) {
@@ -1639,8 +1845,10 @@ module.exports = {
     ]);
     strapi.plugin(PLUGIN).service("settings").projectDefaults();
     strapi.plugin(PLUGIN).service("settings").fields();
+    strapi.plugin(PLUGIN).service("settings").variants();
     registerPublishGuard(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) {
       registerHistory(strapi);
       registerPurge(strapi);
@@ -1658,33 +1866,53 @@ module.exports = {
       const code = strapi.plugin(PLUGIN).config("settings");
       project = null;
       if (code) try {
-        project = validateSettings(code, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi));
+        project = validateSettings(code, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
       } catch (error) {
         strapi.log?.warn(`[${PLUGIN}] "settings" config ignored: ${error.message}. Using the built-in defaults under the saved settings.`);
       }
       return project;
     };
+    let meta;
+    const schemaMeta = () => {
+      if (meta !== void 0) return meta;
+      const notes = [];
+      meta = schemaMetadata({ ...strapi.contentTypes, ...strapi.components }, strapi.plugin(PLUGIN).config("translations"), notes);
+      if (notes.length) strapi.log?.warn(`[${PLUGIN}] schema metadata left out: ${notes.slice(0, 20).join("; ")}${notes.length > 20 ? `; and ${notes.length - 20} more` : ""}.`);
+      return meta;
+    };
     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 stale = [];
+      let code = {};
       try {
-        fields = validateFields(strapi.plugin(PLUGIN).config("fields"), schemas, stale);
+        code = validateFields(strapi.plugin(PLUGIN).config("fields"), schemas, stale);
       } catch (error) {
-        fields = {};
-        strapi.log?.warn(`[${PLUGIN}] "fields" config ignored: ${error.message}. Field labels fall back to the Content Manager's own.`);
+        strapi.log?.warn(`[${PLUGIN}] "fields" config ignored: ${error.message}. Field labels fall back to the schema metadata and the Content Manager's own.`);
       }
       if (stale.length) strapi.log?.warn(`[${PLUGIN}] "fields" entries for fields the schema no longer has were skipped: ${stale.slice(0, 20).join(", ")}${stale.length > 20 ? ` and ${stale.length - 20} more` : ""}.`);
+      fields = structuredClone(schemaMeta().fields);
+      for (const [uid, entries] of Object.entries(code)) for (const [name, entry] of Object.entries(entries)) (fields[uid] ||= {})[name] = { ...fields[uid][name], ...entry };
       return fields;
     };
-    const get = async () => mergeSaved(layer(projectDefaults(), await readSettings(strapi)), componentUids(strapi), contentTypeUids(strapi), apiUids(strapi));
+    let variants;
+    const insertVariants = () => {
+      if (variants !== void 0) return variants;
+      const notes = [];
+      variants = validateVariants(strapi.plugin(PLUGIN).config("components"), strapi.components || {}, notes);
+      for (const note of notes) strapi.log?.warn(`[${PLUGIN}] components variants: ${note}.`);
+      return variants;
+    };
+    const get = async () => mergeSaved(layer(projectDefaults(), await readSettings(strapi)), componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
     return {
       projectDefaults,
       get,
       fields: fieldTexts,
+      schema: schemaMeta,
+      variants: insertVariants,
       async set(value) {
-        const next = validateSettings(value, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi));
+        const next = validateSettings(value, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
         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`);
         }
@@ -1711,10 +1939,12 @@ module.exports = {
           blockPreview: plugin.config("blockPreview"),
           groups: plugin.config("groups"),
           componentUids: componentUids(strapi),
-          schemas: strapi.components
+          schemas: strapi.components,
+          blocks: plugin.service("settings").schema().blocks
         });
         const settings = await plugin.service("settings").get();
         const media = await resolveMedia(strapi, settings);
+        for (const [uid, list] of Object.entries(plugin.service("settings").variants())) base.components[uid] = { ...base.components[uid], variants: list };
         for (const [uid, entry] of Object.entries(settings.components)) {
           base.components[uid] = {
             ...base.components[uid],
@@ -1727,8 +1957,10 @@ module.exports = {
         const hidden = hiddenName(plugin.config("hiddenAttribute")) || null;
         const types = Object.fromEntries(Object.entries(strapi.contentTypes || {}).filter(([uid]) => !uid.startsWith("admin::")).map(([uid, schema]) => [uid, [schema.info?.displayName || "", ...Object.keys(schema.attributes || {})]]));
         const history = STRAPI5 && strapi.documents?.use && !base.disabled && settings.history.enabled ? { contentTypes: apiUids(strapi).filter((uid) => covers(settings.history, uid)) } : null;
+        const layouts = Object.fromEntries(Object.entries(settings.components).filter(([uid, entry]) => entry.layout && base.groups?.[uid]).map(([uid, entry]) => [uid, entry.layout]));
         ctx.body = {
           ...base,
+          layouts,
           palette: settings.palette,
           contentTypes: settings.contentTypes,
           hiddenAttribute: hidden,
@@ -1742,12 +1974,13 @@ module.exports = {
     settings: ({ strapi }) => ({
       async find(ctx) {
         const settings = await strapi.plugin(PLUGIN).service("settings").get();
-        const auto = catalog({ components: strapi.plugin(PLUGIN).config("components"), schemas: strapi.components }).components;
+        const auto = catalog({ components: strapi.plugin(PLUGIN).config("components"), schemas: strapi.components, blocks: strapi.plugin(PLUGIN).service("settings").schema().blocks }).components;
         const components = Object.entries(strapi.components || {}).map(([uid, schema]) => ({
           uid,
           displayName: schema.info?.displayName || uid,
           category: schema.category || uid.split(".")[0],
-          typology: auto[uid]?.typology
+          typology: auto[uid]?.typology,
+          layoutFields: layoutFields(schema)
         }));
         const contentTypes = Object.keys(contentTypeUids(strapi)).map((uid) => ({
           uid,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aduptive/strapi-blockscene",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.9",
   "description": "Visual component gallery for native Strapi dynamic zones.",
   "license": "MIT",
   "author": "Andrea Scarpello <aduptive@gmail.com>",