vue 2.6.13 → 2.7.0-alpha.2

package/src/types/component.ts

@@ -0,0 +1,209 @@
+import type VNode from 'core/vdom/vnode'
+import type Watcher from 'core/observer/watcher'
+import { ComponentOptions, SetupContext } from './options'
+import { ScopedSlotsData, VNodeChildren, VNodeData } from './vnode'
+import { GlobalAPI } from './global-api'
+import { EffectScope } from 'v3/reactivity/effectScope'
+
+// TODO this should be using the same as /component/
+
+/**
+ * @internal
+ */
+export declare class Component {
+  constructor(options?: any)
+  // constructor information
+  static cid: number
+  static options: Record<string, any>
+  // extend
+  static extend: GlobalAPI['extend']
+  static superOptions: Record<string, any>
+  static extendOptions: Record<string, any>
+  static sealedOptions: Record<string, any>
+  static super: typeof Component
+  // assets
+  static directive: GlobalAPI['directive']
+  static component: GlobalAPI['component']
+  static filter: GlobalAPI['filter']
+  // functional context constructor
+  static FunctionalRenderContext: Function
+  static mixin: GlobalAPI['mixin']
+  static use: GlobalAPI['use']
+
+  // public properties
+  $el: any // so that we can attach __vue__ to it
+  $data: Record<string, any>
+  $props: Record<string, any>
+  $options: ComponentOptions
+  $parent: Component | undefined
+  $root: Component
+  $children: Array<Component>
+  $refs: {
+    [key: string]: Component | Element | Array<Component | Element> | undefined
+  }
+  $slots: { [key: string]: Array<VNode> }
+  $scopedSlots: { [key: string]: () => VNode[] | undefined }
+  $vnode: VNode // the placeholder node for the component in parent's render tree
+  $attrs: { [key: string]: string }
+  $listeners: Record<string, Function | Array<Function>>
+  $isServer: boolean
+
+  // public methods
+  $mount: (
+    el?: Element | string,
+    hydrating?: boolean
+  ) => Component & { [key: string]: any }
+  $forceUpdate: () => void
+  $destroy: () => void
+  $set: <T>(
+    target: Record<string, any> | Array<T>,
+    key: string | number,
+    val: T
+  ) => T
+  $delete: <T>(
+    target: Record<string, any> | Array<T>,
+    key: string | number
+  ) => void
+  $watch: (
+    expOrFn: string | (() => any),
+    cb: Function,
+    options?: Record<string, any>
+  ) => Function
+  $on: (event: string | Array<string>, fn: Function) => Component
+  $once: (event: string, fn: Function) => Component
+  $off: (event?: string | Array<string>, fn?: Function) => Component
+  $emit: (event: string, ...args: Array<any>) => Component
+  $nextTick: (fn: (...args: any[]) => any) => void | Promise<any>
+  $createElement: (
+    tag?: string | Component,
+    data?: Record<string, any>,
+    children?: VNodeChildren
+  ) => VNode
+
+  // private properties
+  _uid: number | string
+  _name: string // this only exists in dev mode
+  _isVue: true
+  __v_skip: true
+  _self: Component
+  _renderProxy: Component
+  _renderContext?: Component
+  _watcher: Watcher | null
+  _scope: EffectScope
+  _computedWatchers: { [key: string]: Watcher }
+  _data: Record<string, any>
+  _props: Record<string, any>
+  _events: Record<string, any>
+  _inactive: boolean | null
+  _directInactive: boolean
+  _isMounted: boolean
+  _isDestroyed: boolean
+  _isBeingDestroyed: boolean
+  _vnode?: VNode | null // self root node
+  _staticTrees?: Array<VNode> | null // v-once cached trees
+  _hasHookEvent: boolean
+  _provided: Record<string, any>
+  // _virtualComponents?: { [key: string]: Component };
+
+  // @v3
+  _setupState?: Record<string, any>
+  _setupContext?: SetupContext
+  _attrsProxy?: Record<string, any>
+  _slotsProxy?: Record<string, () => VNode[]>
+  _preWatchers?: Watcher[]
+
+  // private methods
+
+  // lifecycle
+  _init: Function
+  _mount: (el?: Element | void, hydrating?: boolean) => Component
+  _update: (vnode: VNode, hydrating?: boolean) => void
+
+  // rendering
+  _render: () => VNode
+
+  __patch__: (
+    a: Element | VNode | void | null,
+    b: VNode | null,
+    hydrating?: boolean,
+    removeOnly?: boolean,
+    parentElm?: any,
+    refElm?: any
+  ) => any
+
+  // createElement
+
+  // _c is internal that accepts `normalizationType` optimization hint
+  _c: (
+    vnode?: VNode,
+    data?: VNodeData,
+    children?: VNodeChildren,
+    normalizationType?: number
+  ) => VNode | void
+
+  // renderStatic
+  _m: (index: number, isInFor?: boolean) => VNode | VNodeChildren
+  // markOnce
+  _o: (
+    vnode: VNode | Array<VNode>,
+    index: number,
+    key: string
+  ) => VNode | VNodeChildren
+  // toString
+  _s: (value: any) => string
+  // text to VNode
+  _v: (value: string | number) => VNode
+  // toNumber
+  _n: (value: string) => number | string
+  // empty vnode
+  _e: () => VNode
+  // loose equal
+  _q: (a: any, b: any) => boolean
+  // loose indexOf
+  _i: (arr: Array<any>, val: any) => number
+  // resolveFilter
+  _f: (id: string) => Function
+  // renderList
+  _l: (val: any, render: Function) => Array<VNode> | null
+  // renderSlot
+  _t: (
+    name: string,
+    fallback?: Array<VNode>,
+    props?: Record<string, any>
+  ) => Array<VNode> | null
+  // apply v-bind object
+  _b: (
+    data: any,
+    tag: string,
+    value: any,
+    asProp: boolean,
+    isSync?: boolean
+  ) => VNodeData
+  // apply v-on object
+  _g: (data: any, value: any) => VNodeData
+  // check custom keyCode
+  _k: (
+    eventKeyCode: number,
+    key: string,
+    builtInAlias?: number | Array<number>,
+    eventKeyName?: string
+  ) => boolean | null
+  // resolve scoped slots
+  _u: (
+    scopedSlots: ScopedSlotsData,
+    res?: Record<string, any>
+  ) => { [key: string]: Function }
+
+  // SSR specific
+  _ssrNode: Function
+  _ssrList: Function
+  _ssrEscape: Function
+  _ssrAttr: Function
+  _ssrAttrs: Function
+  _ssrDOMProps: Function
+  _ssrClass: Function
+  _ssrStyle: Function
+
+  // allow dynamic method registration
+  // [key: string]: any
+}

