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

package/lib/page/layouts/deploy/deploy.js

@@ -28,7 +28,7 @@ exports.logger = (0, dx_logger_lib_1.getLogger)({
 const createDeployCommand = () => {
     const deployCommand = new commander_1.Command()
         .name('deploy')
-        .addOption(new commander_1.Option('--config <string>', 'File path to the page layout config file').default('./page-layout.yaml'))
+        .addOption(new commander_1.Option('--config <string>', 'File path to the page layout config file'))
         .addOption(new commander_1.Option('-cu, --content-service-url <string>', 'Override the content service url from login')
         .env('CONTENT_SERVICE_URL')
         .hideHelp(true))
@@ -47,16 +47,25 @@ const createDeployCommand = () => {
             tenantId: (_c = options.tenant) !== null && _c !== void 0 ? _c : maybeConfig === null || maybeConfig === void 0 ? void 0 : maybeConfig.tenant,
         });
         const contentServiceUrl = (_d = options.contentServiceUrl) !== null && _d !== void 0 ? _d : new URL('/__dxp/service/components-content', baseUrl).toString();
-        const layoutFile = options.config;
+        let layoutFile = options.config;
+        (0, validation_1.validateLayoutFormat)(exports.logger, layoutFile);
+        if (!layoutFile) {
+            layoutFile = `./${definitions_1.LAYOUT_MANIFEST_FILE}`;
+        }
         exports.logger.info(`Loading layout data from the file ${layoutFile}`);
         try {
             const layout = yield (0, definitions_1.loadLayoutDefinition)(layoutFile);
             if (layout !== undefined) {
-                // Pre-deployment validation: check zones match between YAML and template
+                // Pre-deployment validation: check zones match between manifest and template
                 const zoneValidationError = (0, validation_1.validateZoneConsistency)(layout);
                 if (zoneValidationError) {
                     throw new Error(zoneValidationError);
                 }
+                // Validate Handlebars template only refers to properties if manifest.json is used
+                const propertyValidationError = (0, validation_1.validatePropertyConsistency)(layout, layoutFile);
+                if (propertyValidationError) {
+                    throw new Error(propertyValidationError);
+                }
                 const response = yield uploadLayout(apiService.client, layout, contentServiceUrl, options.dryRun);
                 if (!options.dryRun) {
                     exports.logger.info(`Layout "${layout.name}" version ${response.data.version} deployed successfully.`);
@@ -90,8 +99,34 @@ const createDeployCommand = () => {
     return deployCommand;
 };
 exports.default = createDeployCommand;
+/**
+ * Formats backend error responses into user-friendly error messages.
+ * Handles both validation errors (400s) and unknown server errors (500s).
+ *
+ * @param data - The error response data from the backend
+ * @param statusCode - The HTTP status code (optional)
+ * @returns Formatted error message string
+ */
+function formatErrorResponse(data, statusCode) {
+    // For 500 errors or unknown errors, show a generic message
+    if (statusCode && statusCode >= 500) {
+        return data.message || data.data || 'An unknown error occurred';
+    }
+    // For validation errors (400s), format with details
+    let errorMessage = data.message || 'Validation failed';
+    // Properties/options validation errors come as an object with field keys
+    if (data.details &&
+        typeof data.details === 'object' &&
+        !Array.isArray(data.details)) {
+        const details = Object.entries(data.details)
+            .map(([field, error]) => `  - ${field}: ${error.message}`)
+            .join('\n');
+        errorMessage += `\n${details}`;
+    }
+    return errorMessage;
+}
 function uploadLayout(client, layout, contentServiceUrl, dryRun) {
-    var _a, _b;
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const queryParam = dryRun ? '?_dryRun=true' : '';
@@ -101,13 +136,13 @@ function uploadLayout(client, layout, contentServiceUrl, dryRun) {
             if (response.status === 200) {
                 return response;
             }
-            const error = new Error(response.data.message);
-            if ((_b = (_a = response.data.details) === null || _a === void 0 ? void 0 : _a.input) === null || _b === void 0 ? void 0 : _b.message) {
-                error.message += `: ${response.data.details.input.message}`;
-            }
-            throw error;
+            throw new Error(formatErrorResponse(response.data, response.status));
         }
         catch (error) {
+            // Extract error details from axios error response
+            if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                throw new Error(formatErrorResponse(error.response.data, error.response.status));
+            }
             throw error;
         }
     });

package/lib/page/layouts/deploy/deploy.spec.js

@@ -17,10 +17,12 @@ jest.mock('@squiz/dx-logger-lib', () => ({
     getLogger: () => {
         return {
             info: mockLoggerInfoFn,
+            warn: mockLoggerWarnFn,
         };
     },
 }));
 const mockLoggerInfoFn = jest.fn();
+const mockLoggerWarnFn = jest.fn();
 const nock_1 = __importDefault(require("nock"));
 const deploy_1 = __importDefault(require("./deploy"));
 const definitions_1 = require("../../utils/definitions");
@@ -58,7 +60,7 @@ describe('deployCommand', () => {
         const program = (0, deploy_1.default)();
         yield program.parseAsync(createMockArgs({}));
         const opts = program.opts();
-        expect(opts.config).toEqual('./page-layout.yaml');
+        expect(opts.config).toBeUndefined();
         expect(opts.tenant).toEqual('myTenant');
         expect(opts.dryRun).toEqual(false);
     }));
@@ -90,13 +92,17 @@ describe('deployCommand', () => {
         expect(logSpy).toHaveBeenCalledWith(`NOTICE: CONTENT_SERVICE_URL is set and will deploy to ${contentServiceUrl}`);
     }));
     it('deploys a layout successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-        const file = './src/__tests__/layouts/page-layout.yaml';
+        const file = `./src/__tests__/layouts/${definitions_1.LAYOUT_MANIFEST_FILE}`;
         const dxpBaseUrl = 'http://dxp-base-url.com';
         const mockLayout = {
             name: 'test-layout',
-            zones: {
-                content: { displayName: 'Content', description: 'Main content' },
-            },
+            zones: [
+                {
+                    key: 'content',
+                    displayName: 'Content',
+                    description: 'Main content',
+                },
+            ],
             template: '<div>{{zones.content}}</div>',
         };
         const mockResponse = { name: 'test-layout', version: '12345' };
@@ -116,9 +122,13 @@ describe('deployCommand', () => {
         const dryRun = true;
         const mockLayout = {
             name: 'test-layout',
-            zones: {
-                content: { displayName: 'Content', description: 'Main content' },
-            },
+            zones: [
+                {
+                    key: 'content',
+                    displayName: 'Content',
+                    description: 'Main content',
+                },
+            ],
             template: '<div>{{zones.content}}</div>',
         };
         const mockResponse = { name: 'test-layout', version: '12345' };
@@ -170,7 +180,7 @@ describe('deployCommand', () => {
         const program = (0, deploy_1.default)();
         errorSpy = jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync(createMockArgs({ contentServiceUrl }));
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('An unknown error occurred'));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Internal server error'));
     }));
     it('should log additional details when layout validation fails', () => __awaiter(void 0, void 0, void 0, function* () {
         const dxpBaseUrl = 'http://dxp-base-url.com';
@@ -187,8 +197,53 @@ describe('deployCommand', () => {
         const program = (0, deploy_1.default)();
         errorSpy = jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync(createMockArgs({ dxpBaseUrl }));
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Layout validation failed: ERROR: Validation failed: "version" is an excess property and therefore is not allowed'));
+        const errorCall = errorSpy.mock.calls[0][0];
+        expect(errorCall).toContain('- input: ERROR: Validation failed: "version" is an excess property and therefore is not allowed');
     }));
+    describe('backend property validation error reporting', () => {
+        it('should display clean error when single property validation fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            const contentServiceUrl = 'http://localhost:9999';
+            (0, nock_1.default)(contentServiceUrl)
+                .post('/page-layout')
+                .reply(400, {
+                message: 'Validation failed',
+                details: {
+                    'input.properties.myBoolean': {
+                        message: "Property 'myBoolean' with type 'boolean' can not have values specified",
+                    },
+                },
+            });
+            const program = (0, deploy_1.default)();
+            errorSpy = jest.spyOn(program, 'error').mockImplementation();
+            yield program.parseAsync(createMockArgs({ contentServiceUrl }));
+            const errorCall = errorSpy.mock.calls[0][0];
+            expect(errorCall).toContain('Validation failed');
+            expect(errorCall).toContain("- input.properties.myBoolean: Property 'myBoolean' with type 'boolean' can not have values specified");
+        }));
+        it('should display multiple property validation errors cleanly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const contentServiceUrl = 'http://localhost:9999';
+            (0, nock_1.default)(contentServiceUrl)
+                .post('/page-layout')
+                .reply(400, {
+                message: 'Validation failed',
+                details: {
+                    'input.properties.badBoolean': {
+                        message: "Property 'badBoolean' with type 'boolean' cannot have enum values specified",
+                    },
+                    'input.properties.badProperty.type': {
+                        message: "Property 'badProperty' has invalid type 'INVALID'. Must be one of: string, boolean",
+                    },
+                },
+            });
+            const program = (0, deploy_1.default)();
+            errorSpy = jest.spyOn(program, 'error').mockImplementation();
+            yield program.parseAsync(createMockArgs({ contentServiceUrl }));
+            const errorCall = errorSpy.mock.calls[0][0];
+            expect(errorCall).toContain('Validation failed');
+            expect(errorCall).toContain("- input.properties.badBoolean: Property 'badBoolean' with type 'boolean' cannot have enum values specified");
+            expect(errorCall).toContain("- input.properties.badProperty.type: Property 'badProperty' has invalid type 'INVALID'. Must be one of: string, boolean");
+        }));
+    });
     describe('zone consistency validation', () => {
         it('should handle zone consistency validation errors where zones are used but not defined in the layout', () => __awaiter(void 0, void 0, void 0, function* () {
             const file = './src/__tests__/layout.yaml';
@@ -196,33 +251,69 @@ describe('deployCommand', () => {
             // Mock layout with zones that don't match the template
             const mockLayout = {
                 name: 'test-layout',
-                zones: {
-                    col1: { displayName: 'Column 1', description: 'The first column' },
-                },
+                zones: [
+                    {
+                        key: 'col1',
+                        displayName: 'Column 1',
+                        description: 'The first column',
+                    },
+                ],
                 template: '{{zones.col1}} {{zones.col2}}', // col2 is used but not defined in zones
             };
             definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
             const program = (0, deploy_1.default)();
             errorSpy = jest.spyOn(program, 'error').mockImplementation();
             yield program.parseAsync(createMockArgs({ config: file, dxpBaseUrl }));
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones used in template but not defined in YAML: col2/));
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones used in template but not defined in layout definition: col2/));
         }));
         it('should handle zone consistency validation errors where zones are defined but not used in the template', () => __awaiter(void 0, void 0, void 0, function* () {
             const file = './src/__tests__/layout.yaml';
             const dxpBaseUrl = 'http://dxp-base-url.com';
             const mockLayout = {
                 name: 'test-layout',
-                zones: {
-                    col1: { displayName: 'Column 1', description: 'The first column' },
-                    col2: { displayName: 'Column 2', description: 'The second column' }, // col2 is defined but not used in the template
-                },
+                zones: [
+                    {
+                        key: 'col1',
+                        displayName: 'Column 1',
+                        description: 'The first column',
+                    },
+                    {
+                        key: 'col2',
+                        displayName: 'Column 2',
+                        description: 'The second column',
+                    }, // col2 is defined but not used in the template
+                ],
                 template: '{{zones.col1}}',
             };
             definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
             const program = (0, deploy_1.default)();
             errorSpy = jest.spyOn(program, 'error').mockImplementation();
             yield program.parseAsync(createMockArgs({ config: file, dxpBaseUrl }));
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones defined in YAML but not used in template: col2/));
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones defined in layout definition but not used in template: col2/));
+        }));
+    });
+    describe('property consistency validation', () => {
+        it('should handle property consistency validation errors where properties are used but not defined in the layout', () => __awaiter(void 0, void 0, void 0, function* () {
+            const file = './src/__tests__/manifest.json';
+            const dxpBaseUrl = 'http://dxp-base-url.com';
+            // Mock layout with properties that don't match the template
+            const mockLayout = {
+                name: 'test-layout',
+                zones: [],
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '{{properties.title}} {{properties.undefined}}', // undefined is used but not defined in properties
+            };
+            definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+            const program = (0, deploy_1.default)();
+            errorSpy = jest.spyOn(program, 'error').mockImplementation();
+            yield program.parseAsync(createMockArgs({ config: file, dxpBaseUrl }));
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Property consistency validation failed[\s\S]*Properties used in template but not defined in layout definition: undefined/));
         }));
     });
 });

