vk-typescript-cli 1.0.0

package/bin/sf.js

@@ -0,0 +1,438 @@
+#!/usr/bin/env node
+
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command } from '../lib/commander.js';
+import { createNewCommand } from '../src/commands/new.js';
+import { interactiveMode } from '../src/commands/interactive.js';
+import { addComponentCommand } from '../src/commands/add.js';
+import { mcpAddCommand } from '../src/commands/mcp.js';
+import { skillsAddCommand } from '../src/commands/skills.js';
+// import { upgradeCommand } from '../src/commands/upgrade.js';
+import { themeSwitchCommand } from '../src/commands/theme.js';
+import { infoCommand } from '../src/commands/info.js';
+import { logger } from '../src/utils/logger.js';
+import { printBanner, printHelpFooter } from '../src/utils/banner.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(await readFile(path.join(__dirname, '..', 'package.json'), 'utf8'));
+const CLI_VERSION = pkg.version;
+
+const program = new Command();
+
+program
+  .name('sf')
+  .description('CLI for creating and managing Syncfusion projects. Run without a command to start interactive mode.')
+  .usage('[command] [options]')
+  .version(CLI_VERSION, '-v, --version', 'Output the current CLI version')
+  .helpOption('-h, --help', 'Show CLI help');
+
+const HELP_COMMAND_TERMS = {
+  new: 'sf new [appName] [framework] [options]',
+  add: 'sf add [component]',
+  mcp: 'sf mcp init [editor]',
+  skills: 'sf skills install',
+  theme: 'sf theme switch [themeName]',
+  // upgrade: 'sf upgrade [version]',
+  info: 'sf info'
+};
+
+// List of frameworks that the CLI knows how to scaffold. Used to validate
+// the `--framework` flag in `sf new` and the positional `framework` argument.
+const SUPPORTED_FRAMEWORKS = ['react', 'angular', 'vue', 'typescript'];
+
+program.configureHelp({
+  sortSubcommands: false,
+  helpWidth: 120,
+  subcommandTerm: (cmd) => HELP_COMMAND_TERMS[cmd.name()] || `sf ${cmd.name()}`,
+  optionTerm: (option) => option.flags
+});
+
+// Branded banner shown above --help / help output.
+program.addHelpText('afterAll', () => {
+  printHelpFooter();
+  return '';
+});
+
+program
+  .command('new [appName] [framework] [buildTool] [type] [template] [theme] [styling] [mcp] [skills] [start]')
+  .usage('[appName] [framework] [options]')
+  .description('Create a new Syncfusion project')
+  .option('--appname <appName>', 'Application name')
+  .option('--framework <framework>', 'Framework: react, angular, vue, typescript')
+  .option('--build-tool <buildTool>', 'Build tool for React only: vite, nextjs')
+  .option('--type <type>', 'Type: js, ts')
+  .option('--ts', 'Use TypeScript')
+  .option('--js', 'Use JavaScript')
+  .option('--template <template>', 'Template: empty, grid, chart, scheduler, gantt, file-manager, diagram, rich-text-editor, pdf-viewer, docx-editor, spreadsheet-editor')
+  .option('--theme <theme>', 'Theme: material3, fluent2, bootstrap5.3, tailwind3')
+  .option('--styling <styling>', 'Styling: css, scss')
+  .option('-y, --yes', 'Skip prompts and use defaults')
+  .option('--mcp <assistant>', 'Configure mcp for editor: all, vs-code, code-studio, cursor, jetbrains')
+  .option('--no-mcp', 'Do not configure the Syncfusion MCP integration')
+  .option('--skills', 'Install Syncfusion component skills')
+  .option('--no-skills', 'Do not install Syncfusion component skills')
+  .option('--start', 'Install dependencies and start the dev server')
+  .option('--no-start', 'Do not install dependencies/start the dev server')
+  .action(async (
+    appNameArg,
+    frameworkArg,
+    buildToolArg,
+    typeArg,
+    templateArg,
+    themeArg,
+    stylingArg,
+    mcpArg,
+    skillsArg,
+    startArg,
+    options
+  ) => {
+    try {
+      const normalize = (value) =>
+        typeof value === 'string' ? value.trim().toLowerCase() : value;
+
+      const resolveYesNo = (flagValue, positionalValue, defaultValue = true) => {
+        if (typeof flagValue === 'boolean') {
+          return flagValue;
+        }
+
+        if (positionalValue === undefined) {
+          return defaultValue;
+        }
+
+        const value = normalize(positionalValue);
+        const yesValues = ['yes', 'y', 'true', '1', 'enable', 'enabled', 'on'];
+        const noValues = ['no', 'n', 'false', '0', 'disable', 'disabled', 'off'];
+
+        if (yesValues.includes(value)) {
+          return true;
+        }
+
+        if (noValues.includes(value)) {
+          return false;
+        }
+
+        logger.error(`Invalid yes/no value: ${positionalValue}`);
+        logger.info('Use yes/no, true/false, y/n, 1/0, on/off, or enable/disable.');
+        process.exit(1);
+      };
+
+      const resolvemcp = (flagValue, positionalValue) => {
+        const rawValue = flagValue !== undefined ? flagValue : positionalValue;
+
+        if (rawValue === false || rawValue === undefined) {
+          return { mcp: false, mcpEditors: ['all'] };
+        }
+
+        const value = normalize(rawValue);
+        const yesValues = ['yes', 'y', 'true', '1', 'enable', 'enabled', 'on'];
+        const noValues = ['no', 'n', 'false', '0', 'disable', 'disabled', 'off'];
+        const editorValues = {
+          all: 'all',
+          vscode: 'vscode',
+          'vs-code': 'vscode',
+          codestudio: 'codestudio',
+          'code-studio': 'codestudio',
+          cursor: 'cursor',
+          jetbrains: 'jetbrains'
+        };
+
+        if (yesValues.includes(value)) {
+          return { mcp: true, mcpEditors: ['all'] };
+        }
+
+        if (noValues.includes(value)) {
+          return { mcp: false, mcpEditors: ['all'] };
+        }
+
+        if (editorValues[value]) {
+          return { mcp: true, mcpEditors: [editorValues[value]] };
+        }
+
+        logger.error(`Invalid mcp value: ${rawValue}`);
+        logger.info('Supported mcp values: all, vs-code, code-studio, cursor, jetbrains.');
+        process.exit(1);
+      };
+
+      const getDefaultType = (frameworkValue, buildToolValue) => {
+        const normalizedFramework = normalize(frameworkValue);
+        const normalizedBuildTool = normalize(buildToolValue);
+
+        if (normalizedFramework === 'vue') {
+          return 'js';
+        }
+
+        if (normalizedFramework === 'react' && normalizedBuildTool === 'vite') {
+          return 'js';
+        }
+
+        return 'ts';
+      };
+
+      let appName;
+      let framework;
+      let buildTool;
+      let type;
+      let template;
+      let theme;
+      let styling;
+      let mcpPosition;
+      let skillsPosition;
+      let startPosition;
+
+      if (options.appname) {
+        // Flag mode. Positional values are still allowed as fallback.
+        appName = options.appname;
+        framework = options.framework || frameworkArg || 'react';
+        framework = normalize(framework);
+
+        if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
+          logger.error(`Invalid framework: ${framework}`);
+          logger.info(`Supported frameworks: ${SUPPORTED_FRAMEWORKS.join(', ')}`);
+          process.exit(1);
+        }
+
+        if (framework === 'react') {
+          buildTool = options.buildTool || buildToolArg || 'vite';
+          type = options.type || typeArg || getDefaultType(framework, buildTool);
+          template = options.template || templateArg || 'empty';
+          theme = options.theme || themeArg || 'material3';
+          styling = options.styling || stylingArg || 'css';
+          mcpPosition = mcpArg;
+          skillsPosition = skillsArg;
+          startPosition = startArg;
+        } else {
+          // Build tool is not supported for Angular/Vue/TypeScript, so shift positional values left.
+          if (options.buildTool) {
+            logger.error('--build-tool is supported only for React projects');
+            process.exit(1);
+          }
+
+          buildTool = null;
+          type = options.type || typeArg || getDefaultType(framework, buildTool);
+          template = options.template || templateArg || 'empty';
+          theme = options.theme || themeArg || 'material3';
+          styling = options.styling || stylingArg || 'css';
+          mcpPosition = mcpArg;
+          skillsPosition = skillsArg;
+          startPosition = startArg;
+        }
+      } else {
+        // Positional mode.
+        appName = appNameArg;
+        framework = normalize(frameworkArg || options.framework || 'react');
+
+        if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
+          logger.error(`Invalid framework: ${framework}`);
+          logger.info(`Supported frameworks: ${SUPPORTED_FRAMEWORKS.join(', ')}`);
+          process.exit(1);
+        }
+
+        if (framework === 'react') {
+          buildTool = buildToolArg || options.buildTool || 'vite';
+          type = typeArg || options.type || getDefaultType(framework, buildTool);
+          template = templateArg || options.template || 'empty';
+          theme = themeArg || options.theme || 'material3';
+          styling = stylingArg || options.styling || 'css';
+          mcpPosition = mcpArg;
+          skillsPosition = skillsArg;
+          startPosition = startArg;
+        } else {
+          if (options.buildTool) {
+            logger.error('--build-tool is supported only for React projects');
+            process.exit(1);
+          }
+
+          buildTool = null;
+          type = buildToolArg || options.type || getDefaultType(framework, buildTool);
+          template = typeArg || options.template || 'empty';
+          theme = templateArg || options.theme || 'material3';
+          styling = themeArg || options.styling || 'css';
+          mcpPosition = stylingArg;
+          skillsPosition = mcpArg;
+          startPosition = skillsArg;
+        }
+      }
+
+      if (options.ts && options.js) {
+        logger.error('Use only one of --ts or --js');
+        process.exit(1);
+      }
+
+      if (options.ts) {
+        type = 'ts';
+      } else if (options.js) {
+        type = 'js';
+      }
+
+      if (!appName) {
+        logger.error('❌ Application name is required');
+        logger.info('Command usage: sf new [appname] [framework] [type] [template] [theme] [styling] [mcp] [skills]');
+        logger.info('Example: sf new my-app --framework react --theme tailwind3');
+        process.exit(1);
+      }
+
+      framework = normalize(framework);
+      type = normalize(type || getDefaultType(framework, buildTool));
+      template = normalize(template || 'empty');
+      theme = normalize(theme || 'material3');
+      styling = normalize(styling || 'css');
+
+      if (framework === 'typescript') {
+        // The TypeScript (vanilla EJ2) platform is always TypeScript and does
+        // not use a build tool.
+        buildTool = null;
+        type = 'ts';
+      }
+
+      if (framework === 'react') {
+        buildTool = normalize(buildTool || 'vite');
+        const validBuildTools = ['vite', 'nextjs'];
+
+        if (!validBuildTools.includes(buildTool)) {
+          logger.error(`Invalid build tool: ${buildTool}`);
+          logger.info(`Supported React build tools: ${validBuildTools.join(', ')}`);
+          process.exit(1);
+        }
+      } else {
+        buildTool = null;
+      }
+
+      const { mcp, mcpEditors } = resolvemcp(options.mcp, mcpPosition);
+      const skills = resolveYesNo(options.skills, skillsPosition, false);
+      const start = resolveYesNo(options.start, startPosition, false);
+
+      const commandOptions = {
+        framework,
+        buildTool,
+        type,
+        template,
+        theme,
+        styling,
+        yes: options.yes,
+        empty: options.empty,
+        mcp,
+        mcpEditors: mcpEditors.length > 0 ? mcpEditors : ['all'],
+        nomcp: !mcp,
+        skills,
+        noskills: !skills,
+        start,
+        noStart: !start
+      };
+
+      // Call the create command
+      await createNewCommand(commandOptions.framework, appName, commandOptions);
+
+    } catch (error) {
+      logger.error(`CLI Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// -----------------------------------------------------------------------------
+// sf add <component> — add a Grid/Chart/Scheduler/Gantt/File Manager/Diagram/Rich Text Editor/PDF Viewer/DOCX Editor/Spreadsheet Editor
+// -----------------------------------------------------------------------------
+program
+  .command('add [component]')
+  .description('Add a component sample to the current project')
+  .action(async (component) => {
+    await addComponentCommand(component);
+  });
+
+// -----------------------------------------------------------------------------
+// sf mcp init [editor] — configure the Syncfusion mcp integration
+// for this project. Supported editor values: all, vs-code, code-studio, cursor,
+// jetbrains.
+// -----------------------------------------------------------------------------
+const mcpCommand = program
+  .command('mcp')
+  .description('Set up MCP (Model Context Protocol) for the current project.')
+  .action(() => {
+    logger.error('\n❌ Invalid command: sf mcp');
+    logger.info('\nUsage: sf mcp init [editor]');
+    logger.info('Example: sf mcp init code-studio\n');
+  });
+mcpCommand
+  .command('init [editor]')
+  .description('Configure the Syncfusion mcp integration for your editor')
+  .action(async (editor, options) => {
+    await mcpAddCommand({...options,promptEditor: !editor}, editor);
+  });
+
+// -----------------------------------------------------------------------------
+// sf skills — install Syncfusion component skills for AI agents.
+// -----------------------------------------------------------------------------
+const skillsCommand = program
+  .command('skills')
+  .description('Add Syncfusion component Skills to the current project')
+  .action(() => {
+    logger.error('\n❌ Invalid command: sf skills');
+    logger.info('\nUsage: sf skills install');
+  });
+skillsCommand
+  .command('install')
+  .description('Install Syncfusion component skills into the current project')
+  .action(async () => {
+    await skillsAddCommand({ promptInstallMode: true });
+  });
+
+// -----------------------------------------------------------------------------
+// sf theme switch [theme] — swap the active Syncfusion theme.
+// -----------------------------------------------------------------------------
+const themeCommand = program
+  .command('theme').description('Switch the Syncfusion theme used by the project')
+  .action(() => {
+    logger.error('\n❌ Invalid command: sf theme');
+    logger.info('\nUsage: sf theme switch <themeName>');
+    logger.info('Example: sf theme switch tailwind3\n');
+  });
+  themeCommand
+  .command('switch [themeName]')
+  .description('Switch the active theme: material3, tailwind3, bootstrap5.3, fluent2')
+  .action(async (theme) => {
+    await themeSwitchCommand(theme);
+  });
+
+// -----------------------------------------------------------------------------
+// upgrade commands
+// -----------------------------------------------------------------------------
+// program
+//   .command('upgrade [version]')
+//   .description('Upgrade installed @syncfusion packages to a specified version')
+//   .option('--reinstall', 'Delete node_modules/@syncfusion and reinstall upgraded packages')
+//   .option('--no-reinstall', 'Only update package.json and show manual reinstall steps')
+//   .action(async (version, options) => {
+//     await upgradeCommand({
+//       version,
+//       reinstallSyncfusionPackages: options.reinstall
+//     });
+//   });
+
+program
+  .command('info')
+  .description('Show environment & project information')
+  .action(async () => {
+    await infoCommand();
+  });
+
+program
+  .command('help')
+  .description('Show Syncfusion CLI help')
+  .action(() => {
+    program.help();
+  });
+
+// Parse arguments
+const args = process.argv.slice(2);
+
+// If no arguments provided, run interactive mode
+if (args.length === 0) {
+  printBanner(CLI_VERSION);
+  interactiveMode().catch((error) => {
+    logger.error(`Fatal error: ${error.message}`);
+    process.exit(1);
+  });
+} else {
+  program.parse(process.argv);
+}

package/eslint.config.js

@@ -0,0 +1,90 @@
+import js from '@eslint/js';
+import babelParser from '@babel/eslint-parser';
+
+export default [
+  {
+    ignores: ['node_modules/', 'dist/', '.git/', 'build/', 'coverage/']
+  },
+  {
+    files: ['**/*.js'],
+    languageOptions: {
+      parser: babelParser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+        requireConfigFile: false,
+        ecmaFeatures: {
+          impliedStrict: true
+        }
+      },
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly'
+      }
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      // Quality Rules
+      'use-isnan': 'error',
+      'no-constant-condition': 'error',
+      'no-invalid-regexp': 'error',
+      'no-control-regex': 'error',
+      'eol-last': ['error', 'always'],
+      'guard-for-in': 'error',
+      'no-labels': 'error',
+      'no-debugger': 'error',
+      'no-eval': 'error',
+      'no-extra-semi': 'error',
+      'no-throw-literal': 'error',
+      'no-fallthrough': 'error',
+      'no-cond-assign': ['error', 'always'],
+      'no-redeclare': ['error', { 'builtinGlobals': true }],
+      // Style Rules
+      'semi': ['error', 'always'],
+      'comma-dangle': ['error', 'never'],
+      'no-trailing-spaces': 'error',
+      'eqeqeq': ['error', 'smart'],
+      'camelcase': ['error', {
+        'properties': 'always',
+        'ignoreDestructuring': true,
+        'ignoreImports': true
+      }],
+      'one-var': ['error', 'never'],
+      'no-var': 'error',
+      'radix': 'error',
+      // Type Safety
+      'valid-typeof': ['error', { 'requireStringLiterals': true }],
+      // Whitespace
+      'no-irregular-whitespace': ['error', {
+        'skipStrings': true,
+        'skipComments': true,
+        'skipRegExps': true,
+        'skipTemplates': true
+      }],
+      // Length & Console
+      'max-len': ['error', {
+        'code': 140,
+        'tabWidth': 4,
+        'ignoreComments': true,
+        'ignoreStrings': true,
+        'ignoreTemplateLiterals': true,
+        'ignoreRegExpLiterals': true
+      }],
+      // Variables
+      'no-unused-vars': ['error', {
+        'args': 'after-used',
+        'argsIgnorePattern': '^_',
+        'varsIgnorePattern': '^_'
+      }],
+      'no-undef': 'error',
+      'no-import-assign': 'error',
+      'no-dupe-keys': 'error',
+      'no-empty': 'error',
+      // Warnings
+      'prefer-const': 'warn'
+    }
+  }
+];

package/gulpfile.js

@@ -0,0 +1,157 @@
+import gulp from 'gulp';
+import fs from 'fs';
+import path from 'path';
+import shelljs from 'shelljs';
+import { fileURLToPath } from 'url';
+import { ESLint } from 'eslint';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const branchName = process.env.githubSourceBranch || '';
+const isHotfix = /^hotfix\//g.test(branchName);
+const isRelease = /^release\//g.test(branchName);
+
+gulp.task('syncfusion-cli-publish', function (done) {
+    const packagePath = path.resolve(__dirname);
+    if (!fs.existsSync(packagePath)) {
+        console.log(`Package path does not exist: ${packagePath}`);
+        done();
+        return;
+    }
+    shelljs.cd(packagePath);
+    let nexusRepo = 'ej2-development';
+    if (isRelease) {
+        nexusRepo = 'ej2-release';
+    }
+    if (isHotfix) {
+        nexusRepo = 'ej2-hotfix-new';
+    }
+    const registryPath = `//nexus.syncfusioninternal.com/repository/${nexusRepo}/`;
+    const registryUrl = `https:${registryPath}`;
+    const npmrcContent = [
+        'registry=https://registry.npmjs.org/',
+        `@syncfusion:registry=${registryUrl}`,
+        `${registryPath}:username=${process.env.PRIVATE_NPM_USER}`,
+        `${registryPath}:_password=${process.env.PRIVATE_NPM_PASSWORD}`,
+        `${registryPath}:email=${process.env.PRIVATE_NPM_EMAIL}`,
+        `${registryPath}:always-auth=true`
+    ].join('\n');
+
+    fs.writeFileSync('./.npmrc', npmrcContent);
+    const npmignoreContent = ['gulpfile.js', '.vscode/', '.npmignore', 'Jenkinsfile', 'tempFile', 'eslint.config.js'].join('\n');
+    fs.writeFileSync('./.npmignore', npmignoreContent);
+    const packageJsonPath = path.join(packagePath, 'package.json');
+    const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf8');
+    const packageJson = JSON.parse(packageJsonContent);
+    if (packageJson.devDependencies) { 
+        delete packageJson.devDependencies;
+    }
+    if (packageJson.scripts) {
+        delete packageJson.scripts.publish;
+        delete packageJson.scripts['ci-report'];
+        delete packageJson.scripts.test;
+    }
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+    const publishResult = shelljs.exec('npm publish');
+    if (publishResult.code !== 0) {
+        done(new Error('npm publish failed'));
+        return;
+    }
+    done();
+});
+
+gulp.task('ci-report', function(done) {
+    console.log("Starting 'ci-compile'");
+    console.log("Finished 'ci-compile'");
+    done();
+});
+
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  bold: '\x1b[1m'
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.cyan}ℹ${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}✅ ${msg}${colors.reset}`),
+  error: (msg) => console.log(`${colors.red}❌ ${msg}${colors.reset}`),
+  warning: (msg) => console.log(`${colors.yellow}⚠️  ${msg}${colors.reset}`),
+  header: (msg) => console.log(`\n${colors.bold}${colors.blue}═══════════════════════════════════════${colors.reset}\n${colors.bold}${msg}${colors.reset}\n${colors.bold}${colors.blue}═══════════════════════════════════════${colors.reset}\n`),
+  section: (msg) => console.log(`\n${colors.bold}${colors.cyan}▶ ${msg}${colors.reset}`)
+};
+
+let totalTests = 0;
+let passedTests = 0;
+let failedTests = 0;
+
+async function validateWithESLint() {
+  log.section('Test: ESLint Validation (Syntax, Unused Imports, Parse Errors)');
+  
+  try {
+    const eslint = new ESLint({
+      cwd: __dirname
+    });
+    const filesToCheck = ['bin/sf.js', 'src/**/*.js'];
+    const results = await eslint.lintFiles(filesToCheck);
+    let eslintErrors = 0;
+    let eslintWarnings = 0;
+    for (const result of results) {
+      totalTests++;
+      const fileName = path.relative(__dirname, result.filePath);
+      if (result.messages.length === 0) {
+        log.success(`✓ ${fileName}`);
+        passedTests++;
+      } else {
+        let hasErrors = false;
+        for (const message of result.messages) {
+          if (message.severity === 2) {
+            log.error(`✗ ${fileName} - Line ${message.line}: ${message.message}`);
+            eslintErrors++;
+            hasErrors = true;
+          } else if (message.severity === 1) {
+            log.warning(`${fileName} - Line ${message.line}: ${message.message}`);
+            eslintWarnings++;
+          }
+        }
+        if (hasErrors) {
+          failedTests++;
+        }
+      }
+    }
+
+    return eslintErrors === 0;
+  } catch (error) {
+    log.error(`ESLint Error: ${error.message}`);
+    totalTests++;
+    failedTests++;
+    return false;
+  }
+}
+
+// GULP TASK
+gulp.task('test', async function(done) {
+  totalTests = 0;
+  passedTests = 0;
+  failedTests = 0;
+  log.header('🧪 CLI VALIDATION TEST SUITE');
+  const eslintOk = await validateWithESLint();
+  log.header('📊 TEST SUMMARY');
+  console.log(`${colors.bold}Total Tests:${colors.reset}     ${totalTests}`);
+  console.log(`${colors.green}${colors.bold}Passed:${colors.reset}          ${passedTests}`);
+  console.log(`${colors.red}${colors.bold}Failed:${colors.reset}          ${failedTests}`);
+  if (failedTests === 0) {
+    log.success('ALL TESTS PASSED! ✨');
+    console.log();
+    done();
+  } else {
+    log.error(`${failedTests} TEST(S) FAILED!`);
+    console.log();
+    done(new Error('Tests failed'));
+  }
+});