package/src/types/global-api.ts

@@ -0,0 +1,37 @@
+import { Config } from 'core/config'
+import { Component } from './component'
+
+/**
+ * @internal
+ */
+export interface GlobalAPI {
+  // new(options?: any): Component
+  (options?: any): void
+  cid: number
+  options: Record<string, any>
+  config: Config
+  util: Object
+
+  extend: (options: typeof Component | object) => typeof Component
+  set: <T>(target: Object | Array<T>, key: string | number, value: T) => T
+  delete: <T>(target: Object | Array<T>, key: string | number) => void
+  nextTick: (fn: Function, context?: Object) => void | Promise<any>
+  use: (plugin: Function | Object) => GlobalAPI
+  mixin: (mixin: Object) => GlobalAPI
+  compile: (template: string) => {
+    render: Function
+    staticRenderFns: Array<Function>
+  }
+
+  directive: (id: string, def?: Function | Object) => Function | Object | void
+  component: (
+    id: string,
+    def?: typeof Component | Object
+  ) => typeof Component | void
+  filter: (id: string, def?: Function) => Function | void
+
+  observable: <T>(value: T) => T
+
+  // allow dynamic method registration
+  [key: string]: any
+}

package/src/types/modules.d.ts

@@ -0,0 +1,15 @@
+declare module 'de-indent' {
+  export default function deindent(input: string): string
+}
+
+declare namespace jasmine {
+  interface Matchers<T> {
+    toHaveBeenWarned(): void
+    toHaveBeenTipped(): void
+  }
+
+  interface ArrayLikeMatchers<T> {
+    toHaveBeenWarned(): void
+    toHaveBeenTipped(): void
+  }
+}