package/lib/page/layouts/dev/dev.js

@@ -19,6 +19,7 @@ const definitions_1 = require("../../utils/definitions");
 const path_1 = __importDefault(require("path"));
 const server_1 = require("../../utils/server");
 const parse_args_1 = require("../../utils/parse-args");
+const validation_1 = require("../validation");
 exports.logger = (0, dx_logger_lib_1.getLogger)({
     name: 'layout-dev',
     format: 'human',
@@ -27,13 +28,13 @@ const createDevCommand = () => {
     const devCommand = new commander_1.Command()
         .name('dev')
         .description('Start a development server for page layouts')
-        .option('--config <string>', 'File path to the page layout config file', './page-layout.yaml')
+        .option('--config <string>', 'File path to the page layout config file', `./${definitions_1.LAYOUT_MANIFEST_FILE}`)
         .option('--port <number>', 'Port to run the development server on', '4040')
         .option('--no-open', 'Do not automatically open browser')
         .option('--stylesheet <path>', 'Path to CSS file to include')
         .option('--zones <items>', 'Zone content mappings', parse_args_1.parseZonesList, {})
-        .option('--options <items>', 'Layout options', parse_args_1.parseOptionsList, {})
-        .allowUnknownOption(true)
+        .option('--properties <items>', 'Layout properties', parse_args_1.parsePropertiesList, {})
+        .allowUnknownOption(false)
         .allowExcessArguments(true)
         .action((options) => __awaiter(void 0, void 0, void 0, function* () {
         try {
@@ -43,14 +44,27 @@ const createDevCommand = () => {
             if (!rawLayoutDefinition) {
                 throw new Error(`Failed to load layout definition from ${options.config}`);
             }
+            (0, validation_1.validateLayoutFormat)(exports.logger, options.config);
+            // Check zones match between manifest and template
+            const zoneValidationError = (0, validation_1.validateZoneConsistency)(rawLayoutDefinition);
+            if (zoneValidationError) {
+                throw new Error(zoneValidationError);
+            }
+            // Validate Handlebars template only refers to properties if manifest.json is used
+            const propertyValidationError = (0, validation_1.validatePropertyConsistency)(rawLayoutDefinition, options.config);
+            if (propertyValidationError) {
+                throw new Error(propertyValidationError);
+            }
             // Confirm for entry property
             const layoutDefinition = Object.assign({}, rawLayoutDefinition);
+            // Normalize properties to convert string booleans to actual booleans
+            const normalizedProperties = (0, parse_args_1.normalizeLayoutProperties)(options.properties, layoutDefinition);
             exports.logger.info('Starting development server...');
             yield (0, server_1.startDevServer)({
                 configPath: path_1.default.resolve(options.config),
                 layoutDefinition,
                 zoneContent: options.zones,
-                layoutOptions: options.options,
+                layoutProperties: normalizedProperties,
                 stylesheet: options.stylesheet
                     ? path_1.default.resolve(options.stylesheet)
                     : undefined,

package/lib/page/layouts/dev/dev.spec.js

@@ -47,9 +47,9 @@ function createMockArgs(opts) {
             });
         });
     }
-    if (opts.layoutOptions) {
-        Object.entries(opts.layoutOptions).forEach(([optionName, value]) => {
-            args.push(`--options=${optionName}=${value}`);
+    if (opts.layoutProperties) {
+        Object.entries(opts.layoutProperties).forEach(([propertyName, value]) => {
+            args.push(`--properties=${propertyName}=${value}`);
         });
     }
     return args;
@@ -65,7 +65,7 @@ describe('devCommand', () => {
         process.argv = args;
         yield program.parseAsync(args);
         const opts = program.opts();
-        expect(opts.config).toEqual('./page-layout.yaml');
+        expect(opts.config).toEqual(`./${definitions_1.LAYOUT_MANIFEST_FILE}`);
         expect(opts.port).toEqual('4040');
         expect(opts.open).toEqual(true);
         expect(opts.stylesheet).toBeUndefined();
@@ -121,19 +121,46 @@ describe('devCommand', () => {
             zoneContent,
         }));
     }));
-    it('parses and passes layout options to the server', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('parses and passes layout properties to the server', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockLayout = { name: 'Test Layout' };
         definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
-        const layoutOptions = {
+        const layoutProperties = {
             sizing: 'large',
             theme: 'dark',
         };
         const program = (0, dev_1.default)();
-        const args = createMockArgs({ layoutOptions });
+        const args = createMockArgs({ layoutProperties });
         process.argv = args;
         yield program.parseAsync(args);
         expect(server_1.startDevServer).toHaveBeenCalledWith(expect.objectContaining({
-            layoutOptions,
+            layoutProperties,
+        }));
+    }));
+    it('normalizes boolean properties from strings to actual booleans', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockLayout = {
+            name: 'Test Layout',
+            properties: {
+                showFooter: { type: 'boolean' },
+                showHeader: { type: 'boolean' },
+                theme: { type: 'string' },
+            },
+        };
+        definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+        const layoutProperties = {
+            showFooter: 'true',
+            showHeader: 'false',
+            theme: 'dark',
+        };
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({ layoutProperties });
+        process.argv = args;
+        yield program.parseAsync(args);
+        expect(server_1.startDevServer).toHaveBeenCalledWith(expect.objectContaining({
+            layoutProperties: {
+                showFooter: true,
+                showHeader: false,
+                theme: 'dark', // Remains string
+            },
         }));
     }));
     it('handles failure to load layout definition', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -159,4 +186,86 @@ describe('devCommand', () => {
         yield program.parseAsync(args);
         expect(mockLoggerErrorFn).toHaveBeenCalledWith(expect.stringContaining('Server start failed'));
     }));
+    it('should not allow unknown options (e.g. --options instead of --properties)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const config = './src/__tests__/layout.yaml';
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({ config });
+        args.push('--options=backgroundColor=red');
+        process.argv = args;
+        const errorSpy = jest.spyOn(program, 'error').mockImplementation();
+        yield program.parseAsync(args);
+        expect(errorSpy).toHaveBeenCalledWith("error: unknown option '--options=backgroundColor=red'", { code: 'commander.unknownOption' });
+    }));
+    describe('zone consistency validation', () => {
+        it('should handle zone consistency validation errors where zones are used but not defined in the layout', () => __awaiter(void 0, void 0, void 0, function* () {
+            const config = './src/__tests__/layout.yaml';
+            // Mock layout with zones that don't match the template
+            const mockLayout = {
+                name: 'test-layout',
+                zones: [
+                    {
+                        key: 'col1',
+                        displayName: 'Column 1',
+                        description: 'The first column',
+                    },
+                ],
+                template: '{{zones.col1}} {{zones.col2}}', // col2 is used but not defined in zones
+            };
+            definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+            const program = (0, dev_1.default)();
+            const args = createMockArgs({ config });
+            process.argv = args;
+            yield program.parseAsync(args);
+            expect(mockLoggerErrorFn).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones used in template but not defined in layout definition: col2/));
+        }));
+        it('should handle zone consistency validation errors where zones are defined but not used in the template', () => __awaiter(void 0, void 0, void 0, function* () {
+            const config = './src/__tests__/layout.yaml';
+            const mockLayout = {
+                name: 'test-layout',
+                zones: [
+                    {
+                        key: 'col1',
+                        displayName: 'Column 1',
+                        description: 'The first column',
+                    },
+                    {
+                        key: 'col2',
+                        displayName: 'Column 2',
+                        description: 'The second column',
+                    }, // col2 is defined but not used in the template
+                ],
+                template: '{{zones.col1}}',
+            };
+            definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+            const program = (0, dev_1.default)();
+            const args = createMockArgs({ config });
+            process.argv = args;
+            yield program.parseAsync(args);
+            expect(mockLoggerErrorFn).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones defined in layout definition but not used in template: col2/));
+        }));
+    });
+    describe('property consistency validation', () => {
+        it('should handle property consistency validation errors where properties are used but not defined in the layout', () => __awaiter(void 0, void 0, void 0, function* () {
+            const config = './src/__tests__/manifest.json';
+            // Mock layout with properties that don't match the template
+            const mockLayout = {
+                name: 'test-layout',
+                zones: [],
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '{{properties.title}} {{properties.undefined}}', // undefined is used but not defined in properties
+            };
+            definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+            const program = (0, dev_1.default)();
+            const args = createMockArgs({ config });
+            process.argv = args;
+            yield program.parseAsync(args);
+            expect(mockLoggerErrorFn).toHaveBeenCalledWith(expect.stringMatching(/Property consistency validation failed[\s\S]*Properties used in template but not defined in layout definition: undefined/));
+        }));
+    });
 });

