@contentful/experiences-visual-editor-react 3.6.2 → 3.7.0-prerelease-20250915T1724-8825648.0

package/dist/index.js

@@ -808,6 +808,25 @@ z.object({
     usedComponents: localeWrapper$1(UsedComponentsSchema$1).optional(),
 });
 
+function treeVisit$1$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$1 = 200;
 const THUMBNAIL_IDS$1 = [
     'columns',
     'columnsPlusRight',
@@ -838,7 +857,17 @@ const THUMBNAIL_IDS$1 = [
 const VariableMappingSchema$1 = z.object({
     parameterId: propertyKeySchema$1,
     type: z.literal('ContentTypeMapping'),
-    pathsByContentType: z.record(z.string(), z.object({ path: z.string() })),
+    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$1) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Too many paths defined for variable mapping with id "${variableId}", maximum allowed is ${MAX_ALLOWED_PATHS$1}`,
+            });
+        }
+    }),
 });
 const PassToNodeSchema$1 = z
     .object({
@@ -862,7 +891,10 @@ const ParameterDefinitionSchema$1 = z.object({
     })
         .optional(),
     contentTypes: z.array(z.string()).min(1),
-    passToNodes: z.array(PassToNodeSchema$1).optional(),
+    passToNodes: z
+        .array(PassToNodeSchema$1)
+        .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)
 });
 const ParameterDefinitionsSchema$1 = z.record(propertyKeySchema$1, ParameterDefinitionSchema$1);
 const VariableMappingsSchema$1 = z.record(propertyKeySchema$1, VariableMappingSchema$1);
@@ -883,14 +915,107 @@ const ComponentSettingsSchema$1 = z
     category: z.string().max(50, 'Category must contain at most 50 characters').optional(),
     prebindingDefinitions: z.array(PrebindingDefinitionSchema$1).length(1).optional(),
 })
-    .strict();
-z.object({
+    .strict()
+    .superRefine((componentSettings, ctx) => {
+    const { variableDefinitions, prebindingDefinitions } = componentSettings;
+    if (!prebindingDefinitions || prebindingDefinitions.length === 0) {
+        return;
+    }
+    const { parameterDefinitions, variableMappings, allowedVariableOverrides } = prebindingDefinitions[0];
+    validateAtMostOneNativeParameterDefinition$1(parameterDefinitions, ctx);
+    validateNoOverlapBetweenMappingAndOverrides$1(variableMappings, allowedVariableOverrides, ctx);
+    validateMappingsAgainstVariableDefinitions$1(variableMappings, allowedVariableOverrides, variableDefinitions, ctx);
+    validateMappingsAgainstParameterDefinitions$1(variableMappings, parameterDefinitions, ctx);
+});
+z
+    .object({
     componentTree: localeWrapper$1(ComponentTreeSchema$1),
     dataSource: localeWrapper$1(DataSourceSchema$1),
     unboundValues: localeWrapper$1(UnboundValuesSchema$1),
     usedComponents: localeWrapper$1(UsedComponentsSchema$1).optional(),
     componentSettings: localeWrapper$1(ComponentSettingsSchema$1),
+})
+    .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$1(nonLocalisedComponentTree.children || [], nonLocalisedComponentSettings || {}, ctx);
 });
+const validateAtMostOneNativeParameterDefinition$1 = (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$1 = (variableMappings, allowedVariableOverrides, ctx) => {
+    const variableMappingKeys = Object.keys(variableMappings || {});
+    const overlap = variableMappingKeys.filter((key) => allowedVariableOverrides?.includes(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$1 = (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$1 = (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$1 = (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$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({
@@ -3656,6 +3781,25 @@ 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',
@@ -3686,7 +3830,17 @@ const THUMBNAIL_IDS = [
 const VariableMappingSchema = z.object({
     parameterId: propertyKeySchema,
     type: z.literal('ContentTypeMapping'),
-    pathsByContentType: z.record(z.string(), z.object({ path: z.string() })),
+    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}`,
+            });
+        }
+    }),
 });
 const PassToNodeSchema = z
     .object({
@@ -3710,7 +3864,10 @@ const ParameterDefinitionSchema = z.object({
     })
         .optional(),
     contentTypes: z.array(z.string()).min(1),
-    passToNodes: z.array(PassToNodeSchema).optional(),
+    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)
 });
 const ParameterDefinitionsSchema = z.record(propertyKeySchema, ParameterDefinitionSchema);
 const VariableMappingsSchema = z.record(propertyKeySchema, VariableMappingSchema);
@@ -3731,14 +3888,107 @@ const ComponentSettingsSchema = z
     category: z.string().max(50, 'Category must contain at most 50 characters').optional(),
     prebindingDefinitions: z.array(PrebindingDefinitionSchema).length(1).optional(),
 })
-    .strict();
-z.object({
+    .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({
     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 overlap = variableMappingKeys.filter((key) => allowedVariableOverrides?.includes(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({