@decocms/blocks 7.20.8 → 7.20.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks",
-  "version": "7.20.8",
+  "version": "7.20.9",
   "type": "module",
   "engines": {
     "node": ">=24"

package/src/cms/resolve.test.ts

@@ -638,3 +638,73 @@ describe("resolveDecoPage — #277 client-side navigation disables deferral", ()
     expect(result?.deferredSections).toHaveLength(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Hidden array items — a `never`-gated multivariate wrapper must vanish from
+// the array, not survive as a `null` hole the section renders as empty.
+//
+// The admin (Studio) hides an array item by wrapping it in
+// `{ __resolveType: "website/flags/multivariate.ts", variants: [{ value, rule:
+// { __resolveType: "website/matchers/never.ts" } }] }`. `never` never matches,
+// so the wrapper resolves to "not present" and the item is dropped.
+// ---------------------------------------------------------------------------
+
+describe("hidden array items (never matcher)", () => {
+  const NEVER = "website/matchers/never.ts";
+  const ALWAYS = "website/matchers/always.ts";
+  const MULTIVARIATE = "website/flags/multivariate.ts";
+
+  const hidden = (value: unknown) => ({
+    __resolveType: MULTIVARIATE,
+    variants: [{ value, rule: { __resolveType: NEVER } }],
+  });
+
+  it("drops a hidden item from an array instead of leaving a null hole", async () => {
+    const benefits = [
+      { label: "Parcelamento" },
+      { label: "Frete" },
+      hidden({ label: "RetiradaLoja" }),
+      hidden({ label: "EntregaExpressa" }),
+    ];
+
+    const result = (await resolveValue({ benefits }, undefined, {})) as {
+      benefits: unknown[];
+    };
+
+    expect(result.benefits).toEqual([{ label: "Parcelamento" }, { label: "Frete" }]);
+    // No null holes.
+    expect(result.benefits).not.toContain(null);
+  });
+
+  it("keeps a visible (always-gated) item in the array", async () => {
+    const benefits = [
+      {
+        __resolveType: MULTIVARIATE,
+        variants: [{ value: { label: "Shown" }, rule: { __resolveType: ALWAYS } }],
+      },
+      hidden({ label: "Hidden" }),
+    ];
+
+    const result = (await resolveValue({ benefits }, undefined, {})) as {
+      benefits: unknown[];
+    };
+
+    expect(result.benefits).toEqual([{ label: "Shown" }]);
+  });
+
+  it("preserves a legitimate null value in an array (matched variant resolving to null)", async () => {
+    // A matched variant whose value is literally null stays — only the
+    // no-match sentinel is filtered, not every null.
+    const items = [
+      {
+        __resolveType: MULTIVARIATE,
+        variants: [{ value: null, rule: { __resolveType: ALWAYS } }],
+      },
+      { label: "kept" },
+    ];
+
+    const result = (await resolveValue({ items }, undefined, {})) as { items: unknown[] };
+
+    expect(result.items).toEqual([null, { label: "kept" }]);
+  });
+});

package/src/cms/resolve.ts

@@ -780,7 +780,14 @@ async function resolveProps(
 async function internalResolve(value: unknown, rctx: ResolveContext): Promise<unknown> {
   if (!value || typeof value !== "object") return value;
   if (Array.isArray(value)) {
-    return Promise.all(value.map((item) => internalResolve(item, rctx)));
+    const resolved = await Promise.all(value.map((item) => internalResolve(item, rctx)));
+    // Drop items that resolved to "not present" (`undefined`) — e.g. a hidden
+    // array item (a multivariate wrapped in a `never` matcher, see the admin's
+    // hideArrayItem) where no variant matched. A `never`-gated item must vanish
+    // from the array, NOT become a `null` hole the section then renders as an
+    // empty card. Legitimate `null` values (a matched variant that resolved to
+    // null, a failed loader) are kept — only the no-match sentinel is filtered.
+    return resolved.filter((item) => item !== undefined);
   }
 
   const obj = value as Record<string, unknown>;
@@ -833,7 +840,10 @@ async function internalResolve(value: unknown, rctx: ResolveContext): Promise<un
     resolveType === WELL_KNOWN_TYPES.MULTIVARIATE_SECTION
   ) {
     const variants = obj.variants as Array<{ value: unknown; rule?: unknown }> | undefined;
-    if (!variants || variants.length === 0) return null;
+    // No variant matched (incl. a single `never`-gated variant, i.e. a hidden
+    // item) → resolve to `undefined`, the "not present" sentinel the array
+    // branch filters out, rather than `null`, which would survive as a hole.
+    if (!variants || variants.length === 0) return undefined;
 
     for (const variant of variants) {
       const rule = variant.rule as Record<string, unknown> | undefined;
@@ -841,7 +851,7 @@ async function internalResolve(value: unknown, rctx: ResolveContext): Promise<un
         return internalResolve(variant.value, childCtx);
       }
     }
-    return null;
+    return undefined;
   }
 
   // Commerce loaders