vue 2.6.13 → 2.7.0-alpha.2

package/types/options.d.ts

@@ -1,36 +1,73 @@
-import { Vue, CreateElement, CombinedVueInstance } from "./vue";
-import { VNode, VNodeData, VNodeDirective, NormalizedScopedSlot } from "./vnode";
+import { Vue, CreateElement, CombinedVueInstance } from './vue'
+import { VNode, VNodeData, VNodeDirective, NormalizedScopedSlot } from './vnode'
+import { SetupContext } from './v3'
 
 type Constructor = {
-  new (...args: any[]): any;
+  new (...args: any[]): any
 }
 
 // we don't support infer props in async component
 // N.B. ComponentOptions<V> is contravariant, the default generic should be bottom type
-export type Component<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> =
+export type Component<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> =
   | typeof Vue
   | FunctionalComponentOptions<Props>
-  | ComponentOptions<never, Data, Methods, Computed, Props>
-
-interface EsModuleComponent {
-  default: Component
-}
-
-export type AsyncComponent<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps>
-  = AsyncComponentPromise<Data, Methods, Computed, Props>
-  | AsyncComponentFactory<Data, Methods, Computed, Props>
-
-export type AsyncComponentPromise<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> = (
-  resolve: (component: Component<Data, Methods, Computed, Props>) => void,
+  | ComponentOptions<never, Data, Methods, Computed, Props, SetupBindings>
+
+type EsModule<T> = T | { default: T }
+
+type ImportedComponent<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> = EsModule<Component<Data, Methods, Computed, Props, SetupBindings>>
+
+export type AsyncComponent<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> =
+  | AsyncComponentPromise<Data, Methods, Computed, Props, SetupBindings>
+  | AsyncComponentFactory<Data, Methods, Computed, Props, SetupBindings>
+
+export type AsyncComponentPromise<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> = (
+  resolve: (
+    component: Component<Data, Methods, Computed, Props, SetupBindings>
+  ) => void,
   reject: (reason?: any) => void
-) => Promise<Component | EsModuleComponent> | void;
-
-export type AsyncComponentFactory<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> = () => {
-  component: AsyncComponentPromise<Data, Methods, Computed, Props>;
-  loading?: Component | EsModuleComponent;
-  error?: Component | EsModuleComponent;
-  delay?: number;
-  timeout?: number;
+) => Promise<
+  ImportedComponent<Data, Methods, Computed, Props, SetupBindings>
+> | void
+
+export type AsyncComponentFactory<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> = () => {
+  component: Promise<
+    ImportedComponent<Data, Methods, Computed, Props, SetupBindings>
+  >
+  loading?: ImportedComponent
+  error?: ImportedComponent
+  delay?: number
+  timeout?: number
 }
 
 /**
@@ -47,141 +84,214 @@ type DataDef<Data, Props, V> = Data | ((this: Readonly<Props> & V) => Data)
 /**
  * This type should be used when an array of strings is used for a component's `props` value.
  */
-export type ThisTypedComponentOptionsWithArrayProps<V extends Vue, Data, Methods, Computed, PropNames extends string> =
-  object &
-  ComponentOptions<V, DataDef<Data, Record<PropNames, any>, V>, Methods, Computed, PropNames[], Record<PropNames, any>> &
-  ThisType<CombinedVueInstance<V, Data, Methods, Computed, Readonly<Record<PropNames, any>>>>;
+export type ThisTypedComponentOptionsWithArrayProps<
+  V extends Vue,
+  Data,
+  Methods,
+  Computed,
+  PropNames extends string,
+  SetupBindings
+> = object &
+  ComponentOptions<
+    V,
+    DataDef<Data, Record<PropNames, any>, V>,
+    Methods,
+    Computed,
+    PropNames[],
+    Record<PropNames, any>,
+    SetupBindings
+  > &
+  ThisType<
+    CombinedVueInstance<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Readonly<Record<PropNames, any>>,
+      SetupBindings
+    >
+  >
 
 /**
  * This type should be used when an object mapped to `PropOptions` is used for a component's `props` value.
  */
-export type ThisTypedComponentOptionsWithRecordProps<V extends Vue, Data, Methods, Computed, Props> =
-  object &
-  ComponentOptions<V, DataDef<Data, Props, V>, Methods, Computed, RecordPropsDefinition<Props>, Props> &
-  ThisType<CombinedVueInstance<V, Data, Methods, Computed, Readonly<Props>>>;
-
-type DefaultData<V> =  object | ((this: V) => object);
-type DefaultProps = Record<string, any>;
-type DefaultMethods<V> =  { [key: string]: (this: V, ...args: any[]) => any };
-type DefaultComputed = { [key: string]: any };
+export type ThisTypedComponentOptionsWithRecordProps<
+  V extends Vue,
+  Data,
+  Methods,
+  Computed,
+  Props,
+  SetupBindings
+> = object &
+  ComponentOptions<
+    V,
+    DataDef<Data, Props, V>,
+    Methods,
+    Computed,
+    RecordPropsDefinition<Props>,
+    Props,
+    SetupBindings
+  > &
+  ThisType<
+    CombinedVueInstance<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Readonly<Props>,
+      SetupBindings
+    >
+  >
+
+type DefaultData<V> = object | ((this: V) => object)
+type DefaultProps = Record<string, any>
+type DefaultMethods<V> = { [key: string]: (this: V, ...args: any[]) => any }
+type DefaultComputed = { [key: string]: any }
+
 export interface ComponentOptions<
   V extends Vue,
-  Data=DefaultData<V>,
-  Methods=DefaultMethods<V>,
-  Computed=DefaultComputed,
-  PropsDef=PropsDefinition<DefaultProps>,
-  Props=DefaultProps> {
-  data?: Data;
-  props?: PropsDef;
-  propsData?: object;
-  computed?: Accessors<Computed>;
-  methods?: Methods;
-  watch?: Record<string, WatchOptionsWithHandler<any> | WatchHandler<any>>;
-
-  el?: Element | string;
-  template?: string;
+  Data = DefaultData<V>,
+  Methods = DefaultMethods<V>,
+  Computed = DefaultComputed,
+  PropsDef = PropsDefinition<DefaultProps>,
+  Props = DefaultProps,
+  RawBindings = {}
+> {
+  data?: Data
+  props?: PropsDef
+  propsData?: object
+  computed?: Accessors<Computed>
+  methods?: Methods
+  watch?: Record<string, WatchOptionsWithHandler<any> | WatchHandler<any>>
+
+  setup?: (
+    this: void,
+    props: Props,
+    ctx: SetupContext
+  ) => Promise<RawBindings> | RawBindings | ((h: CreateElement) => VNode) | void
+
+  el?: Element | string
+  template?: string
   // hack is for functional component type inference, should not be used in user code
-  render?(createElement: CreateElement, hack: RenderContext<Props>): VNode;
-  renderError?(createElement: CreateElement, err: Error): VNode;
-  staticRenderFns?: ((createElement: CreateElement) => VNode)[];
-
-  beforeCreate?(this: V): void;
-  created?(): void;
-  beforeDestroy?(): void;
-  destroyed?(): void;
-  beforeMount?(): void;
-  mounted?(): void;
-  beforeUpdate?(): void;
-  updated?(): void;
-  activated?(): void;
-  deactivated?(): void;
-  errorCaptured?(err: Error, vm: Vue, info: string): boolean | void;
-  serverPrefetch?(this: V): Promise<void>;
-
-  directives?: { [key: string]: DirectiveFunction | DirectiveOptions };
-  components?: { [key: string]: Component<any, any, any, any> | AsyncComponent<any, any, any, any> };
-  transitions?: { [key: string]: object };
-  filters?: { [key: string]: Function };
-
-  provide?: object | (() => object);
-  inject?: InjectOptions;
+  render?(createElement: CreateElement, hack: RenderContext<Props>): VNode
+  renderError?(createElement: CreateElement, err: Error): VNode
+  staticRenderFns?: ((createElement: CreateElement) => VNode)[]
+
+  beforeCreate?(this: V): void
+  created?(): void
+  beforeDestroy?(): void
+  destroyed?(): void
+  beforeMount?(): void
+  mounted?(): void
+  beforeUpdate?(): void
+  updated?(): void
+  activated?(): void
+  deactivated?(): void
+  errorCaptured?(err: Error, vm: Vue, info: string): boolean | void
+  serverPrefetch?(this: V): Promise<void>
+  renderTracked?(e: DebuggerEvent): void
+  renderTriggerd?(e: DebuggerEvent): void
+
+  directives?: { [key: string]: DirectiveFunction | DirectiveOptions }
+  components?: {
+    [key: string]:
+      | Component<any, any, any, any>
+      | AsyncComponent<any, any, any, any>
+  }
+  transitions?: { [key: string]: object }
+  filters?: { [key: string]: Function }
+
+  provide?: object | (() => object)
+  inject?: InjectOptions
 
   model?: {
-    prop?: string;
-    event?: string;
-  };
+    prop?: string
+    event?: string
+  }
 
-  parent?: Vue;
-  mixins?: (ComponentOptions<Vue> | typeof Vue)[];
-  name?: string;
+  parent?: Vue
+  mixins?: (ComponentOptions<Vue> | typeof Vue)[]
+  name?: string
   // TODO: support properly inferred 'extends'
-  extends?: ComponentOptions<Vue> | typeof Vue;
-  delimiters?: [string, string];
-  comments?: boolean;
-  inheritAttrs?: boolean;
+  extends?: ComponentOptions<Vue> | typeof Vue
+  delimiters?: [string, string]
+  comments?: boolean
+  inheritAttrs?: boolean
 }
 
-export interface FunctionalComponentOptions<Props = DefaultProps, PropDefs = PropsDefinition<Props>> {
-  name?: string;
-  props?: PropDefs;
+export interface FunctionalComponentOptions<
+  Props = DefaultProps,
+  PropDefs = PropsDefinition<Props>
+> {
+  name?: string
+  props?: PropDefs
   model?: {
-    prop?: string;
-    event?: string;
-  };
-  inject?: InjectOptions;
-  functional: boolean;
-  render?(this: undefined, createElement: CreateElement, context: RenderContext<Props>): VNode | VNode[];
-}
-
-export interface RenderContext<Props=DefaultProps> {
-  props: Props;
-  children: VNode[];
-  slots(): any;
-  data: VNodeData;
-  parent: Vue;
-  listeners: { [key: string]: Function | Function[] };
-  scopedSlots: { [key: string]: NormalizedScopedSlot };
+    prop?: string
+    event?: string
+  }
+  inject?: InjectOptions
+  functional: boolean
+  render?(
+    this: undefined,
+    createElement: CreateElement,
+    context: RenderContext<Props>
+  ): VNode | VNode[]
+}
+
+export interface RenderContext<Props = DefaultProps> {
+  props: Props
+  children: VNode[]
+  slots(): any
+  data: VNodeData
+  parent: Vue
+  listeners: { [key: string]: Function | Function[] }
+  scopedSlots: { [key: string]: NormalizedScopedSlot }
   injections: any
 }
 
-export type Prop<T> = { (): T } | { new(...args: never[]): T & object } | { new(...args: string[]): Function }
+export type Prop<T> =
+  | { (): T }
+  | { new (...args: never[]): T & object }
+  | { new (...args: string[]): Function }
 
-export type PropType<T> = Prop<T> | Prop<T>[];
+export type PropType<T> = Prop<T> | Prop<T>[]
 
-export type PropValidator<T> = PropOptions<T> | PropType<T>;
+export type PropValidator<T> = PropOptions<T> | PropType<T>
 
-export interface PropOptions<T=any> {
-  type?: PropType<T>;
-  required?: boolean;
-  default?: T | null | undefined | (() => T | null | undefined);
-  validator?(value: T): boolean;
+export interface PropOptions<T = any> {
+  type?: PropType<T>
+  required?: boolean
+  default?: T | null | undefined | (() => T | null | undefined)
+  validator?(value: T): boolean
 }
 
 export type RecordPropsDefinition<T> = {
   [K in keyof T]: PropValidator<T[K]>
 }
-export type ArrayPropsDefinition<T> = (keyof T)[];
-export type PropsDefinition<T> = ArrayPropsDefinition<T> | RecordPropsDefinition<T>;
+export type ArrayPropsDefinition<T> = (keyof T)[]
+export type PropsDefinition<T> =
+  | ArrayPropsDefinition<T>
+  | RecordPropsDefinition<T>
 
 export interface ComputedOptions<T> {
-  get?(): T;
-  set?(value: T): void;
-  cache?: boolean;
+  get?(): T
+  set?(value: T): void
+  cache?: boolean
 }
 
-export type WatchHandler<T> = string | ((val: T, oldVal: T) => void);
+export type WatchHandler<T> = string | ((val: T, oldVal: T) => void)
 
 export interface WatchOptions {
-  deep?: boolean;
-  immediate?: boolean;
+  deep?: boolean
+  immediate?: boolean
 }
 
 export interface WatchOptionsWithHandler<T> extends WatchOptions {
-  handler: WatchHandler<T>;
+  handler: WatchHandler<T>
 }
 
 export interface DirectiveBinding extends Readonly<VNodeDirective> {
-  readonly modifiers: { [key: string]: boolean };
+  readonly modifiers: { [key: string]: boolean }
 }
 
 export type DirectiveFunction = (
@@ -189,18 +299,41 @@ export type DirectiveFunction = (
   binding: DirectiveBinding,
   vnode: VNode,
   oldVnode: VNode
-) => void;
+) => void
 
 export interface DirectiveOptions {
-  bind?: DirectiveFunction;
-  inserted?: DirectiveFunction;
-  update?: DirectiveFunction;
-  componentUpdated?: DirectiveFunction;
-  unbind?: DirectiveFunction;
+  bind?: DirectiveFunction
+  inserted?: DirectiveFunction
+  update?: DirectiveFunction
+  componentUpdated?: DirectiveFunction
+  unbind?: DirectiveFunction
 }
 
-export type InjectKey = string | symbol;
+export type InjectKey = string | symbol
+
+export type InjectOptions =
+  | {
+      [key: string]: InjectKey | { from?: InjectKey; default?: any }
+    }
+  | string[]
+
+export type DebuggerEvent = {
+  target: object
+  type: TrackOpTypes | TriggerOpTypes
+  key?: any
+  newValue?: any
+  oldValue?: any
+  oldTarget?: Map<any, any> | Set<any>
+}
 
-export type InjectOptions = {
-  [key: string]: InjectKey | { from?: InjectKey, default?: any }
-} | string[];
+export const enum TrackOpTypes {
+  GET = 'get',
+  TOUCH = 'touch'
+}
+
+export const enum TriggerOpTypes {
+  SET = 'set',
+  ADD = 'add',
+  DELETE = 'delete',
+  ARRAY_MUTATION = 'array mutation'
+}

package/types/plugin.d.ts

@@ -1,8 +1,8 @@
-import { Vue as _Vue } from "./vue";
+import { Vue as _Vue } from './vue'
 
-export type PluginFunction<T> = (Vue: typeof _Vue, options?: T) => void;
+export type PluginFunction<T> = (Vue: typeof _Vue, options?: T) => void
 
 export interface PluginObject<T> {
-  install: PluginFunction<T>;
-  [key: string]: any;
+  install: PluginFunction<T>
+  [key: string]: any
 }

package/types/umd.d.ts

@@ -1,48 +1,68 @@
-import * as V from "./index";
+import * as V from './index'
 import {
   DefaultData,
   DefaultProps,
   DefaultMethods,
   DefaultComputed,
   PropsDefinition
-} from "./options";
+} from './options'
 
 // Expose some types for backward compatibility...
 declare namespace Vue {
   // vue.d.ts
-  export type CreateElement = V.CreateElement;
-  export type VueConstructor<V extends Vue = Vue> = V.VueConstructor<V>;
+  export type CreateElement = V.CreateElement
+  export type VueConstructor<V extends Vue = Vue> = V.VueConstructor<V>
 
   // options.d.ts
-  export type Component<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> = V.Component<Data, Methods, Computed, Props>;
-  export type AsyncComponent<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> = V.AsyncComponent<Data, Methods, Computed, Props>;
-  export type ComponentOptions<V extends Vue, Data=DefaultData<V>, Methods=DefaultMethods<V>, Computed=DefaultComputed, PropsDef=PropsDefinition<DefaultProps>, Props=DefaultProps> = V.ComponentOptions<V, Data, Methods, Computed, PropsDef, Props>;
-  export type FunctionalComponentOptions<Props = DefaultProps, PropDefs = PropsDefinition<Props>> = V.FunctionalComponentOptions<Props, PropDefs>;
-  export type RenderContext<Props=DefaultProps> = V.RenderContext<Props>;
-  export type PropType<T> = V.PropType<T>;
-  export type PropOptions<T=any> = V.PropOptions<T>;
-  export type ComputedOptions<T> = V.ComputedOptions<T>;
-  export type WatchHandler<T> = V.WatchHandler<T>;
-  export type WatchOptions = V.WatchOptions;
-  export type WatchOptionsWithHandler<T> = V.WatchOptionsWithHandler<T>;
-  export type DirectiveFunction = V.DirectiveFunction;
-  export type DirectiveOptions = V.DirectiveOptions;
+  export type Component<
+    Data = DefaultData<never>,
+    Methods = DefaultMethods<never>,
+    Computed = DefaultComputed,
+    Props = DefaultProps
+  > = V.Component<Data, Methods, Computed, Props>
+  export type AsyncComponent<
+    Data = DefaultData<never>,
+    Methods = DefaultMethods<never>,
+    Computed = DefaultComputed,
+    Props = DefaultProps
+  > = V.AsyncComponent<Data, Methods, Computed, Props>
+  export type ComponentOptions<
+    V extends Vue,
+    Data = DefaultData<V>,
+    Methods = DefaultMethods<V>,
+    Computed = DefaultComputed,
+    PropsDef = PropsDefinition<DefaultProps>,
+    Props = DefaultProps
+  > = V.ComponentOptions<V, Data, Methods, Computed, PropsDef, Props>
+  export type FunctionalComponentOptions<
+    Props = DefaultProps,
+    PropDefs = PropsDefinition<Props>
+  > = V.FunctionalComponentOptions<Props, PropDefs>
+  export type RenderContext<Props = DefaultProps> = V.RenderContext<Props>
+  export type PropType<T> = V.PropType<T>
+  export type PropOptions<T = any> = V.PropOptions<T>
+  export type ComputedOptions<T> = V.ComputedOptions<T>
+  export type WatchHandler<T> = V.WatchHandler<T>
+  export type WatchOptions = V.WatchOptions
+  export type WatchOptionsWithHandler<T> = V.WatchOptionsWithHandler<T>
+  export type DirectiveFunction = V.DirectiveFunction
+  export type DirectiveOptions = V.DirectiveOptions
 
   // plugin.d.ts
-  export type PluginFunction<T> = V.PluginFunction<T>;
-  export type PluginObject<T> = V.PluginObject<T>;
+  export type PluginFunction<T> = V.PluginFunction<T>
+  export type PluginObject<T> = V.PluginObject<T>
 
   // vnode.d.ts
-  export type VNodeChildren = V.VNodeChildren;
-  export type VNodeChildrenArrayContents = V.VNodeChildrenArrayContents;
-  export type VNode = V.VNode;
-  export type VNodeComponentOptions = V.VNodeComponentOptions;
-  export type VNodeData = V.VNodeData;
-  export type VNodeDirective = V.VNodeDirective;
+  export type VNodeChildren = V.VNodeChildren
+  export type VNodeChildrenArrayContents = V.VNodeChildrenArrayContents
+  export type VNode = V.VNode
+  export type VNodeComponentOptions = V.VNodeComponentOptions
+  export type VNodeData = V.VNodeData
+  export type VNodeDirective = V.VNodeDirective
 }
 
 declare class Vue extends V.default {}
 
-export = Vue;
+export = Vue
 
-export as namespace Vue;
+export as namespace Vue