vue 2.6.13 → 2.7.0-alpha.2

package/src/server/render-context.js

@@ -1,130 +0,0 @@
-/* @flow */
-
-import { isUndef } from 'shared/util'
-
-type RenderState = {
-  type: 'Element';
-  rendered: number;
-  total: number;
-  children: Array<VNode>;
-  endTag: string;
-} | {
-  type: 'Fragment';
-  rendered: number;
-  total: number;
-  children: Array<VNode>;
-} | {
-  type: 'Component';
-  prevActive: Component;
-} | {
-  type: 'ComponentWithCache';
-  buffer: Array<string>;
-  bufferIndex: number;
-  componentBuffer: Array<Set<Class<Component>>>;
-  key: string;
-};
-
-export class RenderContext {
-  userContext: ?Object;
-  activeInstance: Component;
-  renderStates: Array<RenderState>;
-  write: (text: string, next: Function) => void;
-  renderNode: (node: VNode, isRoot: boolean, context: RenderContext) => void;
-  next: () => void;
-  done: (err: ?Error) => void;
-
-  modules: Array<(node: VNode) => ?string>;
-  directives: Object;
-  isUnaryTag: (tag: string) => boolean;
-
-  cache: any;
-  get: ?(key: string, cb: Function) => void;
-  has: ?(key: string, cb: Function) => void;
-
-  constructor (options: Object) {
-    this.userContext = options.userContext
-    this.activeInstance = options.activeInstance
-    this.renderStates = []
-
-    this.write = options.write
-    this.done = options.done
-    this.renderNode = options.renderNode
-
-    this.isUnaryTag = options.isUnaryTag
-    this.modules = options.modules
-    this.directives = options.directives
-
-    const cache = options.cache
-    if (cache && (!cache.get || !cache.set)) {
-      throw new Error('renderer cache must implement at least get & set.')
-    }
-    this.cache = cache
-    this.get = cache && normalizeAsync(cache, 'get')
-    this.has = cache && normalizeAsync(cache, 'has')
-
-    this.next = this.next.bind(this)
-  }
-
-  next () {
-    // eslint-disable-next-line
-    while (true) {
-      const lastState = this.renderStates[this.renderStates.length - 1]
-      if (isUndef(lastState)) {
-        return this.done()
-      }
-      /* eslint-disable no-case-declarations */
-      switch (lastState.type) {
-        case 'Element':
-        case 'Fragment':
-          const { children, total } = lastState
-          const rendered = lastState.rendered++
-          if (rendered < total) {
-            return this.renderNode(children[rendered], false, this)
-          } else {
-            this.renderStates.pop()
-            if (lastState.type === 'Element') {
-              return this.write(lastState.endTag, this.next)
-            }
-          }
-          break
-        case 'Component':
-          this.renderStates.pop()
-          this.activeInstance = lastState.prevActive
-          break
-        case 'ComponentWithCache':
-          this.renderStates.pop()
-          const { buffer, bufferIndex, componentBuffer, key } = lastState
-          const result = {
-            html: buffer[bufferIndex],
-            components: componentBuffer[bufferIndex]
-          }
-          this.cache.set(key, result)
-          if (bufferIndex === 0) {
-            // this is a top-level cached component,
-            // exit caching mode.
-            this.write.caching = false
-          } else {
-            // parent component is also being cached,
-            // merge self into parent's result
-            buffer[bufferIndex - 1] += result.html
-            const prev = componentBuffer[bufferIndex - 1]
-            result.components.forEach(c => prev.add(c))
-          }
-          buffer.length = bufferIndex
-          componentBuffer.length = bufferIndex
-          break
-      }
-    }
-  }
-}
-
-function normalizeAsync (cache, method) {
-  const fn = cache[method]
-  if (isUndef(fn)) {
-    return
-  } else if (fn.length > 1) {
-    return (key, cb) => fn.call(cache, key, cb)
-  } else {
-    return (key, cb) => cb(fn.call(cache, key))
-  }
-}

package/src/server/render-stream.js

