expeditaea 1.0.0

package/packages/vue-app/template/components/nuxt.js

@@ -0,0 +1,109 @@
+import Vue from 'vue'
+import { compile } from '../utils'
+
+<% if (components.ErrorPage) { %>
+  <% if (('~@').includes(components.ErrorPage.charAt(0))) { %>
+import NuxtError from '<%= components.ErrorPage %>'
+  <% } else { %>
+import NuxtError from '<%= "../" + components.ErrorPage %>'
+  <% } %>
+<% } else { %>
+import NuxtError from './nuxt-error.vue'
+<% } /* components */ %>
+import NuxtChild from './nuxt-child'
+
+<%= isTest ? '// @vue/component' : '' %>
+export default {
+  name: 'Nuxt',
+  components: {
+    NuxtChild,
+    NuxtError
+  },
+  props: {
+    nuxtChildKey: {
+      type: String,
+      default: undefined
+    },
+    keepAlive: Boolean,
+    keepAliveProps: {
+      type: Object,
+      default: undefined
+    },
+    name: {
+      type: String,
+      default: 'default'
+    }
+  },
+  errorCaptured (error) {
+    // if we receive and error while showing the NuxtError component
+    // capture the error and force an immediate update so we re-render
+    // without the NuxtError component
+    if (this.displayingNuxtError) {
+      this.errorFromNuxtError = error
+      this.$forceUpdate()
+    }
+  },
+  computed: {
+    routerViewKey () {
+      // If nuxtChildKey prop is given or current route has children
+      if (typeof this.nuxtChildKey !== 'undefined' || this.$route.matched.length > 1) {
+        return this.nuxtChildKey || compile(this.$route.matched[0].path)(this.$route.params)
+      }
+
+      const [matchedRoute] = this.$route.matched
+
+      if (!matchedRoute) {
+        return this.$route.path
+      }
+
+      const Component = matchedRoute.components.default
+
+      if (Component && Component.options) {
+        const { options } = Component
+
+        if (options.key) {
+          return (typeof options.key === 'function' ? options.key(this.$route) : options.key)
+        }
+      }
+
+      const strict = /\/$/.test(matchedRoute.path)
+      return strict ? this.$route.path : this.$route.path.replace(/\/$/, '')
+    }
+  },
+  beforeCreate () {
+    Vue.util.defineReactive(this, 'nuxt', this.$root.$options.nuxt)
+  },
+  render (h) {
+    // if there is no error
+    if (!this.nuxt.err) {
+      // Directly return nuxt child
+      return h('NuxtChild', {
+        key: this.routerViewKey,
+        props: this.$props
+      })
+    }
+
+    // if an error occurred within NuxtError show a simple
+    // error message instead to prevent looping
+    if (this.errorFromNuxtError) {
+      this.$nextTick(() => (this.errorFromNuxtError = false))
+
+      return h('div', {}, [
+        h('h2', 'An error occurred while showing the error page'),
+        h('p', 'Unfortunately an error occurred and while showing the error page another error occurred'),
+        h('p', `Error details: ${this.errorFromNuxtError.toString()}`),
+        h('nuxt-link', { props: { to: '/' } }, 'Go back to home')
+      ])
+    }
+
+    // track if we are showing the NuxtError component
+    this.displayingNuxtError = true
+    this.$nextTick(() => (this.displayingNuxtError = false))
+
+    return h(NuxtError, {
+      props: {
+        error: this.nuxt.err
+      }
+    })
+  }
+}

package/packages/vue-app/template/empty.js

@@ -0,0 +1 @@
+// This file is intentionally left empty for noop aliases

package/packages/vue-app/template/index.js

