Top 10 Examples of "cli-color in functional component" in JavaScript

return exists(dtsName).then(dtsExists => {
        if (!dtsExists) {
          console.error(clc.red('Error: ') + clc.magenta(file) + clc.red('. Dts file not found.'));
          errors += 1;
          return null;
        }

        return read(dtsName).then(actual => {
          return read(expectedFile).then(expected => {
            expected = normalize(expected);
            actual = normalize(actual);

            expected = expected.trim();
            if (!suppressAmbientDeclaration) {
              actual = actual.split('\n').slice(1, -1).map(l => l.substring(2)/* remove leading whitespace */).join('\n').trim();
            } else {
              actual = actual.replace(/export declare/g, 'export').trim();
            }

// nightwatch marks it as failed
      test.status = Test.TEST_STATUS_SKIPPED;
      return;
    }

    let status = clc.greenBright("PASS");
    let enqueueNote = "";

    /* eslint-disable indent */
    switch (test.status) {
      case Test.TEST_STATUS_SUCCESSFUL:
        // Add this test to the passed test list, then remove it from the failed test
        // list (just in case it's a test we just retried after a previous failure).
        break;
      case Test.TEST_STATUS_FAILED:
        status = clc.redBright("FAIL");

        if (this.settings.gatherTrends) {
          const key = test.toString();
          /*eslint-disable no-magic-numbers*/
          this.trends.failures[key] = this.trends.failures[key] > -1
            ? this.trends.failures[key] + 1 : 1;
        }

        // if suite should bail due to failure
        this.strategies.bail.shouldBail({
          totalTests: this.queue.tests,
          passedTests: this.queue.getPassedTests(),
          failedTests: this.queue.getFailedTests()
        });

        // Note: Tests that failed but can still run again are pushed back into the queue.

// Note: Tests that failed but can still run again are pushed back into the queue.
        // This push happens before the queue is given back flow control (at the end of
        // this callback), which means that the queue isn't given the chance to drain.
        if (!test.canRun()) {
          this.queue.enqueue(test, constants.TEST_PRIORITY.RETRY);

          enqueueNote = clc.cyanBright(`(will retry, ${test.maxAttempts - test.attempts}` +
            ` time(s) left). Spent ${test.getRuntime()} ms`);
        }
        break;
      case Test.TEST_STATUS_NEW:
        // no available resource
        status = clc.yellowBright("RETRY");
        this.queue.enqueue(test, constants.TEST_PRIORITY.RETRY);

        enqueueNote = clc.cyanBright("(will retry). ") + clc.redBright(error.message);
        break;
    }

    const failedTests = this.queue.getFailedTests();
    const passedTests = this.queue.getPassedTests();

    let prefix = `(${failedTests.length + passedTests.length} ` +
      `/ ${this.queue.getTestAmount()})`;

    if (test.attempts > 1) {
      // this is a retry
      prefix = "(retry)";
    }

    if (!this.serial && test.workerIndex > 0) {
      prefix += ` <-- Worker ${test.workerIndex}`;

}, function (err, res, body) {
        if(err) {
          next(err);
          return;
        }
        
        var redirect = _.first(_.flattenDeep(_.compact(_.pluck(body, 'http://dbpedia.org/ontology/wikiPageRedirects'))));
        
        if(followRedirection && redirect && redirect.value && level < 1) {
          var link = redirect.value.split('/').pop();
          if(options.link == link) {
            // no need to scrape again...
            next(null, body);
            return
          }
          console.log(clc.blackBright('following redirection, level'), clc.cyan(level), clc.blackBright('link'), clc.cyan(link))
          setTimeout(function(){
            module.exports.dbpedia({
              link: link,
              level: level + 1
            }, next);
          }, 2300);
          return;
        };
        
        next(null, body)
      })
  },

var q = async.queue(function (resource, next) {
      resource.user = options.marvin;
      resource.languages = _.compact(_.map(resource.languages.split(','),_.trim)).sort()
      
      resource.name = resource.name || resource.title_en;
      // check that every urls exist
      
      
      
      console.log(clc.blackBright('   creating ...', clc.whiteBright(resource.slug)))
      
      
      Resource.create(resource, function (err, res) {
        if(err) {
          q.kill();
          callback(err)
        } else {
          console.log(clc.blackBright('   resource: ', clc.whiteBright(res.id), 'saved,', q.length(), 'resources remaining'));
      
          next();
          
        }
      })
    }, 1);
    q.push(options.data);

if(typeof options[i] != 'string')
          continue;
        var pseuroArray = options[i].match(/^\[([^\]]*)\]$/);
        console.log(options[i],'rrrrr', pseuroArray)
        if(!pseuroArray)
          continue;
        
        options[i] = _.map(pseuroArray[1].split(','), function(d) {
          if(isNaN(d))
            return d.trim();
          else
            return +d;
        });
      }
      
      console.log(clc.blackBright('   executing query: ', clc.magentaBright(options.cypher), '...\n'));
      
      // enrich options with timestamp (always useful though)
      if(!options.exec_time || !options.exec_date){
        var now = require('../../helpers').now();
        options.exec_time = now.time;
        options.exec_date = now.date;
      }


      
      query = (options.profile? 'PROFILE ':'') + parser.agentBrown(queries[path[1]], options);
      console.log(query)
      
      console.log('with params')
      console.log(options)

var q = async.queue(function (triplet, nextTriplet) {
              console.log(clc.blackBright("processing id =", clc.whiteBright(triplet.id), triplet.doi, "remaining", clc.magentaBright(q.length(), loops-n, total_count)));
              var contentToIndex = _.compact(_.unique(_.values(triplet.translations))).join(' ').toLowerCase();
              if(!contentToIndex.length) {
                contentToIndex = _.compact(_.values(triplet.archive)).join(' ').toLowerCase();
              }
              
              if(!contentToIndex.length) {
                console.log(triplet.translations)
                throw 'not enough content'
              }
              contentToIndex = _.compact([ triplet.doi, contentToIndex, helpers.text.translit(contentToIndex)]).join(' ');// + ' ' + helpers.text.translit(contentToIndex);
              neo4j.query(''+
                ' MATCH (res:resource) '+
                '  WHERE id(res) = {id} SET res.full_search = {full_search} RETURN res', {
                  id: triplet.id,
                  full_search: S(contentToIndex).stripTags().s
              }, function (err, n) {

style: { head: ["yellow"] },
  });

  // Order instances newest to oldest.
  const sorted = _.sortBy(instances, "createTime", "asc").reverse();
  sorted.forEach((instance) => {
    table.push([
      _.last(instance.name.split("/")),
      instance.state,
      _.get(instance, "config.source.spec.version", ""),
      instance.createTime,
      instance.updateTime,
    ]);
  });

  utils.logLabeledBullet(logPrefix, `list of extensions installed in ${clc.bold(projectId)}:`);
  logger.info(table.toString());
  return { instances: sorted };
}

for (i in JSONData.players) {
                            // console.log(i);
                            if (JSONData.players[i].id == strikebatid) {
                                console.log(clc.yellowBright(JSONData.players[i].f_name) + clc.cyanBright("  R: ") + clc.yellowBright(this.score.batsman[0].r) + clc.cyanBright(" B: ") + clc.yellowBright(this.score.batsman[0].b) + clc.cyanBright(" 4s: ") + clc.yellowBright(this.score.batsman[0]['4s']) + clc.cyanBright(" 6s: ") + clc.yellowBright(this.score.batsman[0]['6s']))

                            }
                        }

                    }

                    if (this.score.batsman[1] && this.score.batsman[1].strike == "0") {
                        var nonstrikebatid = this.score.batsman[1].id

                        for (i in JSONData.players) {
                            if (JSONData.players[i].id == nonstrikebatid) {
                                console.log(clc.yellowBright(JSONData.players[i].f_name) + clc.cyanBright("  R: ") + clc.yellowBright(this.score.batsman[1].r) + clc.cyanBright(" B: ") + clc.yellowBright(this.score.batsman[1].b) + clc.cyanBright(" 4s: ") + clc.yellowBright(this.score.batsman[1]['4s']) + clc.cyanBright(" 6s: ") + clc.yellowBright(this.score.batsman[1]['6s']))
                            }
                        }

                    }

                    // Bowling Stats
                    if (this.score.bowler) {
                        console.log("----------     Bowling Stats     ----------");
                    }
                    // Current bowler
                    if (this.score.bowler[0]) {
                        var strikebowlid = this.score.bowler[0].id;

                        for (i in JSONData.players) {
                            if (JSONData.players[i].id == strikebowlid) {
                                console.log(clc.yellowBright(JSONData.players[i].f_name + "* ") + clc.cyanBright(" O: ") + clc.yellowBright(this.score.bowler[0].o) + clc.cyanBright(" M: ") + clc.yellowBright(this.score.bowler[0].m) + clc.cyanBright(" R: ") + clc.yellowBright(this.score.bowler[0].r) + clc.cyanBright(" W: ") + clc.yellowBright(this.score.bowler[0].w))

function makeModuleDatabaseTableWithReset(moduleName) {
    console.log(` = Reset database tables for ${clc.yellowBright(moduleName)} module`);

    const connectionInfo = require(path.join('..', configFile))['database'];
    const module = require('../module/' + moduleName + '/lib/database');

    // delete scheme before create table
    module.deleteScheme(connectionInfo, module.createScheme);
}