@@ -1,95 +0,0 @@
-/* @flow */
-
-/**
- * Original RenderStream implementation by Sasha Aickin (@aickin)
- * Licensed under the Apache License, Version 2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Modified by Evan You (@yyx990803)
- */
-
-const stream = require('stream')
-
-import { isTrue, isUndef } from 'shared/util'
-import { createWriteFunction } from './write'
-
-export default class RenderStream extends stream.Readable {
-  buffer: string;
-  render: (write: Function, done: Function) => void;
-  expectedSize: number;
-  write: Function;
-  next: Function;
-  end: Function;
-  done: boolean;
-
-  constructor (render: Function) {
-    super()
-    this.buffer = ''
-    this.render = render
-    this.expectedSize = 0
-
-    this.write = createWriteFunction((text, next) => {
-      const n = this.expectedSize
-      this.buffer += text
-      if (this.buffer.length >= n) {
-        this.next = next
-        this.pushBySize(n)
-        return true // we will decide when to call next
-      }
-      return false
-    }, err => {
-      this.emit('error', err)
-    })
-
-    this.end = () => {
-      this.emit('beforeEnd')
-      // the rendering is finished; we should push out the last of the buffer.
-      this.done = true
-      this.push(this.buffer)
-    }
-  }
-
-  pushBySize (n: number) {
-    const bufferToPush = this.buffer.substring(0, n)
-    this.buffer = this.buffer.substring(n)
-    this.push(bufferToPush)
-  }
-
-  tryRender () {
-    try {
-      this.render(this.write, this.end)
-    } catch (e) {
-      this.emit('error', e)
-    }
-  }
-
-  tryNext () {
-    try {
-      this.next()
-    } catch (e) {
-      this.emit('error', e)
-    }
-  }
-
-  _read (n: number) {
-    this.expectedSize = n
-    // it's possible that the last chunk added bumped the buffer up to > 2 * n,
-    // which means we will need to go through multiple read calls to drain it
-    // down to < n.
-    if (isTrue(this.done)) {
-      this.push(null)
-      return
-    }
-    if (this.buffer.length >= n) {
-      this.pushBySize(n)
-      return
-    }
-    if (isUndef(this.next)) {
-      // start the rendering chain.
-      this.tryRender()
-    } else {
-      // continue with the rendering.
-      this.tryNext()
-    }
-  }
-}

package/src/server/render.js