@@ -0,0 +1,298 @@
+import Vue from 'vue'
+<% if (store) { %>import Vuex from 'vuex'<% } %>
+<% if (features.meta) { %>import Meta from 'vue-meta'<% } %>
+<% if (features.componentClientOnly) { %>import ClientOnly from 'vue-client-only'<% } %>
+<% if (features.deprecations) { %>import NoSsr from 'vue-no-ssr'<% } %>
+import { createRouter } from './router.js'
+import NuxtChild from './components/nuxt-child.js'
+import NuxtError from '<%= components.ErrorPage ? components.ErrorPage : "./components/nuxt-error.vue" %>'
+import Nuxt from './components/nuxt.js'
+import App from '<%= appPath %>'
+import { setContext, getLocation, getRouteData, normalizeError } from './utils'
+<% if (store) { %>import { createStore } from './store.js'<% } %>
+
+/* Plugins */
+<%= isTest ? '/* eslint-disable camelcase */' : '' %>
+<% plugins.forEach((plugin) => { %>import <%= plugin.name %> from '<%= plugin.name %>' // Source: <%= relativeToBuild(plugin.src) %> (mode: '<%= plugin.mode %>')
+<% }) %>
+<%= isTest ? '/* eslint-enable camelcase */' : '' %>
+
+<% if (features.componentClientOnly) { %>
+// Component: <ClientOnly>
+Vue.component(ClientOnly.name, ClientOnly)
+<% } %>
+<% if (features.deprecations) { %>
+// TODO: Remove in Nuxt 3: <NoSsr>
+Vue.component(NoSsr.name, {
+  ...NoSsr,
+  render (h, ctx) {
+    if (process.client && !NoSsr._warned) {
+      NoSsr._warned = true
+      <%= isTest ? '// eslint-disable-next-line no-console' : '' %>
+      console.warn('<no-ssr> has been deprecated and will be removed in Nuxt 3, please use <client-only> instead')
+    }
+    return NoSsr.render(h, ctx)
+  }
+})
+<% } %>
+// Component: <NuxtChild>
+Vue.component(NuxtChild.name, NuxtChild)
+<% if (features.componentAliases) { %>Vue.component('NChild', NuxtChild)<% } %>
+
+// Component NuxtLink is imported in server.js or client.js
+
+// Component: <Nuxt>
+Vue.component(Nuxt.name, Nuxt)
+
+Object.defineProperty(Vue.prototype, '<%= globals.nuxt %>', {
+  get() {
+    const globalNuxt = this.$root.$options.<%= globals.nuxt %>
+    if (process.client && !globalNuxt && typeof window !== 'undefined') {
+      return window.<%= globals.nuxt %>
+    }
+    return globalNuxt
+  },
+  configurable: true
+})
+
+<% if (features.meta) {
+// vue-meta configuration
+const vueMetaOptions = {
+  ...nuxtOptions.vueMeta,
+  keyName: 'head', // the component option name that vue-meta looks for meta info on.
+  attribute: 'data-n-head', // the attribute name vue-meta adds to the tags it observes
+  ssrAttribute: 'data-n-head-ssr', // the attribute name that lets vue-meta know that meta info has already been server-rendered
+  tagIDKeyName: 'hid' // the property name that vue-meta uses to determine whether to overwrite or append a tag
+}
+%>
+Vue.use(Meta, <%= JSON.stringify(vueMetaOptions) %>)<%= isTest ? '// eslint-disable-line' : '' %>
+<% } %>
+
+<% if (features.transitions) { %>
+const defaultTransition = <%=
+  serialize(pageTransition)
+  .replace('beforeEnter(', 'function(').replace('enter(', 'function(').replace('afterEnter(', 'function(')
+  .replace('enterCancelled(', 'function(').replace('beforeLeave(', 'function(').replace('leave(', 'function(')
+  .replace('afterLeave(', 'function(').replace('leaveCancelled(', 'function(').replace('beforeAppear(', 'function(')
+  .replace('appear(', 'function(').replace('afterAppear(', 'function(').replace('appearCancelled(', 'function(')
+%><%= isTest ? '// eslint-disable-line' : '' %>
+<% } %>
+
+<% if (store) { %>
+const originalRegisterModule = Vuex.Store.prototype.registerModule
+
+function registerModule (path, rawModule, options = {}) {
+  const preserveState = process.client && (
+    Array.isArray(path)
+      ? !!path.reduce((namespacedState, path) => namespacedState && namespacedState[path], this.state)
+      : path in this.state
+  )
+  return originalRegisterModule.call(this, path, rawModule, { preserveState, ...options })
+}
+<% } %>
+
+async function createApp(ssrContext, config = {}) {
+  const router = await createRouter(ssrContext, config)
+
+  <% if (store) { %>
+  const store = createStore(ssrContext)
+  // Add this.$router into store actions/mutations
+  store.$router = router
+    <% if (mode === 'universal') { %>
+  // Fix SSR caveat https://github.com/nuxt/nuxt.js/issues/3757#issuecomment-414689141
+  store.registerModule = registerModule
+    <% } %>
+  <% } %>
+
+  // Create Root instance
+
+  // here we inject the router and store to all child components,
+  // making them available everywhere as `this.$router` and `this.$store`.
+  const app = {
+    <% if (features.meta) { %>
+    <%= isTest ? '/* eslint-disable array-bracket-spacing, quotes, quote-props, semi, indent, comma-spacing, key-spacing, object-curly-spacing, space-before-function-paren, object-shorthand  */' : '' %>
+    head: <%= serializeFunction(head) %>,
+    <%= isTest ? '/* eslint-enable array-bracket-spacing, quotes, quote-props, semi, indent, comma-spacing, key-spacing, object-curly-spacing, space-before-function-paren, object-shorthand */' : '' %>
+    <% } %>
+    <% if (store) { %>store,<%  } %>
+    router,
+    nuxt: {
+      <% if (features.transitions) { %>
+      defaultTransition,
+      transitions: [defaultTransition],
+      setTransitions (transitions) {
+        if (!Array.isArray(transitions)) {
+          transitions = [transitions]
+        }
+        transitions = transitions.map((transition) => {
+          if (!transition) {
+            transition = defaultTransition
+          } else if (typeof transition === 'string') {
+            transition = Object.assign({}, defaultTransition, { name: transition })
+          } else {
+            transition = Object.assign({}, defaultTransition, transition)
+          }
+          return transition
+        })
+        this.$options.nuxt.transitions = transitions
+        return transitions
+      },
+      <% } %>
+      err: null,
+      dateErr: null,
+      error (err) {
+        err = err || null
+        app.context._errored = Boolean(err)
+        err = err ? normalizeError(err) : null
+        let nuxt = app.nuxt // to work with @vue/composition-api, see https://github.com/nuxt/nuxt.js/issues/6517#issuecomment-573280207
+        if (this) {
+          nuxt = this.nuxt || this.$options.nuxt
+        }
+        nuxt.dateErr = Date.now()
+        nuxt.err = err
+        // Used in src/server.js
+        if (ssrContext) {
+          ssrContext.nuxt.error = err
+        }
+        return err
+      }
+    },
+    ...App
+  }
+  <% if (store) { %>
+  // Make app available into store via this.app
+  store.app = app
+  <% } %>
+  const next = ssrContext ? ssrContext.next : location => app.router.push(location)
+  // Resolve route
+  let route
+  if (ssrContext) {
+    route = router.resolve(ssrContext.url).route
+  } else {
+    const path = getLocation(router.options.base, router.options.mode)
+    route = router.resolve(path).route
+  }
+
+  // Set context to app.context
+  await setContext(app, {
+    <% if (store) { %>store,<% } %>
+    route,
+    next,
+    error: app.nuxt.error.bind(app),
+    payload: ssrContext ? ssrContext.payload : undefined,
+    req: ssrContext ? ssrContext.req : undefined,
+    res: ssrContext ? ssrContext.res : undefined,
+    beforeRenderFns: ssrContext ? ssrContext.beforeRenderFns : undefined,
+    ssrContext
+  })
+
+  function inject(key, value) {
+    if (!key) {
+      throw new Error('inject(key, value) has no key provided')
+    }
+    if (value === undefined) {
+      throw new Error(`inject('${key}', value) has no value provided`)
+    }
+
+    key = '$' + key
+    // Add into app
+    app[key] = value
+    // Add into context
+    if (!app.context[key]) {
+      app.context[key] = value
+    }
+    <% if (store) { %>
+    // Add into store
+    store[key] = app[key]
+    <% } %>
+    // Check if plugin not already installed
+    const installKey = '__<%= globals.pluginPrefix %>_' + key + '_installed__'
+    if (Vue[installKey]) {
+      return
+    }
+    Vue[installKey] = true
+    // Call Vue.use() to install the plugin into vm
+    Vue.use(() => {
+      if (!Object.prototype.hasOwnProperty.call(Vue.prototype, key)) {
+        Object.defineProperty(Vue.prototype, key, {
+          get () {
+            return this.$root.$options[key]
+          }
+        })
+      }
+    })
+  }
+
+  // Inject runtime config as $config
+  inject('config', config)
+
+  <% if (store) { %>
+  if (process.client) {
+    // Replace store state before plugins execution
+    if (window.<%= globals.context %> && window.<%= globals.context %>.state) {
+      store.replaceState(window.<%= globals.context %>.state)
+    }
+  }
+  <% } %>
+
+  // Add enablePreview(previewData = {}) in context for plugins
+  if (process.static && process.client) {
+    app.context.enablePreview = function (previewData = {}) {
+      app.previewData = Object.assign({}, previewData)
+      inject('preview', previewData)
+    }
+  }
+  // Plugin execution
+  <%= isTest ? '/* eslint-disable camelcase */' : '' %>
+  <% plugins.forEach((plugin) => { %>
+  <% if (plugin.mode == 'client') { %>
+  if (process.client && typeof <%= plugin.name %> === 'function') {
+    await <%= plugin.name %>(app.context, inject)
+  }
+  <% } else if (plugin.mode == 'server') { %>
+  if (process.server && typeof <%= plugin.name %> === 'function') {
+    await <%= plugin.name %>(app.context, inject)
+  }
+  <% } else { %>
+  if (typeof <%= plugin.name %> === 'function') {
+    await <%= plugin.name %>(app.context, inject)
+  }
+  <% } %>
+  <% }) %>
+  <%= isTest ? '/* eslint-enable camelcase */' : '' %>
+  // Lock enablePreview in context
+  if (process.static && process.client) {
+    app.context.enablePreview = function () {
+      console.warn('You cannot call enablePreview() outside a plugin.')
+    }
+  }
+
+  // Wait for async component to be resolved first
+  await new Promise((resolve, reject) => {
+    router.replace(app.context.route.fullPath, resolve, (err) => {
+      // https://github.com/vuejs/vue-router/blob/v3.4.3/src/util/errors.js
+      if (!err._isRouter) return reject(err)
+      if (err.type !== 2 /* NavigationFailureType.redirected */) return resolve()
+
+      // navigated to a different route in router guard
+      const unregister = router.afterEach(async (to, from) => {
+        if (process.server && ssrContext && ssrContext.url) {
+          ssrContext.url = to.fullPath
+        }
+        app.context.route = await getRouteData(to)
+        app.context.params = to.params || {}
+        app.context.query = to.query || {}
+        unregister()
+        resolve()
+      })
+    })
+  })
+
+  return {
+    <% if(store) { %>store,<%  } %>
+    app,
+    router
+  }
+}
+
+export { createApp, NuxtError }

