wip: provide/inject

Author: yyx990803

src/core/instance/inject.ts

@@ -1,12 +1,21 @@
-import { hasOwn } from 'shared/util'
 import { warn, hasSymbol, isFunction } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
 import type { Component } from 'typescript/component'
+import { provide } from 'v3/apiInject'
+import { setCurrentInstance } from '../../v3/currentInstance'
 
 export function initProvide(vm: Component) {
-  const provide = vm.$options.provide
-  if (provide) {
-    vm._provided = isFunction(provide) ? provide.call(vm) : provide
+  const provideOption = vm.$options.provide
+  if (provideOption) {
+    const provided = isFunction(provideOption)
+      ? provideOption.call(vm)
+      : provideOption
+    const keys = hasSymbol ? Reflect.ownKeys(provided) : Object.keys(provided)
+    setCurrentInstance(vm)
+    for (let i = 0; i < keys.length; i++) {
+      provide(keys[i], provided[keys[i]])
+    }
+    setCurrentInstance()
   }
 }
 
@@ -47,24 +56,15 @@ export function resolveInject(
       // #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
-        }
-        // @ts-expect-error
-        source = source.$parent
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          const provideDefault = inject[key].default
-          result[key] = isFunction(provideDefault)
-            ? provideDefault.call(vm)
-            : provideDefault
-        } else if (__DEV__) {
-          warn(`Injection "${key as string}" not found`, vm)
-        }
+      if (provideKey in vm._provided) {
+        result[key] = vm._provided[provideKey]
+      } else if ('default' in inject[key]) {
+        const provideDefault = inject[key].default
+        result[key] = isFunction(provideDefault)
+          ? provideDefault.call(vm)
+          : provideDefault
+      } else if (__DEV__) {
+        warn(`Injection "${key as string}" not found`, vm)
       }
     }
     return result

src/core/instance/lifecycle.ts

@@ -49,6 +49,7 @@ export function initLifecycle(vm: Component) {
   vm.$children = []
   vm.$refs = {}
 
+  vm._provided = parent ? parent._provided : Object.create(null)
   vm._watcher = null
   vm._inactive = null
   vm._directInactive = false

src/v3/apiInject.ts

@@ -1,3 +1,66 @@
-export function provide() {}
+import { isFunction, warn } from 'core/util'
+import { currentInstance } from './currentInstance'
 
-export function inject() {}
+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.`)
+  }
+}

src/v3/index.ts

@@ -69,6 +69,8 @@ export {
 } from 'core/observer/dep'
 export { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 
+export { provide, inject, InjectionKey } from './apiInject'
+
 export { h } from './h'
 export { getCurrentInstance } from './currentInstance'
 export { useSlots, useAttrs } from './apiSetup'