@squiz/dxp-cli-next 5.31.0-develop.4 → 5.31.0-develop.6

package/lib/page/utils/definitions.spec.js

@@ -37,8 +37,60 @@ const definitions_1 = require("./definitions");
 const validation_1 = require("../templates/validation");
 jest.mock('node:fs/promises');
 describe('loadLayoutDefinition', () => {
-    const paintLayoutFileYaml = './some-dir/page-layout.yaml';
-    const paintLayoutFileJson = './some-dir/page-layout.json';
+    const manifestJson = './some-dir/manifest.json';
+    const pageLayoutYaml = './some-dir/page-layout.yaml';
+    const jsonContent = JSON.stringify({
+        name: 'test-layout',
+        displayName: 'Test Layout',
+        description: 'A test layout',
+        zones: [
+            {
+                key: 'main',
+                displayName: 'Main Zone',
+                description: 'Main content area',
+            },
+        ],
+        properties: {
+            color: {
+                title: 'Color',
+                description: 'Color options',
+                type: 'string',
+                enum: ['red', 'blue'],
+            },
+            showHeader: {
+                title: 'Show Header',
+                description: 'Toggle header visibility',
+                type: 'boolean',
+            },
+            customTitle: {
+                title: 'Custom Title',
+                description: 'Enter a custom title',
+                type: 'string',
+            },
+        },
+        entry: 'template.hbs',
+    });
+    // missing "name" field
+    const jsonContentInvalidLayout = JSON.stringify({
+        displayName: 'Test Layout',
+        description: 'A test layout',
+        zones: [
+            {
+                key: 'main',
+                displayName: 'Main Zone',
+                description: 'Main content area',
+            },
+        ],
+        properties: {
+            color: {
+                title: 'Color',
+                description: 'Color options',
+                type: 'string',
+                enum: ['red', 'blue'],
+            },
+        },
+        entry: 'template.hbs',
+    });
     const yamlContent = `
 name: test-layout
 displayName: Test Layout
@@ -71,145 +123,56 @@ options:
     values: ['red', 'blue']
 entry: template.hbs
   `;
-    const jsonContent = JSON.stringify({
-        name: 'test-layout',
-        displayName: 'Test Layout',
-        description: 'A test layout',
-        zones: {
-            main: {
-                displayName: 'Main Zone',
-                description: 'Main content area',
-                minNodes: 1,
-            },
-        },
-        options: {
-            color: {
-                displayName: 'Color',
-                description: 'Color options',
-                values: ['red', 'blue'],
-            },
-        },
-        entry: 'template.hbs',
-    });
-    // missing "name" field
-    const jsonContentInvalidLayout = JSON.stringify({
-        displayName: 'Test Layout',
-        description: 'A test layout',
-        zones: {
-            main: {
-                displayName: 'Main Zone',
-                description: 'Main content area',
-                minNodes: 1,
-            },
-        },
-        options: {
-            color: {
-                displayName: 'Color',
-                description: 'Color options',
-                values: ['red', 'blue'],
-            },
-        },
-        entry: 'template.hbs',
-    });
     const templateContent = '<div>{{content}}</div>';
     beforeEach(() => {
         jest.resetAllMocks();
     });
-    it('should load layout definition from YAML file', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should load layout definition from manifest JSON file', () => __awaiter(void 0, void 0, void 0, function* () {
         fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                return yamlContent;
+            if (filePath.endsWith('manifest.json')) {
+                return jsonContent;
             }
             if (filePath.endsWith('template.hbs')) {
                 return templateContent;
             }
             throw new Error('File not found');
         });
-        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml);
+        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(manifestJson);
         expect(layoutDefinition).toEqual({
             name: 'test-layout',
             displayName: 'Test Layout',
             description: 'A test layout',
-            zones: {
-                main: {
+            zones: [
+                {
+                    key: 'main',
                     displayName: 'Main Zone',
                     description: 'Main content area',
-                    minNodes: 1,
                 },
-            },
-            options: {
+            ],
+            properties: {
                 color: {
-                    displayName: 'Color',
+                    title: 'Color',
                     description: 'Color options',
-                    values: ['red', 'blue'],
+                    type: 'string',
+                    enum: ['red', 'blue'],
                 },
-            },
-            template: templateContent,
-        });
-    }));
-    it('should load layout definition from JSON file', () => __awaiter(void 0, void 0, void 0, function* () {
-        fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                throw { code: 'ENOENT' };
-            }
-            if (filePath.endsWith('page-layout.json')) {
-                return jsonContent;
-            }
-            if (filePath.endsWith('template.hbs')) {
-                return templateContent;
-            }
-            throw new Error('File not found');
-        });
-        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(paintLayoutFileJson);
-        expect(layoutDefinition).toEqual({
-            name: 'test-layout',
-            displayName: 'Test Layout',
-            description: 'A test layout',
-            zones: {
-                main: {
-                    displayName: 'Main Zone',
-                    description: 'Main content area',
-                    minNodes: 1,
+                showHeader: {
+                    title: 'Show Header',
+                    description: 'Toggle header visibility',
+                    type: 'boolean',
                 },
-            },
-            options: {
-                color: {
-                    displayName: 'Color',
-                    description: 'Color options',
-                    values: ['red', 'blue'],
+                customTitle: {
+                    title: 'Custom Title',
+                    description: 'Enter a custom title',
+                    type: 'string',
                 },
             },
             template: templateContent,
         });
     }));
