text: import path from 'path'
  import { remove } from 'fs-extra'
  import consola from 'consola'
  import { getNuxtConfig, Nuxt, Builder } from '../../../../test/utils'
  
  const rootDir = path.resolve(__dirname, '..')
  
  export async function compileTemplate (template, destination, options = {}) {
    if (arguments.length < 3) {
      options = destination || {}
      destination = undefined
    }
  
    const config = getNuxtConfig(options)
  
    config.rootDir = rootDir
    config.dev = false
    config.test = false
    config.server = false
  
    const nuxt = new Nuxt(config)
    const builder = new Builder(nuxt)
  
    const templateContext = builder.createTemplateContext()
  
    const multipleTemplates = Array.isArray(template)
    if (!multipleTemplates) {
      template = [template]
    }
  
    templateContext.templateFiles = template.map((template) => {
      if (typeof template === 'string') {
        return {
          src: path.resolve(rootDir, '../template', template),
          dst: path.join(rootDir, '.nuxt', path.basename(template)),
          custom: false
        }
      }
  
      return {
        src: path.resolve(rootDir, '../template', template.src),
        dst: path.join(rootDir, '.nuxt', template.dst),
        custom: template.custom
      }
    })
  
    try {
      // clear all destinations
      await Promise.all(templateContext.templateFiles.map(({ dst }) => remove(dst)))
  
      await builder.compileTemplates(templateContext)
  
      if (multipleTemplates) {
        return templateContext.templateFiles.map(template => template.dst)
      }
  
      const [template] = templateContext.templateFiles
      return template.dst
    } catch (err) {
      consola.error(`Could not compile template`, err.message, template)
      return false
    }
  }
  
  export function importComponent (componentPath) {
    return import(componentPath).then(m => m.default || m)
  }
  
  export const vmTick = (vm) => {
    return new Promise((resolve) => {
      vm.$nextTick(resolve)
    })
  }
  