vue 2.6.13 → 2.7.0-alpha.2

package/src/platforms/weex/util/index.js

@@ -1,40 +0,0 @@
-/* @flow */
-declare var document: WeexDocument;
-
-import { warn } from 'core/util/index'
-
-export const RECYCLE_LIST_MARKER = '@inRecycleList'
-
-// Register the component hook to weex native render engine.
-// The hook will be triggered by native, not javascript.
-export function registerComponentHook (
-  componentId: string,
-  type: string, // hook type, could be "lifecycle" or "instance"
-  hook: string, // hook name
-  fn: Function
-) {
-  if (!document || !document.taskCenter) {
-    warn(`Can't find available "document" or "taskCenter".`)
-    return
-  }
-  if (typeof document.taskCenter.registerHook === 'function') {
-    return document.taskCenter.registerHook(componentId, type, hook, fn)
-  }
-  warn(`Failed to register component hook "${type}@${hook}#${componentId}".`)
-}
-
-// Updates the state of the component to weex native render engine.
-export function updateComponentData (
-  componentId: string,
-  newData: Object | void,
-  callback?: Function
-) {
-  if (!document || !document.taskCenter) {
-    warn(`Can't find available "document" or "taskCenter".`)
-    return
-  }
-  if (typeof document.taskCenter.updateData === 'function') {
-    return document.taskCenter.updateData(componentId, newData, callback)
-  }
-  warn(`Failed to update component data (${componentId}).`)
-}

package/src/platforms/weex/util/parser.js

@@ -1,60 +0,0 @@
-/* @flow */
-
-// import { warn } from 'core/util/index'
-
-// this will be preserved during build
-// $flow-disable-line
-const acorn = require('acorn') // $flow-disable-line
-const walk = require('acorn/dist/walk') // $flow-disable-line
-const escodegen = require('escodegen')
-
-export function nodeToBinding (node: Object): any {
-  switch (node.type) {
-    case 'Literal': return node.value
-    case 'Identifier':
-    case 'UnaryExpression':
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-    case 'ConditionalExpression':
-    case 'MemberExpression': return { '@binding': escodegen.generate(node) }
-    case 'ArrayExpression': return node.elements.map(_ => nodeToBinding(_))
-    case 'ObjectExpression': {
-      const object = {}
-      node.properties.forEach(prop => {
-        if (!prop.key || prop.key.type !== 'Identifier') {
-          return
-        }
-        const key = escodegen.generate(prop.key)
-        const value = nodeToBinding(prop.value)
-        if (key && value) {
-          object[key] = value
-        }
-      })
-      return object
-    }
-    default: {
-      // warn(`Not support ${node.type}: "${escodegen.generate(node)}"`)
-      return ''
-    }
-  }
-}
-
-export function generateBinding (exp: ?string): any {
-  if (exp && typeof exp === 'string') {
-    let ast = null
-    try {
-      ast = acorn.parse(`(${exp})`)
-    } catch (e) {
-      // warn(`Failed to parse the expression: "${exp}"`)
-      return ''
-    }
-
-    let output = ''
-    walk.simple(ast, {
-      Expression (node) {
-        output = nodeToBinding(node)
-      }
-    })
-    return output
-  }
-}

package/src/server/bundle-renderer/create-bundle-renderer.js

