@squiz/dxp-cli-next 5.31.0 → 5.32.0-develop.2

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 {};

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

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const property_consistency_1 = require("./property-consistency");
+describe('validatePropertyConsistency', () => {
+    const createMockLayout = (layout) => (Object.assign({ name: 'test-layout', displayName: 'Test Layout', description: 'A test layout', zones: [], template: '' }, layout));
+    describe('new format (manifest.json)', () => {
+        it('should return null for valid property consistency', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{#if properties.showHeader}}Header{{/if}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should return null when no template is provided', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should return null when layout has empty properties object', () => {
+            const layout = createMockLayout({
+                properties: {},
+                template: '<div>Static content only</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should return null when layout has undefined properties', () => {
+            const layout = createMockLayout({
+                template: '<div>Static content only</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should allow properties that are defined in the layout, but not used in template', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    unused: {
+                        type: 'string',
+                        title: 'Unused',
+                        description: 'Unused property',
+                    },
+                },
+                template: '<div>{{properties.title}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should detect properties used in template but not defined in layout', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{properties.undefined}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toContain('Property consistency validation failed');
+            expect(result).toContain('Properties used in template but not defined in layout definition: undefined');
+        });
+        it('should handle both unused and undefined properties', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    unused: {
+                        type: 'string',
+                        title: 'Unused',
+                        description: 'Unused property',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{properties.undefined}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toContain('Property consistency validation failed');
+            expect(result).toContain('Properties used in template but not defined in layout definition: undefined');
+        });
+        it('should reject options usage in manifest.json format', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{options.invalid}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toContain('Property consistency validation failed');
+            expect(result).toContain('Options are not supported in the Handlebars template for a layout defined with "manifest.json". Please use properties instead.');
+        });
+        it('should handle complex Handlebars patterns', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                    theme: {
+                        type: 'string',
+                        title: 'Theme',
+                        description: 'Page theme',
+                    },
+                },
+                template: `
+          <div>{{properties.title}}</div>
+          <div>{{toLowerCase properties.title}}</div>
+          <div>
+            {{#if properties.showHeader}}
+              <header>Header</header>
+            {{/if}}
+            {{#ifEq "dark" properties.theme}}
+              <div class="dark">Dark theme</div>
+            {{/ifEq}}
+          </div>
+        `,
+            });
+            const manifestResult = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(manifestResult).toBeNull();
+            const pageLayoutResult = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(pageLayoutResult).toContain('Option consistency validation failed');
+            expect(pageLayoutResult).toContain('Properties are only allowed in the Handlebars template for a layout defined with "manifest.json". Please use options instead.');
+        });
+    });
+    describe('old format (page-layout.yaml)', () => {
+        it('should return null for valid option consistency', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                },
+                template: '<div>{{options.title}}</div><div>{{#if options.showHeader}}Header{{/if}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(result).toBeNull();
+        });
+        it('should allow options that are defined in the layout, but not used in template', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    unused: {
+                        type: 'string',
+                        title: 'Unused',
+                        description: 'Unused option',
+                    },
+                },
+                template: '<div>{{options.title}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(result).toBeNull();
+        });
+        it('should detect options used in template but not defined in layout', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{options.title}}</div><div>{{options.undefined}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(result).toContain('Option consistency validation failed');
+            expect(result).toContain('Options used in template but not defined in layout definition: undefined');
+        });
+        it('should reject properties usage in old format', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{options.title}}</div><div>{{properties.invalid}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(result).toContain('Option consistency validation failed');
+            expect(result).toContain('Properties are only allowed in the Handlebars template for a layout defined with "manifest.json". Please use options instead.');
+        });
+        it('should handle complex Handlebars patterns', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                    theme: {
+                        type: 'string',
+                        title: 'Theme',
+                        description: 'Page theme',
+                    },
+                },
+                template: `
+          <div>{{options.title}}</div>
+          <div>{{toLowerCase options.title}}</div>
+          <div>
+            {{#if options.showHeader}}
+              <header>Header</header>
+            {{/if}}
+            {{#ifEq "dark" options.theme}}
+              <div class="dark">Dark theme</div>
+            {{/ifEq}}
+          </div>
+        `,
+            });
+            const pageLayoutResult = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(pageLayoutResult).toBeNull();
+            const manifestResult = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(manifestResult).toContain('Property consistency validation failed');
+            expect(manifestResult).toContain('Options are not supported in the Handlebars template for a layout defined with "manifest.json". Please use properties instead.');
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle multiple property references in same template', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{properties.title}}</div><div>{{#if properties.title}}Yes{{/if}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should handle property names with different casing', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    Title: {
+                        type: 'string',
+                        title: 'Title Capitalized',
+                        description: 'Title with capital T',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{properties.Title}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+import { Logger } from '@squiz/dx-logger-lib';
+export declare function validateLayoutFormat(logger: Logger, layoutFile?: string): void;

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

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLayoutFormat = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const definitions_1 = require("../../utils/definitions");
+function validateLayoutFormat(logger, layoutFile) {
+    // Warn that the default layout file has been changed
+    if (!layoutFile) {
+        logger.warn(`⚠️  DEFAULT CONFIG FILE: "${definitions_1.LAYOUT_MANIFEST_FILE}" has replaced "page-layout.yaml" as the default config file. ` +
+            `Please migrate to "${definitions_1.LAYOUT_MANIFEST_FILE}" using the new layout definition format. ` +
+            `Support for files other than "${definitions_1.LAYOUT_MANIFEST_FILE}" will be removed in a future version. ` +
+            'For more information, visit https://docs.squiz.net/component-service/latest/layouts/layout-files.html');
+        return;
+    }
+    // Warn that any file other than manifest.json is deprecated
+    const fileName = node_path_1.default.basename(layoutFile);
+    if (fileName !== definitions_1.LAYOUT_MANIFEST_FILE) {
+        logger.warn(`⚠️  DEPRECATED: The file name "${fileName}" is deprecated. ` +
+            `Please migrate to "${definitions_1.LAYOUT_MANIFEST_FILE}" using the new layout definition format. ` +
+            `Support for files other than "${definitions_1.LAYOUT_MANIFEST_FILE}" will be removed in a future version. ` +
+            'For more information, visit https://docs.squiz.net/component-service/latest/layouts/layout-files.html');
+    }
+}
+exports.validateLayoutFormat = validateLayoutFormat;

package/lib/page/layouts/validation/validateLayoutFormat.spec.d.ts

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