-    it('should throw validation error if invalid data for YAML', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should throw validation error if invalid data for manifest JSON', () => __awaiter(void 0, void 0, void 0, function* () {
         fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                return yamlContentInvalidLayout;
-            }
-            if (filePath.endsWith('template.hbs')) {
-                return templateContent;
-            }
-            throw new Error('File not found');
-        });
-        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml)).rejects
-            .toThrowErrorMatchingInlineSnapshot(`
-      "Failed loading layout definition: Failed to parse ./some-dir/page-layout.yaml: [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "received": "undefined",
-          "path": [
-            "name"
-          ],
-          "message": "Required"
-        }
-      ]"
-    `);
-    }));
-    it('should throw validation error if invalid data for JSON', () => __awaiter(void 0, void 0, void 0, function* () {
-        fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.json')) {
+            if (filePath.endsWith('manifest.json')) {
                 return jsonContentInvalidLayout;
             }
             if (filePath.endsWith('template.hbs')) {
@@ -217,49 +180,17 @@ entry: template.hbs
             }
             throw new Error('File not found');
         });
-        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileJson)).rejects
+        yield expect((0, definitions_1.loadLayoutDefinition)(manifestJson)).rejects
             .toThrowErrorMatchingInlineSnapshot(`
-      "Failed loading layout definition: Failed to parse ./some-dir/page-layout.json: [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "received": "undefined",
-          "path": [
-            "name"
-          ],
-          "message": "Required"
-        }
-      ]"
-    `);
-    }));
-    it('should throw an error if YAML layout file has invalid YAML', () => __awaiter(void 0, void 0, void 0, function* () {
-        fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                return 'name: invalid yaml, entry: template.hbs';
-            }
-            if (filePath.endsWith('page-layout.json')) {
-                return jsonContent;
-            }
-            if (filePath.endsWith('template.hbs')) {
-                return templateContent;
-            }
-            throw new Error('File not found');
-        });
-        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml)).rejects
-            .toThrowErrorMatchingInlineSnapshot(`
-      "Failed loading layout definition: Failed to parse ./some-dir/page-layout.yaml: Nested mappings are not allowed in compact mappings at line 1, column 7:
+      "Failed loading layout definition: Failed to parse ./some-dir/manifest.json:
 
-      name: invalid yaml, entry: template.hbs
-            ^
-      "
+      Schema validation failed:
+        - Required at "name""
     `);
     }));
-    it('should throw an error if JSON layout file has invalid JSON', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should throw an error if JSON layout file has invalid manifest JSON', () => __awaiter(void 0, void 0, void 0, function* () {
         fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                throw { code: 'ENOENT' };
-            }
-            if (filePath.endsWith('page-layout.json')) {
+            if (filePath.endsWith('manifest.json')) {
                 return '{invalid: json';
             }
             if (filePath.endsWith('template.hbs')) {
@@ -267,9 +198,9 @@ entry: template.hbs
             }
             throw new Error('File not found');
         });