@@ -1,151 +0,0 @@
-/* @flow */
-
-import { createPromiseCallback } from '../util'
-import { createBundleRunner } from './create-bundle-runner'
-import type { Renderer, RenderOptions } from '../create-renderer'
-import { createSourceMapConsumers, rewriteErrorTrace } from './source-map-support'
-
-const fs = require('fs')
-const path = require('path')
-const PassThrough = require('stream').PassThrough
-
-const INVALID_MSG =
-  'Invalid server-rendering bundle format. Should be a string ' +
-  'or a bundle Object of type:\n\n' +
-`{
-  entry: string;
-  files: { [filename: string]: string; };
-  maps: { [filename: string]: string; };
-}\n`
-
-// The render bundle can either be a string (single bundled file)
-// or a bundle manifest object generated by vue-ssr-webpack-plugin.
-type RenderBundle = {
-  basedir?: string;
-  entry: string;
-  files: { [filename: string]: string; };
-  maps: { [filename: string]: string; };
-  modules?: { [filename: string]: Array<string> };
-};
-
-export function createBundleRendererCreator (
-  createRenderer: (options?: RenderOptions) => Renderer
-) {
-  return function createBundleRenderer (
-    bundle: string | RenderBundle,
-    rendererOptions?: RenderOptions = {}
-  ) {
-    let files, entry, maps
-    let basedir = rendererOptions.basedir
-
-    // load bundle if given filepath
-    if (
-      typeof bundle === 'string' &&
-      /\.js(on)?$/.test(bundle) &&
-      path.isAbsolute(bundle)
-    ) {
-      if (fs.existsSync(bundle)) {
-        const isJSON = /\.json$/.test(bundle)
-        basedir = basedir || path.dirname(bundle)
-        bundle = fs.readFileSync(bundle, 'utf-8')
-        if (isJSON) {
-          try {
-            bundle = JSON.parse(bundle)
-          } catch (e) {
-            throw new Error(`Invalid JSON bundle file: ${bundle}`)
-          }
-        }
-      } else {
-        throw new Error(`Cannot locate bundle file: ${bundle}`)
-      }
-    }
-
-    if (typeof bundle === 'object') {
-      entry = bundle.entry
-      files = bundle.files
-      basedir = basedir || bundle.basedir
-      maps = createSourceMapConsumers(bundle.maps)
-      if (typeof entry !== 'string' || typeof files !== 'object') {
-        throw new Error(INVALID_MSG)
-      }
-    } else if (typeof bundle === 'string') {
-      entry = '__vue_ssr_bundle__'
-      files = { '__vue_ssr_bundle__': bundle }
-      maps = {}
-    } else {
-      throw new Error(INVALID_MSG)
-    }
-
-    const renderer = createRenderer(rendererOptions)
-
-    const run = createBundleRunner(
-      entry,
-      files,
-      basedir,
-      rendererOptions.runInNewContext
-    )
-
-    return {
-      renderToString: (context?: Object, cb: any) => {
-        if (typeof context === 'function') {
-          cb = context
-          context = {}
-        }
-
-        let promise
-        if (!cb) {
-          ({ promise, cb } = createPromiseCallback())
-        }
-
-        run(context).catch(err => {
-          rewriteErrorTrace(err, maps)
-          cb(err)
-        }).then(app => {
-          if (app) {
-            renderer.renderToString(app, context, (err, res) => {
-              rewriteErrorTrace(err, maps)
-              cb(err, res)
-            })
-          }
-        })
-
-        return promise
-      },
-
-      renderToStream: (context?: Object) => {
-        const res = new PassThrough()
-        run(context).catch(err => {
-          rewriteErrorTrace(err, maps)
-          // avoid emitting synchronously before user can
-          // attach error listener
-          process.nextTick(() => {
-            res.emit('error', err)
-          })
-        }).then(app => {
-          if (app) {
-            const renderStream = renderer.renderToStream(app, context)
-
-            renderStream.on('error', err => {
-              rewriteErrorTrace(err, maps)
-              res.emit('error', err)
-            })
-
-            // relay HTMLStream special events
-            if (rendererOptions && rendererOptions.template) {
-              renderStream.on('beforeStart', () => {
-                res.emit('beforeStart')
-              })
-              renderStream.on('beforeEnd', () => {
-                res.emit('beforeEnd')
-              })
-            }
-
-            renderStream.pipe(res)
-          }
-        })
-
-        return res
-      }
-    }
-  }
-}

package/src/server/bundle-renderer/create-bundle-runner.js

