How to use the figures.ellipsis function in figures

type:     'input',
			validate: (id) => {
				if (id.length >= 3) {
					if ((/^(?[a-z][a-z0-9]*)(?-[a-z0-9]+)*$/u).test(id)) {
						return true;
					}

					return 'The project id must be kebab-case';
				}

				return 'The project id must be at least 3 characters long';
			}
		}]);


		echo(chalk.blue(`\n${figures.play} Generating project ${figures.ellipsis}`));

		// Duplicate boilerplate
		fss.copy(BOILERPLATE, NWAYO);
		fss.rename(`${NWAYO}/-gitignore`, `${NWAYO}/.gitignore`);

		// Configuration
		const config = fss.readYaml(CONFIG_ORIGINAL);
		config.root = 'nwayo';
		fss.writeYaml(CONFIG, config);
		fss.remove(CONFIG_ORIGINAL);

		// Bundle
		const bundle = fss.readYaml(BUNDLE);
		bundle.output.konstan = '../pub/build';
		bundle.output.build =   '../pub/build';
		fss.writeYaml(BUNDLE, bundle);

cli() {

		if (fss.exists(EXTENSION)) {
			error(`There is already a 'my-extension' folder`);
		}

		echo(chalk.blue(`\n${figures.play} Generating extension ${figures.ellipsis}`));

		// Duplicate boilerplate
		fss.copy(BOILERPLATE, EXTENSION);
		fss.rename(`${EXTENSION}/-gitignore`, `${EXTENSION}/.gitignore`);
		fss.rename(`${EXTENSION}/-npmignore`, `${EXTENSION}/.npmignore`);


		// Confirmation
		echo(`
${chalk.green(`${figures.tick} ${chalk.bold(`nwayo ${PACKAGE.version}`)} extension created!`)}
		`);
	}

const formatLevel = ({ data: { level }, options: { colorize } }) => {
    // Define existing levels
    const levels = {
        trace: [chalk.gray, figures.ellipsis],
        debug: [chalk.cyan, figures.bullet],
        info: [chalk.blue, figures.info],
        warn: [chalk.yellow, figures.warning],
        error: [chalk.red, figures.cross],
        fatal: [chalk.red, figures.cross]
    };

    // Try calculating the current level index
    const levelIndex = level / 10 - 1;
    let levelString = Object.keys(levels)[levelIndex];
    let [levelColor, levelFigure] = levels[levelString] || [null, null];

    // Fallback for custom levels
    if (!levelString || !levelColor) {
        levelString = `custom`;
        levelColor = chalk.magenta;

const { debug } = useContext(DebugContext)

	if (isSkipped) {
		return null
	}

	return (
		
			
				
					{/* In debug mode, skip the Spinner to reduce noise */}
					{isDone ? (
						 ✔
					) : isRunning ? (
						debug ? (
							figures.ellipsis
						) : (
							
						)
					) : (
						''
					)}
				
				
					{name}
				
			
			{(isRunning || isDone) && children}
		
	)
}

'v'
)}${chalk.bold.magenta(`${pkg.version}`)}`;

export const wpackLogoSmall = gradient.instagram('wpack.io');

export const donationSentence = `If ${wpackLogoSmall} is worthy, 🙏 consider donating.
${donationLink}
Every amount counts.`;

export function addTimeStampToLog(log: string): string {
	const time = new Date().toTimeString().split(' ')[0];
	return `${chalk.dim(`｢${wpackLogoSmall} ${time}｣`)} ${log}`;
}

export const watchSymbol = `${logSymbols.info}`;
export const watchEllipsis = chalk.dim(figures.ellipsis);

export function printWatchingMessage() {
	console.log(
		addTimeStampToLog(`${watchSymbol} watching for changes${watchEllipsis}`)
	);
}

export function printCompilingMessage() {
	console.log(
		addTimeStampToLog(
			`${logSymbols.info} compiling changes${watchEllipsis}`
		)
	);
}

export function printCompileTimeMessage(stat: any, lastStat: any | null) {

npmInstall (addon, argv) {
    const deferred = Promise.defer()

    console.info('running npm install for ' + argv.addon + ' ' + figures.ellipsis)
    exec('npm install ' + addon + '@latest --registry=' + argv.registry, function (err, stdout, stderr) {
      var errMessage = null
      if (err) errMessage = err.message
      if (stderr) errMessage = stderr
      if (errMessage) {
        var msg = figures.cross + ' failed to install ' + argv.addon
        return deferred.reject(Error(msg))
      }

      return deferred.resolve(require(addon))
    })

    return deferred.promise
  },
  exists (addon, argv) {

renderDepsTree(depsTree: DepsTree, output: string[] = []) {
    let indent = Array(depsTree.depth * this.props.indent)
      .fill(' ')
      .join('')
    let frames = Spinners.dots.frames as string[]
    let symbol = {
      [TaskState.waiting]: chalk.gray(logFigures.ellipsis),
      [TaskState.pending]: chalk.blueBright(logFigures.arrowRight),
      [TaskState.loading]: chalk.cyan(frames[this.count(depsTree.uid) % frames.length]),
      [TaskState.succeeded]: chalk.green(logFigures.tick),
      [TaskState.failed]: chalk.red(logFigures.cross),
      [TaskState.skipped]: chalk.yellow(logFigures.info),
      ...this.props.symbolMap,
    }[depsTree.state]
    let color =
      (this.props.grayState || [TaskState.waiting]).indexOf(depsTree.state) >= 0
        ? f => chalk.gray(f)
        : f => f
    let skipped = depsTree.state === TaskState.skipped
    output.push(
      `${indent}${symbol} ${color(depsTree.task.name)}${skipped ? chalk.gray(` [skipped]`) : ''}${depsTree.priority ? chalk.gray(` [priority: ${depsTree.priority}]`) : ''}`,
    )
    let childDeps = ([] as DepsTree[])

logLevel: 'info'
  },
  debug: {
    badge: figures('⬤'),
    color: 'red',
    label: 'debug',
    logLevel: 'debug'
  },
  await: {
    badge: figures.ellipsis,
    color: 'blue',
    label: 'awaiting',
    logLevel: 'info'
  },
  watch: {
    badge: figures.ellipsis,
    color: 'yellow',
    label: 'watching',
    logLevel: 'info'
  },
  log: {
    badge: '',
    color: '',
    label: '',
    logLevel: 'info'
  }
};

transform(code, id) {
      const file = normalizePath(id)
      if (file.includes(":")) {
        return
      }

      const short = file.slice(-limit)
      progress.text = `${prefix} ${short !== file ? figures.ellipsis : ""}${short} [${loaded}]`
      progress.render()
    },

logLevel: 'info'
  },
  star: {
    badge: figures.star,
    color: 'yellow',
    label: 'star',
    logLevel: 'info'
  },
  success: {
    badge: figures.tick,
    color: 'green',
    label: 'success',
    logLevel: 'info'
  },
  wait: {
    badge: figures.ellipsis,
    color: 'blue',
    label: 'waiting',
    logLevel: 'info'
  },
  warn: {
    badge: figures.warning,
    color: 'yellow',
    label: 'warning',
    logLevel: 'warn'
  },
  complete: {
    badge: figures.checkboxOn,
    color: 'cyan',
    label: 'complete',
    logLevel: 'info'
  },