vue 2.6.13 → 2.7.0-alpha.2

package/types/vue.d.ts

@@ -10,123 +10,327 @@ import {
   RecordPropsDefinition,
   ThisTypedComponentOptionsWithArrayProps,
   ThisTypedComponentOptionsWithRecordProps,
-  WatchOptions,
-} from "./options";
-import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from "./vnode";
-import { PluginFunction, PluginObject } from "./plugin";
+  WatchOptions
+} from './options'
+import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from './vnode'
+import { PluginFunction, PluginObject } from './plugin'
 
 export interface CreateElement {
-  (tag?: string | Component<any, any, any, any> | AsyncComponent<any, any, any, any> | (() => Component), children?: VNodeChildren): VNode;
-  (tag?: string | Component<any, any, any, any> | AsyncComponent<any, any, any, any> | (() => Component), data?: VNodeData, children?: VNodeChildren): VNode;
+  (
+    tag?:
+      | string
+      | Component<any, any, any, any>
+      | AsyncComponent<any, any, any, any>
+      | (() => Component),
+    children?: VNodeChildren
+  ): VNode
+  (
+    tag?:
+      | string
+      | Component<any, any, any, any>
+      | AsyncComponent<any, any, any, any>
+      | (() => Component),
+    data?: VNodeData,
+    children?: VNodeChildren
+  ): VNode
 }
 
 export interface Vue {
-  readonly $el: Element;
-  readonly $options: ComponentOptions<Vue>;
-  readonly $parent: Vue;
-  readonly $root: Vue;
-  readonly $children: Vue[];
-  readonly $refs: { [key: string]: Vue | Element | (Vue | Element)[] | undefined };
-  readonly $slots: { [key: string]: VNode[] | undefined };
-  readonly $scopedSlots: { [key: string]: NormalizedScopedSlot | undefined };
-  readonly $isServer: boolean;
-  readonly $data: Record<string, any>;
-  readonly $props: Record<string, any>;
-  readonly $ssrContext: any;
-  readonly $vnode: VNode;
-  readonly $attrs: Record<string, string>;
-  readonly $listeners: Record<string, Function | Function[]>;
-
-  $mount(elementOrSelector?: Element | string, hydrating?: boolean): this;
-  $forceUpdate(): void;
-  $destroy(): void;
-  $set: typeof Vue.set;
-  $delete: typeof Vue.delete;
+  readonly $el: Element
+  readonly $options: ComponentOptions<Vue>
+  readonly $parent: Vue
+  readonly $root: Vue
+  readonly $children: Vue[]
+  readonly $refs: {
+    [key: string]: Vue | Element | (Vue | Element)[] | undefined
+  }
+  readonly $slots: { [key: string]: VNode[] | undefined }
+  readonly $scopedSlots: { [key: string]: NormalizedScopedSlot | undefined }
+  readonly $isServer: boolean
+  readonly $data: Record<string, any>
+  readonly $props: Record<string, any>
+  readonly $ssrContext: any
+  readonly $vnode: VNode
+  readonly $attrs: Record<string, string>
+  readonly $listeners: Record<string, Function | Function[]>
+
+  $mount(elementOrSelector?: Element | string, hydrating?: boolean): this
+  $forceUpdate(): void
+  $destroy(): void
+  $set: typeof Vue.set
+  $delete: typeof Vue.delete
   $watch(
     expOrFn: string,
     callback: (this: this, n: any, o: any) => void,
     options?: WatchOptions
-  ): (() => void);
+  ): () => void
   $watch<T>(
     expOrFn: (this: this) => T,
     callback: (this: this, n: T, o: T) => void,
     options?: WatchOptions
-  ): (() => void);
-  $on(event: string | string[], callback: Function): this;
-  $once(event: string | string[], callback: Function): this;
-  $off(event?: string | string[], callback?: Function): this;
-  $emit(event: string, ...args: any[]): this;
-  $nextTick(callback: (this: this) => void): void;
-  $nextTick(): Promise<void>;
-  $createElement: CreateElement;
+  ): () => void
+  $on(event: string | string[], callback: Function): this
+  $once(event: string | string[], callback: Function): this
+  $off(event?: string | string[], callback?: Function): this
+  $emit(event: string, ...args: any[]): this
+  $nextTick(callback: (this: this) => void): void
+  $nextTick(): Promise<void>
+  $createElement: CreateElement
 }
 
