@squiz/dxp-cli-next 5.24.0 → 5.25.0-develop.2

package/lib/auth/login/login.js

@@ -52,7 +52,7 @@ const createLoginCommand = () => {
         .addOption(new commander_1.Option('--dxp-base-url <baseURL>', 'DXP Console URL')
         .env('DXP_BASE_URL')
         .default(constants_1.PRODUCTION_URL))
-        .addOption(new commander_1.Option('--region <region>').choices(['au']).default('au'))
+        .addOption(new commander_1.Option('--region <region>').choices(['au', 'us', 'uk']).default('au'))
         .addOption(new commander_1.Option('--override-session', 'Override the existing authorized session if it exists'))
         .addOption(new commander_1.Option('--tenant <tenantID>'))
         .configureOutput({

package/lib/cdp/instance/activate/activate.js

@@ -32,10 +32,6 @@ const createActivateCommand = () => {
     const activateCommand = new commander_1.Command('deploy')
         .name('activate')
         .description('Activate a CDP instance')
-        .addOption(new commander_1.Option('-t, --tenant <string>', 'Tenant ID to run against. If not provided will use configured tenant from login'))
-        .addOption(new commander_1.Option('-r, --region <string>', 'Region for your instance to be activated e.g. au')
-        .choices(['au', 'uk', 'us'])
-        .makeOptionMandatory())
         .configureOutput({
         outputError(str, write) {
             write(chalk_1.default.red(str));
@@ -51,7 +47,7 @@ const createActivateCommand = () => {
                     return status < 400 || status === 404;
                 },
             });
-            const scvDeployBaseUrl = yield (0, utils_1.buildDXPUrl)(constants_1.SCV_DEPLOY_SERVICE_NAME, options.tenant, options.overrideUrl, options.region);
+            const scvDeployBaseUrl = yield (0, utils_1.buildDXPUrl)(constants_1.SCV_DEPLOY_SERVICE_NAME);
             const apiUrl = `${scvDeployBaseUrl.dxpUrl}/${scvDeployBaseUrl.tenant}`;
             const getDeployResponse = (yield apiService.client
                 .get(apiUrl)
@@ -66,11 +62,7 @@ const createActivateCommand = () => {
             }
             (0, utils_1.logDebug)(`PUT ${apiUrl}`);
             const activateInstanceAndDeploySchemaResponse = (yield apiService.client
-                .put(apiUrl, null, {
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            })
+                .put(apiUrl)
                 .catch((err) => {
                 (0, utils_1.logDebug)(`RAW ERROR: ${JSON.stringify(err)}`);
                 if (err.response) {
@@ -94,9 +86,6 @@ const createActivateCommand = () => {
             (0, utils_1.handleCommandError)(error);
         }
     }));
-    if (process.env.ENABLE_OVERRIDE_CDP_SCHEMA_URL === 'true') {
-        activateCommand.addOption(new commander_1.Option('-ou, --overrideUrl <string>', 'Developer option to override the entire DXP url with a custom value'));
-    }
     return activateCommand;
 };
 exports.default = createActivateCommand;

package/lib/cdp/instance/activate/activate.spec.js

@@ -35,26 +35,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const nock_1 = __importDefault(require("nock"));
 const activate_1 = __importStar(require("./activate"));
 const deploy_const_1 = require("../../schema/deploy/deploy.const");
 const utils_1 = require("../../utils");
 const activate = __importStar(require("./activate"));
+const utils = __importStar(require("../../utils"));
+const axios_1 = __importDefault(require("axios"));
+jest.mock('axios');
 const mockDomainWithPath = 'http://localhost:9999/__dxp/us/scv-deploy/myTenant';
-function createMockArgs(region, tenantID, filePath, mockDomain) {
-    return [
-        'node',
-        'dxp-cli',
-        'cdp',
-        'instance',
-        'activate',
-        '-t',
-        tenantID,
-        '-r',
-        region,
-        '-ou',
-        'http://localhost:9999',
-    ];
+function createMockArgs() {
+    return ['node', 'dxp-cli', 'cdp', 'instance', 'activate'];
 }
 describe('cdpInstanceCommand', () => {
     let mockTenant;
@@ -63,73 +53,59 @@ describe('cdpInstanceCommand', () => {
     let mockDomain;
     let logSpy;
     let errorSpy;
-    let activateErrorSpy;
     beforeEach(() => {
         process.env.ENABLE_CDP_ADMIN = 'true';
-        process.env.ENABLE_OVERRIDE_CDP_SCHEMA_URL = 'true';
         mockTenant = 'myTenant';
         mockRegion = 'us';
         mockFilePath = './src/__tests__/cdp/scv/schema.json';
         mockDomain = 'http://localhost:9999';
         logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
         errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-        activateErrorSpy = jest
-            .spyOn(activate, 'handleActivateError')
-            .mockImplementation(() => { });
-        if (!nock_1.default.isActive()) {
-            nock_1.default.activate();
-        }
-        nock_1.default.cleanAll(); // Ensures each test runs in isolation
     });
     afterEach(() => {
-        jest.clearAllMocks(); // Clear all spies after each test
-        nock_1.default.cleanAll(); // Clear all HTTP mocks
+        jest.clearAllMocks();
     });
     it('should throw error when tenant exists', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockedAxiosInstance = {
+            get: jest.fn().mockResolvedValue({ status: 200 }),
+            interceptors: {
+                request: { use: jest.fn() },
+                response: { use: jest.fn() },
+            },
+        };
+        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
+            tenant: mockTenant,
+        });
         const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
         expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        (0, nock_1.default)(mockDomain)
-            .get(mockPath)
-            .reply(200, { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR });
         const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs(mockRegion, mockTenant, mockFilePath, mockDomain));
+        yield program.parseAsync(createMockArgs());
         expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(activate_1.errorMessage));
     }));
-    it('should throw error when get tenant returns 403', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
-        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        (0, nock_1.default)(mockDomain).get(mockPath).reply(403, {
-            title: 'Forbidden',
-            status: 403,
-        });
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs(mockRegion, mockTenant, mockFilePath, mockDomain));
-        expect(activateErrorSpy).toHaveBeenCalledWith(403, {
-            status: 403,
-            title: 'Forbidden',
-        });
-    }));
     it('deploys a default schema and activate an instance', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
+            tenant: mockTenant,
+        });
+        jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+        const mockedAxiosInstance = {
+            get: jest.fn().mockResolvedValue({ status: 404 }),
+            put: jest
+                .fn()
+                .mockResolvedValue({ status: 200, data: { message: 'Success' } }),
+            interceptors: {
+                request: { use: jest.fn() },
+                response: { use: jest.fn() },
+            },
+        };
+        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
         const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
         expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        (0, nock_1.default)(mockDomain)
-            .get(mockPath)
-            .reply(404, {
-            status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR,
-        })
-            .put(mockPath)
-            .reply(200, {
-            tenantid: 'myTenant',
-            version: 'unknown',
-            stack: 'stackName',
-            status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
-        })
-            .get(mockPath)
-            .reply(200, {
-            status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYED,
-        });
         const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs(mockRegion, mockTenant, mockFilePath, mockDomain));
