@contentful/experiences-components-react 3.7.0-beta.0 → 3.7.0-dev-20250917T1203-0e23897.0

package/dist/index.js

@@ -3,7 +3,7 @@ import React, { forwardRef } from 'react';
 import { documentToReactComponents } from '@contentful/rich-text-react-renderer';
 import { BLOCKS } from '@contentful/rich-text-types';
 import { z } from 'zod';
-import cloneDeep from 'lodash.clonedeep';
+import { cloneDeep } from 'lodash-es';
 import 'md5';
 import { create } from 'zustand';
 
@@ -1339,7 +1339,7 @@ const BreakpointSchema = z
     id: propertyKeySchema,
     // Can be replace with z.templateLiteral when upgrading to zod v4
     query: z.string().refine((s) => BREAKPOINT_QUERY_REGEX.test(s)),
-    previewSize: z.string().optional(),
+    previewSize: z.string(),
     displayName: z.string(),
     displayIcon: z.enum(['desktop', 'tablet', 'mobile']).optional(),
 })
@@ -1393,25 +1393,6 @@ z.object({
     usedComponents: localeWrapper(UsedComponentsSchema).optional(),
 });
 
-function treeVisit$1(initialNode, onNode) {
-    const _treeVisit = (currentNode) => {
-        const children = [...currentNode.children];
-        onNode(currentNode);
-        for (const child of children) {
-            _treeVisit(child);
-        }
-    };
-    if (Array.isArray(initialNode)) {
-        for (const node of initialNode) {
-            _treeVisit(node);
-        }
-    }
-    else {
-        _treeVisit(initialNode);
-    }
-}
-
-const MAX_ALLOWED_PATHS = 200;
 const THUMBNAIL_IDS = [
     'columns',
     'columnsPlusRight',
@@ -1442,17 +1423,7 @@ const THUMBNAIL_IDS = [
 const VariableMappingSchema = z.object({
     parameterId: propertyKeySchema,
     type: z.literal('ContentTypeMapping'),
-    pathsByContentType: z
-        .record(z.string(), z.object({ path: z.string() }))
-        .superRefine((paths, ctx) => {
-        const variableId = ctx.path[ctx.path.length - 2];
-        if (Object.keys(paths).length > MAX_ALLOWED_PATHS) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `Too many paths defined for variable mapping with id "${variableId}", maximum allowed is ${MAX_ALLOWED_PATHS}`,
-            });
-        }
-    }),
+    pathsByContentType: z.record(z.string(), z.object({ path: z.string() })),
 });
 const PassToNodeSchema = z
     .object({
@@ -1476,10 +1447,7 @@ const ParameterDefinitionSchema = z.object({
     })
         .optional(),
     contentTypes: z.array(z.string()).min(1),
-    passToNodes: z
-        .array(PassToNodeSchema)
-        .max(1, 'At most one "passToNodes" element is allowed per parameter definition.')
-        .optional(), // we might change this to be empty array for native parameter definitions, that's why we don't use .length(1)
+    passToNodes: z.array(PassToNodeSchema).optional(),
 });
 const ParameterDefinitionsSchema = z.record(propertyKeySchema, ParameterDefinitionSchema);
 const VariableMappingsSchema = z.record(propertyKeySchema, VariableMappingSchema);
@@ -1500,108 +1468,14 @@ const ComponentSettingsSchema = z
     category: z.string().max(50, 'Category must contain at most 50 characters').optional(),
     prebindingDefinitions: z.array(PrebindingDefinitionSchema).length(1).optional(),
 })
