How to use the vue/dist/vue.js function in vue

// Load preset, throw error if not found
    let preset = modals[presetId]
    if (!preset) { return reject(new Error(`Preset ${ presetId } not found`)) }

    // Extract controller and template - throw error if template is not found
    // (Controller is not required)
    let { controller, template } = preset
    controller = controller || {}
    if (!template) { return reject(new Error('Modal template was not set'))}

    toggleOverlay(true)

    let { el, inner } = renderModal(presetId, template)

    // Instanciate modal's VM
    let modal = new Vue({
      el      : inner,
      methods : controller.methods || {},
      data    : () => _.extend({}, SCOPE_DEFAULTS, controller.scope || {}, ctx),
      filters : filters
    })

    // Run `ready` function if set in modal's controller
    if (controller.ready) { controller.ready.call(modal) }

    // Define modal close method that resolve the returned promise
    modal.close = function (value) {
      close(modal)
      resolve(typeof value === 'undefined' ? this.value || null : value)
    }

    // Reference wrapping element inside VM Object to retrieve it when closing

/* eslint-disable */
import '../../assets/css/reset.css';
import '../../assets/css/public.less';
import '../../assets/css/style.less';
import '../../assets/css/icon.less';
import '../../assets/css/ant-markdown.css';
import Vue from 'vue/dist/vue.js'
//const Vue = require('vue');
let baseApp = new Vue({
    el: '#app',
    data() {
        return {
            nav: {
                isShow: false
            }
        }
    },
    methods: {
        clickSearch() {
            alert('搜索功能开发中');
        }
    }
});

it(' - should work', done => {
      const eventLogs = []
      const vm = new Vue({
        template: `<div>
                      
                      
                  </div>
                  `,
        components: {
          'VueCodemirror': codemirror
        },
        data: {
          code: '<p>test content</p>',
          cmOption: {
            mode: 'text/html'
          }

it("should render correct contents with local provided directive", () => {
    const vm = new Vue({
      template: `<input placeholder="Guardian" type="text">`,
      directives: { MyAutowidth: VueInputAutoWidth },
      data: { name: "Cayde-6" }
    }).$mount("#app");
    expect(vm.$el.placeholder).to.equal("Guardian");
    expect(vm.name).to.equal("Cayde-6");
  });
});

beforeEach(() => {
    $vm = new Vue({
      data: {
        values: [],
        group: false
      },
      template: `
        Button 1
        Button 2
        Button 3
      `
    }).$mount()
    document.body.appendChild($vm.$el)
  })

class='test-dom-container__toggle'
                >{this.buttonText}
                <div class="test-dom-container__content">
                  {
                    h({
                      render: template,
                      name: 'JsxTestContainer',
                      ...opts
                    })
                  }
                </div>
              
            )
          }
        }
  const vm = new Vue({
    el: context.DOMElement,
    data: {
      visible: false
    },
    computed: {
      containerClasses () {
        return {
          'test-dom-container': true,
          'test-dom-container--hidden': !this.visible
        }
      },
      buttonText () {
        return this.visible ? '-' : '+'
      }
    },
    methods: {

beforeEach(() => {
    $vm = new Vue({
      data: {
        calendar: {
          year: undefined,
          month: undefined
        },
        min: null,
        max: null,
        disabledDates: [],
        dates: [],
        unpick: false,
        pick: false
      },
      template: `

export function createKarmaTest (context, template, opts) {
  const el = document.createElement('div')
  document.getElementById('tests').appendChild(el)
  const render = typeof template === 'string'
               ? { template }
               : { render: template }
  return new Vue({
    el,
    name: 'Test',
    ...render,
    ...opts
  })
}

layer: 'landmask'
      },
      'countries': {
        data: this.layers['borders'].options.countries,
        layer: 'borders'
      }
    }

    registerRangeSlider(this, propertyMap)
    registerCheckboxOption(this, propertyMap)
    registerRenderModes(this, this.scene)
    registerProjections(this, this.scene)

    //this.enableStats()

    this.vue = new Vue({ el: '.map-controls' })

    this.updateQueued = false
    _.each(this.layers, (layer, name) => {
      _.defer(() => { this.layerUpdated(name) })
    })

    window.addEventListener('resize', () => { this.updated() })
    window.addEventListener('texture-loaded', () => { this.updated() })
  }

//Import axios for ajax
const axios = require('axios');
axios.defaults.xsrfHeaderName = "X-CSRFTOKEN"
axios.defaults.xsrfCookieName = "csrftoken"

//Global Vue Components
Vue.component('vSelect',vSelect);
Vue.component('Editor',Editor);

//Validation
import Vuelidate from 'vuelidate'
Vue.use(Vuelidate)

//Construction of the VUE App
window.vm = new Vue({
    el: "#app",
    components: {
        GetStakeholders,
        NewRequirements,
        Vuelidate,
    },
    data() {
        return {};
    },
    methods: {},
    mounted() {
        //Remove the loader
        var loader_elem = document.getElementById("loader");
        loader_elem.style.transform = "translateY(-100vh)";
    }
});