package/src/types/options.ts

@@ -0,0 +1,120 @@
+import VNode from 'core/vdom/vnode'
+import { DebuggerEvent } from 'v3'
+import { Component } from './component'
+
+export type InternalComponentOptions = {
+  _isComponent: true
+  parent: Component
+  _parentVnode: VNode
+  render?: Function
+  staticRenderFns?: Array<Function>
+}
+
+type InjectKey = string | Symbol
+
+/**
+ * @internal
+ */
+export interface SetupContext {
+  attrs: Record<string, any>
+  slots: Record<string, () => VNode[]>
+  emit: (event: string, ...args: any[]) => any
+}
+
+/**
+ * @internal
+ */
+export type ComponentOptions = {
+  // v3
+  setup?: (props: Record<string, any>, ctx: SetupContext) => unknown
+
+  [key: string]: any
+
+  componentId?: string
+
+  // data
+  data: object | Function | void
+  props?: { [key: string]: PropOptions }
+  propsData?: object
+  computed?: {
+    [key: string]:
+      | Function
+      | {
+          get?: Function
+          set?: Function
+          cache?: boolean
+        }
+  }
+  methods?: { [key: string]: Function }
+  watch?: { [key: string]: Function | string }
+
+  // DOM
+  el?: string | Element
+  template?: string
+  render: (h: () => VNode) => VNode
+  renderError?: (h: () => VNode, err: Error) => VNode
+  staticRenderFns?: Array<() => VNode>
+
+  // lifecycle
+  beforeCreate?: Function
+  created?: Function
+  beforeMount?: Function
+  mounted?: Function
+  beforeUpdate?: Function
+  updated?: Function
+  activated?: Function
+  deactivated?: Function
+  beforeDestroy?: Function
+  destroyed?: Function
+  errorCaptured?: () => boolean | void
+  serverPrefetch?: Function
+  renderTracked?(e: DebuggerEvent): void
+  renderTriggerd?(e: DebuggerEvent): void
+
+  // assets
+  directives?: { [key: string]: object }
+  components?: { [key: string]: Component }
+  transitions?: { [key: string]: object }
+  filters?: { [key: string]: Function }
+
+  // context
+  provide?: Record<string | symbol, any> | (() => Record<string | symbol, any>)
+  inject?:
+    | { [key: string]: InjectKey | { from?: InjectKey; default?: any } }
+    | Array<string>
+
+  // component v-model customization
+  model?: {
+    prop?: string
+    event?: string
+  }
+
+  // misc
+  parent?: Component
+  mixins?: Array<object>
+  name?: string
+  extends?: Component | object
+  delimiters?: [string, string]
+  comments?: boolean
+  inheritAttrs?: boolean
+
+  // Class API
+  abstract?: any
+
+  // private
+  _isComponent?: true
+  _propKeys?: Array<string>
+  _parentVnode?: VNode
+  _parentListeners?: object | null
+  _renderChildren?: Array<VNode> | null
+  _componentTag: string | null
+  _scopeId: string | null
+  _base: typeof Component
+}
+
+export type PropOptions = {
+  type: Function | Array<Function> | null
+  default: any
+  required: boolean | null
+  validator: Function | null
+}

package/src/types/ssr.ts

@@ -0,0 +1,27 @@
+import VNode from 'core/vdom/vnode'
+import { Component } from './component'
+
+export type ComponentWithCacheContext = {
+  type: 'ComponentWithCache'
+  bufferIndex: number
+  buffer: Array<string>
+  key: string
+}
+
+export type ElementContext = {
+  type: 'Element'
+  children: Array<VNode>
+  rendered: number
+  endTag: string
+  total: number
+}
+
+export type ComponentContext = {
+  type: 'Component'
+  prevActive: Component
+}
+
+export type RenderState =
+  | ComponentContext
+  | ComponentWithCacheContext
+  | ElementContext

