@eui/cli 21.0.5-snapshot-1771153461655 → 21.0.5-snapshot-1771237470720

package/README.md

@@ -1,26 +1,84 @@
-# eUI platform
+# @eui/cli
 
-## Pre-requisites
+Command-line interface for scaffolding and managing eUI applications.
 
-**NodeJS 20.19.x**
+## Installation
 
-**Yarn**
+```sh
+npm install -g @eui/cli
+```
 
+## Usage with npx
 
-## Quickstart
+Run without installing globally:
+
+```sh
+npx @eui/cli new
+```
 
-The entry point of eUI is the @eui/cli package, this will help you scaffold an eUI app of your choice :
+## Usage
 
-### Install @eui/cli
+### Generate a new application
 
 ```sh
-npm install -g @eui/cli@latest
+eui-cli new
 ```
 
-### Generate an app
+Or simply:
+
 ```sh
-cd <your-root-dev-folder>
-mkdir myApp
-cd myApp
 eui-cli
 ```
+
+### Build application
+
+```sh
+eui-cli build-app [options]
+```
+
+Options:
+- `--skipLint` - Skip linting step
+- `--skipTest` - Skip testing step
+- `--skipCompile` - Skip compilation step
+- `-c, --configuration <config>` - Angular build configuration
+- `--baseHref <href>` - Base href for the application
+- `--statsJson` - Generate stats.json file
+- `--sourceMap` - Generate source maps
+
+### Serve application
+
+```sh
+eui-cli serve-app [options]
+```
+
+Options:
+- `-c, --configuration <config>` - Angular build configuration
+- `-p, --port <port>` - Port number (default: 4200)
+- `-h, --host <host>` - Host to serve on
+- `--proxyConfig <path>` - Path to proxy configuration file
+- `--open` - Open browser automatically
+
+### Lint application
+
+```sh
+eui-cli lint-app
+```
+
+### Generate SVG sprite
+
+```sh
+eui-cli generate-sprite -i <input-folder> -o <output-file>
+```
+
+Options:
+- `-i, --inFolder <path>` - Input folder containing SVG files (required)
+- `-o, --outFile <filename>` - Output sprite filename with .svg extension (required)
+
+## Requirements
+
+- Node.js 24.x or higher
+- npm or yarn
+
+## License
+
+EUPL-1.1

package/bin/eui-cli.js

@@ -1,62 +1,119 @@
 #!/usr/bin/env node
 
