@aduptive/strapi-blockscene 2.0.0-alpha.10 → 2.0.0-alpha.12

package/dist/server.cjs

@@ -21,6 +21,10 @@ var require_groups = __commonJS({
       return Object.keys(out).length ? out : null;
     }
     var uidOf = (row) => typeof row?.__component === "string" ? row.__component : "";
+    var invalidComponents2 = (rows, allowed) => {
+      const uids = new Set(Array.isArray(allowed) ? allowed : []);
+      return (Array.isArray(rows) ? rows : []).flatMap((row, index) => uidOf(row) && !uids.has(uidOf(row)) ? [{ index, uid: uidOf(row) }] : []);
+    };
     var isOpener = (row, g) => Boolean(g) && Object.prototype.hasOwnProperty.call(g, uidOf(row));
     var isClose = (row, g) => Boolean(g) && Object.values(g).includes(uidOf(row));
     var blockKey = (row) => row && row.id != null ? `${row.__component}#${row.id}` : row && row.__temp_key__ != null ? String(row.__temp_key__) : null;
@@ -127,6 +131,7 @@ var require_groups = __commonJS({
     module2.exports = {
       safeGroups: safeGroups2,
       validateGroups: validateGroups2,
+      invalidComponents: invalidComponents2,
       groupRange,
       groupRows,
       topLevelRanges,
@@ -182,7 +187,7 @@ var require_settings = __commonJS({
         // Edit view labels that are still the raw attribute name read as "Mobile columns count" (see README "Field labels").
         friendlyLabels: true,
         // Page preview pane (Strapi 5): which toolbar controls show, in order, and the width menu's entries.
-        previewToolbar: ["modes", "history", "devices", "status", "actions"],
+        previewToolbar: ["modes", "history", "versions", "devices", "status", "actions"],
         previewDevices: ["fit", "mobile", "tablet", "desktop"]
       },
       // Per content type (only the ones with a Dynamic Zone): { enabled: false } turns the plugin off there;
@@ -197,7 +202,7 @@ var require_settings = __commonJS({
     var SIDEBAR_POSITIONS = ["left", "right", "bottom"];
     var OPENS = ["modal", "drawer"];
     var LABEL = /^[^<>]{1,40}$/;
-    var TOOLBAR = ["modes", "history", "devices", "status", "actions"];
+    var TOOLBAR = ["modes", "history", "versions", "devices", "status", "actions"];
     var DEVICE_NAMES = ["fit", "mobile", "tablet", "desktop"];
     var previewToolbar = (value) => Array.isArray(value) && value.every((id) => TOOLBAR.includes(id)) && new Set(value).size === value.length;
     var DEVICE_LABEL = /^[^<>]{1,24}$/;
@@ -619,6 +624,102 @@ var require_settings = __commonJS({
       }
       return out;
     }
+    function requiredProblems(schema, values, schemas, path, media, problems) {
+      for (const [field, attr] of Object.entries(schema?.attributes || {})) {
+        const at = `${path}.${field}`;
+        const supplied = Object.hasOwn(values, field);
+        const value = supplied ? values[field] : attr.default;
+        if (attr.type === "media" || attr.type === "relation") {
+          if (attr.required && !supplied) media.push(at);
+          continue;
+        }
+        if (attr.type === "component") {
+          const nested = schemas[attr.component];
+          if (!nested) {
+            problems.push(`${at}: unknown component "${attr.component}"`);
+            continue;
+          }
+          if (attr.repeatable) {
+            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 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);
+          continue;
+        }
+        if (attr.required && (value === void 0 || value === null || value === "")) problems.push(`${at} is required`);
+      }
+    }
+    function validateKits2(input, contentTypes = {}, schemas = {}, 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");
+        return {};
+      }
+      const out = {};
+      for (const [uid, kits] of Object.entries(input)) {
+        const type = contentTypes[uid];
+        if (!type || !uid.startsWith("api::")) {
+          notes.push(`${uid}: unknown content type`);
+          continue;
+        }
+        if (!Array.isArray(kits) || kits.length > 12) {
+          notes.push(`${uid}: kits must be a list of at most 12`);
+          continue;
+        }
+        const ids = /* @__PURE__ */ new Set();
+        for (const kit of kits) {
+          const name = `${uid} kit "${kit?.id ?? "?"}"`;
+          try {
+            if (!plain(kit) || Object.keys(kit).some((key) => !["id", "label", "locales", "zones"].includes(key))) throw new Error("expected { id, label, locales?, zones }");
+            if (!text(kit.id) || !VARIANT.id.test(kit.id) || ids.has(kit.id)) throw new Error('id must be 1 to 40 lowercase letters, digits, "-" or "_", unique per content type');
+            if (!fieldText(kit.label, 60)) throw new Error('label must be a string of 1 to 60 characters, or { "<locale>": string }');
+            if (kit.locales !== void 0 && (!Array.isArray(kit.locales) || !kit.locales.length || kit.locales.length > 20 || kit.locales.some((locale) => !text(locale) || !LOCALE.test(locale)))) throw new Error("locales must be 1 to 20 locale codes");
+            if (!plain(kit.zones) || !Object.keys(kit.zones).length) throw new Error("zones must be a non-empty object");
+            const zones = {};
+            for (const [zoneName, rows] of Object.entries(kit.zones)) {
+              const zone = type.attributes?.[zoneName];
+              if (zone?.type !== "dynamiczone") throw new Error(`unknown Dynamic Zone "${zoneName}"`);
+              if (!Array.isArray(rows) || !rows.length || rows.length > 50) throw new Error(`${zoneName} must contain 1 to 50 rows`);
+              const clean = [];
+              for (let index = 0; index < rows.length; index++) {
+                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`);
+                const skipped = [];
+                const values = variantValues(row, schemas[component], schemas, `${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);
+                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`);
+                  clean.push({ __component: close, values: {} });
+                }
+              }
+              if (clean.length > (zone.max ?? Infinity)) throw new Error(`${zoneName} exceeds its maximum of ${zone.max}`);
+              zones[zoneName] = clean;
+            }
+            for (const [zoneName, zone] of Object.entries(type.attributes || {})) {
+              if (zone?.type !== "dynamiczone") continue;
+              const minimum = Math.max(zone.min ?? 0, zone.required ? 1 : 0);
+              if ((zones[zoneName]?.length || 0) < minimum) throw new Error(`${zoneName} requires at least ${minimum} row${minimum === 1 ? "" : "s"}`);
+            }
+            ids.add(kit.id);
+            (out[uid] ||= []).push({ id: kit.id, label: structuredClone(kit.label), ...kit.locales && { locales: [...new Set(kit.locales)] }, zones });
+          } 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");
@@ -631,7 +732,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, validateVariants: validateVariants2, schemaMetadata: schemaMetadata2, 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, validateKits: validateKits2, schemaMetadata: schemaMetadata2, mergeSaved: mergeSaved2, layer: layer2, overrides: overrides2, safeUrl: safeUrl2, fail: fail2 };
   }
 });
 
@@ -821,8 +922,8 @@ var require_diff = __commonJS({
     }
     function summarize(before, after, schema) {
       const zones = Object.entries(schema?.attributes || {}).filter(([, attr]) => attr?.type === "dynamiczone").map(([name]) => name);
-      const blocks = { added: 0, removed: 0, changed: 0 };
-      if (!before) return { initial: true, fields: [], blocks };
+      const blocks = { total: zones.reduce((n, name) => n + (Array.isArray(after?.[name]) ? after[name].length : 0), 0), added: 0, removed: 0, changed: 0 };
+      if (!before) return { initial: true, fields: [], blocks: { ...blocks, added: blocks.total } };
       const names = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after || {})])];
       const fields = names.filter((name) => !zones.includes(name) && !same(before[name], after?.[name])).sort();
       for (const name of zones) for (const { op } of diffRows(before[name], after?.[name])) if (op !== "same") blocks[op]++;
@@ -1293,7 +1394,6 @@ var require_history = __commonJS({
     var CRON2 = "blocksceneHistoryPurge";
     var BATCH = 500;
     var DAY = 24 * 60 * 60 * 1e3;
-    var LIST_LIMIT = 100;
     var ACTORS_LIMIT = 500;
     var SEARCH_LIMIT = 200;
     var eventContentType2 = { schema: {
@@ -1436,14 +1536,23 @@ var require_history = __commonJS({
           return name && name !== "id" && schemaOf(uid)?.attributes?.[name] && !["relation", "media", "component", "dynamiczone", "password", "json", "blocks"].includes(schemaOf(uid).attributes[name].type) ? name : null;
         },
         // Latest events of one document and locale, newest first; `stored`: its snapshot (or an identical one) can be loaded.
-        async list({ uid, documentId, locale }) {
-          const where = { contentType: uid, relatedDocumentId: documentId, locale: locale || null };
-          const [list, kept] = await Promise.all([
-            events().findMany({ select: ["id", "action", "actor", "actorName", "at", "summary", "hash", "size"], where, orderBy: [{ at: "desc" }, { id: "desc" }], limit: LIST_LIMIT }),
-            events().findMany({ select: ["hash"], where: { ...where, size: { $gt: 0 } } })
+        async list({ uid, documentId, locale, actor = "", page = 1, pageSize = 25 }) {
+          const scope2 = { contentType: uid, relatedDocumentId: documentId, locale: locale || null };
+          const where = { ...scope2, ...actor && { actor } };
+          const [list, kept, total, people] = await Promise.all([
+            events().findMany({ select: ["id", "action", "actor", "actorName", "at", "summary", "hash", "size"], where, orderBy: [{ at: "desc" }, { id: "desc" }], offset: (page - 1) * pageSize, limit: pageSize }),
+            events().findMany({ select: ["hash"], where: { ...scope2, size: { $gt: 0 } } }),
+            events().count({ where }),
+            events().findMany({ select: ["actor", "actorName"], where: scope2, orderBy: [{ at: "desc" }, { id: "desc" }] })
           ]);
           const hashes = new Set(kept.map((row) => row.hash));
-          return list.map(({ hash, size, ...event }) => ({ ...event, stored: Boolean(hash && hashes.has(hash)) }));
+          const actors2 = [...new Map(people.slice().reverse().map(({ actor: actor2, actorName }) => [actor2, { actor: actor2, actorName }])).values()];
+          return {
+            results: list.map(({ hash, size, ...event }) => ({ ...event, stored: Boolean(hash && hashes.has(hash)) })),
+            pagination: { page, pageSize, total, pageCount: Math.ceil(total / pageSize) },
+            actors: actors2,
+            locale: locale || null
+          };
         },
         // One event with its snapshot (from an identical event when this one was deduplicated) and what loading it needs:
         // the media files and relation targets that still exist (relation labels from the Content Manager's main field).
@@ -1655,10 +1764,13 @@ var require_history = __commonJS({
       async list(ctx) {
         const { uid, documentId } = ctx.params || {};
         const locale = ctx.query?.locale || "";
-        if (!String(uid).startsWith("api::") || !strapi.contentTypes?.[uid] || !DOCUMENT_ID.test(documentId || "") || locale && !LOCALE.test(locale)) return ctx.badRequest("Invalid content type, document or locale");
+        const actor = ctx.query?.actor || "";
+        const page = int(ctx.query?.page, 1, 1e6), pageSize = int(ctx.query?.pageSize, 25, 100);
+        if (typeof actor !== "string" || actor && !ACTOR.test(actor) || [page, pageSize].some(Number.isNaN)) return ctx.badRequest("Invalid history filters");
+        if (!String(uid).startsWith("api::") || !strapi.contentTypes?.[uid] || !DOCUMENT_ID.test(documentId || "") || typeof locale !== "string" || locale && !LOCALE.test(locale)) return ctx.badRequest("Invalid content type, document or locale");
         if (!canRead(strapi, ctx, uid)) return ctx.forbidden();
         const history = strapi.plugin(PLUGIN2).service("history");
-        ctx.body = { results: await history.list({ uid, documentId, locale: (await history.scope(uid, locale || void 0))[0] }) };
+        ctx.body = await history.list({ uid, documentId, locale: (await history.scope(uid, locale || void 0))[0], actor, page, pageSize });
       },
       async find(ctx) {
         const id = Number(ctx.params?.id);
@@ -1685,8 +1797,8 @@ var require_history = __commonJS({
 });
 
 // server/index.js
-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 { PLUGIN, TEMPLATES, TYPOLOGIES, DEFAULTS, catalog, validateSettings, validateFields, validateVariants, validateKits, schemaMetadata, mergeSaved, layer, overrides, validatePrefs, mergePrefs, safeUrl, fail } = require_settings();
+var { safeGroups, validateGroups, invalidComponents, 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();
@@ -1719,6 +1831,18 @@ var contentTypeUids = (strapi) => Object.fromEntries(Object.entries(strapi.conte
 var apiUids = (strapi) => Object.keys(strapi.contentTypes || {}).filter((uid) => uid.startsWith("api::"));
 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})`}`;
+var componentLabel = (error) => `row ${error.index + 1}: component "${error.uid}" is not allowed in this Dynamic Zone`;
+function checkComponents(strapi, uid, entry) {
+  const schema = strapi.getModel(uid);
+  for (const name of zonesOf(schema)) {
+    if (!Array.isArray(entry?.[name])) continue;
+    const errors = invalidComponents(entry[name], schema.attributes[name].components);
+    if (errors.length) fail(
+      `Block components in "${name}" are not allowed by its schema (${errors.map(componentLabel).join("; ")}).`,
+      { plugin: PLUGIN, field: name, errors: errors.map((error) => ({ path: [name, error.index], message: componentLabel(error), name: "ValidationError", code: "componentNotAllowed", uid: error.uid })) }
+    );
+  }
+}
 function checkZones(strapi, uid, entry, groups) {
   for (const name of zonesOf(strapi.getModel(uid))) {
     const errors = validateGroups(Array.isArray(entry?.[name]) ? entry[name] : [], groups);
@@ -1728,11 +1852,10 @@ function checkZones(strapi, uid, entry, groups) {
     );
   }
 }
-function registerPublishGuard(strapi) {
+function registerZoneGuards(strapi) {
   const plugin = strapi.plugin(PLUGIN);
   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();
@@ -1749,12 +1872,14 @@ function registerPublishGuard(strapi) {
     strapi.documents.use(async (ctx, next) => {
       const { action, params = {} } = ctx;
       const publishing = action === "publish" || (action === "create" || action === "update") && params.status === "published";
-      if (!publishing || !ctx.uid) return next();
+      if (!ctx.uid || !["create", "update", "publish"].includes(action)) return next();
       const model = strapi.getModel(ctx.uid);
       const zones = zonesOf(model);
       if (!zones.length || !await active(ctx.uid)) return next();
+      if (action === "create" || action === "update") checkComponents(strapi, ctx.uid, params.data || {});
+      if (!publishing) return next();
       if (action === "create") {
-        checkZones(strapi, ctx.uid, params.data || {}, groups);
+        if (groups) checkZones(strapi, ctx.uid, params.data || {}, groups);
         return next();
       }
       const populate = Object.fromEntries(zones.map((name) => [name, true]));
@@ -1769,7 +1894,8 @@ function registerPublishGuard(strapi) {
       }
       for (const draft of drafts) {
         const entry = action === "update" ? { ...draft || {}, ...Object.fromEntries(zones.filter((name) => Array.isArray(params.data?.[name])).map((name) => [name, params.data[name]])) } : draft;
-        checkZones(strapi, ctx.uid, entry, groups);
+        checkComponents(strapi, ctx.uid, entry);
+        if (groups) checkZones(strapi, ctx.uid, entry, groups);
       }
       return next();
     });
@@ -1778,20 +1904,31 @@ function registerPublishGuard(strapi) {
   const published = (data) => Boolean(data && data.publishedAt);
   strapi.db.lifecycles.subscribe({
     async beforeCreate(event) {
-      if (published(event.params?.data) && await active(event.model.uid)) checkZones(strapi, event.model.uid, event.params.data, groups);
+      const data = event.params?.data, uid = event.model.uid;
+      if (!zonesOf(strapi.getModel(uid)).length || !await active(uid)) return;
+      checkComponents(strapi, uid, data || {});
+      if (groups && published(data)) checkZones(strapi, uid, data, groups);
     },
     async beforeUpdate(event) {
       const { data, where } = event.params || {};
       const zones = zonesOf(strapi.getModel(event.model.uid));
-      if (!published(data) || !zones.length || !await active(event.model.uid)) return;
+      if (!zones.length || !await active(event.model.uid)) return;
+      checkComponents(strapi, event.model.uid, data || {});
+      if (!published(data)) 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);
+      checkComponents(strapi, event.model.uid, entry);
+      if (groups) 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 || !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);
+      if (!zones.length || !await active(event.model.uid)) return;
+      checkComponents(strapi, event.model.uid, data || {});
+      if (!published(data)) return;
+      for (const entry of await strapi.entityService.findMany(event.model.uid, { filters: where, populate: zones })) {
+        checkComponents(strapi, event.model.uid, entry);
+        if (groups) checkZones(strapi, event.model.uid, entry, groups);
+      }
     }
   });
 }
@@ -1812,6 +1949,8 @@ module.exports = {
       settings: null,
       // Edit view field texts from code (never stored): { uid: { attribute: { label, description, placeholder } } }. See README "Field labels".
       fields: null,
+      // Initial block sets per content type, shown only on a new empty entry. See README "Starter kits".
+      kits: 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,
@@ -1846,7 +1985,8 @@ module.exports = {
     strapi.plugin(PLUGIN).service("settings").projectDefaults();
     strapi.plugin(PLUGIN).service("settings").fields();
     strapi.plugin(PLUGIN).service("settings").variants();
-    registerPublishGuard(strapi);
+    strapi.plugin(PLUGIN).service("settings").kits();
+    registerZoneGuards(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) {
@@ -1904,6 +2044,14 @@ module.exports = {
       for (const note of notes) strapi.log?.warn(`[${PLUGIN}] components variants: ${note}.`);
       return variants;
     };
+    let kits;
+    const starterKits = () => {
+      if (kits !== void 0) return kits;
+      const notes = [];
+      kits = validateKits(strapi.plugin(PLUGIN).config("kits"), strapi.contentTypes || {}, strapi.components || {}, safeGroups(strapi.plugin(PLUGIN).config("groups"), componentUids(strapi)), notes);
+      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);
     return {
       projectDefaults,
@@ -1911,6 +2059,7 @@ module.exports = {
       fields: fieldTexts,
       schema: schemaMeta,
       variants: insertVariants,
+      kits: starterKits,
       async set(value) {
         const next = validateSettings(value, componentUids(strapi), contentTypeUids(strapi), apiUids(strapi), strapi.components);
         for (const [uid, entry] of Object.entries(next.components)) {
@@ -1961,6 +2110,7 @@ module.exports = {
         ctx.body = {
           ...base,
           layouts,
+          kits: plugin.service("settings").kits(),
           palette: settings.palette,
           contentTypes: settings.contentTypes,
           hiddenAttribute: hidden,

package/package.json

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