expeditaea 1.0.0

package/packages/vue-renderer/src/renderers/spa.js

@@ -0,0 +1,214 @@
+import { extname } from 'path'
+import { cloneDeep } from 'lodash'
+import VueMeta from 'vue-meta'
+import { createRenderer } from 'vue-server-renderer'
+import LRU from 'lru-cache'
+import devalue from '@nuxt/devalue'
+import { TARGETS, isModernRequest } from '@nuxt/utils'
+import BaseRenderer from './base'
+
+export default class SPARenderer extends BaseRenderer {
+  constructor (serverContext) {
+    super(serverContext)
+
+    this.cache = new LRU()
+
+    this.vueMetaConfig = {
+      ssrAppId: '1',
+      ...this.options.vueMeta,
+      keyName: 'head',
+      attribute: 'data-n-head',
+      ssrAttribute: 'data-n-head-ssr',
+      tagIDKeyName: 'hid'
+    }
+  }
+
+  createRenderer () {
+    return createRenderer()
+  }
+
+  async render (renderContext) {
+    const { url = '/', req = {} } = renderContext
+    const modernMode = this.options.modern
+    const modern = (modernMode && this.options.target === TARGETS.static) || isModernRequest(req, modernMode)
+    const cacheKey = `${modern ? 'modern:' : 'legacy:'}${url}`
+    let meta = this.cache.get(cacheKey)
+
+    if (meta) {
+      // Return a copy of the content, so that future
+      // modifications do not effect the data in cache
+      return cloneDeep(meta)
+    }
+
+    meta = {
+      HTML_ATTRS: '',
+      HEAD_ATTRS: '',
+      BODY_ATTRS: '',
+      HEAD: '',
+      BODY_SCRIPTS_PREPEND: '',
+      BODY_SCRIPTS: ''
+    }
+
+    if (this.options.features.meta) {
+      // Get vue-meta context
+      renderContext.head = typeof this.options.head === 'function'
+        ? this.options.head()
+        : cloneDeep(this.options.head)
+    }
+
+    // Allow overriding renderContext
+    await this.serverContext.nuxt.callHook('vue-renderer:spa:prepareContext', renderContext)
+
+    if (this.options.features.meta) {
+      const m = VueMeta.generate(renderContext.head || {}, this.vueMetaConfig)
+
+      // HTML_ATTRS
+      meta.HTML_ATTRS = m.htmlAttrs.text()
+
+      // HEAD_ATTRS
+      meta.HEAD_ATTRS = m.headAttrs.text()
+
+      // BODY_ATTRS
+      meta.BODY_ATTRS = m.bodyAttrs.text()
+
+      // HEAD tags
+      meta.HEAD =
+        m.title.text() +
+        m.meta.text() +
+        m.link.text() +
+        m.style.text() +
+        m.script.text() +
+        m.noscript.text()
+
+      // Add <base href=""> meta if router base specified
+      if (this.options._routerBaseSpecified) {
+        meta.HEAD += `<base href="${this.options.router.base}">`
+      }
+
+      // BODY_SCRIPTS (PREPEND)
+      meta.BODY_SCRIPTS_PREPEND =
+        m.meta.text({ pbody: true }) +
+        m.link.text({ pbody: true }) +
+        m.style.text({ pbody: true }) +
+        m.script.text({ pbody: true }) +
+        m.noscript.text({ pbody: true })
+
+      // BODY_SCRIPTS (APPEND)
+      meta.BODY_SCRIPTS =
+        m.meta.text({ body: true }) +
+        m.link.text({ body: true }) +
+        m.style.text({ body: true }) +
+        m.script.text({ body: true }) +
+        m.noscript.text({ body: true })
+    }
+
+    // Resources Hints
+    meta.resourceHints = ''
+
+    const { resources: { modernManifest, clientManifest } } = this.serverContext
+    const manifest = modern ? modernManifest : clientManifest
+
+    const { shouldPreload, shouldPrefetch } = this.options.render.bundleRenderer
+
+    if (this.options.render.resourceHints && manifest) {
+      const publicPath = manifest.publicPath || '/_nuxt/'
+
+      // Preload initial resources
+      if (Array.isArray(manifest.initial)) {
+        const { crossorigin } = this.options.render
+        const cors = `${crossorigin ? ` crossorigin="${crossorigin}"` : ''}`
+
+        meta.preloadFiles = manifest.initial
+          .map(SPARenderer.normalizeFile)
+          .filter(({ fileWithoutQuery, asType }) => shouldPreload(fileWithoutQuery, asType))
+          .map(file => ({ ...file, modern }))
+
+        meta.resourceHints += meta.preloadFiles
+          .map(({ file, extension, fileWithoutQuery, asType, modern }) => {
+            let extra = ''
+            if (asType === 'font') {
+              extra = ` type="font/${extension}"${cors ? '' : ' crossorigin'}`
+            }
+            const rel = modern && asType === 'script' ? 'modulepreload' : 'preload'
+            return `<link rel="${rel}"${cors} href="${publicPath}${file}"${
+              asType !== '' ? ` as="${asType}"` : ''}${extra}>`
+          })
+          .join('')
+      }
+
+      // Prefetch async resources
+      if (Array.isArray(manifest.async)) {
+        meta.resourceHints += manifest.async
+          .map(SPARenderer.normalizeFile)
+          .filter(({ fileWithoutQuery, asType }) => shouldPrefetch(fileWithoutQuery, asType))
+          .map(({ file }) => `<link rel="prefetch" href="${publicPath}${file}">`)
+          .join('')
+      }
+
+      // Add them to HEAD
+      if (meta.resourceHints) {
+        meta.HEAD += meta.resourceHints
+      }
+    }
+
+    // Serialize state (runtime config)
+    let APP = `${meta.BODY_SCRIPTS_PREPEND}<div id="${this.serverContext.globals.id}">${this.serverContext.resources.loadingHTML}</div>${meta.BODY_SCRIPTS}`
+
+    const payload = {
+      config: renderContext.runtimeConfig.public
+    }
+    if (renderContext.staticAssetsBase) {
+      payload.staticAssetsBase = renderContext.staticAssetsBase
+    }
+    APP += `<script>window.${this.serverContext.globals.context}=${devalue(payload)}</script>`
+
+    // Prepare template params
+    const templateParams = {
+      ...meta,
+      APP,
+      ENV: this.options.env
+    }
+
+    // Call spa:templateParams hook
+    await this.serverContext.nuxt.callHook('vue-renderer:spa:templateParams', templateParams)
+
+    // Render with SPA template
+    const html = this.renderTemplate(this.serverContext.resources.spaTemplate, templateParams)
+    const content = {
+      html,
+      preloadFiles: meta.preloadFiles || []
+    }
+
+    // Set meta tags inside cache
+    this.cache.set(cacheKey, content)
+
+    // Return a copy of the content, so that future
+    // modifications do not effect the data in cache
+    return cloneDeep(content)
+  }
+
+  static normalizeFile (file) {
+    const withoutQuery = file.replace(/\?.*/, '')
+    const extension = extname(withoutQuery).slice(1)
+    return {
+      file,
+      extension,
+      fileWithoutQuery: withoutQuery,
+      asType: SPARenderer.getPreloadType(extension)
+    }
+  }
+
+  static getPreloadType (ext) {
+    if (ext === 'js') {
+      return 'script'
+    } else if (ext === 'css') {
+      return 'style'
+    } else if (/jpe?g|png|svg|gif|webp|ico|avif/.test(ext)) {
+      return 'image'
+    } else if (/woff2?|ttf|otf|eot/.test(ext)) {
+      return 'font'
+    } else {
+      return ''
+    }
+  }
+}

