@contentful/experiences-core 1.11.0-dev-20240718T2005-1c07c3a.0 → 1.11.0-prerelease-20240726T1510-9e11672.0

package/dist/entity/EntityStore.d.ts

@@ -19,9 +19,9 @@ declare class EntityStore extends EntityStoreBase {
     get schemaVersion(): "2023-09-28" | undefined;
     get breakpoints(): {
         id: string;
-        displayName: string;
         query: string;
         previewSize: string;
+        displayName: string;
         displayIcon?: "desktop" | "tablet" | "mobile" | undefined;
     }[];
     get dataSource(): Record<string, {

package/dist/index.js

@@ -972,21 +972,7 @@ let designTokensRegistry = {};
 // Therefore only border and in the future text related design tokens are/will be checked in this funciton.
 // Ensuring values for simple key-value design tokens are not neccessary since they are required via typescript.
 const ensureValidCompositeValues = (designTokenDefinition) => {
-    // Text token validation
-    if (designTokenDefinition.text) {
-        for (const textKey in designTokenDefinition.text) {
-            const textValue = designTokenDefinition.text[textKey];
-            designTokenDefinition.text[textKey] = {
-                emphasis: textValue.emphasis || 'none',
-                fontSize: textValue.fontSize || '16px',
-                case: textValue.case || 'normal',
-                fontWeight: textValue.fontWeight || '400',
-                lineHeight: textValue.lineHeight || '20px',
-                letterSpacing: textValue.letterSpacing || '0px',
-                color: textValue.color || '#000000',
-            };
-        }
-    }
+    // TODO: add validation logic when text related design tokens are added
     // Border validation
     if (designTokenDefinition.border) {
         for (const borderKey in designTokenDefinition.border) {
@@ -1071,17 +1057,13 @@ const DefinitionPropertyTypeSchema = z.enum([
 const DefinitionPropertyKeySchema = z
     .string()
     .regex(/^[a-zA-Z0-9-_]{1,32}$/, { message: 'Property needs to match: /^[a-zA-Z0-9-_]{1,32}$/' });
-z.object({
-    id: DefinitionPropertyKeySchema,
-    variables: z.record(DefinitionPropertyKeySchema, z.object({
-        // TODO - extend with definition of validations and defaultValue
-        displayName: z.string().optional(),
-        type: DefinitionPropertyTypeSchema,
-        description: z.string().optional(),
-        group: z.string().optional(),
-    })),
-});
-
+const PrimitiveValueSchema = z.union([
+    z.string(),
+    z.boolean(),
+    z.number(),
+    z.record(z.any(), z.any()),
+    z.undefined(),
+]);
 const uuidKeySchema = z
     .string()
     .regex(/^[a-zA-Z0-9-_]{1,21}$/, { message: 'Does not match /^[a-zA-Z0-9-_]{1,21}$/' });
@@ -1100,13 +1082,6 @@ const DataSourceSchema = z.record(uuidKeySchema, z.object({
         linkType: z.enum(['Entry', 'Asset']),
     }),
 }));
-const PrimitiveValueSchema = z.union([
-    z.string(),
-    z.boolean(),
-    z.number(),
-    z.record(z.any(), z.any()),
-    z.undefined(),
-]);
 const ValuesByBreakpointSchema = z.record(z.lazy(() => PrimitiveValueSchema));
 const DesignValueSchema = z
     .object({
@@ -1168,27 +1143,29 @@ const BaseComponentTreeNodeSchema = z.object({
 const ComponentTreeNodeSchema = BaseComponentTreeNodeSchema.extend({
     children: z.lazy(() => ComponentTreeNodeSchema.array()),
 });
-const ComponentSettingsSchema = z.object({
-    variableDefinitions: z.record(z.string().regex(/^[a-zA-Z0-9-_]{1,54}$/), // Here the key is <variableName>_<nanoidId> so we need to allow for a longer length
-    z.object({
-        displayName: z.string().optional(),
-        type: DefinitionPropertyTypeSchema,
-        defaultValue: PrimitiveValueSchema.or(ComponentPropertyValueSchema).optional(),
-        description: z.string().optional(),
-        group: z.string().optional(),
-        validations: z
-            .object({
-            required: z.boolean().optional(),
-            format: z.literal('URL').optional(),
-            in: z
-                .array(z.object({
-                value: z.union([z.string(), z.number()]),
-                displayName: z.string().optional(),
-            }))
-                .optional(),
-        })
+const ComponentVariableSchema = z.object({
+    displayName: z.string().optional(),
+    type: DefinitionPropertyTypeSchema,
+    description: z.string().optional(),
+    group: z.string().optional(),
+    defaultValue: PrimitiveValueSchema.or(ComponentPropertyValueSchema).optional(),
+    validations: z
+        .object({
+        required: z.boolean().optional(),
+        format: z.literal('URL').optional(),
+        in: z
+            .array(z.object({
+            value: z.union([z.string(), z.number()]),
+            displayName: z.string().optional(),
+        }))
             .optional(),
-    })),
+    })
+        .optional(),
+});
+const ComponentVariablesSchema = z.record(z.string().regex(/^[a-zA-Z0-9-_]{1,54}$/), // Here the key is <variableName>_<nanoidId> so we need to allow for a longer length
+ComponentVariableSchema);
+const ComponentSettingsSchema = z.object({
+    variableDefinitions: ComponentVariablesSchema,
 });
 const UsedComponentsSchema = z.array(z.object({
     sys: z.object({
@@ -1267,6 +1244,115 @@ z
 })
     .superRefine(componentSettingsRefinement);
 
+z.object({
+    id: DefinitionPropertyKeySchema,
+    variables: z.record(DefinitionPropertyKeySchema, ComponentVariableSchema.extend({
+        defaultValue: PrimitiveValueSchema.optional(),
+    }).superRefine((val, ctx) => {
+        switch (val.type) {
+            case 'Array':
+                if (typeof val.defaultValue !== 'undefined') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue is not supported for "Array" type for ${ctx.path.join('.')}`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Boolean':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'boolean') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be a boolean when type is "Boolean" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Date':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'string') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be a string when type is "Date" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Hyperlink':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'string') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be a string when type is "Hyperlink" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Link':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'object') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue is not supported for "Link" type for ${ctx.path.join('.')}`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Location':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'object') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be an object when type is "Location" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Media':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'string') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be a string when type is "Media" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Number':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'number') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be a number when type is "Number" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Object':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'object') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be an object when type is "Object" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'RichText':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'object') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be an object when type is "RichText" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+            case 'Text':
+                if (typeof val.defaultValue !== 'undefined' && typeof val.defaultValue !== 'string') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `defaultValue must be a string when type is "Text" for ${ctx.path.join('.')}, got ${typeof val.defaultValue} instead`,
+                        fatal: false,
+                    });
+                }
+                break;
+        }
+    })),
+});
+
 var CodeNames;
 (function (CodeNames) {
     CodeNames["Type"] = "type";
@@ -1367,6 +1453,7 @@ const zodToContentfulError = (issue) => {
             return defaultConversion(issue);
     }
 };
+
 const validateBreakpointsDefinition = (breakpoints) => {
     const result = z
         .array(BreakpointSchema)