-export type CombinedVueInstance<Instance extends Vue, Data, Methods, Computed, Props> =  Data & Methods & Computed & Props & Instance;
-export type ExtendedVue<Instance extends Vue, Data, Methods, Computed, Props> = VueConstructor<CombinedVueInstance<Instance, Data, Methods, Computed, Props> & Vue>;
+export type CombinedVueInstance<
+  Instance extends Vue,
+  Data,
+  Methods,
+  Computed,
+  Props,
+  SetupBindings
+> = Data & Methods & Computed & Props & Instance & SetupBindings
+
+export type ExtendedVue<
+  Instance extends Vue,
+  Data,
+  Methods,
+  Computed,
+  Props,
+  SetupBindings
+> = VueConstructor<
+  CombinedVueInstance<Instance, Data, Methods, Computed, Props, SetupBindings> &
+    Vue
+>
 
 export interface VueConfiguration {
-  silent: boolean;
-  optionMergeStrategies: any;
-  devtools: boolean;
-  productionTip: boolean;
-  performance: boolean;
-  errorHandler(err: Error, vm: Vue, info: string): void;
-  warnHandler(msg: string, vm: Vue, trace: string): void;
-  ignoredElements: (string | RegExp)[];
-  keyCodes: { [key: string]: number | number[] };
-  async: boolean;
+  silent: boolean
+  optionMergeStrategies: any
+  devtools: boolean
+  productionTip: boolean
+  performance: boolean
+  errorHandler(err: Error, vm: Vue, info: string): void
+  warnHandler(msg: string, vm: Vue, trace: string): void
+  ignoredElements: (string | RegExp)[]
+  keyCodes: { [key: string]: number | number[] }
+  async: boolean
 }
 
 export interface VueConstructor<V extends Vue = Vue> {
-  new <Data = object, Methods = object, Computed = object, PropNames extends string = never>(options?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): CombinedVueInstance<V, Data, Methods, Computed, Record<PropNames, any>>;
-  // ideally, the return type should just contain Props, not Record<keyof Props, any>. But TS requires to have Base constructors with the same return type.
-  new <Data = object, Methods = object, Computed = object, Props = object>(options?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): CombinedVueInstance<V, Data, Methods, Computed, Record<keyof Props, any>>;
-  new (options?: ComponentOptions<V>): CombinedVueInstance<V, object, object, object, Record<keyof object, any>>;
-
-  extend<Data, Methods, Computed, PropNames extends string = never>(options?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): ExtendedVue<V, Data, Methods, Computed, Record<PropNames, any>>;
-  extend<Data, Methods, Computed, Props>(options?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
-  extend<PropNames extends string = never>(definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>>;
-  extend<Props>(definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>): ExtendedVue<V, {}, {}, {}, Props>;
-  extend(options?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}>;
-
-  nextTick<T>(callback: (this: T) => void, context?: T): void;
+  /**
+   * new with array props
+   */
+  new <
+    Data = object,
+    Methods = object,
+    Computed = object,
+    PropNames extends string = never,
+    SetupBindings = {}
+  >(
+    options?: ThisTypedComponentOptionsWithArrayProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      PropNames,
+      SetupBindings
+    >
+  ): CombinedVueInstance<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Record<PropNames, any>,
+    SetupBindings
+  >
+
+  /**
+   * new with object props
+   * ideally, the return type should just contain Props,
+   * not Record<keyof Props, any>. But TS requires to have Base constructors
+   * with the same return type.
+   */
+  new <
+    Data = object,
+    Methods = object,
+    Computed = object,
+    Props = object,
+    SetupBindings = {}
+  >(
+    options?: ThisTypedComponentOptionsWithRecordProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Props,
+      SetupBindings
+    >
+  ): CombinedVueInstance<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Record<keyof Props, any>,
+    SetupBindings
+  >
+
+  /**
+   * new with no props
+   */
+  new (options?: ComponentOptions<V>): CombinedVueInstance<
+    V,
+    object,
+    object,
+    object,
+    Record<keyof object, any>,
+    {}
+  >
+
+  /**
+   * extend with array props
+   */
+  extend<
+    Data,
+    Methods,
+    Computed,
+    PropNames extends string = never,
+    SetupBindings = {}
+  >(
+    options?: ThisTypedComponentOptionsWithArrayProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      PropNames,
+      SetupBindings
+    >
+  ): ExtendedVue<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Record<PropNames, any>,
+    SetupBindings
+  >
+
+  /**
+   * extend with object props
+   */
+  extend<Data, Methods, Computed, Props, SetupBindings = {}>(
+    options?: ThisTypedComponentOptionsWithRecordProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Props,
+      SetupBindings
+    >
+  ): ExtendedVue<V, Data, Methods, Computed, Props, SetupBindings>
+
+  /**
+   * extend with functional + array props
+   */
+  extend<PropNames extends string = never>(
+    definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>
+  ): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>, {}>
+
+  /**
+   * extend with functional + object props
+   */
+  extend<Props>(
+    definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>
+  ): ExtendedVue<V, {}, {}, {}, Props, {}>
+
+  /**
+   * extend with no props
+   */
+  extend(options?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}, {}>
+
+  nextTick<T>(callback: (this: T) => void, context?: T): void
   nextTick(): Promise<void>
-  set<T>(object: object, key: string | number, value: T): T;
-  set<T>(array: T[], key: number, value: T): T;
-  delete(object: object, key: string | number): void;
-  delete<T>(array: T[], key: number): void;
+  set<T>(object: object, key: string | number, value: T): T
+  set<T>(array: T[], key: number, value: T): T
+  delete(object: object, key: string | number): void
+  delete<T>(array: T[], key: number): void
 
   directive(
     id: string,
     definition?: DirectiveOptions | DirectiveFunction
-  ): DirectiveOptions;
-  filter(id: string, definition?: Function): Function;
-
-  component(id: string): VueConstructor;
-  component<VC extends VueConstructor>(id: string, constructor: VC): VC;
-  component<Data, Methods, Computed, Props>(id: string, definition: AsyncComponent<Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
-  component<Data, Methods, Computed, PropNames extends string = never>(id: string, definition?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): ExtendedVue<V, Data, Methods, Computed, Record<PropNames, any>>;
-  component<Data, Methods, Computed, Props>(id: string, definition?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
-  component<PropNames extends string>(id: string, definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>>;
-  component<Props>(id: string, definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>): ExtendedVue<V, {}, {}, {}, Props>;
-  component(id: string, definition?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}>;
-
-  use<T>(plugin: PluginObject<T> | PluginFunction<T>, options?: T): VueConstructor<V>;
-  use(plugin: PluginObject<any> | PluginFunction<any>, ...options: any[]): VueConstructor<V>;
-  mixin(mixin: VueConstructor | ComponentOptions<Vue>): VueConstructor<V>;
+  ): DirectiveOptions
+  filter(id: string, definition?: Function): Function
+
+  component(id: string): VueConstructor
+  component<VC extends VueConstructor>(id: string, constructor: VC): VC
+  component<Data, Methods, Computed, Props, SetupBindings>(
+    id: string,
+    definition: AsyncComponent<Data, Methods, Computed, Props>
+  ): ExtendedVue<V, Data, Methods, Computed, Props, SetupBindings>
+  component<
+    Data,
+    Methods,
+    Computed,
+    PropNames extends string = never,
+    SetupBindings = {}
+  >(
+    id: string,
+    definition?: ThisTypedComponentOptionsWithArrayProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      PropNames,
+      SetupBindings
+    >
+  ): ExtendedVue<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Record<PropNames, any>,
+    SetupBindings
+  >
+  component<Data, Methods, Computed, Props, SetupBindings>(
+    id: string,
+    definition?: ThisTypedComponentOptionsWithRecordProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Props,
+      SetupBindings
+    >
+  ): ExtendedVue<V, Data, Methods, Computed, Props, SetupBindings>
+  component<PropNames extends string>(
+    id: string,
+    definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>
+  ): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>, {}>
+  component<Props>(
+    id: string,
+    definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>
+  ): ExtendedVue<V, {}, {}, {}, Props, {}>
+  component(
+    id: string,
+    definition?: ComponentOptions<V>
+  ): ExtendedVue<V, {}, {}, {}, {}, {}>
+
+  use<T>(
+    plugin: PluginObject<T> | PluginFunction<T>,
+    options?: T
+  ): VueConstructor<V>
+  use(
+    plugin: PluginObject<any> | PluginFunction<any>,
+    ...options: any[]
+  ): VueConstructor<V>
+  mixin(mixin: VueConstructor | ComponentOptions<Vue>): VueConstructor<V>
   compile(template: string): {
-    render(createElement: typeof Vue.prototype.$createElement): VNode;
-    staticRenderFns: (() => VNode)[];
-  };
+    render(createElement: typeof Vue.prototype.$createElement): VNode
+    staticRenderFns: (() => VNode)[]
+  }
 
-  observable<T>(obj: T): T;
+  observable<T>(obj: T): T
 
   util: {
-    warn(msg: string, vm?: InstanceType<VueConstructor>): void;
-  };
+    warn(msg: string, vm?: InstanceType<VueConstructor>): void
+  }
 
-  config: VueConfiguration;
-  version: string;
+  config: VueConfiguration
+  version: string
 }
 
-export const Vue: VueConstructor;
+export const Vue: VueConstructor

package/dist/README.md

@@ -1,122 +0,0 @@
-## Explanation of Build Files
-
-| | UMD | CommonJS | ES Module |
-| --- | --- | --- | --- |
-| **Full** | vue.js | vue.common.js | vue.esm.js |
-| **Runtime-only** | vue.runtime.js | vue.runtime.common.js | vue.runtime.esm.js |
-| **Full (production)** | vue.min.js | | |
-| **Runtime-only (production)** | vue.runtime.min.js | | |
-
-### Terms
-
-- **Full**: builds that contain both the compiler and the runtime.
-
-- **Compiler**: code that is responsible for compiling template strings into JavaScript render functions.
-
-- **Runtime**: code that is responsible for creating Vue instances, rendering and patching virtual DOM, etc. Basically everything minus the compiler.
-
-- **[UMD](https://github.com/umdjs/umd)**: UMD builds can be used directly in the browser via a `<script>` tag. The default file from Unpkg CDN at [https://unpkg.com/vue](https://unpkg.com/vue) is the Runtime + Compiler UMD build (`vue.js`).
-
-- **[CommonJS](http://wiki.commonjs.org/wiki/Modules/1.1)**: CommonJS builds are intended for use with older bundlers like [browserify](http://browserify.org/) or [webpack 1](https://webpack.github.io). The default file for these bundlers (`pkg.main`) is the Runtime only CommonJS build (`vue.runtime.common.js`).
-
-- **[ES Module](http://exploringjs.com/es6/ch_modules.html)**: ES module builds are intended for use with modern bundlers like [webpack 2](https://webpack.js.org) or [rollup](http://rollupjs.org/). The default file for these bundlers (`pkg.module`) is the Runtime only ES Module build (`vue.runtime.esm.js`).
-
-### Runtime + Compiler vs. Runtime-only
-
-If you need to compile templates on the fly (e.g. passing a string to the `template` option, or mounting to an element using its in-DOM HTML as the template), you will need the compiler and thus the full build.
-
-When using `vue-loader` or `vueify`, templates inside `*.vue` files are compiled into JavaScript at build time. You don't really need the compiler in the final bundle, and can therefore, use the runtime-only build.
-
-Since the runtime-only builds are roughly 30% lighter-weight than their full-build counterparts, you should use it whenever you can. If you wish to use the full build instead, you need to configure an alias in your bundler.
-
-#### Webpack
-
-``` js
-module.exports = {
-  // ...
-  resolve: {
-    alias: {
-      'vue$': 'vue/dist/vue.esm.js' // 'vue/dist/vue.common.js' for webpack 1
-    }
-  }
-}
-```
-
-#### Rollup
-
-``` js
-const alias = require('rollup-plugin-alias')
-
-rollup({
-  // ...
-  plugins: [
-    alias({
-      'vue': 'vue/dist/vue.esm.js'
-    })
-  ]
-})
-```
-
-#### Browserify
-
-Add to your project's `package.json`:
-
-``` js
-{
-  // ...
-  "browser": {
-    "vue": "vue/dist/vue.common.js"
-  }
-}
-```
-
-### Development vs. Production Mode
-
-Development/production modes are hard-coded for the UMD builds: the un-minified files are for development, and the minified files are for production.
-
-CommonJS and ES Module builds are intended for bundlers, therefore we don't provide minified versions for them. You will be responsible for minifying the final bundle yourself.
-
-CommonJS and ES Module builds also preserve raw checks for `process.env.NODE_ENV` to determine the mode they should run in. You should use appropriate bundler configurations to replace these environment variables in order to control which mode Vue will run in. Replacing `process.env.NODE_ENV` with string literals also allows minifiers like UglifyJS to completely drop the development-only code blocks, reducing final file size.
-
-#### Webpack
-
-Use Webpack's [DefinePlugin](https://webpack.js.org/plugins/define-plugin/):
-
-``` js
-var webpack = require('webpack')
-
-module.exports = {
-  // ...
-  plugins: [
-    // ...
-    new webpack.DefinePlugin({
-      'process.env.NODE_ENV': JSON.stringify('production')
-    })
-  ]
-}
-```
-
-#### Rollup
-
-Use [rollup-plugin-replace](https://github.com/rollup/rollup-plugin-replace):
-
-``` js
-const replace = require('rollup-plugin-replace')
-
-rollup({
-  // ...
-  plugins: [
-    replace({
-      'process.env.NODE_ENV': JSON.stringify('production')
-    })
-  ]
-}).then(...)
-```
-
-#### Browserify
-
-Apply a global [envify](https://github.com/hughsk/envify) transform to your bundle.
-
-``` bash
-NODE_ENV=production browserify -g envify -e main.js | uglifyjs -c -m > build.js
-```

package/src/compiler/directives/bind.js

@@ -1,11 +0,0 @@
-/* @flow */
-
-export default function bind (el: ASTElement, dir: ASTDirective) {
-  el.wrapData = (code: string) => {
-    return `_b(${code},'${el.tag}',${dir.value},${
-      dir.modifiers && dir.modifiers.prop ? 'true' : 'false'
-    }${
-      dir.modifiers && dir.modifiers.sync ? ',true' : ''
-    })`
-  }
-}

package/src/core/global-api/use.js

@@ -1,23 +0,0 @@
-/* @flow */
-
-import { toArray } from '../util/index'
-
-export function initUse (Vue: GlobalAPI) {
-  Vue.use = function (plugin: Function | Object) {
-    const installedPlugins = (this._installedPlugins || (this._installedPlugins = []))
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
-    }
-
-    // additional parameters
-    const args = toArray(arguments, 1)
-    args.unshift(this)
-    if (typeof plugin.install === 'function') {
-      plugin.install.apply(plugin, args)
-    } else if (typeof plugin === 'function') {
-      plugin.apply(null, args)
-    }
-    installedPlugins.push(plugin)
-    return this
-  }
-}

package/src/core/instance/inject.js

@@ -1,73 +0,0 @@
-/* @flow */
-
-import { hasOwn } from 'shared/util'
-import { warn, hasSymbol } from '../util/index'
-import { defineReactive, toggleObserving } from '../observer/index'
-
-export function initProvide (vm: Component) {
-  const provide = vm.$options.provide
-  if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide
-  }
-}
-
-export function initInjections (vm: Component) {
-  const result = resolveInject(vm.$options.inject, vm)
-  if (result) {
-    toggleObserving(false)
-    Object.keys(result).forEach(key => {
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, key, result[key], () => {
-          warn(
-            `Avoid mutating an injected value directly since the changes will be ` +
-            `overwritten whenever the provided component re-renders. ` +
-            `injection being mutated: "${key}"`,
-            vm
-          )
-        })
-      } else {
-        defineReactive(vm, key, result[key])
-      }
-    })
-    toggleObserving(true)
-  }
-}
-
-export function resolveInject (inject: any, vm: Component): ?Object {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    const result = Object.create(null)
-    const keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject)
-
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') continue
-      const provideKey = inject[key].from
-      let source = vm
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey]
-          break
-        }
-        source = source.$parent
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          const provideDefault = inject[key].default
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault
-        } else if (process.env.NODE_ENV !== 'production') {
-          warn(`Injection "${key}" not found`, vm)
-        }
-      }
-    }
-    return result
-  }
-}

package/src/core/vdom/helpers/is-async-placeholder.js

@@ -1,5 +0,0 @@
-/* @flow */
-
-export function isAsyncPlaceholder (node: VNode): boolean {
-  return node.isComment && node.asyncFactory
-}