-    .strict()
-    .superRefine((componentSettings, ctx) => {
-    const { variableDefinitions, prebindingDefinitions } = componentSettings;
-    if (!prebindingDefinitions || prebindingDefinitions.length === 0) {
-        return;
-    }
-    const { parameterDefinitions, variableMappings, allowedVariableOverrides } = prebindingDefinitions[0];
-    validateAtMostOneNativeParameterDefinition(parameterDefinitions, ctx);
-    validateNoOverlapBetweenMappingAndOverrides(variableMappings, allowedVariableOverrides, ctx);
-    validateMappingsAgainstVariableDefinitions(variableMappings, allowedVariableOverrides, variableDefinitions, ctx);
-    validateMappingsAgainstParameterDefinitions(variableMappings, parameterDefinitions, ctx);
-});
-z
-    .object({
+    .strict();
+z.object({
     componentTree: localeWrapper(ComponentTreeSchema),
     dataSource: localeWrapper(DataSourceSchema),
     unboundValues: localeWrapper(UnboundValuesSchema),
     usedComponents: localeWrapper(UsedComponentsSchema).optional(),
     componentSettings: localeWrapper(ComponentSettingsSchema),
-})
-    .superRefine((patternFields, ctx) => {
-    const { componentTree, componentSettings } = patternFields;
-    // values at this point are wrapped under locale code
-    const nonLocalisedComponentTree = Object.values(componentTree)[0];
-    const nonLocalisedComponentSettings = Object.values(componentSettings)[0];
-    if (!nonLocalisedComponentSettings || !nonLocalisedComponentTree) {
-        return;
-    }
-    validatePassToNodes(nonLocalisedComponentTree.children || [], nonLocalisedComponentSettings || {}, ctx);
 });
-const validateAtMostOneNativeParameterDefinition = (parameterDefinitions, ctx) => {
-    const nativeParamDefinitions = Object.values(parameterDefinitions).filter((paramDefinition) => !(paramDefinition.passToNodes && paramDefinition.passToNodes.length > 0));
-    if (nativeParamDefinitions.length > 1) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Only one native parameter definition (parameter definition without passToNodes) is allowed per prebinding definition.`,
-        });
-    }
-};
-const validateNoOverlapBetweenMappingAndOverrides = (variableMappings, allowedVariableOverrides, ctx) => {
-    const variableMappingKeys = Object.keys(variableMappings || {});
-    const overridesSet = new Set(allowedVariableOverrides || []);
-    const overlap = variableMappingKeys.filter((key) => overridesSet.has(key));
-    if (overlap.length > 0) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Found both variable mapping and allowed override for the following keys: ${overlap.map((key) => `"${key}"`).join(', ')}.`,
-        });
-    }
-};
-const validateMappingsAgainstVariableDefinitions = (variableMappings, allowedVariableOverrides, variableDefinitions, ctx) => {
-    const nonDesignVariableDefinitionKeys = Object.entries(variableDefinitions)
-        .filter(([_, def]) => def.group !== 'style')
-        .map(([key]) => key);
-    const variableMappingKeys = Object.keys(variableMappings || {});
-    const allKeys = [...variableMappingKeys, ...(allowedVariableOverrides || [])];
-    const invalidMappings = allKeys.filter((key) => !nonDesignVariableDefinitionKeys.includes(key));
-    if (invalidMappings.length > 0) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `The following variable mappings or overrides are missing from the variable definitions: ${invalidMappings.map((key) => `"${key}"`).join(', ')}.`,
-        });
-    }
-};
-const validateMappingsAgainstParameterDefinitions = (variableMappings, parameterDefinitions, ctx) => {
-    const parameterDefinitionKeys = Object.keys(parameterDefinitions || {});
-    for (const [mappingKey, mappingValue] of Object.entries(variableMappings || {})) {
-        if (!parameterDefinitionKeys.includes(mappingValue.parameterId)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `The variable mapping with id "${mappingKey}" references a non-existing parameterId "${mappingValue.parameterId}".`,
-            });
-        }
-    }
-};
-const validatePassToNodes = (rootChildren, componentSettings, ctx) => {
-    if (!componentSettings.prebindingDefinitions ||
-        componentSettings.prebindingDefinitions.length === 0) {
-        return;
-    }
-    const { parameterDefinitions } = componentSettings.prebindingDefinitions[0];
-    let nodeIds = new Set();
-    for (const paramDef of Object.values(parameterDefinitions || {})) {
-        paramDef.passToNodes?.forEach((n) => nodeIds.add(n.nodeId));
-    }
-    treeVisit$1(rootChildren, (node) => {
-        if (!node.id)
-            return;
-        if (nodeIds.has(node.id)) {
-            nodeIds.delete(node.id);
-        }
-    });
-    if (nodeIds.size > 0) {
-        const stringifiedNodeIds = Array.from(nodeIds)
-            .map((id) => `"${id}"`)
-            .join(', ');
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `The following node IDs referenced in passToNodes are not present in the component tree: ${stringifiedNodeIds}.`,
-        });
-    }
-};
 
 z
     .object({