package/lib/page/layouts/validation/index.d.ts

@@ -1 +1,3 @@
+export { validateLayoutFormat } from './validateLayoutFormat';
+export { validatePropertyConsistency } from './property-consistency';
 export { validateZoneConsistency } from './zone-consistency';

package/lib/page/layouts/validation/index.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateZoneConsistency = void 0;
+exports.validateZoneConsistency = exports.validatePropertyConsistency = exports.validateLayoutFormat = void 0;
+var validateLayoutFormat_1 = require("./validateLayoutFormat");
+Object.defineProperty(exports, "validateLayoutFormat", { enumerable: true, get: function () { return validateLayoutFormat_1.validateLayoutFormat; } });
+var property_consistency_1 = require("./property-consistency");
+Object.defineProperty(exports, "validatePropertyConsistency", { enumerable: true, get: function () { return property_consistency_1.validatePropertyConsistency; } });
 var zone_consistency_1 = require("./zone-consistency");
 Object.defineProperty(exports, "validateZoneConsistency", { enumerable: true, get: function () { return zone_consistency_1.validateZoneConsistency; } });

package/lib/page/layouts/validation/property-consistency.d.ts

@@ -0,0 +1,7 @@
+import { LayoutDefinition } from '../../utils/definitions';
+/**
+ * Validates that options/properties defined in layout definition match options/properties used in the Handlebars template
+ * @param layout The layout definition containing options/properties and template
+ * @returns Error message if validation fails, null if validation passes
+ */
+export declare function validatePropertyConsistency(layout: LayoutDefinition, filePath: string): string | null;