package/packages/vue-renderer/src/renderers/ssr.js

@@ -0,0 +1,307 @@
+import path from 'path'
+import crypto from 'crypto'
+import { format } from 'util'
+import fs from 'fs-extra'
+import consola from 'consola'
+import { TARGETS, urlJoin } from '@nuxt/utils'
+import { parsePath, withoutTrailingSlash } from 'ufo'
+import devalue from '@nuxt/devalue'
+import { createBundleRenderer } from 'vue-server-renderer'
+import BaseRenderer from './base'
+
+export default class SSRRenderer extends BaseRenderer {
+  get rendererOptions () {
+    const hasModules = fs.existsSync(path.resolve(this.options.rootDir, 'node_modules'))
+
+    return {
+      clientManifest: this.serverContext.resources.clientManifest,
+      // for globally installed nuxt command, search dependencies in global dir
+      basedir: hasModules ? this.options.rootDir : __dirname,
+      ...this.options.render.bundleRenderer
+    }
+  }
+
+  addAttrs (tags, referenceTag, referenceAttr) {
+    const reference = referenceTag ? `<${referenceTag}` : referenceAttr
+    if (!reference) {
+      return tags
+    }
+
+    const { render: { crossorigin } } = this.options
+    if (crossorigin) {
+      tags = tags.replace(
+        new RegExp(reference, 'g'),
+        `${reference} crossorigin="${crossorigin}"`
+      )
+    }
+
+    return tags
+  }
+
+  renderResourceHints (renderContext) {
+    return this.addAttrs(renderContext.renderResourceHints(), null, 'rel="preload"')
+  }
+
+  renderScripts (renderContext) {
+    let renderedScripts = this.addAttrs(renderContext.renderScripts(), 'script')
+    if (this.options.render.asyncScripts) {
+      renderedScripts = renderedScripts.replace(/defer>/g, 'defer async>')
+    }
+    return renderedScripts
+  }
+
+  renderStyles (renderContext) {
+    return this.addAttrs(renderContext.renderStyles(), 'link')
+  }
+
+  getPreloadFiles (renderContext) {
+    return renderContext.getPreloadFiles()
+  }
+
+  createRenderer () {
+    // Create bundle renderer for SSR
+    return createBundleRenderer(
+      this.serverContext.resources.serverManifest,
+      this.rendererOptions
+    )
+  }
+
+  useSSRLog () {
+    if (!this.options.render.ssrLog) {
+      return
+    }
+    const logs = []
+    const devReporter = {
+      log (logObj) {
+        logs.push({
+          ...logObj,
+          args: logObj.args.map(arg => format(arg))
+        })
+      }
+    }
+    consola.addReporter(devReporter)
+
+    return () => {
+      consola.removeReporter(devReporter)
+      return logs
+    }
+  }
+
+  async render (renderContext) {
+    // Call ssr:context hook to extend context from modules
+    await this.serverContext.nuxt.callHook('vue-renderer:ssr:prepareContext', renderContext)
+
+    const getSSRLog = this.useSSRLog()
+
+    // Call Vue renderer renderToString
+    let APP = await this.vueRenderer.renderToString(renderContext)
+
+    if (typeof getSSRLog === 'function') {
+      renderContext.nuxt.logs = getSSRLog()
+    }
+
+    // Call ssr:context hook
+    await this.serverContext.nuxt.callHook('vue-renderer:ssr:context', renderContext)
+
+    // TODO: Remove in next major release (#4722)
+    await this.serverContext.nuxt.callHook('_render:context', renderContext.nuxt)
+
+    // Fallback to empty response
+    if (!renderContext.nuxt.serverRendered) {
+      APP = `<div id="${this.serverContext.globals.id}"></div>`
+    }
+
+    // Perf: early returns if server target and redirected
+    if (renderContext.redirected && renderContext.target === TARGETS.server) {
+      return {
+        html: APP,
+        error: renderContext.nuxt.error,
+        redirected: renderContext.redirected
+      }
+    }
+
+    let HEAD = ''
+
+    // Inject head meta
+    // (this is unset when features.meta is false in server template)
+    const meta = renderContext.meta && renderContext.meta.inject({
+      isSSR: renderContext.nuxt.serverRendered,
+      ln: this.options.dev
+    })
+
+    if (meta) {
+      HEAD += meta.title.text() + meta.meta.text()
+    }
+
+    // Add <base href=""> meta if router base specified
+    if (this.options._routerBaseSpecified) {
+      HEAD += `<base href="${this.options.router.base}">`
+    }
+
+    if (meta) {
+      HEAD += meta.link.text() +
+        meta.style.text() +
+        meta.script.text() +
+        meta.noscript.text()
+    }
+
+    // Check if we need to inject scripts and state
+    const shouldInjectScripts = this.options.render.injectScripts !== false
+
+    // Inject resource hints
+    if (this.options.render.resourceHints && shouldInjectScripts) {
+      HEAD += this.renderResourceHints(renderContext)
+    }
+
+    // Inject styles
+    HEAD += this.renderStyles(renderContext)
+
+    if (meta) {
+      const prependInjectorOptions = { pbody: true }
+
+      const BODY_PREPEND =
+        meta.meta.text(prependInjectorOptions) +
+        meta.link.text(prependInjectorOptions) +
+        meta.style.text(prependInjectorOptions) +
+        meta.script.text(prependInjectorOptions) +
+        meta.noscript.text(prependInjectorOptions)
+
+      if (BODY_PREPEND) {
+        APP = `${BODY_PREPEND}${APP}`
+      }
+    }
+
+    const { csp } = this.options.render
+    // Only add the hash if 'unsafe-inline' rule isn't present to avoid conflicts (#5387)
+    const containsUnsafeInlineScriptSrc = csp.policies && csp.policies['script-src'] && csp.policies['script-src'].includes('\'unsafe-inline\'')
+    const shouldHashCspScriptSrc = csp && (csp.unsafeInlineCompatibility || !containsUnsafeInlineScriptSrc)
+    const inlineScripts = []
+
+    if (shouldInjectScripts && renderContext.staticAssetsBase) {
+      const preloadScripts = []
+      renderContext.staticAssets = []
+      const { staticAssetsBase, url, nuxt, staticAssets } = renderContext
+      const { data, fetch, mutations, ...state } = nuxt
+
+      // Initial state
+      const stateScript = `window.${this.serverContext.globals.context}=${devalue({
+        staticAssetsBase,
+        ...state
+      })};`
+
+      // Make chunk for initial state > 10 KB
+      const stateScriptKb = (stateScript.length * 4 /* utf8 */) / 100
+      if (stateScriptKb > 10) {
+        const statePath = urlJoin(url, 'state.js')
+        const stateUrl = urlJoin(staticAssetsBase, statePath)
+        staticAssets.push({ path: statePath, src: stateScript })
+        if (this.options.render.asyncScripts) {
+          APP += `<script defer async src="${stateUrl}"></script>`
+        } else {
+          APP += `<script defer src="${stateUrl}"></script>`
+        }
+        preloadScripts.push(stateUrl)
+      } else {
+        APP += `<script>${stateScript}</script>`
+      }
+
+      // Save payload only if no error or redirection were made
+      if (!renderContext.nuxt.error && !renderContext.redirected) {
+        // Page level payload.js (async loaded for CSR)
+        const payloadPath = urlJoin(url, 'payload.js')
+        const payloadUrl = urlJoin(staticAssetsBase, payloadPath)
+        const routePath = withoutTrailingSlash(parsePath(url).pathname)
+        const payloadScript = `__NUXT_JSONP__("${routePath}", ${devalue({ data, fetch, mutations })});`
+        staticAssets.push({ path: payloadPath, src: payloadScript })
+        preloadScripts.push(payloadUrl)
+        // Add manifest preload
+        if (this.options.generate.manifest) {
+          const manifestUrl = urlJoin(staticAssetsBase, 'manifest.js')
+          preloadScripts.push(manifestUrl)
+        }
+      }
+
+      // Preload links
+      for (const href of preloadScripts) {
+        HEAD += `<link rel="preload" href="${href}" as="script">`
+      }
+    } else {
+      // Serialize state
+      let serializedSession
+      if (shouldInjectScripts || shouldHashCspScriptSrc) {
+        // Only serialized session if need inject scripts or csp hash
+        serializedSession = `window.${this.serverContext.globals.context}=${devalue(renderContext.nuxt)};`
+        inlineScripts.push(serializedSession)
+      }
+
+      if (shouldInjectScripts) {
+        APP += `<script>${serializedSession}</script>`
+      }
+    }
+
+    // Calculate CSP hashes
+    const cspScriptSrcHashes = []
+    if (csp) {
+      if (shouldHashCspScriptSrc) {
+        for (const script of inlineScripts) {
+          const hash = crypto.createHash(csp.hashAlgorithm)
+          hash.update(script)
+          cspScriptSrcHashes.push(`'${csp.hashAlgorithm}-${hash.digest('base64')}'`)
+        }
+      }
+
+      // Call ssr:csp hook
+      await this.serverContext.nuxt.callHook('vue-renderer:ssr:csp', cspScriptSrcHashes)
+
+      // Add csp meta tags
+      if (csp.addMeta) {
+        HEAD += `<meta http-equiv="Content-Security-Policy" content="script-src ${cspScriptSrcHashes.join()}">`
+      }
+    }
+
+    // Prepend scripts
+    if (shouldInjectScripts) {
+      APP += this.renderScripts(renderContext)
+    }
+
+    if (meta) {
+      const appendInjectorOptions = { body: true }
+
+      // Append body scripts
+      APP += meta.meta.text(appendInjectorOptions)
+      APP += meta.link.text(appendInjectorOptions)
+      APP += meta.style.text(appendInjectorOptions)
+      APP += meta.script.text(appendInjectorOptions)
+      APP += meta.noscript.text(appendInjectorOptions)
+    }
+
+    // Template params
+    const templateParams = {
+      HTML_ATTRS: meta ? meta.htmlAttrs.text(renderContext.nuxt.serverRendered /* addSrrAttribute */) : '',
+      HEAD_ATTRS: meta ? meta.headAttrs.text() : '',
+      BODY_ATTRS: meta ? meta.bodyAttrs.text() : '',
+      HEAD,
+      APP,
+      ENV: this.options.env
+    }
+
+    // Call ssr:templateParams hook
+    await this.serverContext.nuxt.callHook('vue-renderer:ssr:templateParams', templateParams, renderContext)
+
+    // Render with SSR template
+    const html = this.renderTemplate(this.serverContext.resources.ssrTemplate, templateParams)
+
+    let preloadFiles
+    if (this.options.render.http2.push) {
+      preloadFiles = this.getPreloadFiles(renderContext)
+    }
+
+    return {
+      html,
+      cspScriptSrcHashes,
+      preloadFiles,
+      error: renderContext.nuxt.error,
+      redirected: renderContext.redirected
+    }
+  }
+}