+        yield program.parseAsync(createMockArgs());
+        expect(mockedAxiosInstance.put).toHaveBeenCalledWith(`${mockDomain}${mockPath}`);
         // Note the output from the spinner doesn't seem to appear here but this still tests that it
         // ran without displaying an error.
         expect(logSpy).toHaveBeenNthCalledWith(1, '');
@@ -138,4 +114,54 @@ describe('cdpInstanceCommand', () => {
         expect(logSpy).toHaveBeenNthCalledWith(4, '');
         expect(errorSpy).not.toHaveBeenCalled();
     }));
+    it('should throw error when trying to activate an instance currently', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
+            tenant: mockTenant,
+        });
+        jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+        const mockedAxios = axios_1.default;
+        //GET request (404)
+        mockedAxios.get.mockResolvedValueOnce({
+            status: 404,
+            data: { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR },
+        });
+        // PUT request (409)
+        mockedAxios.put.mockResolvedValueOnce({
+            status: 409,
+            data: {
+                tenantid: 'myTenant',
+                version: 'unknown',
+                stack: 'stackName',
+                status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
+            },
+        });
+        axios_1.default.create.mockReturnValue(mockedAxios);
+        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+        const program = (0, activate_1.default)();
+        yield program.parseAsync(createMockArgs());
+        expect(mockedAxios.put).toHaveBeenCalledWith(`${mockDomain}${mockPath}`);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Currently activating instance. Please try again later.'));
+    }));
+    it('should throw error when get tenant returns 403', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockedAxiosInstance = {
+            get: jest.fn().mockRejectedValue({
+                response: { status: 403, data: {} },
+            }),
+            interceptors: {
+                request: { use: jest.fn() },
+                response: { use: jest.fn() },
+            },
+        };
+        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
+            tenant: mockTenant,
+        });
+        const handleActivateErrorSpy = jest.spyOn(activate, 'handleActivateError');
+        const program = (0, activate_1.default)();
+        yield program.parseAsync(createMockArgs());
+        expect(handleActivateErrorSpy).toHaveBeenCalledWith(403, {});
+    }));
 });

