How to use the signale.await function in signale

return () => {
            // Allow only building for specific browser targets.
            // Useful in local dev for faster builds.
            if (process.env.TARGETS && !process.env.TARGETS.includes(browser)) {
                return
            }

            signale.await(`Building the ${title} ${env} bundle`)

            copyExtensionAssets(buildDir)

            const zipDest = path.resolve(process.cwd(), `${BUILDS_DIR}/bundles/${BROWSER_BUNDLE_ZIPS[browser]}`)
            if (zipDest) {
                shelljs.mkdir('-p', `./${BUILDS_DIR}/bundles`)
                shelljs.exec(`cd ${buildDir} && zip -q -r ${zipDest} *`)
            }

            signale.success(`Done building the ${title} ${env} bundle`)
        }
    }

import signale from 'signale'
import webpack from 'webpack'
import config from '../config/webpack/prod.config'
import * as tasks from './tasks'

const buildChrome = tasks.buildChrome('prod')
const buildFirefox = tasks.buildFirefox('prod')

tasks.copyAssets()

const compiler = webpack(config)

signale.await('Webpack compilation')

compiler.run((err, stats) => {
    console.log(stats.toString(tasks.WEBPACK_STATS_OPTIONS))

    if (stats.hasErrors()) {
        signale.error('Webpack compilation error')
        process.exit(1)
    }
    signale.success('Webpack compilation done')

    buildChrome()
    buildFirefox()
    tasks.copyIntegrationAssets()
    signale.success('Build done')
})

export function logAwait(message: string) {
  signale.await(message);
}

async function createMultiProcessPrism(options: CreateBaseServerOptions) {
  if (cluster.isMaster) {
    cluster.setupMaster({ silent: true });

    signale.await({ prefix: chalk.bgWhiteBright.black('[CLI]'), message: 'Starting Prism…' });

    const worker = cluster.fork();

    if (worker.process.stdout) {
      pipeOutputToSignale(worker.process.stdout);
    }

    return;
  } else {
    const logInstance = createLogger('CLI', cliSpecificLoggerOptions);
    try {
      return await createPrismServerWithLogger(options, logInstance);
    } catch (e) {
      logInstance.fatal(e.message);
      cluster.worker.kill();
    }

async reloadSiteList() {
        signale.await("Reloading sites list")
        this.siteList = await this.cmdp("siteList", [])
        this.siteAddrs = this.siteList.map(s => s.address)
        signale.success(`SiteList: ${this.siteList.length}`)
    }

compiler.hooks.watchRun.tap('Notify', () => signale.await('Compiling...'))

export function copyAssets(): void {
    signale.await('Copy assets')
    const dir = 'build/dist'
    shelljs.rm('-rf', dir)
    shelljs.mkdir('-p', dir)
    shelljs.cp('-R', 'src/extension/assets/*', dir)
    shelljs.cp('-R', 'src/extension/views/*', dir)
    signale.success('Assets copied')
}

async updateAll() {
        signale.await("Updating all sites")
        await this.reloadSiteList()
        for (let site of this.siteList) {
            await this.cmdp("siteUpdate", site.address).then(() => signale.complete(`Site updated ${site.address}`))
            signale.start("Update site: " + site.address)
        }
    }

async function createSingleProcessPrism(options: CreateBaseServerOptions) {
  signale.await({ prefix: chalk.bgWhiteBright.black('[CLI]'), message: 'Starting Prism…' });

  const logStream = new PassThrough();
  const logInstance = createLogger('CLI', cliSpecificLoggerOptions, logStream);
  pipeOutputToSignale(logStream);

  try {
    return await createPrismServerWithLogger(options, logInstance);
  } catch (e) {
    logInstance.fatal(e.message);
  }
}