@@ -1,150 +0,0 @@
-import { isPlainObject } from 'shared/util'
-
-const vm = require('vm')
-const path = require('path')
-const resolve = require('resolve')
-const NativeModule = require('module')
-
-function createSandbox (context) {
-  const sandbox = {
-    Buffer,
-    console,
-    process,
-    setTimeout,
-    setInterval,
-    setImmediate,
-    clearTimeout,
-    clearInterval,
-    clearImmediate,
-    __VUE_SSR_CONTEXT__: context
-  }
-  sandbox.global = sandbox
-  return sandbox
-}
-
-function compileModule (files, basedir, runInNewContext) {
-  const compiledScripts = {}
-  const resolvedModules = {}
-
-  function getCompiledScript (filename) {
-    if (compiledScripts[filename]) {
-      return compiledScripts[filename]
-    }
-    const code = files[filename]
-    const wrapper = NativeModule.wrap(code)
-    const script = new vm.Script(wrapper, {
-      filename,
-      displayErrors: true
-    })
-    compiledScripts[filename] = script
-    return script
-  }
-
-  function evaluateModule (filename, sandbox, evaluatedFiles = {}) {
-    if (evaluatedFiles[filename]) {
-      return evaluatedFiles[filename]
-    }
-
-    const script = getCompiledScript(filename)
-    const compiledWrapper = runInNewContext === false
-      ? script.runInThisContext()
-      : script.runInNewContext(sandbox)
-    const m = { exports: {}}
-    const r = file => {
-      file = path.posix.join('.', file)
-      if (files[file]) {
-        return evaluateModule(file, sandbox, evaluatedFiles)
-      } else if (basedir) {
-        return require(
-          resolvedModules[file] ||
-          (resolvedModules[file] = resolve.sync(file, { basedir }))
-        )
-      } else {
-        return require(file)
-      }
-    }
-    compiledWrapper.call(m.exports, m.exports, r, m)
-
-    const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
-      ? m.exports.default
-      : m.exports
-    evaluatedFiles[filename] = res
-    return res
-  }
-  return evaluateModule
-}
-
-function deepClone (val) {
-  if (isPlainObject(val)) {
-    const res = {}
-    for (const key in val) {
-      res[key] = deepClone(val[key])
-    }
-    return res
-  } else if (Array.isArray(val)) {
-    return val.slice()
-  } else {
-    return val
-  }
-}
-
-export function createBundleRunner (entry, files, basedir, runInNewContext) {
-  const evaluate = compileModule(files, basedir, runInNewContext)
-  if (runInNewContext !== false && runInNewContext !== 'once') {
-    // new context mode: creates a fresh context and re-evaluate the bundle
-    // on each render. Ensures entire application state is fresh for each
-    // render, but incurs extra evaluation cost.
-    return (userContext = {}) => new Promise(resolve => {
-      userContext._registeredComponents = new Set()
-      const res = evaluate(entry, createSandbox(userContext))
-      resolve(typeof res === 'function' ? res(userContext) : res)
-    })
-  } else {
-    // direct mode: instead of re-evaluating the whole bundle on
-    // each render, it simply calls the exported function. This avoids the
-    // module evaluation costs but requires the source code to be structured
-    // slightly differently.
-    let runner // lazy creation so that errors can be caught by user
-    let initialContext
-    return (userContext = {}) => new Promise(resolve => {
-      if (!runner) {
-        const sandbox = runInNewContext === 'once'
-          ? createSandbox()
-          : global
-        // the initial context is only used for collecting possible non-component
-        // styles injected by vue-style-loader.
-        initialContext = sandbox.__VUE_SSR_CONTEXT__ = {}
-        runner = evaluate(entry, sandbox)
-        // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-        // to prevent cross-request pollution.
-        delete sandbox.__VUE_SSR_CONTEXT__
-        if (typeof runner !== 'function') {
-          throw new Error(
-            'bundle export should be a function when using ' +
-            '{ runInNewContext: false }.'
-          )
-        }
-      }
-      userContext._registeredComponents = new Set()
-
-      // vue-style-loader styles imported outside of component lifecycle hooks
-      if (initialContext._styles) {
-        userContext._styles = deepClone(initialContext._styles)
-        // #6353 ensure "styles" is exposed even if no styles are injected
-        // in component lifecycles.
-        // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-        const renderStyles = initialContext._renderStyles
-        if (renderStyles) {
-          Object.defineProperty(userContext, 'styles', {
-            enumerable: true,
-            get () {
-              return renderStyles(userContext._styles)
-            }
-          })
-        }
-      }
-
-      resolve(runner(userContext))
-    })
-  }
-}

package/src/server/bundle-renderer/source-map-support.js

