vue 2.7.1 → 2.7.2

package/types/v3-generated.d.ts

@@ -133,7 +133,9 @@ declare type MultiWatchSources = (WatchSource<unknown> | object)[];
 
 export declare function nextTick(): Promise<void>;
 
-export declare function nextTick(cb: (...args: any[]) => any, ctx?: object): void;
+export declare function nextTick<T>(this: T, cb: (this: T, ...args: any[]) => any): void;
+
+export declare function nextTick<T>(cb: (this: T, ...args: any[]) => any, ctx: T): void;
 
 export declare const onActivated: (fn: () => void, target?: any) => void;
 

package/types/v3-setup-context.d.ts

@@ -29,12 +29,6 @@ export type EmitFn<
       }[Event]
     >
 
-export type ComponentRenderEmitFn<
-  Options = ObjectEmitsOptions,
-  Event extends keyof Options = keyof Options,
-  T extends Vue | void = void
-> = EmitFn<Options, Event, T>
-
 export interface SetupContext<E extends EmitsOptions = {}> {
   attrs: Data
   slots: Slots

package/types/vnode.d.ts

@@ -1,4 +1,18 @@
 import { Vue } from './vue'
+import { DirectiveFunction, DirectiveOptions } from './options'
+
+/**
+ * For extending allowed non-declared props on components in TSX
+ */
+export interface ComponentCustomProps {}
+
+/**
+ * Default allowed non-declared props on component in TSX
+ */
+export interface AllowedComponentProps {
+  class?: unknown
+  style?: unknown
+}
 
 export type ScopedSlot = (props: any) => ScopedSlotReturnValue
 type ScopedSlotReturnValue =
@@ -86,4 +100,5 @@ export interface VNodeDirective {
   arg?: string
   oldArg?: string
   modifiers?: { [key: string]: boolean }
+  def?: DirectiveFunction | DirectiveOptions
 }

package/types/v3-component-proxy.d.ts

@@ -1,189 +0,0 @@
-import { ExtractDefaultPropTypes, ExtractPropTypes } from './v3-component-props'
-import {
-  nextTick,
-  ShallowUnwrapRef,
-  UnwrapNestedRefs,
-  WatchOptions,
-  WatchStopHandle
-} from './v3-generated'
-import { Data } from './common'
-
-import { Vue, VueConstructor } from './vue'
-import { ComponentOptions as Vue2ComponentOptions } from './options'
-import {
-  ComputedOptions,
-  MethodOptions,
-  ExtractComputedReturns
-} from './v3-component-options'
-import {
-  ComponentRenderEmitFn,
-  EmitFn,
-  EmitsOptions,
-  ObjectEmitsOptions,
-  Slots
-} from './v3-setup-context'
-
-type EmitsToProps<T extends EmitsOptions> = T extends string[]
-  ? {
-      [K in string & `on${Capitalize<T[number]>}`]?: (...args: any[]) => any
-    }
-  : T extends ObjectEmitsOptions
-  ? {
-      [K in string &
-        `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}`
-        ? T[Uncapitalize<C>] extends null
-          ? (...args: any[]) => any
-          : (
-              ...args: T[Uncapitalize<C>] extends (...args: infer P) => any
-                ? P
-                : never
-            ) => any
-        : never
-    }
-  : {}
-
-export type ComponentInstance = InstanceType<VueConstructor>
-
-// public properties exposed on the proxy, which is used as the render context
-// in templates (as `this` in the render option)
-export type ComponentRenderProxy<
-  P = {}, // props type extracted from props option
-  B = {}, // raw bindings returned from setup()
-  D = {}, // return from data()
-  C extends ComputedOptions = {},
-  M extends MethodOptions = {},
-  Mixin = {},
-  Extends = {},
-  Emits extends EmitsOptions = {},
-  PublicProps = P,
-  Defaults = {},
-  MakeDefaultsOptional extends boolean = false
-> = {
-  $data: D
-  $props: Readonly<
-    MakeDefaultsOptional extends true
-      ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
-      : P & PublicProps
-  >
-  $attrs: Record<string, string>
-  $emit: ComponentRenderEmitFn<
-    Emits,
-    keyof Emits,
-    ComponentRenderProxy<
-      P,
-      B,
-      D,
-      C,
-      M,
-      Mixin,
-      Extends,
-      Emits,
-      PublicProps,
-      Defaults,
-      MakeDefaultsOptional
-    >
-  >
-} & Readonly<P> &
-  ShallowUnwrapRef<B> &
-  D &
-  M &
-  ExtractComputedReturns<C> &
-  Omit<Vue, '$data' | '$props' | '$attrs' | '$emit'>
-
-// for Vetur and TSX support
-type VueConstructorProxy<
-  PropsOptions,
-  RawBindings,
-  Data,
-  Computed extends ComputedOptions,
-  Methods extends MethodOptions,
-  Mixin = {},
-  Extends = {},
-  Emits extends EmitsOptions = {},
-  Props = ExtractPropTypes<PropsOptions> &
-    ({} extends Emits ? {} : EmitsToProps<Emits>)
-> = Omit<VueConstructor, never> & {
-  new (...args: any[]): ComponentRenderProxy<
-    Props,
-    ShallowUnwrapRef<RawBindings>,
-    Data,
-    Computed,
-    Methods,
-    Mixin,
-    Extends,
-    Emits,
-    Props,
-    ExtractDefaultPropTypes<PropsOptions>,
-    true
-  >
-}
-
-type DefaultData<V> = object | ((this: V) => object)
-type DefaultMethods<V> = { [key: string]: (this: V, ...args: any[]) => any }
-type DefaultComputed = { [key: string]: any }
-
-export type VueProxy<
-  PropsOptions,
-  RawBindings,
-  Data = DefaultData<Vue>,
-  Computed extends ComputedOptions = DefaultComputed,
-  Methods extends MethodOptions = DefaultMethods<Vue>,
-  Mixin = {},
-  Extends = {},
-  Emits extends EmitsOptions = {}
-> = Vue2ComponentOptions<
-  Vue,
-  ShallowUnwrapRef<RawBindings> & Data,
-  Methods,
-  Computed,
-  PropsOptions,
-  ExtractPropTypes<PropsOptions>
-> &
-  VueConstructorProxy<
-    PropsOptions,
-    RawBindings,
-    Data,
-    Computed,
-    Methods,
-    Mixin,
-    Extends,
-    Emits
-  >
-
-// public properties exposed on the proxy, which is used as the render context
-// in templates (as `this` in the render option)
-export type ComponentPublicInstance<
-  P = {}, // props type extracted from props option
-  B = {}, // raw bindings returned from setup()
-  D = {}, // return from data()
-  C extends ComputedOptions = {},
-  M extends MethodOptions = {},
-  E extends EmitsOptions = {},
-  PublicProps = P,
-  Defaults = {},
-  MakeDefaultsOptional extends boolean = false
-> = {
-  $data: D
-  $props: MakeDefaultsOptional extends true
-    ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
-    : P & PublicProps
-  $attrs: Data
-  $refs: Data
-  $slots: Slots
-  $root: ComponentPublicInstance | null
-  $parent: ComponentPublicInstance | null
-  $emit: EmitFn<E>
-  $el: any
-  // $options: Options & MergedComponentOptionsOverride
-  $forceUpdate: () => void
-  $nextTick: typeof nextTick
-  $watch(
-    source: string | Function,
-    cb: Function,
-    options?: WatchOptions
-  ): WatchStopHandle
-} & P &
-  ShallowUnwrapRef<B> &
-  UnwrapNestedRefs<D> &
-  ExtractComputedReturns<C> &
-  M