@@ -1,437 +0,0 @@
-/* @flow */
-
-import { escape } from 'web/server/util'
-import { SSR_ATTR } from 'shared/constants'
-import { RenderContext } from './render-context'
-import { resolveAsset } from 'core/util/options'
-import { generateComponentTrace } from 'core/util/debug'
-import { ssrCompileToFunctions } from 'web/server/compiler'
-import { installSSRHelpers } from './optimizing-compiler/runtime-helpers'
-
-import { isDef, isUndef, isTrue } from 'shared/util'
-
-import {
-  createComponent,
-  createComponentInstanceForVnode
-} from 'core/vdom/create-component'
-
-let warned = Object.create(null)
-const warnOnce = msg => {
-  if (!warned[msg]) {
-    warned[msg] = true
-    // eslint-disable-next-line no-console
-    console.warn(`\n\u001b[31m${msg}\u001b[39m\n`)
-  }
-}
-
-const onCompilationError = (err, vm) => {
-  const trace = vm ? generateComponentTrace(vm) : ''
-  throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`)
-}
-
-const normalizeRender = vm => {
-  const { render, template, _scopeId } = vm.$options
-  if (isUndef(render)) {
-    if (template) {
-      const compiled = ssrCompileToFunctions(template, {
-        scopeId: _scopeId,
-        warn: onCompilationError
-      }, vm)
-
-      vm.$options.render = compiled.render
-      vm.$options.staticRenderFns = compiled.staticRenderFns
-    } else {
-      throw new Error(
-        `render function or template not defined in component: ${
-          vm.$options.name || vm.$options._componentTag || 'anonymous'
-        }`
-      )
-    }
-  }
-}
-
-function waitForServerPrefetch (vm, resolve, reject) {
-  let handlers = vm.$options.serverPrefetch
-  if (isDef(handlers)) {
-    if (!Array.isArray(handlers)) handlers = [handlers]
-    try {
-      const promises = []
-      for (let i = 0, j = handlers.length; i < j; i++) {
-        const result = handlers[i].call(vm, vm)
-        if (result && typeof result.then === 'function') {
-          promises.push(result)
-        }
-      }
-      Promise.all(promises).then(resolve).catch(reject)
-      return
-    } catch (e) {
-      reject(e)
-    }
-  }
-  resolve()
-}
-
-function renderNode (node, isRoot, context) {
-  if (node.isString) {
-    renderStringNode(node, context)
-  } else if (isDef(node.componentOptions)) {
-    renderComponent(node, isRoot, context)
-  } else if (isDef(node.tag)) {
-    renderElement(node, isRoot, context)
-  } else if (isTrue(node.isComment)) {
-    if (isDef(node.asyncFactory)) {
-      // async component
-      renderAsyncComponent(node, isRoot, context)
-    } else {
-      context.write(`<!--${node.text}-->`, context.next)
-    }
-  } else {
-    context.write(
-      node.raw ? node.text : escape(String(node.text)),
-      context.next
-    )
-  }
-}
-
-function registerComponentForCache (options, write) {
-  // exposed by vue-loader, need to call this if cache hit because
-  // component lifecycle hooks will not be called.
-  const register = options._ssrRegister
-  if (write.caching && isDef(register)) {
-    write.componentBuffer[write.componentBuffer.length - 1].add(register)
-  }
-  return register
-}
-
-function renderComponent (node, isRoot, context) {
-  const { write, next, userContext } = context
-
-  // check cache hit
-  const Ctor = node.componentOptions.Ctor
-  const getKey = Ctor.options.serverCacheKey
-  const name = Ctor.options.name
-  const cache = context.cache
-  const registerComponent = registerComponentForCache(Ctor.options, write)
-
-  if (isDef(getKey) && isDef(cache) && isDef(name)) {
-    const rawKey = getKey(node.componentOptions.propsData)
-    if (rawKey === false) {
-      renderComponentInner(node, isRoot, context)
-      return
-    }
-    const key = name + '::' + rawKey
-    const { has, get } = context
-    if (isDef(has)) {
-      has(key, hit => {
-        if (hit === true && isDef(get)) {
-          get(key, res => {
-            if (isDef(registerComponent)) {
-              registerComponent(userContext)
-            }
-            res.components.forEach(register => register(userContext))
-            write(res.html, next)
-          })
-        } else {
-          renderComponentWithCache(node, isRoot, key, context)
-        }
-      })
-    } else if (isDef(get)) {
-      get(key, res => {
-        if (isDef(res)) {
-          if (isDef(registerComponent)) {
-            registerComponent(userContext)
-          }
-          res.components.forEach(register => register(userContext))
-          write(res.html, next)
-        } else {
-          renderComponentWithCache(node, isRoot, key, context)
-        }
-      })
-    }
-  } else {
-    if (isDef(getKey) && isUndef(cache)) {
-      warnOnce(
-        `[vue-server-renderer] Component ${
-          Ctor.options.name || '(anonymous)'
-        } implemented serverCacheKey, ` +
-        'but no cache was provided to the renderer.'
-      )
-    }
-    if (isDef(getKey) && isUndef(name)) {
-      warnOnce(
-        `[vue-server-renderer] Components that implement "serverCacheKey" ` +
-        `must also define a unique "name" option.`
-      )
-    }
-    renderComponentInner(node, isRoot, context)
-  }
-}
-
-function renderComponentWithCache (node, isRoot, key, context) {
-  const write = context.write
-  write.caching = true
-  const buffer = write.cacheBuffer
-  const bufferIndex = buffer.push('') - 1
-  const componentBuffer = write.componentBuffer
-  componentBuffer.push(new Set())
-  context.renderStates.push({
-    type: 'ComponentWithCache',
-    key,
-    buffer,
-    bufferIndex,
-    componentBuffer
-  })
-  renderComponentInner(node, isRoot, context)
-}
-
-function renderComponentInner (node, isRoot, context) {
-  const prevActive = context.activeInstance
-  // expose userContext on vnode
-  node.ssrContext = context.userContext
-  const child = context.activeInstance = createComponentInstanceForVnode(
-    node,
-    context.activeInstance
-  )
-  normalizeRender(child)
-
-  const resolve = () => {
-    const childNode = child._render()
-    childNode.parent = node
-    context.renderStates.push({
-      type: 'Component',
-      prevActive
-    })
-    renderNode(childNode, isRoot, context)
-  }
-
-  const reject = context.done
-
-  waitForServerPrefetch(child, resolve, reject)
-}
-
-function renderAsyncComponent (node, isRoot, context) {
-  const factory = node.asyncFactory
-
-  const resolve = comp => {
-    if (comp.__esModule && comp.default) {
-      comp = comp.default
-    }
-    const { data, children, tag } = node.asyncMeta
-    const nodeContext = node.asyncMeta.context
-    const resolvedNode: any = createComponent(
-      comp,
-      data,
-      nodeContext,
-      children,
-      tag
-    )
-    if (resolvedNode) {
-      if (resolvedNode.componentOptions) {
-        // normal component
-        renderComponent(resolvedNode, isRoot, context)
-      } else if (!Array.isArray(resolvedNode)) {
-        // single return node from functional component
-        renderNode(resolvedNode, isRoot, context)
-      } else {
-        // multiple return nodes from functional component
-        context.renderStates.push({
-          type: 'Fragment',
-          children: resolvedNode,
-          rendered: 0,
-          total: resolvedNode.length
-        })
-        context.next()
-      }
-    } else {
-      // invalid component, but this does not throw on the client
-      // so render empty comment node
-      context.write(`<!---->`, context.next)
-    }
-  }
-
-  if (factory.resolved) {
-    resolve(factory.resolved)
-    return
-  }
-
-  const reject = context.done
-  let res
-  try {
-    res = factory(resolve, reject)
-  } catch (e) {
-    reject(e)
-  }
-  if (res) {
-    if (typeof res.then === 'function') {
-      res.then(resolve, reject).catch(reject)
-    } else {
-      // new syntax in 2.3
-      const comp = res.component
-      if (comp && typeof comp.then === 'function') {
-        comp.then(resolve, reject).catch(reject)
-      }
-    }
-  }
-}
-
-function renderStringNode (el, context) {
-  const { write, next } = context
-  if (isUndef(el.children) || el.children.length === 0) {
-    write(el.open + (el.close || ''), next)
-  } else {
-    const children: Array<VNode> = el.children
-    context.renderStates.push({
-      type: 'Element',
-      children,
-      rendered: 0,
-      total: children.length,
-      endTag: el.close
-    })
-    write(el.open, next)
-  }
-}
-
-function renderElement (el, isRoot, context) {
-  const { write, next } = context
-
-  if (isTrue(isRoot)) {
-    if (!el.data) el.data = {}
-    if (!el.data.attrs) el.data.attrs = {}
-    el.data.attrs[SSR_ATTR] = 'true'
-  }
-
-  if (el.fnOptions) {
-    registerComponentForCache(el.fnOptions, write)
-  }
-
-  const startTag = renderStartingTag(el, context)
-  const endTag = `</${el.tag}>`
-  if (context.isUnaryTag(el.tag)) {
-    write(startTag, next)
-  } else if (isUndef(el.children) || el.children.length === 0) {
-    write(startTag + endTag, next)
-  } else {
-    const children: Array<VNode> = el.children
-    context.renderStates.push({
-      type: 'Element',
-      children,
-      rendered: 0,
-      total: children.length,
-      endTag
-    })
-    write(startTag, next)
-  }
-}
-
-function hasAncestorData (node: VNode) {
-  const parentNode = node.parent
-  return isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
-}
-
-function getVShowDirectiveInfo (node: VNode): ?VNodeDirective {
-  let dir: VNodeDirective
-  let tmp
-
-  while (isDef(node)) {
-    if (node.data && node.data.directives) {
-      tmp = node.data.directives.find(dir => dir.name === 'show')
-      if (tmp) {
-        dir = tmp
-      }
-    }
-    node = node.parent
-  }
-  return dir
-}
-
-function renderStartingTag (node: VNode, context) {
-  let markup = `<${node.tag}`
-  const { directives, modules } = context
-
-  // construct synthetic data for module processing
-  // because modules like style also produce code by parent VNode data
-  if (isUndef(node.data) && hasAncestorData(node)) {
-    node.data = {}
-  }
-  if (isDef(node.data)) {
-    // check directives
-    const dirs = node.data.directives
-    if (dirs) {
-      for (let i = 0; i < dirs.length; i++) {
-        const name = dirs[i].name
-        if (name !== 'show') {
-          const dirRenderer = resolveAsset(context, 'directives', name)
-          if (dirRenderer) {
-            // directives mutate the node's data
-            // which then gets rendered by modules
-            dirRenderer(node, dirs[i])
-          }
-        }
-      }
-    }
-
-    // v-show directive needs to be merged from parent to child
-    const vshowDirectiveInfo = getVShowDirectiveInfo(node)
-    if (vshowDirectiveInfo) {
-      directives.show(node, vshowDirectiveInfo)
-    }
-
-    // apply other modules
-    for (let i = 0; i < modules.length; i++) {
-      const res = modules[i](node)
-      if (res) {
-        markup += res
-      }
-    }
-  }
-  // attach scoped CSS ID
-  let scopeId
-  const activeInstance = context.activeInstance
-  if (isDef(activeInstance) &&
-    activeInstance !== node.context &&
-    isDef(scopeId = activeInstance.$options._scopeId)
-  ) {
-    markup += ` ${(scopeId: any)}`
-  }
-  if (isDef(node.fnScopeId)) {
-    markup += ` ${node.fnScopeId}`
-  } else {
-    while (isDef(node)) {
-      if (isDef(scopeId = node.context.$options._scopeId)) {
-        markup += ` ${scopeId}`
-      }
-      node = node.parent
-    }
-  }
-  return markup + '>'
-}
-
-export function createRenderFunction (
-  modules: Array<(node: VNode) => ?string>,
-  directives: Object,
-  isUnaryTag: Function,
-  cache: any
-) {
-  return function render (
-    component: Component,
-    write: (text: string, next: Function) => void,
-    userContext: ?Object,
-    done: Function
-  ) {
-    warned = Object.create(null)
-    const context = new RenderContext({
-      activeInstance: component,
-      userContext,
-      write, done, renderNode,
-      isUnaryTag, modules, directives,
-      cache
-    })
-    installSSRHelpers(component)
-    normalizeRender(component)
-
-    const resolve = () => {
-      renderNode(component._render(), true, context)
-    }
-    waitForServerPrefetch(component, resolve, done)
-  }
-}

package/src/server/template-renderer/create-async-file-mapper.js

@@ -1,57 +0,0 @@
-/* @flow */
-
-/**
- * Creates a mapper that maps components used during a server-side render
- * to async chunk files in the client-side build, so that we can inline them
- * directly in the rendered HTML to avoid waterfall requests.
- */
-
-import type { ClientManifest } from './index'
-
-export type AsyncFileMapper = (files: Array<string>) => Array<string>;
-
-export function createMapper (
-  clientManifest: ClientManifest
-): AsyncFileMapper {
-  const map = createMap(clientManifest)
-  // map server-side moduleIds to client-side files
-  return function mapper (moduleIds: Array<string>): Array<string> {
-    const res = new Set()
-    for (let i = 0; i < moduleIds.length; i++) {
-      const mapped = map.get(moduleIds[i])
-      if (mapped) {
-        for (let j = 0; j < mapped.length; j++) {
-          res.add(mapped[j])
-        }
-      }
-    }
-    return Array.from(res)
-  }
-}
-
-function createMap (clientManifest) {
-  const map = new Map()
-  Object.keys(clientManifest.modules).forEach(id => {
-    map.set(id, mapIdToFile(id, clientManifest))
-  })
-  return map
-}
-
-function mapIdToFile (id, clientManifest) {
-  const files = []
-  const fileIndices = clientManifest.modules[id]
-  if (fileIndices) {
-    fileIndices.forEach(index => {
-      const file = clientManifest.all[index]
-      // only include async files or non-js, non-css assets
-      if (
-        file &&
-        (clientManifest.async.indexOf(file) > -1 ||
-          !/\.(js|css)($|\?)/.test(file))
-      ) {
-        files.push(file)
-      }
-    })
-  }
-  return files
-}