package/lib/page/layouts/dev/dev.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { Logger } from '@squiz/dx-logger-lib';
+export declare const logger: Logger;
+declare const createDevCommand: () => Command;
+export default createDevCommand;

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

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const commander_1 = require("commander");
+const dx_logger_lib_1 = require("@squiz/dx-logger-lib");
+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");
+exports.logger = (0, dx_logger_lib_1.getLogger)({
+    name: 'layout-dev',
+    format: 'human',
+});
+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('--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)
+        .allowExcessArguments(true)
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            // Load layout definition
+            exports.logger.info(`Loading layout definition from ${options.config}`);
+            const rawLayoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(options.config);
+            if (!rawLayoutDefinition) {
+                throw new Error(`Failed to load layout definition from ${options.config}`);
+            }
+            // Confirm for entry property
+            const layoutDefinition = Object.assign({}, rawLayoutDefinition);
+            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,
+                stylesheet: options.stylesheet
+                    ? path_1.default.resolve(options.stylesheet)
+                    : undefined,
+                port: parseInt(options.port) || 4040,
+                openBrowser: options.open !== false,
+            });
+        }
+        catch (error) {
+            if (error.stack && process.env.DEBUG) {
+                console.error(error.stack);
+            }
+            exports.logger.error(error.message || 'An unknown error occurred');
+        }
+    }));
+    return devCommand;
+};
+exports.default = createDevCommand;

package/lib/page/layouts/dev/dev.spec.d.ts

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

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