package/src/types/utils.ts

@@ -0,0 +1,3 @@
+// If the the type T accepts type "any", output type Y, otherwise output type N.
+// https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
+export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N

package/src/types/vnode.ts

@@ -0,0 +1,127 @@
+import VNode from 'core/vdom/vnode'
+import { Ref } from 'v3'
+import { Component } from './component'
+import { ASTModifiers } from './compiler'
+
+/**
+ * @internal
+ */
+export type VNodeChildren =
+  | Array<null | VNode | string | number | VNodeChildren>
+  | string
+
+/**
+ * @internal
+ */
+export type VNodeComponentOptions = {
+  Ctor: typeof Component
+  propsData?: Object
+  listeners?: Record<string, Function | Function[]>
+  children?: Array<VNode>
+  tag?: string
+}
+
+/**
+ * @internal
+ */
+export type MountedComponentVNode = VNode & {
+  context: Component
+  componentOptions: VNodeComponentOptions
+  componentInstance: Component
+  parent: VNode
+  data: VNodeData
+}
+
+/**
+ * @internal
+ */
+// interface for vnodes in update modules
+export type VNodeWithData = VNode & {
+  tag: string
+  data: VNodeData
+  children: Array<VNode>
+  text: void
+  elm: any
+  ns: string | void
+  context: Component
+  key: string | number | undefined
+  parent?: VNodeWithData
+  componentOptions?: VNodeComponentOptions
+  componentInstance?: Component
+  isRootInsert: boolean
+}
+
+// // interface for vnodes in update modules
+// export type VNodeWithData = {
+//   tag: string;
+//   data: VNodeData;
+//   children: Array<VNode>;
+//   text: void;
+//   elm: any;
+//   ns: string | void;
+//   context: Component;
+//   key: string | number | undefined;
+//   parent?: VNodeWithData;
+//   componentOptions?: VNodeComponentOptions;
+//   componentInstance?: Component;
+//   isRootInsert: boolean;
+// };
+
+/**
+ * @internal
+ */
+export interface VNodeData {
+  key?: string | number
+  slot?: string
+  ref?: string | Ref | ((el: any) => void)
+  is?: string
+  pre?: boolean
+  tag?: string
+  staticClass?: string
+  class?: any
+  staticStyle?: { [key: string]: any }
+  style?: string | Array<Object> | Object
+  normalizedStyle?: Object
+  props?: { [key: string]: any }
+  attrs?: { [key: string]: string }
+  domProps?: { [key: string]: any }
+  hook?: { [key: string]: Function }
+  on?: { [key: string]: Function | Array<Function> }
+  nativeOn?: { [key: string]: Function | Array<Function> }
+  transition?: Object
+  show?: boolean // marker for v-show
+  inlineTemplate?: {
+    render: Function
+    staticRenderFns: Array<Function>
+  }
+  directives?: Array<VNodeDirective>
+  keepAlive?: boolean
+  scopedSlots?: { [key: string]: Function }
+  model?: {
+    value: any
+    callback: Function
+  }
+
+  [key: string]: any
+}
+
+/**
+ * @internal
+ */
+export type VNodeDirective = {
+  name: string
+  rawName: string
+  value?: any
+  oldValue?: any
+  arg?: string
+  oldArg?: string
+  modifiers?: ASTModifiers
+  def?: Object
+}
+
+/**
+ * @internal
+ */
+export type ScopedSlotsData = Array<
+  { key: string; fn: Function } | ScopedSlotsData
+>

package/src/v3/apiInject.ts