-        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileJson)).rejects
+        yield expect((0, definitions_1.loadLayoutDefinition)(manifestJson)).rejects
             .toThrowErrorMatchingInlineSnapshot(`
-      "Failed loading layout definition: Failed to parse ./some-dir/page-layout.json: Flow map must end with a } at line 1, column 15:
+      "Failed loading layout definition: Failed to parse ./some-dir/manifest.json: Flow map must end with a } at line 1, column 15:
 
       {invalid: json
                     ^
@@ -277,122 +208,38 @@ entry: template.hbs
     `);
     }));
     it('should throw an error if layout file do not have valid extension', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield expect((0, definitions_1.loadLayoutDefinition)('/foo/paint-layout.html')).rejects.toThrow('Layout file must have a valid extension: [yaml|json]');
+        yield expect((0, definitions_1.loadLayoutDefinition)('/foo/manifest.html')).rejects.toThrow('Layout file must have a valid extension: [yaml|json]');
     }));
     it('should throw an error if template file is not found', () => __awaiter(void 0, void 0, void 0, function* () {
         fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                return yamlContent;
+            if (filePath.endsWith('manifest.json')) {
+                return jsonContent;
             }
             throw Error('File not found');
         });
-        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml)).rejects.toThrow('Failed loading layout definition: Failed loading template file "template.hbs": File not found');
-    }));
-    it('should load layout definition without options field from YAML file', () => __awaiter(void 0, void 0, void 0, function* () {
-        const yamlContentWithoutOptions = `
-name: test-layout
-displayName: Test Layout
-description: A test layout
-zones:
-  main:
-    displayName: Main Zone
-    description: Main content area
-    minNodes: 1
-entry: template.hbs
-    `;
-        fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                return yamlContentWithoutOptions;
-            }
-            if (filePath.endsWith('template.hbs')) {
-                return templateContent;
-            }
-            throw new Error('File not found');
-        });
-        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml);
-        expect(layoutDefinition).toEqual({
-            name: 'test-layout',
-            displayName: 'Test Layout',
-            description: 'A test layout',
-            zones: {
-                main: {
-                    displayName: 'Main Zone',
-                    description: 'Main content area',
-                    minNodes: 1,
-                },
-            },
-            template: templateContent,
-        });
-    }));
-    it('should load layout definition without maxNodes in zones from YAML file', () => __awaiter(void 0, void 0, void 0, function* () {
-        const yamlContentWithoutMaxNodes = `
-name: test-layout
-displayName: Test Layout
-description: A test layout
-zones:
-  main:
-    displayName: Main Zone
-    description: Main content area
-    minNodes: 1
-  sidebar:
-    displayName: Sidebar Zone
-    description: Sidebar content area
-    minNodes: 0
-entry: template.hbs
-    `;
-        fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                return yamlContentWithoutMaxNodes;
-            }
-            if (filePath.endsWith('template.hbs')) {
-                return templateContent;
-            }
-            throw new Error('File not found');
-        });
-        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml);
-        expect(layoutDefinition).toEqual({
-            name: 'test-layout',
-            displayName: 'Test Layout',
-            description: 'A test layout',
-            zones: {
-                main: {
-                    displayName: 'Main Zone',
-                    description: 'Main content area',
-                    minNodes: 1,
-                },
-                sidebar: {
-                    displayName: 'Sidebar Zone',
-                    description: 'Sidebar content area',
-                    minNodes: 0,
-                },
-            },
-            template: templateContent,
-        });
+        yield expect((0, definitions_1.loadLayoutDefinition)(manifestJson)).rejects.toThrow('Failed loading layout definition: Failed loading template file "template.hbs": File not found');
     }));