package/lib/page/layouts/validation/property-consistency.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePropertyConsistency = void 0;
+const path = __importStar(require("node:path"));
+const definitions_1 = require("../../utils/definitions");
+/**
+ * Validates that options/properties defined in layout definition match options/properties used in the Handlebars template
+ * @param layout The layout definition containing options/properties and template
+ * @returns Error message if validation fails, null if validation passes
+ */
+function validatePropertyConsistency(layout, filePath) {
+    var _a;
+    const layoutProperties = (_a = layout.properties) !== null && _a !== void 0 ? _a : {};
+    const template = layout.template;
+    // If no template or properties are provided, skip validation
+    if (!template) {
+        return null;
+    }
+    const uniquePropertyKeys = new Set(Object.keys(layoutProperties));
+    if (uniquePropertyKeys.size !== Object.keys(layoutProperties).length) {
+        return 'Duplicate property keys found in layout definition';
+    }
+    // Extract property references from Handlebars template
+    // Look for patterns like {{properties.propertyName}}, {{#if properties.propertyName}} {{#ifEq 'value' properties.propertyName}}
+    const propertyPattern = /\{\{#*(?:[^\}]+\s)*properties\.(\w+)/g;
+    const optionPattern = /\{\{#*(?:[^\}]+\s)*options\.(\w+)/g;
+    // Keep track of properties/options used in the Handlebars template
+    const templateProperties = getTemplateMatches(template, propertyPattern);
+    const templateOptions = getTemplateMatches(template, optionPattern);
+    // Create an array of errors
+    const errors = [];
+    // Check that properties/options are being used correctly based on the layout definition file format
+    const fileName = path.basename(filePath);
+    const isNewFormat = fileName === definitions_1.LAYOUT_MANIFEST_FILE;
+    const templateSetToCheck = isNewFormat ? templateProperties : templateOptions;
+    // Check for incorrect option/property usage based on the layout definition file format
+    if (isNewFormat) {
+        if (templateOptions.size > 0) {
+            errors.push('Options are not supported in the Handlebars template for a layout defined with "manifest.json". Please use properties instead.');
+        }
+    }
+    else {
+        if (templateProperties.size > 0) {
+            errors.push('Properties are only allowed in the Handlebars template for a layout defined with "manifest.json". Please use options instead.');
+        }
+    }
+    // Find options/properties used in template but not defined in layout definition
+    const undefinedTemplateProperties = Array.from(templateSetToCheck).filter(property => !Object.keys(layoutProperties).includes(property));
+    // Add the undefined options/properties to the errors
+    if (undefinedTemplateProperties.length > 0) {
+        errors.push(`${isNewFormat ? 'Properties' : 'Options'} used in template but not defined in layout definition: ${undefinedTemplateProperties.join(', ')}`);
+    }
+    // If there are errors, return the errors
+    if (errors.length > 0) {
+        return `${isNewFormat ? 'Property' : 'Option'} consistency validation failed:\n${errors
+            .map(err => `  - ${err}`)
+            .join('\n')}`;
+    }
+    return null;
+}
+exports.validatePropertyConsistency = validatePropertyConsistency;
+function getTemplateMatches(template, pattern) {
+    const matches = new Set();
+    let match;
+    while ((match = pattern.exec(template)) !== null) {
+        matches.add(match[1]);
+    }
+    return matches;
+}

package/lib/page/layouts/validation/property-consistency.spec.d.ts

@@ -0,0 +1 @@
+export {};