-const spawn = require('cross-spawn');
-const args = process.argv.slice(2);
-
-const scriptIndex = args.findIndex(
-  (x) =>
-    x === '' ||
-    x === undefined || 
-    x === 'new' ||
-    x === 'build-app' ||
-    x === 'serve-app' ||
-    x === 'lint-app' ||
-    x === 'inject-config-app' ||
-    x === 'generate-sprite'
-);
-const script = scriptIndex === -1 ? args[0] : args[scriptIndex];
-const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : [];
-
-switch (script) {
-    case '':
-    case undefined:
-    case 'new':
-    case 'build-app':
-    case 'serve-app':
-    case 'lint-app':
-    case 'inject-config-app': 
-    case 'generate-sprite': {
-        let genScript = script;
-        if (script === '' || script === undefined) {
-            genScript = 'new';
-        }
-        const result = spawn.sync(
-            'node',
-            nodeArgs
-                .concat(require.resolve('./scripts/' + genScript))
-                .concat(args.slice(scriptIndex + 1)),
-            { stdio: 'inherit' }
-        );
-        if (result.signal) {
-            if (result.signal === 'SIGKILL') {
-                console.log(
-                    'The build failed because the process exited too early. '+
-                    'This probably means the system ran out of memory or someone called ' +
-                    '`kill -9` on the process.'
-                );
-            } else if(result.signal === 'SIGTERM') {
-                console.log(
-                    'The build failed because the process exited too early. ' +
-                    'Someone might have called `kill` or `killall`, or the system could ' +
-                    'be shutting down.'
-                )
-            }
-            process.exit(1);
-        }
-        process.exit(result.status);
-        break;
+const { Command } = require('commander');
+const config = require('../lib/config');
+
+const program = new Command();
+
+program
+  .name('eui-cli')
+  .description('eUI CLI app generator & tools')
+  .version(config.version, '-v, --version', 'output the current version');
+
+function buildProcessArgv(options, command) {
+  const scriptArgs = [];
+
+  Object.keys(options).forEach(key => {
+    if (key !== 'parent' && options[key] !== undefined) {
+      const value = options[key];
+      if (value === true) {
+        scriptArgs.push(`--${key}`);
+      } else if (value !== false) {
+        scriptArgs.push(`--${key}=${value}`);
+      }
     }
-    default:
-        console.log('Unknown script "' + script + '".');
-        break;
+  });
+
+  if (command && command.args) {
+    scriptArgs.push(...command.args);
+  }
+
+  process.argv = ['node', 'eui-cli', ...scriptArgs];
 }
+
+async function handleCommand(scriptPath, options, command) {
+  buildProcessArgv(options, command);
+
+  try {
+    const script = require(scriptPath);
+    // If script exports a function, call it; otherwise it's a promise
+    if (typeof script === 'function') {
+      await script();
+    } else {
+      await script;
+    }
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+program
+  .command('new', { isDefault: true })
+  .description('Generate a new eUI application')
+  .option('-c, --config <path>', 'Path to configuration file')
+  .option('-t, --targetPath <path>', 'Target path for the generated application')
+  .action((options, command) => handleCommand('./scripts/new', options, command));
+
+program
+  .command('build-app')
+  .description('Build the eUI application')
+  .option('--skipLint', 'Skip linting step')
+  .option('--skipTest', 'Skip testing step')
+  .option('--skipCompile', 'Skip compilation step')
+  .option('-c, --configuration <config>', 'Angular build configuration')
+  .option('--baseHref <href>', 'Base href for the application')
+  .option('--servePath <path>', 'Serve path for the application')
+  .option('-w, --watch', 'Enable watch mode for tests')
+  .option('--dryRun', 'Run in dry-run mode')
+  .option('--maxSpaceSize', 'Use increased memory allocation')
+  .option('--statsJson', 'Generate stats.json file')
+  .option('--ci', 'Enable CI mode')
+  .option('--deployUrl <url>', 'Deploy URL for the application')
+  .option('--sourceMap', 'Generate source maps')
+  .option('--configEnvTarget <target>', 'Environment target for configuration')
+  .option('--project <name>', 'Project name')
+  .option('-d, --debug', 'Enable debug mode')
+  .action((options, command) => handleCommand('./scripts/build-app', options, command));
+
+program
+  .command('serve-app')
+  .description('Serve the eUI application')
+  .option('-c, --configuration <config>', 'Angular build configuration')
+  .option('--baseHref <href>', 'Base href for the application')
+  .option('--servePath <path>', 'Serve path for the application')
+  .option('-h, --host <host>', 'Host to serve on')
+  .option('--proxyConfig <path>', 'Path to proxy configuration file')
+  .option('--maxSpaceSize', 'Use increased memory allocation')
+  .option('-p, --port <port>', 'Port number to serve on')
+  .option('--disableHostCheck', 'Disable host check')
+  .option('--open <value>', 'Open browser automatically')
+  .option('-d, --debug', 'Enable debug mode')
+  .option('--configEnvTarget <target>', 'Environment target for configuration')
+  .option('--noLiveReload', 'Disable live reload')
+  .option('--project <name>', 'Project name (default: "app")')
+  .action((options, command) => handleCommand('./scripts/serve-app', options, command));
+
+program
+  .command('lint-app')
+  .description('Lint the eUI application')
+  .option('-p, --project <name>', 'Project name (default: "app")')
+  .option('-d, --debug', 'Enable debug mode')
+  .action((options, command) => handleCommand('./scripts/lint-app', options, command));
+
+program
+  .command('inject-config-app')
+  .description('Inject configuration into the application')
+  .requiredOption('-c, --configEnvTarget <target>', 'Environment target for configuration')
+  .option('-d, --debug', 'Enable debug mode')
+  .action((options, command) => handleCommand('./scripts/inject-config-app', options, command));
+
+program
+  .command('generate-sprite')
+  .description('Generate SVG sprite')
+  .requiredOption('-i, --inFolder <path>', 'Input folder path containing SVG files')
+  .requiredOption('-o, --outFile <filename>', 'Output SVG sprite filename (must have .svg extension)')
+  .option('-d, --debug', 'Enable debug mode')
+  .action((options, command) => handleCommand('./scripts/generate-sprite', options, command));
+
+program.parse(process.argv);

package/bin/scripts/build-app.js

@@ -2,11 +2,4 @@
 
 const build = require('../../lib/app-utils/build');
 
-Promise.resolve()
-  .then(() => {
-    return build.run();
-  })
-  .catch((e) => {
-    console.error(e);
-    process.exit(1);
-  });
+module.exports = build.run();

package/bin/scripts/generate-sprite.js

@@ -2,11 +2,4 @@
 
 const svgUtils = require('../../lib/app-utils/svg-utils');
 
-Promise.resolve()
-  .then(() => {
-    return svgUtils.generateSprite();
-  })
-  .catch((e) => {
-    console.error(e);
-    process.exit(1);
-  });
+module.exports = svgUtils.generateSprite();

package/bin/scripts/inject-config-app.js

@@ -2,11 +2,4 @@
 
 const common = require('../../lib/app-utils/common');
 
-Promise.resolve()
-  .then(() => {
-    return common.injectAppConfig();
-  })
-  .catch((e) => {
-    console.error(e);
-    process.exit(1);
-  });
+module.exports = common.injectAppConfig();

package/bin/scripts/lint-app.js

@@ -6,17 +6,13 @@ const execSync = childProcess.execSync;
 
 const utils = require('../../lib/utils');
 
-Promise.resolve()
-  .then(() => {
-    const prjName = 'app';
+module.exports = () => {
+    const args = utils.getArgs();
+    const prjName = args.project || 'app';
 
     utils.logTitle(`Linting application : ${prjName}...`);
 
-    const ng = path.resolve(process.cwd(), '@angular', 'cli', 'bin', 'ng');    
+    const ng = path.resolve(process.cwd(), '@angular', 'cli', 'bin', 'ng');
 
-    execSync(`ng lint ${prjName}`);  
-  })
-  .catch((e) => {
-    console.error(e);
-    process.exit(1);
-  });
+    execSync(`ng lint ${prjName}`);
+};

package/bin/scripts/new.js

@@ -3,37 +3,38 @@ const generators = require('../../lib/generators');
 const config = require('../../lib/config');
 const utils = require('../../lib/utils');
 
-// fetching cli arguments
-const args = utils.getArgs();
+module.exports = function run() {
+  // fetching cli arguments
+  const args = utils.getArgs();
 
-// Print header and version
-utils.logBigTitle('eUI CLI');
-utils.logAccent(` --- v${config.version} ---\n`);
+  // Print header and version
+  utils.logBigTitle('eUI CLI');
+  utils.logAccent(` --- v${config.version} ---\n`);
 
-// remapping config if passed as argument - automated mode
-let inputConfig = config.parseInputConfig(args.config);
+  // remapping config if passed as argument - automated mode
+  let inputConfig = config.parseInputConfig(args.config);
 
-// Detecting targetPath and create it if present as argument - local and automated mode
-let targetPath;
+  // Detecting targetPath and create it if present as argument - local and automated mode
+  let targetPath;
 
-if (args.targetPath) {
-  targetPath = path.join(config.targetPath, args.targetPath);
+  if (args.targetPath) {
+    targetPath = path.join(config.targetPath, args.targetPath);
 
-  if (!utils.isDirExists(targetPath)) {
-    utils.mkdir(targetPath);
-  }
-
-// otherwise taking the default config targetPath defined
-} else {
-  targetPath = config.targetPath;
-}
+    if (!utils.isDirExists(targetPath)) {
+      utils.mkdir(targetPath);
+    }
 
-if (args.v) {
-  console.info('Current eUI CLI version installed : ' + config.version);
+  // otherwise taking the default config targetPath defined
+  } else {
+    targetPath = config.targetPath;
+  }
 
-} else {
-  return generators.appGenerate({
-    inputConfig: inputConfig,
-    targetPath: targetPath
-  });
-}
+  if (args.v) {
+    console.info('Current eUI CLI version installed : ' + config.version);
+  } else {
+    return generators.appGenerate({
+      inputConfig: inputConfig,
+      targetPath: targetPath
+    });
+  }
+};

package/bin/scripts/serve-app.js

@@ -2,11 +2,4 @@
 
 const serve = require('../../lib/app-utils/serve');
 
-Promise.resolve()
-  .then(() => {
-    return serve.run();
-  })
-  .catch((e) => {
-    console.error(e);
-    process.exit(1);
-  });
+module.exports = serve.run();

package/lib/app-utils/build.js

@@ -3,8 +3,29 @@ const childProcess = require('child_process');
 const execSync = childProcess.execSync;
 
 const utils = require('../utils');
-const common = require('./common'); 
-
+const common = require('./common');
+
+/**
+ * Runs the application build process with configurable parameters for linting, testing, and compilation.
+ *
+ * @param {Object} args - Arguments object (retrieved via utils.getArgs())
+ * @param {boolean} [args.skipLint] - Skip linting step
+ * @param {boolean} [args.skipTest] - Skip testing step
+ * @param {boolean} [args.skipCompile] - Skip compilation step
+ * @param {string} [args.configuration] - Angular build configuration (defaults to 'production')
+ * @param {string} [args.baseHref] - Base href for the application
+ * @param {string} [args.servePath] - Serve path for the application
+ * @param {boolean} [args.watch] - Enable watch mode for tests
+ * @param {boolean} [args.dryRun] - Run in dry-run mode without executing commands
+ * @param {boolean} [args.maxSpaceSize] - Use increased memory allocation (8096MB)
+ * @param {boolean} [args.statsJson] - Generate stats.json file
+ * @param {boolean} [args.ci] - Enable CI mode (disables progress)
+ * @param {string} [args.deployUrl] - Deploy URL for the application
+ * @param {boolean} [args.sourceMap] - Generate source maps
+ * @param {string} [args.configEnvTarget] - Environment target for configuration injection
+ * @param {string} [args.project] - Project name (defaults to 'app')
+ * @returns {Promise<void>} Promise that resolves when build process is complete
+ */
 module.exports.run = () => {
   let {
     skipLint,
@@ -34,21 +55,13 @@ module.exports.run = () => {
 
   const ng = path.resolve(process.cwd(), 'node_modules', '@angular', 'cli', 'bin', 'ng');
 
-  return Promise.resolve()
-    .then(() => {
       if (configEnvTarget) {
-        return common.injectAppConfig();
+        common.injectAppConfig();
       }
-    })
-
-    .then(() => {
       if (!skipLint) {
           utils.logInfo(`running ng lint ${prjName}`);
-          execSync(`ng lint ${prjName}`, { cwd: process.cwd(), stdio: 'inherit' });        
+          execSync(`ng lint ${prjName}`, { cwd: process.cwd(), stdio: 'inherit' });
       }
-    })
-
-    .then(() => {
       if (!skipLint) {
         utils.logSuccess();
       }
@@ -77,9 +90,6 @@ module.exports.run = () => {
           execSync(`node ${args.join(' ')}`, { cwd: process.cwd(), stdio: 'inherit' });
         }
       }
-    })
-
-    .then(() => {
       if (!skipTest) {
         utils.logSuccess();
       }
@@ -99,7 +109,7 @@ module.exports.run = () => {
 
       if (configuration) {
         args.push(`--configuration=${configuration}`);
-      } 
+      }
 
       if (baseHref) {
         args.push(`--base-href=${baseHref}`);
@@ -128,10 +138,5 @@ module.exports.run = () => {
       if (!dryRun && !skipCompile) {
         execSync(`node ${args.join(' ')}`, { cwd: process.cwd(), stdio: 'inherit' });
       }
-    })
-
-    .catch((e) => {
-      throw e;
-    });
 };
 

package/lib/app-utils/common.js

@@ -1,9 +1,15 @@
 const path = require('path');
 const utils = require('../utils');
 
+/**
+ * Injects application configuration by replacing the default env-json-config.json file
+ * with environment-specific configuration.
+ *
+ * @param {string} args.configEnvTarget - Target environment for configuration injection (required)
+ * @returns {Promise<void>} Promise that resolves when configuration injection is complete
+ * @throws {Error} When configEnvTarget is not provided or environment config file is missing
+ */
 module.exports.injectAppConfig = () => {
-  return Promise.resolve()
-    .then(() => {
       let { configEnvTarget } = utils.getArgs();
 
       if (!configEnvTarget) {
@@ -35,9 +41,4 @@ module.exports.injectAppConfig = () => {
       utils.copy(envFilePath, path.join(process.cwd(), `${replacedFile}`));
 
       utils.logSuccess();
-    })
-
-    .catch((e) => {
-      throw e;
-    });
-}
+}

package/lib/app-utils/serve.js

@@ -5,8 +5,29 @@ const childProcess = require('child_process');
 const execSync = childProcess.execSync;
 
 const utils = require('../utils');
-const common = require('./common'); 
-
+const common = require('./common');
+
+/**
+ * Serves an Angular application using ng serve with configurable options.
+ *
+ * @function run
+ * @param {string} [configuration] - Angular build configuration (e.g., 'development', 'production')
+ * @param {string} [baseHref] - Base href for the application
+ * @param {string} [servePath] - Path to serve the application from
+ * @param {string} [host] - Host to serve the application on
+ * @param {string} [proxyConfig] - Path to proxy configuration file
+ * @param {boolean} [maxSpaceSize] - Enable max old space size of 8192MB for Node.js
+ * @param {string|number} [port] - Port number to serve the application on
+ * @param {boolean} [disableHostCheck] - Disable host check for webpack dev server
+ * @param {string|boolean} [open] - Open browser automatically (default: true, set to 'false' to disable)
+ * @param {boolean} [debug] - Enable debug mode
+ * @param {boolean} [configEnvTarget] - Inject app configuration before serving
+ * @param {boolean} [noLiveReload] - Disable live reload functionality
+ * @param {string} [project] - Angular project name to serve (default: 'app')
+ * @example
+ * // Command line usage:
+ * // node script.js --configuration=development --port=4200 --host=localhost
+ */
 module.exports.run = () => {
 
   let { configuration, baseHref, servePath, host, proxyConfig, maxSpaceSize, port, disableHostCheck, open, debug, configEnvTarget, noLiveReload, project } = utils.getArgs();
@@ -19,15 +40,9 @@ module.exports.run = () => {
     prjName = project;
   }
 
-  return Promise.resolve()
-    .then(() => {
       if (configEnvTarget) {
-        return common.injectAppConfig();
+        common.injectAppConfig();
       }
-    })
-
-    // trigger ng serve with parameters provided
-    .then(() => {
       utils.logTitle(`Serving application : ${prjName}...`);
 
       let args;
@@ -77,8 +92,4 @@ module.exports.run = () => {
       utils.logInfo(`ng serve with args ${args}`);
 
       return execSync(`node ${args.join(' ')}`, { cwd: process.cwd(), stdio: 'inherit' });
-    })
-    .catch((e) => {
-      throw e;
-    });
 }