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

package/lib/page/utils/normalize.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * @license
+ * Copyright (c) 2025, Squiz Australia Pty Ltd.
+ * All rights reserved.
+ */
+import { InputLayoutDefinition, LayoutDefinition } from './definitions';
+export declare function normalizeZones(zones: InputLayoutDefinition['zones']): LayoutDefinition['zones'];
+export declare function normalizeProperties(layout: InputLayoutDefinition): LayoutDefinition['properties'];

package/lib/page/utils/normalize.js

@@ -0,0 +1,61 @@
+"use strict";
+/*!
+ * @license
+ * Copyright (c) 2025, Squiz Australia Pty Ltd.
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeProperties = exports.normalizeZones = void 0;
+const render_1 = require("./render");
+function normalizeZones(zones) {
+    if (Array.isArray(zones)) {
+        return zones;
+    }
+    if (typeof zones !== 'object' || zones === null) {
+        throw new Error('zones must be an object or array');
+    }
+    return Object.entries(zones).map(([key, zone]) => ({
+        key,
+        displayName: zone.displayName,
+        description: zone.description,
+    }));
+}
+exports.normalizeZones = normalizeZones;
+function normalizeProperties(layout) {
+    if ('properties' in layout) {
+        return layout.properties;
+    }
+    if (!('options' in layout) || layout.options === undefined) {
+        return undefined;
+    }
+    return Object.entries(layout.options).reduce((acc, [key, option]) => {
+        switch (option.valueType) {
+            case render_1.LayoutOptionValueType.boolean:
+                acc[key] = {
+                    type: render_1.LayoutPropertyType.boolean,
+                    title: option.displayName,
+                    description: option.description,
+                };
+                break;
+            case render_1.LayoutOptionValueType.text:
+                acc[key] = {
+                    type: render_1.LayoutPropertyType.string,
+                    title: option.displayName,
+                    description: option.description,
+                };
+                break;
+            case render_1.LayoutOptionValueType.stringEnum:
+            default:
+                acc[key] = {
+                    type: render_1.LayoutPropertyType.string,
+                    title: option.displayName,
+                    description: option.description,
+                };
+                if (option.values !== undefined) {
+                    acc[key].enum = option.values;
+                }
+        }
+        return acc;
+    }, {});
+}
+exports.normalizeProperties = normalizeProperties;

package/lib/page/utils/normalize.spec.d.ts

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

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

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalize_1 = require("./normalize");
+const render_1 = require("./render");
+describe('normalizeZones', () => {
+    it('should return zones array as-is when zones is already an array (V2 format)', () => {
+        const zones = [
+            {
+                key: 'main',
+                displayName: 'Main Zone',
+                description: 'Main content area',
+            },
+            {
+                key: 'sidebar',
+                displayName: 'Sidebar Zone',
+                description: 'Sidebar content area',
+            },
+        ];
+        const result = (0, normalize_1.normalizeZones)(zones);
+        expect(result).toEqual(zones);
+        expect(result).toBe(zones); // Should return the same reference
+    });
+    it('should convert zones object to array format (V1 format)', () => {
+        const zones = {
+            main: {
+                displayName: 'Main Zone',
+                description: 'Main content area',
+                minNodes: 1,
+                maxNodes: 5,
+            },
+            sidebar: {
+                displayName: 'Sidebar Zone',
+                description: 'Sidebar content area',
+                minNodes: 0,
+            },
+        };
+        const result = (0, normalize_1.normalizeZones)(zones);
+        expect(result).toEqual([
+            {
+                key: 'main',
+                displayName: 'Main Zone',
+                description: 'Main content area',
+            },
+            {
+                key: 'sidebar',
+                displayName: 'Sidebar Zone',
+                description: 'Sidebar content area',
+            },
+        ]);
+    });
+    it('should handle empty zones object', () => {
+        const zones = {};
+        const result = (0, normalize_1.normalizeZones)(zones);
+        expect(result).toEqual([]);
+    });
+    it('should handle empty zones array', () => {
+        const zones = [];
+        const result = (0, normalize_1.normalizeZones)(zones);
+        expect(result).toEqual([]);
+    });
+    it('should throw error when zones is null', () => {
+        expect(() => (0, normalize_1.normalizeZones)(null)).toThrow('zones must be an object or array');
+    });
+    it('should throw error when zones is a string', () => {
+        expect(() => (0, normalize_1.normalizeZones)('invalid')).toThrow('zones must be an object or array');
+    });
+    it('should throw error when zones is a number', () => {
+        expect(() => (0, normalize_1.normalizeZones)(123)).toThrow('zones must be an object or array');
+    });
+    it('should throw error when zones is undefined', () => {
+        expect(() => (0, normalize_1.normalizeZones)(undefined)).toThrow('zones must be an object or array');
+    });
+});
+describe('normalizeProperties', () => {
+    describe('V2 format (properties)', () => {
+        it('should return properties as-is when layout has properties', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: [],
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                },
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toEqual(layout.properties);
+            expect(result).toBe(layout.properties); // Should return the same reference
+        });
+        it('should return undefined when layout has no properties', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: [],
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('V1 format (options)', () => {
+        it('should convert boolean option to boolean property', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+                options: {
+                    showHeader: {
+                        displayName: 'Show Header',
+                        description: 'Whether to show header',
+                        valueType: render_1.LayoutOptionValueType.boolean,
+                    },
+                },
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toEqual({
+                showHeader: {
+                    type: 'boolean',
+                    title: 'Show Header',
+                    description: 'Whether to show header',
+                },
+            });
+        });
+        it('should convert text option to string property', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+                options: {
+                    title: {
+                        displayName: 'Title',
+                        description: 'Page title',
+                        valueType: render_1.LayoutOptionValueType.text,
+                    },
+                },
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toEqual({
+                title: {
+                    type: 'string',
+                    title: 'Title',
+                    description: 'Page title',
+                },
+            });
+        });
+        it('should convert stringEnum option to string property with enum', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+                options: {
+                    theme: {
+                        displayName: 'Theme',
+                        description: 'Color theme',
+                        valueType: render_1.LayoutOptionValueType.stringEnum,
+                        values: ['light', 'dark', 'auto'],
+                    },
+                },
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toEqual({
+                theme: {
+                    type: 'string',
+                    title: 'Theme',
+                    description: 'Color theme',
+                    enum: ['light', 'dark', 'auto'],
+                },
+            });
+        });
+        it('should convert stringEnum option without values to string property without enum', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+                options: {
+                    theme: {
+                        displayName: 'Theme',
+                        description: 'Color theme',
+                        valueType: render_1.LayoutOptionValueType.stringEnum,
+                    },
+                },
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toEqual({
+                theme: {
+                    type: 'string',
+                    title: 'Theme',
+                    description: 'Color theme',
+                },
+            });
+        });
+        it('should default to string property when valueType is undefined', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+                options: {
+                    title: {
+                        displayName: 'Title',
+                        description: 'Page title',
+                    },
+                },
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toEqual({
+                title: {
+                    type: 'string',
+                    title: 'Title',
+                    description: 'Page title',
+                },
+            });
+        });
+        it('should convert multiple options to properties', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+                options: {
+                    title: {
+                        displayName: 'Title',
+                        description: 'Page title',
+                        valueType: render_1.LayoutOptionValueType.text,
+                    },
+                    showHeader: {
+                        displayName: 'Show Header',
+                        description: 'Whether to show header',
+                        valueType: render_1.LayoutOptionValueType.boolean,
+                    },
+                    theme: {
+                        displayName: 'Theme',
+                        description: 'Color theme',
+                        values: ['light', 'dark'],
+                    },
+                },
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toEqual({
+                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: 'Color theme',
+                    enum: ['light', 'dark'],
+                },
+            });
+        });
+        it('should return undefined when options is undefined', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toBeUndefined();
+        });
+        it('should return undefined when options is explicitly undefined', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+                options: undefined,
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toBeUndefined();
+        });
+        it('should handle empty options object', () => {
+            const layout = {
+                name: 'test-layout',
+                displayName: 'Test Layout',
+                description: 'A test layout',
+                entry: 'template.hbs',
+                zones: {},
+                options: {},
+            };
+            const result = (0, normalize_1.normalizeProperties)(layout);
+            expect(result).toEqual({});
+        });
+    });
+});

package/lib/page/utils/parse-args.d.ts

@@ -13,16 +13,32 @@ export declare function parseZonesList(value: string, previous: Record<string, s
     [x: string]: string[];
 };
 /**
- * Parse options list from command line
+ * Parse properties list from command line
  * Supports multiple formats:
  * - Single pair: 'key=value' or 'key:value'
  * - Comma-separated list: 'key1=value1,key2=value2' or 'key1:value1,key2:value2'
- * - Multiple --options flags: later values override earlier ones
+ * - Multiple --properties flags: later values override earlier ones
+ *
+ * Note: All values are returned as strings. Use normalizeLayoutProperties() to convert
+ * boolean properties to actual boolean types based on the layout definition.
  *
  * @param value Current value being processed
  * @param previous Previously processed value (used for multiple flags)
- * @returns Record of option names to values
+ * @returns Record of property names to string values
  */