package/packages/webpack/package.js

@@ -0,0 +1,21 @@
+export default {
+  build: true,
+  ignoreUnused: [
+    '@nuxt/babel-preset-app',
+    '@babel/core', // peerDependency of babel-loader
+    'babel-loader',
+    'cache-loader',
+    'caniuse-lite',
+    'css-loader',
+    'cssnano',
+    'eventsource-polyfill',
+    'file-loader',
+    'postcss-loader',
+    'postcss-preset-env',
+    'postcss-url',
+    'style-resources-loader',
+    'vue-style-loader', // vue-loader
+    'vue-template-compiler', // vue-loader
+    'url-loader'
+  ]
+}

package/packages/webpack/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@nuxt/webpack",
+  "version": "2.15.6",
+  "repository": "nuxt/nuxt.js",
+  "license": "MIT",
+  "main": "dist/webpack.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@babel/core": "^7.14.0",
+    "@nuxt/babel-preset-app": "2.15.6",
+    "@nuxt/friendly-errors-webpack-plugin": "^2.5.1",
+    "@nuxt/utils": "2.15.6",
+    "babel-loader": "^8.2.2",
+    "cache-loader": "^4.1.0",
+    "caniuse-lite": "^1.0.30001228",
+    "consola": "^2.15.3",
+    "css-loader": "^4.3.0",
+    "cssnano": "^4.1.11",
+    "eventsource-polyfill": "^0.9.6",
+    "extract-css-chunks-webpack-plugin": "^4.9.0",
+    "file-loader": "^6.2.0",
+    "glob": "^7.1.7",
+    "hard-source-webpack-plugin": "^0.13.1",
+    "hash-sum": "^2.0.0",
+    "html-webpack-plugin": "^4.5.1",
+    "lodash": "^4.17.21",
+    "memory-fs": "^0.5.0",
+    "optimize-css-assets-webpack-plugin": "^5.0.4",
+    "pify": "^5.0.0",
+    "pnp-webpack-plugin": "^1.6.4",
+    "postcss": "^7.0.32",
+    "postcss-import": "^12.0.1",
+    "postcss-import-resolver": "^2.0.0",
+    "postcss-loader": "^3.0.0",
+    "postcss-preset-env": "^6.7.0",
+    "postcss-url": "^8.0.0",
+    "semver": "^7.3.5",
+    "std-env": "^2.3.0",
+    "style-resources-loader": "^1.4.1",
+    "terser-webpack-plugin": "^4.2.3",
+    "thread-loader": "^3.0.4",
+    "time-fix-plugin": "^2.0.7",
+    "ufo": "^0.7.4",
+    "url-loader": "^4.1.1",
+    "vue-loader": "^15.9.7",
+    "vue-style-loader": "^4.1.3",
+    "vue-template-compiler": "^2.6.12",
+    "webpack": "^4.46.0",
+    "webpack-bundle-analyzer": "^4.4.1",
+    "webpack-dev-middleware": "^4.2.0",
+    "webpack-hot-middleware": "^2.25.0",
+    "webpack-node-externals": "^3.0.0",
+    "webpackbar": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}