TypeScript bold.red方法代码示例

export default function enhanceUnexpectedTokenMessage(e: Error) {
  e.stack =
    `${chalk.bold.red('Jest encountered an unexpected token')}

This usually means that you are trying to import a file which Jest cannot parse, e.g. it's not plain JavaScript.

By default, if Jest sees a Babel config, it will use that to transform your files, ignoring "node_modules".

Here's what you can do:
${DOT}To have some of your "node_modules" files transformed, you can specify a custom ${chalk.bold(
      '"transformIgnorePatterns"',
    )} in your config.
${DOT}If you need a custom transformation specify a ${chalk.bold(
      '"transform"',
    )} option in your config.
${DOT}If you simply want to mock your non-JS modules (e.g. binary assets) you can stub them out with the ${chalk.bold(
      '"moduleNameMapper"',
    )} config option.

You'll find more details and examples of these config options in the docs:
${chalk.cyan('https://jestjs.io/docs/en/configuration.html')}

${chalk.bold.red('Details:')}

` + e.stack;

  return e;
}

 diffResult.diffSet.forEach(function(entry) {
   switch (entry.state) {
     case 'equal':
       return;
     case 'left':
       const expectedFileRelPath =
           path.join(entry.relativePath || '/', entry.name1);
       errorOutputLines.push((chalk.bold.green(' + ' + expectedFileRelPath)));
       return;
     case 'right':
       const actualFileRelPath =
           path.join(entry.relativePath || '/', entry.name2);
       errorOutputLines.push((chalk.bold.red(' - ' + actualFileRelPath)));
       return;
     case 'distinct':
       const diffedFileRelPath =
           path.join(entry.relativePath || '/', entry.name1);
       const expectedFilePath = path.join(entry.path1, entry.name1);
       const actualFilePath = path.join(entry.path2, entry.name2);
       const patch = diff.createPatch(
           'string',
           fs.readFileSync(expectedFilePath, 'utf8'),
           fs.readFileSync(actualFilePath, 'utf8'),
           'expected',
           'converted');
       errorOutputLines.push((chalk.bold.red('<> ' + diffedFileRelPath)));
       errorOutputLines.push(formatDiffPatch(patch));
       return;
     default:
       throw new Error('Unexpected diff-entry format: ' + entry);
   }
 });

    tailer.on('exit', (result, details) => {
      debug('Install: Build tools tailer exited');

      if (result === 'error') {
        debug('Installer: Tailer found error with installer', details);
        reject(new Error(`Found error with VCC installer: ${details}`));
      }

      if (result === 'success') {
        vccLastLines = [ chalk.bold.green('Successfully installed Visual Studio Build Tools.') ];
        debug('Installer: Successfully installed Visual Studio Build Tools according to tailer');
        resolve({ success: true, toConfigure: true });
      }

      // Stop the log now. If we need to report failures, we need
      // to do it after the single-line-logger has stopped messing
      // with the terminal.
      logStatus();
      stopLog();

      if (result === 'failure') {
        log(chalk.bold.red('\nCould not install Visual Studio Build Tools.'));
        log('Please find more details in the log files, which can be found at');
        log(getWorkDirectory() + '\n');
        debug('Installer: Failed to install according to tailer');
        resolve({ success: false });
      }
    });

export const errorMessage = (
  option: string,
  received: any,
  defaultValue: any,
  options: ValidationOptions,
  path?: Array<string>,
): void => {
  const conditions = getValues(defaultValue);
  const validTypes: Array<string> = Array.from(
    new Set(conditions.map(getType)),
  );

  const message = `  Option ${chalk.bold(
    `"${path && path.length > 0 ? path.join('.') + '.' : ''}${option}"`,
  )} must be of type:
    ${validTypes.map(e => chalk.bold.green(e)).join(' or ')}
  but instead received:
    ${chalk.bold.red(getType(received))}

  Example:
${formatExamples(option, conditions)}`;

  const comment = options.comment;
  const name = (options.title && options.title.error) || ERROR;

  throw new ValidationError(name, message, comment);
};

 mutants.forEach(mutant => {
   switch (mutant.status) {
     case MutantStatus.KILLED:
       mutantsKilled++;
       break;
     case MutantStatus.TIMEDOUT:
       mutantsTimedOut++;
       break;
     case MutantStatus.SURVIVED:
       console.log(chalk.bold.red('Mutant survived!'));
       console.log(mutant.filename + ': line ' + mutant.lineNumber + ':' + mutant.columnNumber);
       console.log('Mutation: ' + mutant.mutation.name);
       console.log(chalk.red('-   ' + mutant.originalLine));
       console.log(chalk.green('+   ' + mutant.mutatedLine));
       console.log('\n');
       console.log('Tests ran: ');
       _.forEach(mutant.specsRan, function(spec: string) {
         console.log('    ' + spec);
       });
       console.log('\n');
       break;
     case MutantStatus.UNTESTED:
       mutantsUntested++;
       break;
   }
 });

			(key, options) => {
				if (argv[key] === undefined && isRequiredOption(options)) {
					if (!validationError) {
						validationError = `\n${chalk.bold.red('Error(s):')}`;
					}
					validationError = `${validationError}\n  Required option '${chalk.redBright(key)}' not provided`;
				}
			},

    public printError(error: string) {
        let message = `abort: ${error}${EOL}`;
        if (this._colorStderr) {
            message = chalk.bold.red(message);
        }

        this.stderr.write(message, "utf8");
    }

function output(msg: string, severity: string) {
    if (severity === "warning") {
        console.warn(chalk.bold.yellow(msg));
    } else if (severity === "error") {
        console.error(chalk.bold.red(msg));
    } else {
        console.log(msg);
    }
}

export function error(...args: any[]) {
  if (args.length > 1) {
    args[0] = chalk.bold.red(args[0]);
  }

  if (!process.env.MUTE_CLI_LOG) {
    console.error.apply(console, args);
  }
}