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

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;
@@ -282,7 +316,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 +352,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 +380,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 +410,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 +449,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 +473,87 @@ var require_settings = __commonJS({
       }
       return out;
     }
+    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 +566,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, mergeSaved: mergeSaved2, layer: layer2, overrides: overrides2, safeUrl: safeUrl2, fail: fail2 };
   }
 });
 
@@ -1485,8 +1604,8 @@ 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 { PLUGIN, TEMPLATES, TYPOLOGIES, DEFAULTS, catalog, validateSettings, validateFields, validateVariants, mergeSaved, layer, overrides, validatePrefs, mergePrefs, safeUrl, fail } = require_settings();
+var { safeGroups, validateGroups, layoutFields } = require_groups();
 var { hiddenName, injectHidden, registerHiddenStrip } = require_hidden();
 var { CRON, covers, eventContentType, historyService, historyController, registerHistory, registerPurge } = require_history();
 var { trashContentType, trashService, trashController } = require_trash();
@@ -1639,6 +1758,7 @@ 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 (STRAPI5) {
@@ -1658,7 +1778,7 @@ 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.`);
       }
@@ -1678,13 +1798,22 @@ module.exports = {
       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` : ""}.`);
       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,
+      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`);
         }
@@ -1715,6 +1844,7 @@ module.exports = {
         });
         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 +1857,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,
@@ -1747,7 +1879,8 @@ module.exports = {
           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.8",
   "description": "Visual component gallery for native Strapi dynamic zones.",
   "license": "MIT",
   "author": "Andrea Scarpello <aduptive@gmail.com>",