@aduptive/strapi-blockscene 2.0.0-alpha.4 → 2.0.0-alpha.5

package/dist/server.cjs

@@ -118,6 +118,7 @@ var require_settings = __commonJS({
     var TEMPLATES2 = ["generic", "banner", "cards", "imageText", "faq", "none"];
     var INITIAL_STATES = ["closed", "open", "remember"];
     var PREVIEW_MODES = ["form", "split", "preview"];
+    var HIDDEN_MODES = ["strip", "flag", "off"];
     var DEFAULTS2 = {
       palette: { background: "#F6F6F9", surface: "#DCDCE4", text: "#32324D", accent: "#4945FF" },
       components: {},
@@ -125,11 +126,88 @@ var require_settings = __commonJS({
       // blockPreviewInForm: compact read-only preview above a block's fields in form
       // mode. Only installations that ship the accordion integration (server config
       // `blockPreview: true`) show and honour it; the page preview is the editor.
-      editor: { enabled: true, showOpenAll: true, showCloseAll: true, initialState: "closed", previewMode: "form", previewUrl: "", blockPreviewInForm: false }
+      editor: {
+        enabled: true,
+        showOpenAll: true,
+        showCloseAll: true,
+        showRowThumbnails: true,
+        initialState: "closed",
+        previewMode: "form",
+        previewUrl: "",
+        blockPreviewUrl: "",
+        blockPreviewInForm: false,
+        // Strapi 5: rich-text custom fields render a read-only preview until clicked (see admin/LazyInput.tsx).
+        lazyEditors: true,
+        lazyFields: ["plugin::ckeditor5.CKEditor"],
+        // Row actions in each block header (see README "Row actions"). hiddenBlocks: what the content API does with rows
+        // hidden on the site: 'strip' removes them, 'flag' sends them with the attribute, 'off' hides the eye icon.
+        confirmDelete: true,
+        hiddenBlocks: "strip",
+        duplicate: true,
+        clipboard: true
+      },
+      // 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: {}
+    };
+    var ICONS = ["text", "tag", "seo", "settings", "image", "link", "palette", "list", "globe", "info"];
+    var SIDEBAR_POSITIONS = ["left", "right", "bottom"];
+    var OPENS = ["modal", "drawer"];
+    var LABEL = /^[^<>]{1,40}$/;
+    var sidebarItem = (item, attributes) => item && typeof item === "object" && !Array.isArray(item) && Object.keys(item).every((key) => ["label", "icon", "open", "fields"].includes(key)) && typeof item.label === "string" && LABEL.test(item.label.trim()) && (item.icon === void 0 || item.icon === "" || ICONS.includes(item.icon)) && OPENS.includes(item.open) && Array.isArray(item.fields) && item.fields.length > 0 && item.fields.length <= 30 && item.fields.every((field) => typeof field === "string" && (!attributes || attributes.includes(field)));
+    var TYPE_KEYS = {
+      enabled: (value) => typeof value === "boolean",
+      previewMode: (value) => PREVIEW_MODES.includes(value),
+      sidebarPosition: (value) => SIDEBAR_POSITIONS.includes(value),
+      sidebar: (value, attributes) => Array.isArray(value) && value.length <= 12 && value.every((item) => sidebarItem(item, attributes))
     };
+    var typeMap = (types) => Array.isArray(types) ? Object.fromEntries(types.map((uid) => [uid, null])) : types || {};
     var PREVIEW_URL = /^https?:\/\/[^\s"'<>]{1,500}$/;
+    var blockPreviewUrl = (value) => typeof value === "string" && (value === "" || PREVIEW_URL.test(value) && !/[{}]/.test(value.replace(/\{(uid|name|category|variant|locale)\}/g, "")) && URL.canParse?.(value.replace(/[{}]/g, "")) !== false);
     var COLOR = /^#[0-9A-Fa-f]{6}$/;
+    var FIELD_UID = /^(plugin|global)::[\w.-]+$/;
+    var lazyFields = (value) => Array.isArray(value) && value.length <= 20 && value.every((uid) => typeof uid === "string" && FIELD_UID.test(uid));
     var UID = /^[a-z0-9-]+\.[a-z0-9-]+$/;
+    var TYPOLOGIES2 = ["hero", "text", "media", "listing", "cards", "cta", "form", "layout"];
+    var TAG = /^[^<>\n]{1,24}$/;
+    var cleanTags = (value) => Array.isArray(value) ? [...new Set(value.filter((tag) => typeof tag === "string" && TAG.test(tag.trim())).map((tag) => tag.trim()))].slice(0, 10) : [];
+    var validTags = (value) => Array.isArray(value) && value.length <= 10 && value.every((tag) => typeof tag === "string" && TAG.test(tag.trim()));
+    var GUESSES = [
+      ["hero", /hero|banner|cover/],
+      ["text", /text|rich|quote|title/],
+      ["media", /image|media|video|gallery|carousel/],
+      ["listing", /list|query|archive|related|posts|projects/],
+      ["cards", /card/],
+      ["cta", /cta|button|link/],
+      ["form", /form|contact/],
+      ["layout", /wrapper|column|grid|divider|divisor|spacer|section/]
+    ];
+    function guessTypology(uid, displayName = "") {
+      const name = `${uid.split(".").pop()} ${displayName}`.toLowerCase();
+      return GUESSES.find(([, pattern]) => pattern.test(name))?.[0] || "text";
+    }
+    function facetsOf(uid, schema, schemas = {}) {
+      const facets = /* @__PURE__ */ new Set();
+      const read = (attributes, nested) => {
+        for (const attr of Object.values(attributes || {})) {
+          if (attr?.type === "media") {
+            const allowed = attr.allowedTypes;
+            if (!allowed || allowed.includes("images")) facets.add("image");
+            if (!allowed || allowed.includes("videos")) facets.add("video");
+            if (attr.multiple) facets.add("gallery");
+          } else if (["richtext", "blocks"].includes(attr?.type) || attr?.type === "customField" && /ckeditor/i.test(String(attr.customField))) facets.add("richtext");
+          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);
+          }
+        }
+      };
+      read(schema?.attributes, false);
+      if (/query|archive|related/i.test(uid)) facets.add("dynamic");
+      if (/form|contact/i.test(`${uid} ${schema?.info?.displayName || ""}`)) facets.add("form");
+      return [...facets];
+    }
     var safeUrl2 = (value) => typeof value === "string" && (/^\/(?!\/)/.test(value) || /^https?:\/\//.test(value)) ? value : void 0;
     var { safeGroups: safeGroups2 } = require_groups();
     var safeVersion = (value) => typeof value === "string" && /^[\w.-]{1,32}$/.test(value) ? value : void 0;
@@ -156,6 +234,15 @@ var require_settings = __commonJS({
           ["label", "description", "category", "keywords"].filter((key) => typeof entry[key] === "string").map((key) => [key, entry[key]])
         );
         entries[uid].image = safeUrl2(entry.image);
+        if (TYPOLOGIES2.includes(entry.typology)) entries[uid].typology = entry.typology;
+        const tags = cleanTags(entry.tags);
+        if (tags.length || entries[uid].category) entries[uid].tags = tags.length ? tags : cleanTags([entries[uid].category]);
+      }
+      for (const [uid, schema] of Object.entries(config.schemas || {})) {
+        const entry = entries[uid] ||= {};
+        entry.facets = facetsOf(uid, schema, config.schemas);
+        entry.typology ||= guessTypology(uid, schema?.info?.displayName);
+        entry.tags ||= [];
       }
       return {
         components: entries,
@@ -167,7 +254,8 @@ var require_settings = __commonJS({
         groups: safeGroups2(config.groups, config.componentUids)
       };
     }
-    function validateSettings2(input, componentUids2) {
+    function validateSettings2(input, componentUids2, contentTypeUids2 = []) {
+      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");
       const out = structuredClone(DEFAULTS2);
@@ -179,9 +267,9 @@ var require_settings = __commonJS({
       }
       for (const [key, value] of Object.entries(input.editor || {})) {
         if (!(key in DEFAULTS2.editor)) fail2(`Unknown editor option "${key}"`);
-        const valid = key === "initialState" ? INITIAL_STATES.includes(value) : key === "previewMode" ? PREVIEW_MODES.includes(value) : key === "previewUrl" ? value === "" || typeof value === "string" && PREVIEW_URL.test(value) : typeof value === "boolean";
+        const valid = key === "initialState" ? INITIAL_STATES.includes(value) : key === "previewMode" ? PREVIEW_MODES.includes(value) : key === "hiddenBlocks" ? HIDDEN_MODES.includes(value) : key === "previewUrl" ? value === "" || typeof value === "string" && PREVIEW_URL.test(value) : key === "blockPreviewUrl" ? blockPreviewUrl(value) : key === "lazyFields" ? lazyFields(value) : typeof value === "boolean";
         if (!valid) fail2(`Invalid value for editor option "${key}"`);
-        out.editor[key] = key === "previewUrl" && value ? String(new URL(value).href).replace(/\/$/, "") : value;
+        out.editor[key] = key === "previewUrl" && value ? String(new URL(value).href).replace(/\/$/, "") : key === "lazyFields" ? [...new Set(value)] : value;
       }
       const components = input.components || {};
       if (typeof components !== "object" || Array.isArray(components)) fail2("components must be an object");
@@ -193,6 +281,12 @@ var require_settings = __commonJS({
           if (key === "template") {
             if (!TEMPLATES2.includes(entry.template)) fail2(`Unknown template for "${uid}"`);
             clean.template = entry.template;
+          } else if (key === "typology") {
+            if (!TYPOLOGIES2.includes(entry.typology)) fail2(`Unknown typology for "${uid}"`);
+            clean.typology = entry.typology;
+          } else if (key === "tags") {
+            if (!validTags(entry.tags)) fail2(`Invalid tags for "${uid}": up to 10, each 1 to 24 characters`);
+            clean.tags = cleanTags(entry.tags);
           } else if (key === "mediaId") {
             if (!Number.isInteger(entry.mediaId) || entry.mediaId <= 0) fail2(`Invalid media for "${uid}"`);
             clean.mediaId = entry.mediaId;
@@ -200,9 +294,21 @@ var require_settings = __commonJS({
         }
         if (Object.keys(clean).length) out.components[uid] = clean;
       }
+      const perType = input.contentTypes || {};
+      if (typeof perType !== "object" || Array.isArray(perType)) fail2("contentTypes must be an object");
+      for (const [uid, entry] of Object.entries(perType)) {
+        if (!(uid in types)) fail2(`Unknown content type "${uid}"`);
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) fail2(`Invalid entry for "${uid}"`);
+        for (const [key, value] of Object.entries(entry)) {
+          if (!(key in TYPE_KEYS)) fail2(`Unknown content type setting "${key}"`);
+          if (!TYPE_KEYS[key](value, types[uid])) fail2(`Invalid value for "${key}" of "${uid}"`);
+        }
+        if (Object.keys(entry).length) out.contentTypes[uid] = structuredClone(entry);
+      }
       return out;
     }
-    function mergeSaved2(saved, componentUids2) {
+    function mergeSaved2(saved, componentUids2, contentTypeUids2 = []) {
+      const types = typeMap(contentTypeUids2);
       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];
@@ -211,19 +317,156 @@ var require_settings = __commonJS({
         if (value === void 0 || typeof value !== typeof DEFAULTS2.editor[key]) continue;
         if (key === "initialState" && !INITIAL_STATES.includes(value)) continue;
         if (key === "previewMode" && !PREVIEW_MODES.includes(value)) continue;
+        if (key === "hiddenBlocks" && !HIDDEN_MODES.includes(value)) continue;
         if (key === "previewUrl" && value && !PREVIEW_URL.test(value)) continue;
+        if (key === "blockPreviewUrl" && !blockPreviewUrl(value)) continue;
+        if (key === "lazyFields") {
+          if (!Array.isArray(value)) continue;
+          out.editor[key] = [...new Set(value.filter((uid) => lazyFields([uid])))].slice(0, 20);
+          continue;
+        }
         out.editor[key] = value;
       }
-      for (const [uid, entry] of Object.entries(saved.components || {})) if (componentUids2.includes(uid) && entry && typeof entry === "object") out.components[uid] = { ...entry };
+      for (const [uid, entry] of Object.entries(saved.components || {})) {
+        if (!componentUids2.includes(uid) || !entry || typeof entry !== "object") continue;
+        const clean = { ...entry };
+        if ("typology" in clean && !TYPOLOGIES2.includes(clean.typology)) delete clean.typology;
+        if ("tags" in clean) {
+          clean.tags = cleanTags(clean.tags);
+          if (!clean.tags.length) delete clean.tags;
+        }
+        if (Object.keys(clean).length) out.components[uid] = clean;
+      }
+      for (const [uid, entry] of Object.entries(saved.contentTypes || {})) {
+        if (!(uid in types) || !entry || typeof entry !== "object") continue;
+        const fix = (key, value) => key === "sidebar" && Array.isArray(value) ? value.filter((item) => sidebarItem(item, types[uid])) : value;
+        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;
+      }
+      return out;
+    }
+    var ENTRY_KEYS = ["components", "contentTypes"];
+    function layer2(base, saved) {
+      if (!base) return saved;
+      const doc = saved && typeof saved === "object" ? saved : {};
+      return Object.fromEntries(Object.keys(DEFAULTS2).map((key) => [key, { ...base[key], ...doc[key] && typeof doc[key] === "object" ? doc[key] : {} }]));
+    }
+    function overrides2(next, base) {
+      if (!base) return next;
+      return Object.fromEntries(Object.keys(DEFAULTS2).map((key) => {
+        const entries = Object.entries(next[key] || {}).filter(([name, value]) => JSON.stringify(value) !== JSON.stringify(base[key]?.[name]));
+        if (ENTRY_KEYS.includes(key)) {
+          for (const uid of Object.keys(base[key] || {})) if (!(uid in (next[key] || {}))) entries.push([uid, {}]);
+        }
+        return [key, Object.fromEntries(entries)];
+      }));
+    }
+    var PREFS = { starred: 200, recent: 20 };
+    function validatePrefs2(input, componentUids2) {
+      if (!input || typeof input !== "object" || Array.isArray(input)) fail2("Preferences must be an object");
+      const out = { starred: [], recent: [] };
+      for (const [key, value] of Object.entries(input)) {
+        if (!(key in PREFS)) fail2(`Unknown preference "${key}"`);
+        if (!Array.isArray(value) || value.length > PREFS[key] || !value.every((uid) => typeof uid === "string" && componentUids2.includes(uid))) fail2(`Invalid value for "${key}"`);
+        out[key] = [...new Set(value)];
+      }
       return out;
     }
-    module2.exports = { PLUGIN: PLUGIN2, TEMPLATES: TEMPLATES2, DEFAULTS: DEFAULTS2, catalog: catalog2, validateSettings: validateSettings2, mergeSaved: mergeSaved2, safeUrl: safeUrl2, fail: fail2 };
+    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, mergeSaved: mergeSaved2, layer: layer2, overrides: overrides2, safeUrl: safeUrl2, fail: fail2 };
+  }
+});
+
+// server/hidden.js
+var require_hidden = __commonJS({
+  "server/hidden.js"(exports2, module2) {
+    "use strict";
+    var NAME = /^[a-zA-Z][a-zA-Z0-9_]{0,39}$/;
+    var DEFAULT_NAME = "bsHidden";
+    var hiddenName2 = (value) => value === void 0 ? DEFAULT_NAME : value === false ? false : typeof value === "string" && NAME.test(value) ? value : null;
+    var zoneComponents = (contentTypes) => [...new Set(Object.values(contentTypes || {}).flatMap((schema) => Object.values(schema?.attributes || {}).filter((attr) => attr?.type === "dynamiczone").flatMap((attr) => attr.components || [])))];
+    function injectHidden2(components, contentTypes, name) {
+      const added = [], skipped = [];
+      for (const uid of zoneComponents(contentTypes)) {
+        const schema = components?.[uid];
+        if (!schema) continue;
+        schema.attributes ||= {};
+        const current = schema.attributes[name];
+        if (current && current.type !== "boolean") {
+          skipped.push(uid);
+          continue;
+        }
+        if (!current) schema.attributes[name] = { type: "boolean", default: false, visible: false, configurable: false };
+        added.push(uid);
+      }
+      return { added, skipped };
+    }
+    function stripHidden(data, schema, schemaOf, name, depth = 0) {
+      if (!data || typeof data !== "object" || !schema || depth > 20) return data;
+      if (Array.isArray(data)) {
+        data.forEach((item) => stripHidden(item, schema, schemaOf, name, depth));
+        return data;
+      }
+      const walk = (value, target) => Array.isArray(value) ? value.forEach((item) => stripHidden(item, target, schemaOf, name, depth + 1)) : stripHidden(value, target, schemaOf, name, depth + 1);
+      for (const [key, attr] of Object.entries(schema.attributes || {})) {
+        const value = data[key];
+        if (value == null || typeof value !== "object") continue;
+        if (attr?.type === "dynamiczone" && Array.isArray(value)) {
+          data[key] = value.filter((row) => !(row && row[name] === true));
+          for (const row of data[key]) stripHidden(row, schemaOf(row?.__component), schemaOf, name, depth + 1);
+        } else if (attr?.type === "component") walk(value, schemaOf(attr.component));
+        else if (attr?.type === "relation" && attr.target) walk(value, schemaOf(attr.target));
+      }
+      return data;
+    }
+    var contentApi = (strapi) => {
+      try {
+        return strapi.requestContext?.get?.()?.state?.route?.info?.type === "content-api";
+      } catch {
+        return false;
+      }
+    };
+    var READS = ["findMany", "findOne", "findFirst"];
+    function registerHiddenStrip2(strapi, name, plugin) {
+      if (!name) return;
+      const schemaOf = (uid) => uid && (strapi.getModel?.(uid) || strapi.components?.[uid] || strapi.contentTypes?.[uid]);
+      const stripping = async () => {
+        try {
+          return (await plugin.service("settings").get()).editor.hiddenBlocks === "strip";
+        } catch {
+          return true;
+        }
+      };
+      const apply = async (uid, result) => result && contentApi(strapi) && await stripping() ? stripHidden(result, schemaOf(uid), schemaOf, name) : result;
+      if (strapi.documents?.use) {
+        strapi.documents.use(async (ctx, next) => {
+          const result = await next();
+          return READS.includes(ctx.action) ? apply(ctx.uid, result) : result;
+        });
+        return;
+      }
+      strapi.entityService?.decorate?.((service) => ({
+        async findMany(uid, params) {
+          return apply(uid, await service.findMany(uid, params));
+        },
+        async findOne(uid, id, params) {
+          return apply(uid, await service.findOne(uid, id, params));
+        },
+        async findPage(uid, params) {
+          const page = await service.findPage(uid, params);
+          if (page?.results) await apply(uid, page.results);
+          return page;
+        }
+      }));
+    }
+    module2.exports = { DEFAULT_NAME, hiddenName: hiddenName2, zoneComponents, injectHidden: injectHidden2, stripHidden, registerHiddenStrip: registerHiddenStrip2 };
   }
 });
 
 // server/index.js
-var { PLUGIN, TEMPLATES, DEFAULTS, catalog, validateSettings, mergeSaved, safeUrl, fail } = require_settings();
+var { PLUGIN, TEMPLATES, TYPOLOGIES, DEFAULTS, catalog, validateSettings, mergeSaved, layer, overrides, validatePrefs, mergePrefs, safeUrl, fail } = require_settings();
 var { safeGroups, validateGroups } = require_groups();
+var { hiddenName, injectHidden, registerHiddenStrip } = require_hidden();
 var store = (strapi) => strapi.store({ type: "plugin", name: PLUGIN });
 var LEGACY_PLUGIN = "block-picker";
 async function readSettings(strapi) {
@@ -247,6 +490,7 @@ async function resolveMedia(strapi, settings) {
   }
   return resolved;
 }
+var contentTypeUids = (strapi) => Object.fromEntries(Object.entries(strapi.contentTypes || {}).filter(([uid, schema]) => uid.startsWith("api::") && zonesOf(schema).length).map(([uid, schema]) => [uid, Object.keys(schema.attributes || {})]));
 var zonesOf = (schema) => Object.entries(schema?.attributes || {}).filter(([, attr]) => attr?.type === "dynamiczone").map(([name]) => name);
 var label = (error) => `row ${error.index + 1}: ${error.code === "closeBeforeOpen" ? `close marker ${error.uid} has no open marker before it` : error.code === "mismatch" ? `close marker ${error.uid} does not match the open group ${error.open} (expected ${error.expected})` : `group ${error.uid} is not closed (expected ${error.expected})`}`;
 function checkZones(strapi, uid, entry, groups) {
@@ -263,6 +507,11 @@ function registerPublishGuard(strapi) {
   const groups = safeGroups(plugin.config("groups"), componentUids(strapi));
   if (plugin.config("groups") && !groups) strapi.log.warn(`[${PLUGIN}] "groups" config ignored: expected { "<open component uid>": "<close component uid>" } with existing components; every block is treated as ordinary.`);
   if (!groups) return;
+  const active = async (uid) => {
+    if (plugin.config("disabled") === true) return false;
+    const settings = await plugin.service("settings").get();
+    return settings.editor.enabled && settings.contentTypes?.[uid]?.enabled !== false;
+  };
   if (strapi.documents?.use) {
     const defaultLocale = async () => {
       try {
@@ -277,7 +526,7 @@ function registerPublishGuard(strapi) {
       if (!publishing || !ctx.uid) return next();
       const model = strapi.getModel(ctx.uid);
       const zones = zonesOf(model);
-      if (!zones.length) return next();
+      if (!zones.length || !await active(ctx.uid)) return next();
       if (action === "create") {
         checkZones(strapi, ctx.uid, params.data || {}, groups);
         return next();
@@ -303,19 +552,19 @@ function registerPublishGuard(strapi) {
   const published = (data) => Boolean(data && data.publishedAt);
   strapi.db.lifecycles.subscribe({
     async beforeCreate(event) {
-      if (published(event.params?.data)) checkZones(strapi, event.model.uid, event.params.data, groups);
+      if (published(event.params?.data) && await active(event.model.uid)) checkZones(strapi, event.model.uid, event.params.data, groups);
     },
     async beforeUpdate(event) {
       const { data, where } = event.params || {};
       const zones = zonesOf(strapi.getModel(event.model.uid));
-      if (!published(data) || !zones.length) return;
+      if (!published(data) || !zones.length || !await active(event.model.uid)) return;
       const entry = zones.every((name) => Array.isArray(data[name])) ? data : { ...await strapi.entityService.findOne(event.model.uid, where?.id, { populate: zones }), ...data };
       checkZones(strapi, event.model.uid, entry, groups);
     },
     async beforeUpdateMany(event) {
       const { data, where } = event.params || {};
       const zones = zonesOf(strapi.getModel(event.model.uid));
-      if (!published(data) || !zones.length) return;
+      if (!published(data) || !zones.length || !await active(event.model.uid)) return;
       for (const entry of await strapi.entityService.findMany(event.model.uid, { filters: where, populate: zones })) checkZones(strapi, event.model.uid, entry, groups);
     }
   });
@@ -332,30 +581,65 @@ module.exports = {
       blockPreview: false,
       // Optional layout groups: OPEN component uid -> its CLOSE uid, e.g. { 'wrappers.join': 'wrappers.close' }.
       // Empty/absent: every Dynamic Zone component is an ordinary block. See README "Layout groups".
-      groups: null
+      groups: null,
+      // Project defaults from code: same shape as the stored settings, e.g. require('./blockscene.json'). See README "Settings page".
+      settings: null,
+      // "Hide on the site": boolean attribute added to every Dynamic Zone component (a DB column); false adds nothing.
+      hiddenAttribute: "bsHidden"
     },
     validator: catalog
   },
+  // Before the database schema sync, so the column exists. A name the host already uses with another type is skipped.
+  register({ strapi }) {
+    const plugin = strapi.plugin(PLUGIN);
+    const name = hiddenName(plugin.config("hiddenAttribute"));
+    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);
+    if (skipped.length) strapi.log.warn(`[${PLUGIN}] "${name}" already exists with another type on ${skipped.join(", ")}; those blocks cannot be hidden.`);
+  },
   async bootstrap({ strapi }) {
     await strapi.admin.services.permission.actionProvider.registerMany([
       { section: "plugins", displayName: "Read gallery settings", uid: "settings.read", pluginName: PLUGIN },
       { section: "plugins", displayName: "Change gallery settings", uid: "settings.update", pluginName: PLUGIN }
     ]);
+    strapi.plugin(PLUGIN).service("settings").projectDefaults();
     registerPublishGuard(strapi);
+    registerHiddenStrip(strapi, hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")), strapi.plugin(PLUGIN));
   },
-  services: { settings: ({ strapi }) => ({
-    async get() {
-      return mergeSaved(await readSettings(strapi), componentUids(strapi));
-    },
-    async set(value) {
-      const next = validateSettings(value, componentUids(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`);
+  services: { settings: ({ strapi }) => {
+    let project;
+    const projectDefaults = () => {
+      if (project !== void 0) return project;
+      const code = strapi.plugin(PLUGIN).config("settings");
+      project = null;
+      if (code) try {
+        project = validateSettings(code, componentUids(strapi), contentTypeUids(strapi));
+      } catch (error) {
+        strapi.log?.warn(`[${PLUGIN}] "settings" config ignored: ${error.message}. Using the built-in defaults under the saved settings.`);
       }
-      await store(strapi).set({ key: "settings", value: next });
-      return next;
-    }
-  }) },
+      return project;
+    };
+    const get = async () => mergeSaved(layer(projectDefaults(), await readSettings(strapi)), componentUids(strapi), contentTypeUids(strapi));
+    return {
+      projectDefaults,
+      get,
+      async set(value) {
+        const next = validateSettings(value, componentUids(strapi), contentTypeUids(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`);
+        }
+        await store(strapi).set({ key: "settings", value: overrides(next, projectDefaults()) });
+        return next;
+      },
+      // Back to the project defaults (or the built-in ones); the legacy copy goes too, or it would be migrated again.
+      async reset() {
+        await store(strapi).delete({ key: "settings" });
+        await strapi.store({ type: "plugin", name: LEGACY_PLUGIN }).delete({ key: "settings" });
+        return get();
+      }
+    };
+  } },
   controllers: {
     catalog: ({ strapi }) => ({
       async find(ctx) {
@@ -367,52 +651,92 @@ module.exports = {
           disabled: plugin.config("disabled"),
           blockPreview: plugin.config("blockPreview"),
           groups: plugin.config("groups"),
-          componentUids: componentUids(strapi)
+          componentUids: componentUids(strapi),
+          schemas: strapi.components
         });
         const settings = await plugin.service("settings").get();
         const media = await resolveMedia(strapi, settings);
         for (const [uid, entry] of Object.entries(settings.components)) {
-          base.components[uid] = { ...base.components[uid], ...media[uid], template: entry.template };
+          base.components[uid] = {
+            ...base.components[uid],
+            ...media[uid],
+            template: entry.template,
+            ...entry.typology && { typology: entry.typology },
+            ...entry.tags && { tags: entry.tags }
+          };
         }
+        const hidden = hiddenName(plugin.config("hiddenAttribute")) || null;
         ctx.body = {
           ...base,
           palette: settings.palette,
-          editor: { ...settings.editor, enabled: settings.editor.enabled && !base.disabled }
+          contentTypes: settings.contentTypes,
+          hiddenAttribute: hidden,
+          editor: { ...settings.editor, enabled: settings.editor.enabled && !base.disabled, ...!hidden && { hiddenBlocks: "off" } }
         };
       }
     }),
     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 components = Object.entries(strapi.components || {}).map(([uid, schema]) => ({
           uid,
           displayName: schema.info?.displayName || uid,
-          category: schema.category || uid.split(".")[0]
+          category: schema.category || uid.split(".")[0],
+          typology: auto[uid]?.typology
+        }));
+        const contentTypes = Object.keys(contentTypeUids(strapi)).map((uid) => ({
+          uid,
+          displayName: strapi.contentTypes[uid].info?.displayName || uid,
+          kind: strapi.contentTypes[uid].kind,
+          attributes: Object.entries(strapi.contentTypes[uid].attributes || {}).filter(([, attr]) => attr?.type !== "dynamiczone" && !attr?.private).map(([name, attr]) => ({ name, type: attr.type }))
         }));
         ctx.body = {
           settings,
           components,
+          contentTypes,
           media: await resolveMedia(strapi, settings),
           templates: TEMPLATES,
+          typologies: TYPOLOGIES,
           disabled: strapi.plugin(PLUGIN).config("disabled") === true,
+          hiddenAttribute: hiddenName(strapi.plugin(PLUGIN).config("hiddenAttribute")) || null,
           blockPreviewAvailable: strapi.plugin(PLUGIN).config("blockPreview") === true,
-          defaults: DEFAULTS
+          defaults: DEFAULTS,
+          projectDefaults: strapi.plugin(PLUGIN).service("settings").projectDefaults()
         };
       },
       async update(ctx) {
         ctx.body = await strapi.plugin(PLUGIN).service("settings").set(ctx.request?.body);
+      },
+      async reset(ctx) {
+        ctx.body = await strapi.plugin(PLUGIN).service("settings").reset();
+      }
+    }),
+    prefs: ({ strapi }) => ({
+      async find(ctx) {
+        const id = ctx.state?.user?.id;
+        if (!id) return ctx.unauthorized();
+        ctx.body = mergePrefs(await store(strapi).get({ key: `prefs:${id}` }), componentUids(strapi));
+      },
+      async update(ctx) {
+        const id = ctx.state?.user?.id;
+        if (!id) return ctx.unauthorized();
+        const value = validatePrefs(ctx.request?.body, componentUids(strapi));
+        await store(strapi).set({ key: `prefs:${id}`, value });
+        ctx.body = value;
       }
     })
   },
   routes: { admin: { type: "admin", routes: [
     { method: "GET", path: "/catalog", handler: "catalog.find", config: { policies: ["admin::isAuthenticatedAdmin"] } },
-    ...["find", "update"].map((handler, index) => ({
-      method: index ? "PUT" : "GET",
+    ...["GET", "PUT"].map((method) => ({ method, path: "/me/prefs", handler: `prefs.${method === "GET" ? "find" : "update"}`, config: { policies: ["admin::isAuthenticatedAdmin"] } })),
+    ...[["GET", "find", "read"], ["PUT", "update", "update"], ["DELETE", "reset", "update"]].map(([method, handler, action]) => ({
+      method,
       path: "/settings",
       handler: `settings.${handler}`,
       config: { policies: ["admin::isAuthenticatedAdmin", {
         name: "admin::hasPermissions",
-        config: { actions: [`plugin::${PLUGIN}.settings.${index ? "update" : "read"}`] }
+        config: { actions: [`plugin::${PLUGIN}.settings.${action}`] }
       }] }
     }))
   ] } }

package/package.json

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