@@ -1,45 +0,0 @@
-/* @flow */
-
-const SourceMapConsumer = require('source-map').SourceMapConsumer
-
-const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/
-
-export function createSourceMapConsumers (rawMaps: Object) {
-  const maps = {}
-  Object.keys(rawMaps).forEach(file => {
-    maps[file] = new SourceMapConsumer(rawMaps[file])
-  })
-  return maps
-}
-
-export function rewriteErrorTrace (e: any, mapConsumers: {
-  [key: string]: SourceMapConsumer
-}) {
-  if (e && typeof e.stack === 'string') {
-    e.stack = e.stack.split('\n').map(line => {
-      return rewriteTraceLine(line, mapConsumers)
-    }).join('\n')
-  }
-}
-
-function rewriteTraceLine (trace: string, mapConsumers: {
-  [key: string]: SourceMapConsumer
-}) {
-  const m = trace.match(filenameRE)
-  const map = m && mapConsumers[m[1]]
-  if (m != null && map) {
-    const originalPosition = map.originalPositionFor({
-      line: Number(m[2]),
-      column: Number(m[3])
-    })
-    if (originalPosition.source != null) {
-      const { source, line, column } = originalPosition
-      const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`
-      return trace.replace(filenameRE, mappedPosition)
-    } else {
-      return trace
-    }
-  } else {
-    return trace
-  }
-}

package/src/server/create-basic-renderer.js

@@ -1,37 +0,0 @@
-/* @flow */
-
-import { createWriteFunction } from './write'
-import { createRenderFunction } from './render'
-import type { RenderOptions } from './create-renderer'
-
-export function createBasicRenderer ({
-  modules = [],
-  directives = {},
-  isUnaryTag = (() => false),
-  cache
-}: RenderOptions = {}) {
-  const render = createRenderFunction(modules, directives, isUnaryTag, cache)
-
-  return function renderToString (
-    component: Component,
-    context: any,
-    done: any
-  ): void {
-    if (typeof context === 'function') {
-      done = context
-      context = {}
-    }
-    let result = ''
-    const write = createWriteFunction(text => {
-      result += text
-      return false
-    }, done)
-    try {
-      render(component, write, context, () => {
-        done(null, result)
-      })
-    } catch (e) {
-      done(e)
-    }
-  }
-}

package/src/server/create-renderer.js

@@ -1,152 +0,0 @@
-/* @flow */
-
-import RenderStream from './render-stream'
-import { createWriteFunction } from './write'
-import { createRenderFunction } from './render'
-import { createPromiseCallback } from './util'
-import TemplateRenderer from './template-renderer/index'
-import type { ClientManifest } from './template-renderer/index'
-
-export type Renderer = {
-  renderToString: (component: Component, context: any, cb: any) => ?Promise<string>;
-  renderToStream: (component: Component, context?: Object) => stream$Readable;
-};
-
-type RenderCache = {
-  get: (key: string, cb?: Function) => string | void;
-  set: (key: string, val: string) => void;
-  has?: (key: string, cb?: Function) => boolean | void;
-};
-
-export type RenderOptions = {
-  modules?: Array<(vnode: VNode) => ?string>;
-  directives?: Object;
-  isUnaryTag?: Function;
-  cache?: RenderCache;
-  template?: string | (content: string, context: any) => string;
-  inject?: boolean;
-  basedir?: string;
-  shouldPreload?: Function;
-  shouldPrefetch?: Function;
-  clientManifest?: ClientManifest;
-  serializer?: Function;
-  runInNewContext?: boolean | 'once';
-};
-
-export function createRenderer ({
-  modules = [],
-  directives = {},
-  isUnaryTag = (() => false),
-  template,
-  inject,
-  cache,
-  shouldPreload,
-  shouldPrefetch,
-  clientManifest,
-  serializer
-}: RenderOptions = {}): Renderer {
-  const render = createRenderFunction(modules, directives, isUnaryTag, cache)
-  const templateRenderer = new TemplateRenderer({
-    template,
-    inject,
-    shouldPreload,
-    shouldPrefetch,
-    clientManifest,
-    serializer
-  })
-
-  return {
-    renderToString (
-      component: Component,
-      context: any,
-      cb: any
-    ): ?Promise<string> {
-      if (typeof context === 'function') {
-        cb = context
-        context = {}
-      }
-      if (context) {
-        templateRenderer.bindRenderFns(context)
-      }
-
-      // no callback, return Promise
-      let promise
-      if (!cb) {
-        ({ promise, cb } = createPromiseCallback())
-      }
-
-      let result = ''
-      const write = createWriteFunction(text => {
-        result += text
-        return false
-      }, cb)
-      try {
-        render(component, write, context, err => {
-          if (err) {
-            return cb(err)
-          }
-          if (context && context.rendered) {
-            context.rendered(context)
-          }
-          if (template) {
-            try {
-              const res = templateRenderer.render(result, context)
-              if (typeof res !== 'string') {
-                // function template returning promise
-                res
-                  .then(html => cb(null, html))
-                  .catch(cb)
-              } else {
-                cb(null, res)
-              }
-            } catch (e) {
-              cb(e)
-            }
-          } else {
-            cb(null, result)
-          }
-        })
-      } catch (e) {
-        cb(e)
-      }
-
-      return promise
-    },
-
-    renderToStream (
-      component: Component,
-      context?: Object
-    ): stream$Readable {
-      if (context) {
-        templateRenderer.bindRenderFns(context)
-      }
-      const renderStream = new RenderStream((write, done) => {
-        render(component, write, context, done)
-      })
-      if (!template) {
-        if (context && context.rendered) {
-          const rendered = context.rendered
-          renderStream.once('beforeEnd', () => {
-            rendered(context)
-          })
-        }
-        return renderStream
-      } else if (typeof template === 'function') {
-        throw new Error(`function template is only supported in renderToString.`)
-      } else {
-        const templateStream = templateRenderer.createStream(context)
-        renderStream.on('error', err => {
-          templateStream.emit('error', err)
-        })
-        renderStream.pipe(templateStream)
-        if (context && context.rendered) {
-          const rendered = context.rendered
-          renderStream.once('beforeEnd', () => {
-            rendered(context)
-          })
-        }
-        return templateStream
-      }
-    }
-  }
-}