package/packages/vue-app/template/jsonp.js

@@ -0,0 +1,83 @@
+const chunks = {} // chunkId => exports
+const chunksInstalling = {} // chunkId => Promise
+const failedChunks = {}
+
+function importChunk(chunkId, src) {
+  // Already installed
+  if (chunks[chunkId]) {
+    return Promise.resolve(chunks[chunkId])
+  }
+
+  // Failed loading
+  if (failedChunks[chunkId]) {
+    return Promise.reject(failedChunks[chunkId])
+  }
+
+  // Installing
+  if (chunksInstalling[chunkId]) {
+    return chunksInstalling[chunkId]
+  }
+
+  // Set a promise in chunk cache
+  let resolve, reject
+  const promise = chunksInstalling[chunkId] = new Promise((_resolve, _reject) => {
+    resolve = _resolve
+    reject = _reject
+  })
+
+  // Clear chunk data from cache
+  delete chunks[chunkId]
+
+  // Start chunk loading
+  const script = document.createElement('script')
+  script.charset = 'utf-8'
+  script.timeout = 120
+  script.src = src
+  let timeout
+
+  // Create error before stack unwound to get useful stacktrace later
+  const error = new Error()
+
+  // Complete handlers
+  const onScriptComplete = script.onerror = script.onload = (event) => {
+    // Cleanups
+    clearTimeout(timeout)
+    delete chunksInstalling[chunkId]
+
+    // Avoid mem leaks in IE
+    script.onerror = script.onload = null
+
+    // Verify chunk is loaded
+    if (chunks[chunkId]) {
+      return resolve(chunks[chunkId])
+    }
+
+    // Something bad happened
+    const errorType = event && (event.type === 'load' ? 'missing' : event.type)
+    const realSrc = event && event.target && event.target.src
+    error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')'
+    error.name = 'ChunkLoadError'
+    error.type = errorType
+    error.request = realSrc
+    failedChunks[chunkId] = error
+    reject(error)
+  }
+
+  // Timeout
+  timeout = setTimeout(() => {
+    onScriptComplete({ type: 'timeout', target: script })
+  }, 120000)
+
+  // Append script
+  document.head.appendChild(script)
+
+  // Return promise
+  return promise
+}
+
+export function installJsonp() {
+  window.__NUXT_JSONP__ = function (chunkId, exports) { chunks[chunkId] = exports }
+  window.__NUXT_JSONP_CACHE__ = chunks
+  window.__NUXT_IMPORT__ = importChunk
+}
+

