@decocms/blocks-cli 7.37.4 → 7.37.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks-cli",
-  "version": "7.37.4",
+  "version": "7.37.6",
   "type": "module",
   "description": "Deco codegen (generate-blocks, generate-schema, generate-invoke) and Fresh-to-TanStack migration tooling",
   "repository": {
@@ -31,7 +31,7 @@
     "lint:unused": "knip"
   },
   "dependencies": {
-    "@decocms/blocks": "7.37.4",
+    "@decocms/blocks": "7.37.6",
     "ts-morph": "^27.0.0",
     "tsx": "^4.22.5"
   },

package/scripts/generate-schema.test.ts

@@ -191,6 +191,68 @@ describe("typeToJsonSchema with intersection types", () => {
   }, 30_000);
 });
 
+describe("typeToJsonSchema Section-typed props", () => {
+  // The framework's `Section` is opaque (`export type Section = any`), so a
+  // Section-typed prop is a "pick any section" reference emitted as a
+  // __SECTION_REF__ picker. This must keep working.
+  it("emits a __SECTION_REF__ picker for the framework's opaque Section[]", () => {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { skipLibCheck: true },
+    });
+    const sf = project.createSourceFile(
+      "props.ts",
+      `
+        type Section = any;
+        export interface Props {
+          children?: Section[] | null;
+        }
+      `,
+    );
+    const schema = typeToJsonSchema(sf.getInterfaceOrThrow("Props").getType());
+
+    expect(schema.properties.children).toMatchObject({
+      type: "array",
+      items: { $ref: "#/definitions/__SECTION_REF__" },
+    });
+  }, 30_000);
+
+  // Regression (casaevideo footer): a component that declares its own local
+  // `type Section = { label; items }` used to collide with the magic name and
+  // collapse into a non-editable __SECTION_REF__ picker — the footer columns
+  // showed only a drag handle, no expand arrow, no form. A concretely-shaped
+  // local type is user data and must render as an inline editable object.
+  it("keeps a user-defined local `type Section` as an inline editable object", () => {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { skipLibCheck: true },
+    });
+    const sf = project.createSourceFile(
+      "props.ts",
+      `
+        interface Item { label: string; href: string; }
+        type Section = { label: string; items: Item[] };
+        export interface Props {
+          sections?: Section[];
+        }
+      `,
+    );
+    const schema = typeToJsonSchema(sf.getInterfaceOrThrow("Props").getType());
+
+    const sections = schema.properties.sections;
+    // Editable array of objects — NOT a section-picker reference.
+    expect(sections.type).toBe("array");
+    expect(JSON.stringify(sections)).not.toContain("__SECTION_REF__");
+
+    const item = sections.items;
+    expect(item.type).toBe("object");
+    expect(item.properties.label).toMatchObject({ type: "string" });
+    expect(item.properties.items.type).toBe("array");
+    expect(item.properties.items.items.type).toBe("object");
+    expect(item.properties.items.items.properties.href).toMatchObject({ type: "string" });
+  }, 30_000);
+});
+
 describe("typeToJsonSchema loader block-ref matching", () => {
   // Regression: a loader that returns an array whose element type has no
   // resolvable name (`VNode[]`, `string[]`, …) used to be bucketed under the

package/scripts/generate-schema.ts

@@ -306,6 +306,33 @@ const SECTION_REF_DEF_KEY = "__SECTION_REF__";
 // Well-known definition key for Resolvable (saved blocks picker)
 const RESOLVABLE_KEY = "Resolvable";
 
+/**
+ * Whether a prop annotated `Section` / `Section[]` is the framework's opaque
+ * Section type (a "pick any section" reference) rather than a user-defined type
+ * that merely happens to be named `Section`.
+ *
+ * The framework's `Section` is opaque — `export type Section = any` in the
+ * scaffolded `~/types/deco.ts` — so it resolves to `any` (or `unknown`). A
+ * component that declares its own local `type Section = { label; items }`
+ * (e.g. a footer column list) resolves to a concrete object with properties;
+ * that is user data and must render as an inline editable object, NOT a picker.
+ *
+ * Discriminates by the resolved shape after stripping `| null | undefined` and
+ * the array wrapper: only the opaque type is a section reference.
+ */
+function isOpaqueSectionType(propType: Type): boolean {
+  let type = propType;
+  if (type.isUnion()) {
+    const nonNull = type.getUnionTypes().filter((u) => !u.isNull() && !u.isUndefined());
+    if (nonNull.length === 1) type = nonNull[0];
+  }
+  if (type.isArray()) {
+    const el = type.getArrayElementType();
+    if (el) type = el;
+  }
+  return type.isAny() || type.isUnknown();
+}
+
 // Only truly React-internal props that are never user-defined.
 // Do NOT include "children", "type", "props", or "key" — those are commonly
 // used as legitimate property names in data interfaces (e.g. SelectedFacet
@@ -560,9 +587,16 @@ export function typeToJsonSchema(type: Type, visited = new Set<string>(), ctx?:
           if (tn) typeHint = tn.getText();
         }
 
-        // Section type → section picker reference (resolved by composeMeta)
+        // Section type → section picker reference (resolved by composeMeta).
+        // Guard on the resolved shape: the name `Section` is not reserved, so a
+        // component may declare its own local `type Section = { label; items }`
+        // (e.g. a footer column list). Only the framework's opaque Section type
+        // becomes a picker; a concretely-shaped local type falls through to the
+        // normal inline-object handling below (`isOpaqueSectionType`).
         const baseHint = typeHint.replace(/\s*\|\s*(null|undefined)/g, "").trim();
-        if (baseHint === "Section" || baseHint === "Section[]" || baseHint === "Section[] | null") {
+        const isSectionName =
+          baseHint === "Section" || baseHint === "Section[]" || baseHint === "Section[] | null";
+        if (isSectionName && isOpaqueSectionType(propType)) {
           const isArray = baseHint.includes("[]");
           const sectionSchema: any = isArray
             ? {