@@ -0,0 +1,162 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('../../utils/definitions');
+jest.mock('../../utils/server');
+jest.mock('@squiz/dx-logger-lib', () => ({
+    getLogger: () => {
+        return {
+            info: mockLoggerInfoFn,
+            error: mockLoggerErrorFn,
+            warn: jest.fn(),
+        };
+    },
+}));
+const mockLoggerInfoFn = jest.fn();
+const mockLoggerErrorFn = jest.fn();
+const dev_1 = __importDefault(require("./dev"));
+const definitions_1 = require("../../utils/definitions");
+const server_1 = require("../../utils/server");
+const path_1 = __importDefault(require("path"));
+const originalProcessArgv = process.argv;
+function createMockArgs(opts) {
+    const args = ['node', 'dxp-cli', 'dev'];
+    if (opts.config)
+        args.push('--config', opts.config);
+    if (opts.port)
+        args.push('--port', opts.port.toString());
+    if (opts.open === false)
+        args.push('--no-open');
+    if (opts.stylesheet)
+        args.push('--stylesheet', opts.stylesheet);
+    if (opts.zoneContent) {
+        Object.entries(opts.zoneContent).forEach(([zoneName, filePaths]) => {
+            filePaths.forEach(filePath => {
+                args.push(`--zones=${zoneName}=${filePath}`);
+            });
+        });
+    }
+    if (opts.layoutOptions) {
+        Object.entries(opts.layoutOptions).forEach(([optionName, value]) => {
+            args.push(`--options=${optionName}=${value}`);
+        });
+    }
+    return args;
+}
+describe('devCommand', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.argv = originalProcessArgv;
+    });
+    it('correctly handles command option defaults', () => __awaiter(void 0, void 0, void 0, function* () {
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({});
+        process.argv = args;
+        yield program.parseAsync(args);
+        const opts = program.opts();
+        expect(opts.config).toEqual('./page-layout.yaml');
+        expect(opts.port).toEqual('4040');
+        expect(opts.open).toEqual(true);
+        expect(opts.stylesheet).toBeUndefined();
+    }));
+    it('correctly handles command arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+        const config = './src/__tests__/layout.yaml';
+        const port = '3000';
+        const open = false;
+        const stylesheet = './src/__tests__/styles.css';
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({
+            config,
+            port,
+            open,
+            stylesheet,
+        });
+        process.argv = args;
+        yield program.parseAsync(args);
+        const opts = program.opts();
+        expect(opts.config).toEqual(config);
+        expect(opts.port).toEqual(port);
+        expect(opts.open).toEqual(open);
+        expect(opts.stylesheet).toEqual(stylesheet);
+    }));
+    it('loads the layout definition and starts the server', () => __awaiter(void 0, void 0, void 0, function* () {
+        const config = './src/__tests__/layout.yaml';
+        const mockLayout = { name: 'Test Layout' };
+        definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({ config });
+        process.argv = args;
+        yield program.parseAsync(args);
+        expect(definitions_1.loadLayoutDefinition).toHaveBeenCalledWith(config);
+        expect(mockLoggerInfoFn).toHaveBeenNthCalledWith(1, `Loading layout definition from ${config}`);
+        expect(mockLoggerInfoFn).toHaveBeenNthCalledWith(2, 'Starting development server...');
+        expect(server_1.startDevServer).toHaveBeenCalledWith(expect.objectContaining({
+            configPath: path_1.default.resolve(config),
+            layoutDefinition: mockLayout,
+        }));
+    }));
+    it('parses and passes zone content to the server', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockLayout = { name: 'Test Layout' };
+        definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+        const zoneContent = {
+            main: ['./example.main.0.html', './example.main.1.html'],
+            aside: ['./example.aside.html'],
+        };
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({ zoneContent });
+        process.argv = args;
+        yield program.parseAsync(args);
+        expect(server_1.startDevServer).toHaveBeenCalledWith(expect.objectContaining({
+            zoneContent,
+        }));
+    }));
+    it('parses and passes layout options to the server', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockLayout = { name: 'Test Layout' };
+        definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+        const layoutOptions = {
+            sizing: 'large',
+            theme: 'dark',
+        };
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({ layoutOptions });
+        process.argv = args;
+        yield program.parseAsync(args);
+        expect(server_1.startDevServer).toHaveBeenCalledWith(expect.objectContaining({
+            layoutOptions,
+        }));
+    }));
+    it('handles failure to load layout definition', () => __awaiter(void 0, void 0, void 0, function* () {
+        const config = './src/__tests__/layout.yaml';
+        definitions_1.loadLayoutDefinition.mockResolvedValue(undefined);
+        const originalError = mockLoggerErrorFn;
+        mockLoggerErrorFn.mockClear();
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({ config });
+        process.argv = args;
+        yield program.parseAsync(args);
+        expect(mockLoggerErrorFn).toHaveBeenCalledWith(expect.stringContaining(`Failed to load layout definition from ${config}`));
+    }));
+    it('handles server startup error', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockLayout = { name: 'Test Layout' };
+        definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+        server_1.startDevServer.mockRejectedValue(new Error('Server start failed'));
+        const originalError = mockLoggerErrorFn;
+        mockLoggerErrorFn.mockClear();
+        const program = (0, dev_1.default)();
+        const args = createMockArgs({});
+        process.argv = args;
+        yield program.parseAsync(args);
+        expect(mockLoggerErrorFn).toHaveBeenCalledWith(expect.stringContaining('Server start failed'));
+    }));
+});

package/lib/page/layouts/layouts.js

@@ -5,11 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const deploy_1 = __importDefault(require("./deploy/deploy"));
+const dev_1 = __importDefault(require("./dev/dev"));
 const createLayoutsCommand = () => {
     const layoutsCommand = new commander_1.Command('layouts');
     layoutsCommand
         .description('Page Contents Layouts Commands')
-        .addCommand((0, deploy_1.default)());
+        .addCommand((0, deploy_1.default)())
+        .addCommand((0, dev_1.default)());
     return layoutsCommand;
 };
 exports.default = createLayoutsCommand;

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

@@ -6,10 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const layouts_1 = __importDefault(require("./layouts"));
 const deploy_1 = __importDefault(require("./deploy/deploy"));
+const dev_1 = __importDefault(require("./dev/dev"));
 jest.mock('./deploy/deploy');
 deploy_1.default.mockImplementation(() => {
     return new commander_1.Command('mock-deploy');
 });