@@ -0,0 +1,66 @@
+import { isFunction, warn } from 'core/util'
+import { currentInstance } from './currentInstance'
+
+export interface InjectionKey<T> extends Symbol {}
+
+export function provide<T>(key: InjectionKey<T> | string | number, value: T) {
+  if (!currentInstance) {
+    if (__DEV__) {
+      warn(`provide() can only be used inside setup().`)
+    }
+  } else {
+    let provides = currentInstance._provided
+    // by default an instance inherits its parent's provides object
+    // but when it needs to provide values of its own, it creates its
+    // own provides object using parent provides object as prototype.
+    // this way in `inject` we can simply look up injections from direct
+    // parent and let the prototype chain do the work.
+    const parentProvides =
+      currentInstance.$parent && currentInstance.$parent._provided
+    if (parentProvides === provides) {
+      provides = currentInstance._provided = Object.create(parentProvides)
+    }
+    // TS doesn't allow symbol as index type
+    provides[key as string] = value
+  }
+}
+
+export function inject<T>(key: InjectionKey<T> | string): T | undefined
+export function inject<T>(
+  key: InjectionKey<T> | string,
+  defaultValue: T,
+  treatDefaultAsFactory?: false
+): T
+export function inject<T>(
+  key: InjectionKey<T> | string,
+  defaultValue: T | (() => T),
+  treatDefaultAsFactory: true
+): T
+export function inject(
+  key: InjectionKey<any> | string,
+  defaultValue?: unknown,
+  treatDefaultAsFactory = false
+) {
+  // fallback to `currentRenderingInstance` so that this can be called in
+  // a functional component
+  const instance = currentInstance
+  if (instance) {
+    // #2400
+    // to support `app.use` plugins,
+    // fallback to appContext's `provides` if the instance is at root
+    const provides = instance.$parent && instance.$parent._provided
+
+    if (provides && (key as string | symbol) in provides) {
+      // TS doesn't allow symbol as index type
+      return provides[key as string]
+    } else if (arguments.length > 1) {
+      return treatDefaultAsFactory && isFunction(defaultValue)
+        ? defaultValue.call(instance)
+        : defaultValue
+    } else if (__DEV__) {
+      warn(`injection "${String(key)}" not found.`)
+    }
+  } else if (__DEV__) {
+    warn(`inject() can only be used inside setup() or functional components.`)
+  }
+}

package/src/v3/apiLifecycle.ts

@@ -0,0 +1,53 @@
+import { DebuggerEvent } from './debug'
+import { Component } from 'types/component'
+import { mergeLifecycleHook, warn } from '../core/util'
+import { currentInstance } from './currentInstance'
+
+function createLifeCycle<T extends (...args: any[]) => any = () => void>(
+  hookName: string
+) {
+  return (fn: T, target: any = currentInstance) => {
+    if (!target) {
+      __DEV__ &&
+        warn(
+          `${formatName(
+            hookName
+          )} is called when there is no active component instance to be ` +
+            `associated with. ` +
+            `Lifecycle injection APIs can only be used during execution of setup().`
+        )
+      return
+    }
+    return injectHook(target, hookName, fn)
+  }
+}
+
+function formatName(name: string) {
+  if (name === 'beforeDestroy') {
+    name = 'beforeUnmount'
+  } else if (name === 'destroyed') {
+    name = 'unmounted'
+  }
+  return `on${name[0].toUpperCase() + name.slice(1)}`
+}
+
+function injectHook(instance: Component, hookName: string, fn: () => void) {
+  const options = instance.$options
+  options[hookName] = mergeLifecycleHook(options[hookName], fn)
+}
+
+export const onBeforeMount = createLifeCycle('beforeMount')
+export const onMounted = createLifeCycle('mounted')
+export const onBeforeUpdate = createLifeCycle('beforeUpdate')
+export const onUpdated = createLifeCycle('updated')
+export const onBeforeUnmount = createLifeCycle('beforeDestroy')
+export const onUnmounted = createLifeCycle('destroyed')
+export const onErrorCaptured = createLifeCycle('errorCaptured')
+export const onActivated = createLifeCycle('activated')
+export const onDeactivated = createLifeCycle('deactivated')
+export const onServerPrefetch = createLifeCycle('serverPrefetch')
+
+export const onRenderTracked =
+  createLifeCycle<(e: DebuggerEvent) => any>('renderTracked')
+export const onRenderTriggered =
+  createLifeCycle<(e: DebuggerEvent) => any>('renderTriggered')