How to use pretty-ms - 10 common examples

return;
	}

	console.log(`> Cold: ${c.bold.green(ms(firstRun.duration))}`);

	// warm up
	let i = n;
	while (i--) run(code, file);

	// take average
	i = n;
	let total = 0;
	while (i--) total += run(code, file).duration;

	const avg = total / n;
	console.log(`> Warm: ${c.bold.green(ms(avg))} (average of ${n} runs)`);
}

stayAwake.prevent(err => {
    if (err) {
      console.error(err);
    }
  });

  if (turnOff) {
    turnOffScreen();
  }

  console.log();
  console.log(chalk.bold.green('Time remaining: '));

  const duration: number = minutes * 60 * 1000;
  const spinner = ora({
    text: prettyMs(duration, { secDecimalDigits: 0 }),
    spinner: 'clock',
    interval: 80,
  }).start();

  timer.start(duration);

  timer.on('tick', currentTime => {
    spinner.text = prettyMs(currentTime, {
      secDecimalDigits: 0,
    });
  });

  timer.on(
    'done',
    (): void => {
      spinner.succeed(chalk.bold("Time's up"));

async function run(commandName: string, promiseFn: () => Promise) {
  console.log(`Starting ${commandName}...`);
  console.log();
  const startTime = now();
  await promiseFn();
  console.log("Completed in %s", prettyMS(now() - startTime));
  console.log();
}

export default (level, data) => {
  const prefix = PREFIXES[level] || PREFIXES.SILLY;
  const handler = handlers[data.type] || unknownTypeLogger;
  const now = Date.now();
  const relativeClose = now - lastLogTime <= 1000;
  const shouldLogDelta = relativeClose && now - lastFullTime <= 5000;
  const timeStr = shouldLogDelta
    ? ` +${prettyMs(now - lastLogTime)}`.padStart(29, '-')
    : format(now);

  if (!shouldLogDelta) lastFullTime = now;

  lastLogTime = now;

  console.log(`${prefix} ${chalk.italic.dim(timeStr)}:`, handler(data.payload));
};

const handleComplete = result => {
    const finishedAt = Date.now();

    println();
    println(
      chalk.green(`passed: ${result.pass}  `) +
      chalk.red(`failed: ${result.fail || 0}  `) +
      chalk.white(`of ${result.count} tests  `) +
      chalk.dim(`(${prettyMs(finishedAt - startedAt)})`)
    );
    println();

    if (result.ok) {
      println(chalk.green(`All of ${result.count} tests passed!`));
    } else {
      println(chalk.red(`${result.fail || 0} of ${result.count} tests failed.`));
      stream.isFailed = true;
    }

    println();
  };

async function updateStopwatchData(data) {
  const watch = data[0];
  const btnEl = $('.active-stopwatch-trigger');
  if (!watch) {
    btnEl.addClass('hidden');
  } else {
    const {repo_owner_name, repo_name, issue_index, seconds} = watch;
    const issueUrl = `${AppSubUrl}/${repo_owner_name}/${repo_name}/issues/${issue_index}`;
    $('.stopwatch-link').attr('href', issueUrl);
    $('.stopwatch-commit').attr('action', `${issueUrl}/times/stopwatch/toggle`);
    $('.stopwatch-cancel').attr('action', `${issueUrl}/times/stopwatch/cancel`);
    $('.stopwatch-issue').text(`${repo_owner_name}/${repo_name}#${issue_index}`);
    $('.stopwatch-time').text(prettyMilliseconds(seconds * 1000));
    updateStopwatchTime(seconds);
    btnEl.removeClass('hidden');
  }

  return !!data.length;
}

server.get('/', async (_, res) => {
  const message = `MockBot v4 is up since ${ prettyMs(Date.now() - up) } ago, processed ${ numActivities } activities.`;
  const separator = new Array(message.length).fill('-').join('');

  res.set('Content-Type', 'text/plain');
  res.send(JSON.stringify({
    human: [
      separator,
      message,
      separator
    ],
    computer: {
      numActivities,
      up
    }
  }, null, 2));
});

export const sanitizeMetric = function (metric, value) {
    if (SCORE_METRICS.includes(metric)) {
        const scoreValue = value < 1 ? Math.round(value * 100) : value
        return scoreValue + '/100'
    }

    if (MB_UNIT_METRICS.includes(metric)) {
        return (value / 10 ** 6).toFixed(2) + 'MB'
    }

    if (NO_UNIT_METRICS.includes(metric)) {
        return value
    }

    return value ? prettyMs(value) : value
}

  const timing = () => (startTime ? `-- after ${`${prettyMs(Date.now() - startTime)}`.cyan}` : null);
  const fake: OraImpl = {

private determinePunishment(peer, offence: IOffence): IPunishment {
        if (this.isRepeatOffender(peer)) {
            offence = this.offences.REPEAT_OFFENDER;
        }

        const until = dato()[offence.period](offence.number);
        const untilDiff = until.diff(dato());

        this.logger.debug(
            `Suspended ${peer.ip} for ${prettyMs(untilDiff, {
                verbose: true,
            })} because of "${offence.reason}"`,
        );

        return {
            until,
            reason: offence.reason,
            weight: offence.weight,
        };
    }
}