-    it('should load layout definition without options and maxNodes from JSON file', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should load layout definition without options and maxNodes from manifest JSON file', () => __awaiter(void 0, void 0, void 0, function* () {
         const jsonContentWithoutOptionsAndMaxNodes = JSON.stringify({
             name: 'test-layout',
             displayName: 'Test Layout',
             description: 'A test layout',
-            zones: {
-                main: {
+            zones: [
+                {
+                    key: 'main',
                     displayName: 'Main Zone',
                     description: 'Main content area',
-                    minNodes: 1,
                 },
-                sidebar: {
+                {
+                    key: 'sidebar',
                     displayName: 'Sidebar Zone',
                     description: 'Sidebar content area',
-                    minNodes: 0,
                 },
-            },
+            ],
             entry: 'template.hbs',
         });
         fs.readFile.mockImplementation((filePath) => {
-            if (filePath.endsWith('page-layout.yaml')) {
-                throw { code: 'ENOENT' };
-            }
-            if (filePath.endsWith('page-layout.json')) {
+            if (filePath.endsWith('manifest.json')) {
                 return jsonContentWithoutOptionsAndMaxNodes;
             }
             if (filePath.endsWith('template.hbs')) {
@@ -400,41 +247,443 @@ entry: template.hbs
             }
             throw new Error('File not found');
         });
-        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(paintLayoutFileJson);
+        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(manifestJson);
         expect(layoutDefinition).toEqual({
             name: 'test-layout',
             displayName: 'Test Layout',
             description: 'A test layout',
-            zones: {
-                main: {
+            zones: [
+                {
+                    key: 'main',
                     displayName: 'Main Zone',
                     description: 'Main content area',
-                    minNodes: 1,
                 },
-                sidebar: {
+                {
+                    key: 'sidebar',
                     displayName: 'Sidebar Zone',
                     description: 'Sidebar content area',
-                    minNodes: 0,
                 },
-            },
+            ],
             template: templateContent,
         });
     }));
+    describe('YAML format (deprecated)', () => {
+        it('should load layout definition from YAML file', () => __awaiter(void 0, void 0, void 0, function* () {
+            fs.readFile.mockImplementation((filePath) => {
+                if (filePath.endsWith('page-layout.yaml')) {
+                    return yamlContent;
+                }
+                if (filePath.endsWith('template.hbs')) {
+                    return templateContent;
+                }
+                throw new Error('File not found');
+            });
+            const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(pageLayoutYaml);
+            expect(layoutDefinition).toEqual({
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                zones: [
+                    {
+                        key: 'main',
+                        displayName: 'Main Zone',
+                        description: 'Main content area',
+                    },
+                ],
+                properties: {
+                    color: {
+                        title: 'Color',
+                        description: 'Color options',
+                        type: 'string',
+                        enum: ['red', 'blue'],
+                    },
+                },
+                template: templateContent,
+            });
+        }));
+        it('should throw validation error if invalid data for YAML', () => __awaiter(void 0, void 0, void 0, function* () {
+            fs.readFile.mockImplementation((filePath) => {
+                if (filePath.endsWith('page-layout.yaml')) {
+                    return yamlContentInvalidLayout;
+                }
+                if (filePath.endsWith('template.hbs')) {
+                    return templateContent;
+                }
+                throw new Error('File not found');
+            });
+            yield expect((0, definitions_1.loadLayoutDefinition)(pageLayoutYaml)).rejects
+                .toThrowErrorMatchingInlineSnapshot(`
+        "Failed loading layout definition: Failed to parse ./some-dir/page-layout.yaml:
+
+        Schema validation failed:
+          - Required at "name""
+      `);
+        }));
+        it('should throw an error if YAML contains properties (instead of options)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const yamlContentWithProperties = `
+      name: test-layout
+      displayName: Test Layout
+      description: A test layout
+      zones:
+        main:
+          displayName: Main Zone
+          description: Main content area
+      properties:
+        color:
+          title: Color
+          description: Color options
+          type: string
+          enum: ['red', 'blue']
+      entry: template.hbs
+      `;
+            fs.readFile.mockImplementation((filePath) => {
+                if (filePath.endsWith('page-layout.yaml')) {
+                    return yamlContentWithProperties;
+                }
+                if (filePath.endsWith('template.hbs')) {
+                    return templateContent;
+                }
+                throw new Error('File not found');
+            });
+            yield expect((0, definitions_1.loadLayoutDefinition)(pageLayoutYaml)).rejects
+                .toThrowErrorMatchingInlineSnapshot(`
+        "Failed loading layout definition: Failed to parse ./some-dir/page-layout.yaml:
+
+        Schema validation failed:
+          - Unrecognized key(s) in object: 'properties'"
+      `);
+        }));
+        it('should throw an error if YAML layout file has invalid YAML', () => __awaiter(void 0, void 0, void 0, function* () {
+            fs.readFile.mockImplementation((filePath) => {
+                if (filePath.endsWith('page-layout.yaml')) {
+                    return 'name: invalid yaml, entry: template.hbs';
+                }
+                if (filePath.endsWith('template.hbs')) {
+                    return templateContent;
+                }
+                throw new Error('File not found');
+            });
+            yield expect((0, definitions_1.loadLayoutDefinition)(pageLayoutYaml)).rejects
+                .toThrowErrorMatchingInlineSnapshot(`
+        "Failed loading layout definition: Failed to parse ./some-dir/page-layout.yaml: Nested mappings are not allowed in compact mappings at line 1, column 7:
+
+        name: invalid yaml, entry: template.hbs
+              ^
+        "
+      `);
+        }));
+        it('should load layout definition without options field from YAML file', () => __awaiter(void 0, void 0, void 0, function* () {
+            const yamlContentWithoutOptions = `
+  name: test-layout
+  displayName: Test Layout
+  description: A test layout
+  zones:
+    main:
+      displayName: Main Zone
+      description: Main content area
+      minNodes: 1
+  entry: template.hbs
+      `;
+            fs.readFile.mockImplementation((filePath) => {
+                if (filePath.endsWith('page-layout.yaml')) {
+                    return yamlContentWithoutOptions;
+                }
+                if (filePath.endsWith('template.hbs')) {
+                    return templateContent;
+                }
+                throw new Error('File not found');
+            });
+            const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(pageLayoutYaml);
+            expect(layoutDefinition).toEqual({
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                zones: [
+                    {
+                        key: 'main',
+                        displayName: 'Main Zone',
+                        description: 'Main content area',
+                    },
+                ],
+                template: templateContent,
+            });
+        }));
+        it('should load layout definition without maxNodes in zones from YAML file', () => __awaiter(void 0, void 0, void 0, function* () {
+            const yamlContentWithoutMaxNodes = `
+  name: test-layout
+  displayName: Test Layout
+  description: A test layout
+  zones:
+    main:
+      displayName: Main Zone
+      description: Main content area
+      minNodes: 1
+    sidebar:
+      displayName: Sidebar Zone
+      description: Sidebar content area
+      minNodes: 0
+  entry: template.hbs
+      `;
+            fs.readFile.mockImplementation((filePath) => {
+                if (filePath.endsWith('page-layout.yaml')) {
+                    return yamlContentWithoutMaxNodes;
+                }
+                if (filePath.endsWith('template.hbs')) {
+                    return templateContent;
+                }
+                throw new Error('File not found');
+            });
+            const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(pageLayoutYaml);
+            expect(layoutDefinition).toEqual({
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                zones: [
+                    {
+                        key: 'main',
+                        displayName: 'Main Zone',
+                        description: 'Main content area',
+                    },
+                    {
+                        key: 'sidebar',
+                        displayName: 'Sidebar Zone',
+                        description: 'Sidebar content area',
+                    },
+                ],
+                template: templateContent,
+            });
+        }));
+    });
 });
 describe('LayoutDefinitionParse', () => {
-    it('should allow zone.minNodes to be undefined', () => {
-        const layoutDefinition = definitions_1.BaseLayoutDefinition.parse({
-            name: 'test-layout',
-            displayName: 'Test Layout',
-            description: 'A test layout',
-            zones: {
-                main: {
-                    displayName: 'Main Zone',
-                    description: 'Main content area',
+    describe('V1 format - zones objects and options (deprecated)', () => {
+        it('should allow zone.minNodes to be undefined', () => {
+            const layoutDefinition = definitions_1.InputLayoutDefinitionV1.parse({
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {
+                    main: {
+                        displayName: 'Main Zone',
+                        description: 'Main content area',
+                    },
                 },
-            },
+            });
+            expect(layoutDefinition.zones.main.minNodes).toBe(0);
+        });
+        describe('option schema validation', () => {
+            it('should accept specified valueTypes', () => {
+                var _a, _b, _c;
+                const layoutDefinition = definitions_1.InputLayoutDefinitionV1.parse({
+                    name: 'test-layout',
+                    displayName: 'Test Layout',
+                    description: 'A test layout',
+                    entry: 'template.hbs',
+                    zones: {
+                        main: {
+                            displayName: 'Main Zone',
+                            description: 'Main content area',
+                        },
+                    },
+                    options: {
+                        theme: {
+                            displayName: 'Theme',
+                            description: 'Color theme',
+                            valueType: 'string-enum',
+                            values: ['light', 'dark'],
+                        },
+                        showSidebar: {
+                            displayName: 'Show Sidebar',
+                            description: 'Toggle sidebar',
+                            valueType: 'boolean',
+                        },
+                        customCss: {
+                            displayName: 'Custom CSS',
+                            description: 'Enter custom CSS',
+                            valueType: 'text',
+                        },
+                    },
+                });
+                expect((_a = layoutDefinition.options) === null || _a === void 0 ? void 0 : _a.theme.valueType).toBe('string-enum');
+                expect((_b = layoutDefinition.options) === null || _b === void 0 ? void 0 : _b.showSidebar.valueType).toBe('boolean');
+                expect((_c = layoutDefinition.options) === null || _c === void 0 ? void 0 : _c.customCss.valueType).toBe('text');
+            });
+            it('should reject invalid valueType', () => {
+                expect(() => definitions_1.InputLayoutDefinitionV1.parse({
+                    name: 'test-layout',
+                    displayName: 'Test Layout',
+                    description: 'A test layout',
+                    entry: 'template.hbs',
+                    zones: {
+                        main: {
+                            displayName: 'Main Zone',
+                            description: 'Main content area',
+                        },
+                    },
+                    options: {
+                        badOption: {
+                            displayName: 'Bad Option',
+                            description: 'Invalid valueType',
+                            valueType: 'INVALID_TYPE',
+                        },
+                    },
+                })).toThrow();
+            });
+            it('should allow valueType and values to be optional', () => {
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                const layoutDefinition = definitions_1.InputLayoutDefinitionV1.parse({
+                    name: 'test-layout',
+                    displayName: 'Test Layout',
+                    description: 'A test layout',
+                    entry: 'template.hbs',
+                    zones: {
+                        main: {
+                            displayName: 'Main Zone',
+                            description: 'Main content area',
+                        },
+                    },
+                    options: {
+                        withBoth: {
+                            displayName: 'With Both',
+                            description: 'Has valueType and values',
+                            valueType: 'string-enum',
+                            values: ['option1', 'option2'],
+                        },
+                        withValueTypeOnly: {
+                            displayName: 'With ValueType Only',
+                            description: 'Has valueType but no values',
+                            valueType: 'boolean',
+                        },
+                        withValuesOnly: {
+                            displayName: 'With Values Only',
+                            description: 'Has values but no valueType (legacy)',
+                            values: ['legacy1', 'legacy2'],
+                        },
+                        withNeither: {
+                            displayName: 'With Neither',
+                            description: 'Has neither valueType nor values',
+                        },
+                    },
+                });
+                // Schema accepts all combinations - Business logic validation (e.g., boolean/text can't have values) happens on backend and reported in CLI on deploy.
+                expect((_a = layoutDefinition.options) === null || _a === void 0 ? void 0 : _a.withBoth.valueType).toBe('string-enum');
+                expect((_b = layoutDefinition.options) === null || _b === void 0 ? void 0 : _b.withBoth.values).toEqual([
+                    'option1',
+                    'option2',
+                ]);
+                expect((_c = layoutDefinition.options) === null || _c === void 0 ? void 0 : _c.withValueTypeOnly.valueType).toBe('boolean');
+                expect((_d = layoutDefinition.options) === null || _d === void 0 ? void 0 : _d.withValueTypeOnly.values).toBeUndefined();
+                expect((_e = layoutDefinition.options) === null || _e === void 0 ? void 0 : _e.withValuesOnly.valueType).toBeUndefined();
+                expect((_f = layoutDefinition.options) === null || _f === void 0 ? void 0 : _f.withValuesOnly.values).toEqual([
+                    'legacy1',
+                    'legacy2',
+                ]);
+                expect((_g = layoutDefinition.options) === null || _g === void 0 ? void 0 : _g.withNeither.valueType).toBeUndefined();
+                expect((_h = layoutDefinition.options) === null || _h === void 0 ? void 0 : _h.withNeither.values).toBeUndefined();
+            });
+            it('should reject properties (instead of options)', () => {
+                expect(() => definitions_1.InputLayoutDefinitionV1.parse({
+                    name: 'test-layout',
+                    displayName: 'Test Layout',
+                    description: 'A test layout',
+                    entry: 'template.hbs',
+                    zones: {
+                        main: {
+                            displayName: 'Main Zone',
+                            description: 'Main content area',
+                        },
+                    },
+                    properties: {
+                        color: {
+                            title: 'Color',
+                            description: 'Color options',
+                            type: 'string',
+                            enum: ['red', 'blue'],
+                        },
+                    },
+                })).toThrow();
+            });
+        });
+    });
+    describe('V2 format - zones arrays and properties', () => {
+        it('should not allow minNodes to be defined in a zone', () => {
+            expect(() => definitions_1.InputLayoutDefinitionV2.parse({
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: [
+                    {
+                        key: 'main',
+                        displayName: 'Main Zone',
+                        description: 'Main content area',
+                        minNodes: 1,
+                    },
+                ],
+            })).toThrow();
+        });
+        describe('property schema validation', () => {
+            it('should accept specified types', () => {
+                var _a, _b, _c;
+                const layoutDefinition = definitions_1.InputLayoutDefinitionV2.parse({
+                    name: 'test-layout',
+                    displayName: 'Test Layout',
+                    description: 'A test layout',
+                    entry: 'template.hbs',
+                    zones: [
+                        {
+                            key: 'main',
+                            displayName: 'Main Zone',
+                            description: 'Main content area',
+                        },
+                    ],
+                    properties: {
+                        theme: {
+                            title: 'Theme',
+                            description: 'Color theme',
+                            type: 'string',
+                            enum: ['light', 'dark'],
+                        },
+                        showSidebar: {
+                            title: 'Show Sidebar',
+                            description: 'Toggle sidebar',
+                            type: 'boolean',
+                        },
+                        customCss: {
+                            title: 'Custom CSS',
+                            description: 'Enter custom CSS',
+                            type: 'string',
+                        },
+                    },
+                });
+                expect((_a = layoutDefinition.properties) === null || _a === void 0 ? void 0 : _a.theme.type).toBe('string');
+                expect((_b = layoutDefinition.properties) === null || _b === void 0 ? void 0 : _b.showSidebar.type).toBe('boolean');
+                expect((_c = layoutDefinition.properties) === null || _c === void 0 ? void 0 : _c.customCss.type).toBe('string');
+            });
+            it('should reject invalid type', () => {
+                expect(() => definitions_1.InputLayoutDefinitionV2.parse({
+                    name: 'test-layout',
+                    displayName: 'Test Layout',
+                    description: 'A test layout',
+                    entry: 'template.hbs',
+                    zones: [
+                        {
+                            key: 'main',
+                            displayName: 'Main Zone',
+                            description: 'Main content area',
+                        },
+                    ],
+                    properties: {
+                        badProperty: {
+                            title: 'Bad Property',
+                            description: 'Invalid type',
+                            type: 'INVALID_TYPE',
+                        },
+                    },
+                })).toThrow();
+            });
         });
-        expect(layoutDefinition.zones.main.minNodes).toBe(0);
     });
 });
 describe('validateTemplateFile', () => {