+jest.mock('./dev/dev');
+dev_1.default.mockImplementation(() => {
+    return new commander_1.Command('mock-dev');
+});
 describe('createLayoutsCommand', () => {
     it('should create a layouts command with deploy subcommand', () => {
         const layoutsCommand = (0, layouts_1.default)();
@@ -18,5 +23,7 @@ describe('createLayoutsCommand', () => {
         expect(layoutsCommand.description()).toBe('Page Contents Layouts Commands');
         expect(deploy_1.default).toHaveBeenCalled();
         expect(layoutsCommand.commands.map(cmd => cmd.name())).toContain('mock-deploy');
+        expect(dev_1.default).toHaveBeenCalled();
+        expect(layoutsCommand.commands.map(cmd => cmd.name())).toContain('mock-dev');
     });
 });

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 export declare function loadLayoutDefinition(layoutFile: string): Promise<LayoutDefinition>;
+export declare function loadLayoutFromFile(layoutFile: string): Promise<InputLayoutDefinition>;
 export declare const BaseLayoutDefinition: z.ZodObject<{
     /**
      * User defined identifier for a Page Layout

package/lib/page/utils/definitions.js

@@ -43,7 +43,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LayoutDefinition = exports.InputLayoutDefinition = exports.BaseLayoutDefinition = exports.loadLayoutDefinition = void 0;
+exports.LayoutDefinition = exports.InputLayoutDefinition = exports.BaseLayoutDefinition = exports.loadLayoutFromFile = exports.loadLayoutDefinition = void 0;
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 const zod_1 = require("zod");
@@ -82,6 +82,7 @@ function loadLayoutFromFile(layoutFile) {
         }
     });
 }
+exports.loadLayoutFromFile = loadLayoutFromFile;
 function loadTemplate(layoutDirectory, templateFile) {
     return __awaiter(this, void 0, void 0, function* () {
         try {

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

@@ -0,0 +1,28 @@
+/**
+ * Parse zones list from command line
+ * Supports multiple formats:
+ * - Single pair: 'main=./main.html' or 'main:./main.html'
+ * - Comma-separated list: 'main=./main.html,aside=./aside.html' or 'main:./main.html,aside:./aside.html'
+ * - Multiple --zones flags: merged together
+ *
+ * @param value Current value being processed
+ * @param previous Previously processed value (used for multiple flags)
+ * @returns Record of zone names to file paths
+ */
+export declare function parseZonesList(value: string, previous: Record<string, string[]>): {
+    [x: string]: string[];
+};
+/**
+ * Parse options 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
+ *
+ * @param value Current value being processed
+ * @param previous Previously processed value (used for multiple flags)
+ * @returns Record of option names to values
+ */
+export declare function parseOptionsList(value: string, previous: Record<string, string>): {
+    [x: string]: string;
+};

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOptionsList = exports.parseZonesList = void 0;
+/**
+ * Parse zones list from command line
+ * Supports multiple formats:
+ * - Single pair: 'main=./main.html' or 'main:./main.html'
+ * - Comma-separated list: 'main=./main.html,aside=./aside.html' or 'main:./main.html,aside:./aside.html'
+ * - Multiple --zones flags: merged together
+ *
+ * @param value Current value being processed
+ * @param previous Previously processed value (used for multiple flags)
+ * @returns Record of zone names to file paths
+ */
+function parseZonesList(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 zoneName;
+        let filePath;
+        // Handle both colon and equals separators
+        if (part.includes('=')) {
+            [zoneName, filePath] = part.split('=');
+        }
+        else if (part.includes(':')) {
+            [zoneName, filePath] = part.split(':');
+        }
+        else {
+            continue; // Skip invalid format
+        }
+        // Skip empty zone names or file paths
+        if (!zoneName || !filePath) {
+            continue;
+        }
+        if (!result[zoneName]) {
+            result[zoneName] = [];
+        }
+        result[zoneName].push(filePath);
+    }
+    return result;
+}
+exports.parseZonesList = parseZonesList;
+/**
+ * Parse options 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
+ *
+ * @param value Current value being processed
+ * @param previous Previously processed value (used for multiple flags)
+ * @returns Record of option names to values
+ */
+function parseOptionsList(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;
+        // Handle both colon and equals separators
+        if (part.includes('=')) {
+            [optionName, optionValue] = part.split('=');
+        }
+        else if (part.includes(':')) {
+            [optionName, optionValue] = part.split(':');
+        }
+        else {
+            continue; // Skip invalid format
+        }
+        // Skip empty option names or values
+        if (!optionName || !optionValue) {
+            continue;
+        }
+        result[optionName] = optionValue;
+    }
+    return result;
+}
+exports.parseOptionsList = parseOptionsList;

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

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