-export declare function parseOptionsList(value: string, previous: Record<string, string>): {
+export declare function parsePropertiesList(value: string, previous: Record<string, string>): {
     [x: string]: string;
 };
+/**
+ * Normalizes layout properties by converting string boolean values to actual booleans
+ * based on the layout definition's property types.
+ *
+ * @param properties The parsed properties from CLI (all strings)
+ * @param layoutDefinition The layout definition with property type information
+ * @returns Properties with boolean values converted to actual booleans
+ */
+export declare function normalizeLayoutProperties(properties: Record<string, string>, layoutDefinition: {
+    properties?: Record<string, {
+        type?: string;
+    }>;
+}): Record<string, string | boolean>;

package/lib/page/utils/parse-args.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOptionsList = exports.parseZonesList = void 0;
+exports.normalizeLayoutProperties = exports.parsePropertiesList = exports.parseZonesList = void 0;
+const render_1 = require("./render");
 /**
  * Parse zones list from command line
  * Supports multiple formats:
@@ -44,41 +45,75 @@ function parseZonesList(value, previous) {
 }
 exports.parseZonesList = parseZonesList;
 /**
- * Parse options list from command line
+ * Parse properties list from command line
  * Supports multiple formats:
  * - Single pair: 'key=value' or 'key:value'
  * - Comma-separated list: 'key1=value1,key2=value2' or 'key1:value1,key2:value2'
- * - Multiple --options flags: later values override earlier ones
+ * - Multiple --properties flags: later values override earlier ones
+ *
+ * Note: All values are returned as strings. Use normalizeLayoutProperties() to convert
+ * boolean properties to actual boolean types based on the layout definition.
  *
  * @param value Current value being processed
  * @param previous Previously processed value (used for multiple flags)
- * @returns Record of option names to values
+ * @returns Record of property names to string values
  */
-function parseOptionsList(value, previous) {
+function parsePropertiesList(value, previous) {
     const result = Object.assign({}, previous);
     if (!value)
         return result;
     // Split comma-separated values if present
     const parts = value.includes(',') ? value.split(',') : [value];
     for (const part of parts) {
-        let optionName;
-        let optionValue;
+        let propertyName;
+        let propertyValue;
         // Handle both colon and equals separators
         if (part.includes('=')) {
-            [optionName, optionValue] = part.split('=');
+            [propertyName, propertyValue] = part.split('=');
         }
         else if (part.includes(':')) {
-            [optionName, optionValue] = part.split(':');
+            [propertyName, propertyValue] = part.split(':');
         }
         else {
             continue; // Skip invalid format
         }
-        // Skip empty option names or values
-        if (!optionName || !optionValue) {
+        // Skip empty property names or values
+        if (!propertyName || !propertyValue) {
             continue;
         }
-        result[optionName] = optionValue;
+        result[propertyName] = propertyValue;
     }
     return result;
 }
-exports.parseOptionsList = parseOptionsList;
+exports.parsePropertiesList = parsePropertiesList;
+/**
+ * Normalizes layout properties by converting string boolean values to actual booleans
+ * based on the layout definition's property types.
+ *
+ * @param properties The parsed properties from CLI (all strings)
+ * @param layoutDefinition The layout definition with property type information
+ * @returns Properties with boolean values converted to actual booleans
+ */
+function normalizeLayoutProperties(properties, layoutDefinition) {
+    const normalized = Object.assign({}, properties);
+    if (!layoutDefinition.properties) {
+        return normalized;
+    }
+    // Convert string "true"/"false" to actual booleans for boolean-type properties
+    for (const [key, propertyDef] of Object.entries(layoutDefinition.properties)) {
+        if (propertyDef.type === render_1.LayoutPropertyType.boolean && key in normalized) {
+            const value = normalized[key];
+            if (value === 'true') {
+                normalized[key] = true;
+            }
+            else if (value === 'false') {
+                normalized[key] = false;
+            }
+            else {
+                throw new Error(`Invalid boolean value "${value}" for property "${key}". Must be "true" or "false".`);
+            }
+        }
+    }
+    return normalized;
+}
+exports.normalizeLayoutProperties = normalizeLayoutProperties;