helper.ts

import Vue, { VNode, ComponentOptions, VueConstructor } from 'vue'
import { ComponentInstance } from '../component'
import {
  ComponentInternalInstance,
  getCurrentInstance,
  getVueConstructor,
  Slot,
} from '../runtimeContext'
import { warn } from './utils'

export function getCurrentInstanceForFn(
  hook: string,
  target?: ComponentInternalInstance | null
): ComponentInternalInstance | null {
  target = target || getCurrentInstance()
  if (__DEV__ && !target) {
    warn(
      `${hook} 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 target
}

export function defineComponentInstance<V extends Vue = Vue>(
  Ctor: VueConstructor<V>,
  options: ComponentOptions<V> = {}
) {
  const silent = Ctor.config.silent
  Ctor.config.silent = true
  const vm = new Ctor(options)
  Ctor.config.silent = silent
  return vm
}

export function isComponentInstance(obj: any) {
  const Vue = getVueConstructor()
  return Vue && obj instanceof Vue
}

export function createSlotProxy(vm: ComponentInstance, slotName: string): Slot {
  return ((...args: any) => {
    if (!vm.$scopedSlots[slotName]) {
      if (__DEV__)
        return warn(
          `slots.${slotName}() got called outside of the "render()" scope`,
          vm
        )
      return
    }

    return vm.$scopedSlots[slotName]!.apply(vm, args)
  }) as Slot
}

export function resolveSlots(
  slots: { [key: string]: Function } | void,
  normalSlots: { [key: string]: VNode[] | undefined }
): { [key: string]: true } {
  let res: { [key: string]: true }
  if (!slots) {
    res = {}
  } else if (slots._normalized) {
    // fast path 1: child component re-render only, parent did not change
    return slots._normalized as any
  } else {
    res = {}
    for (const key in slots) {
      if (slots[key] && key[0] !== '$') {
        res[key] = true
      }
    }
  }

  // expose normal slots on scopedSlots
  for (const key in normalSlots) {
    if (!(key in res)) {
      res[key] = true
    }
  }

  return res
}

let vueInternalClasses:
  | {
      Watcher: any
      Dep: any
    }
  | undefined

export const getVueInternalClasses = () => {
  if (!vueInternalClasses) {
    const vm: any = defineComponentInstance(getVueConstructor(), {
      computed: {
        value() {
          return 0
        },
      },
    })

    // to get Watcher class
    const Watcher = vm._computedWatchers.value.constructor
    // to get Dep class
    const Dep = vm._data.__ob__.dep.constructor

    vueInternalClasses = {
      Watcher,
      Dep,
    }

    vm.$destroy()
  }

  return vueInternalClasses
}