package/packages/vue-app/template/layouts/default.vue

@@ -0,0 +1,3 @@
+<template>
+  <Nuxt />
+</template>

package/packages/vue-app/template/middleware.js

@@ -0,0 +1,12 @@
+const middleware = {}
+<%= isTest ? '/* eslint-disable dot-notation */' : '' %>
+<% for (const m of middleware) {
+  // TODO: remove duplicate logic in v3 (see builder.resolveMiddleware)
+  const name = m.name || m.src.replace(new RegExp(`\\.(${extensions})$`), '')
+  const dst = m.dst || relativeToBuild(srcDir, dir.middleware, m.src)
+%>
+middleware['<%= name %>'] = require('<%= dst %>')
+middleware['<%= name %>'] = middleware['<%= name %>'].default || middleware['<%= name %>']
+<% } %>
+<%= isTest ? '/* eslint-enable dot-notation */' : '' %>
+export default middleware

package/packages/vue-app/template/mixins/fetch.client.js

@@ -0,0 +1,134 @@
+import Vue from 'vue'
+import { hasFetch, normalizeError, addLifecycleHook, createGetCounter } from '../utils'
+
+const isSsrHydration = (vm) => vm.$vnode && vm.$vnode.elm && vm.$vnode.elm.dataset && vm.$vnode.elm.dataset.fetchKey
+const nuxtState = window.<%= globals.context %>
+
+export default {
+  beforeCreate () {
+    if (!hasFetch(this)) {
+      return
+    }
+
+    this._fetchDelay = typeof this.$options.fetchDelay === 'number' ? this.$options.fetchDelay : 200
+
+    Vue.util.defineReactive(this, '$fetchState', {
+      pending: false,
+      error: null,
+      timestamp: Date.now()
+    })
+
+    this.$fetch = $fetch.bind(this)
+    addLifecycleHook(this, 'created', created)
+    addLifecycleHook(this, 'beforeMount', beforeMount)
+  }
+}
+
+function beforeMount() {
+  if (!this._hydrated) {
+    return this.$fetch()
+  }
+}
+
+function created() {
+  if (!isSsrHydration(this)) {
+    <% if (isFullStatic) { %>createdFullStatic.call(this)<% } %>
+    return
+  }
+
+  // Hydrate component
+  this._hydrated = true
+  this._fetchKey = this.$vnode.elm.dataset.fetchKey
+  const data = nuxtState.fetch[this._fetchKey]
+
+  // If fetch error
+  if (data && data._error) {
+    this.$fetchState.error = data._error
+    return
+  }
+
+  // Merge data
+  for (const key in data) {
+    Vue.set(this.$data, key, data[key])
+  }
+}
+
+<% if (isFullStatic) { %>
+function createdFullStatic() {
+  // Check if component has been fetched on server
+  let fetchedOnServer = this.$options.fetchOnServer !== false
+  if (typeof this.$options.fetchOnServer === 'function') {
+    fetchedOnServer = this.$options.fetchOnServer.call(this) !== false
+  }
+  if (!fetchedOnServer || this.<%= globals.nuxt %>.isPreview || !this.<%= globals.nuxt %>._pagePayload) {
+    return
+  }
+  this._hydrated = true
+
+  const defaultKey = this.$options._scopeId || this.$options.name || ''
+  const getCounter = createGetCounter(this.<%= globals.nuxt %>._fetchCounters, defaultKey)
+
+  if (typeof this.$options.fetchKey === 'function') {
+    this._fetchKey = this.$options.fetchKey.call(this, getCounter)
+  } else {
+    const key = 'string' === typeof this.$options.fetchKey ? this.$options.fetchKey : defaultKey
+    this._fetchKey = key ? key + ':' + getCounter(key) : String(getCounter(key))
+  }
+
+  const data = this.<%= globals.nuxt %>._pagePayload.fetch[this._fetchKey]
+
+  // If fetch error
+  if (data && data._error) {
+    this.$fetchState.error = data._error
+    return
+  }
+
+  // If there is a missing payload
+  if (!data) {
+    this.$fetch()
+    return
+  }
+
+  // Merge data
+  for (const key in data) {
+    Vue.set(this.$data, key, data[key])
+  }
+}
+<% } %>
+
+function $fetch() {
+  if (!this._fetchPromise) {
+    this._fetchPromise = $_fetch.call(this)
+      .then(() => { delete this._fetchPromise })
+  }
+  return this._fetchPromise
+}
+
+async function $_fetch() {
+  this.<%= globals.nuxt %>.nbFetching++
+  this.$fetchState.pending = true
+  this.$fetchState.error = null
+  this._hydrated = false
+  let error = null
+  const startTime = Date.now()
+
+  try {
+    await this.$options.fetch.call(this)
+  } catch (err) {
+    if (process.dev) {
+      console.error('Error in fetch():', err)
+    }
+    error = normalizeError(err)
+  }
+
+  const delayLeft = this._fetchDelay - (Date.now() - startTime)
+  if (delayLeft > 0) {
+    await new Promise(resolve => setTimeout(resolve, delayLeft))
+  }
+
+  this.$fetchState.error = error
+  this.$fetchState.pending = false
+  this.$fetchState.timestamp = Date.now()
+
+  this.$nextTick(() => this.<%= globals.nuxt %>.nbFetching--)
+}