@mpxjs/core 2.9.71 → 2.9.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpxjs/core",
-  "version": "2.9.71",
+  "version": "2.9.72",
   "description": "mpx runtime core",
   "keywords": [
     "miniprogram",
@@ -24,17 +24,16 @@
     "miniprogram-api-typings": "^3.10.0"
   },
   "peerDependencies": {
-    "@ant-design/react-native": "^5.1.3",
     "@d11/react-native-fast-image": "^8.6.12",
     "@mpxjs/api-proxy": "^2.9.0",
     "@mpxjs/store": "^2.9.0",
     "@react-navigation/native": "^7.0.3",
     "@react-navigation/stack": "^7.0.4",
-    "promise": "^8.3.0",
     "react": "*",
     "react-native": "*",
     "react-native-gesture-handler": "^2.19.0",
     "react-native-linear-gradient": "^2.8.3",
+    "react-native-reanimated": "^3.15.2",
     "react-native-safe-area-context": "^4.14.0",
     "react-native-screens": "^4.1.0",
     "react-native-webview": "^13.10.5",
@@ -62,7 +61,7 @@
     "react-native": {
       "optional": true
     },
-    "promise": {
+    "react-native-reanimated": {
       "optional": true
     },
     "@react-navigation/native": {
@@ -71,9 +70,6 @@
     "@react-navigation/stack": {
       "optional": true
     },
-    "@ant-design/react-native": {
-      "optional": true
-    },
     "react-native-safe-area-context": {
       "optional": true
     },
@@ -109,5 +105,5 @@
     "url": "https://github.com/didi/mpx/issues"
   },
   "sideEffects": false,
-  "gitHead": "38446f301a17e78dbe3ca7dacd771c79eb7a8ede"
+  "gitHead": "5ceca0430a79a41456260d87a81760f2cd31fad1"
 }

package/src/convertor/wxToReact.js

@@ -5,7 +5,7 @@ import {
 import { implemented } from '../core/implement'
 
 // 暂不支持的wx选项，后期需要各种花式支持
-const unsupported = ['relations', 'moved', 'definitionFilter']
+const unsupported = ['moved', 'definitionFilter']
 
 function convertErrorDesc (key) {
   error(`Options.${key} is not supported in runtime conversion from wx to react native.`, global.currentResource)

package/src/core/proxy.js

@@ -171,6 +171,8 @@ export default class MpxProxy {
       // web中BEFORECREATE钩子通过vue的beforeCreate钩子单独驱动
       this.callHook(BEFORECREATE)
       setCurrentInstance(this)
+      this.parent = this.resolveParent()
+      this.provides = this.parent ? this.parent.provides : Object.create(null)
       // 在 props/data 初始化之前初始化 inject
       this.initInject()
       this.initProps()
@@ -195,6 +197,18 @@ export default class MpxProxy {
     }
   }
 
+  resolveParent () {
+    if (isReact) {
+      return {
+        provides: this.target.__parentProvides
+      }
+    }
+    if (isFunction(this.target.selectOwnerComponent)) {
+      const parent = this.target.selectOwnerComponent()
+      return parent ? parent.__mpxProxy : null
+    }
+  }
+
   createRenderTask (isEmptyRender) {
     if ((!this.isMounted() && this.currentRenderTask) || (this.isMounted() && isEmptyRender)) {
       return
@@ -234,16 +248,6 @@ export default class MpxProxy {
       // 页面/组件销毁清除上下文的缓存
       contextMap.remove(this.uid)
     }
-    if (!isWeb && this.options.__type__ === 'page') {
-      // 小程序页面销毁时移除对应的 provide
-      if (isFunction(this.target.getPageId)) {
-        const pageId = this.target.getPageId()
-        const providesMap = global.__mpxProvidesMap
-        if (providesMap.__pages[pageId]) {
-          delete providesMap.__pages[pageId]
-        }
-      }
-    }
     this.callHook(BEFOREUNMOUNT)
     this.scope?.stop()
     if (this.update) this.update.active = false

package/src/platform/builtInMixins/index.js

@@ -22,7 +22,8 @@ export default function getBuiltInMixins ({ type, rawOptions = {} }) {
       directiveHelperMixin(),
       styleHelperMixin(),
       refsMixin(),
-      i18nMixin()
+      i18nMixin(),
+      relationsMixin(type)
     ]
   } else if (__mpx_mode__ === 'web') {
     bulitInMixins = [

package/src/platform/builtInMixins/relationsMixin.ios.js

@@ -0,0 +1,67 @@
+import { BEFORECREATE, MOUNTED, BEFOREUNMOUNT } from '../../core/innerLifecycle'
+
+const relationTypeMap = {
+  parent: 'child',
+  ancestor: 'descendant'
+}
+
+export default function relationsMixin (mixinType) {
+  if (mixinType === 'component') {
+    return {
+      [BEFORECREATE] () {
+        this.__relationNodesMap = {}
+      },
+      [MOUNTED] () {
+        this.__mpxExecRelations('linked')
+      },
+      [BEFOREUNMOUNT] () {
+        this.__mpxExecRelations('unlinked')
+        this.__relationNodesMap = {}
+      },
+      methods: {
+        getRelationNodes (path) {
+          return this.__relationNodesMap[path] || null
+        },
+        __mpxExecRelations (type) {
+          const relations = this.__mpxProxy.options.relations
+          const relationContext = this.__relation
+          const currentPath = this.__componentPath
+          if (relations && relationContext) {
+            Object.keys(relations).forEach((path) => {
+              const relation = relations[path]
+              const relationType = relation.type
+              if ((relationType === 'parent' || relationType === 'ancestor') && relationContext[path]) {
+                const target = relationContext[path]
+                const targetRelation = target.__mpxProxy.options.relations?.[currentPath]
+                if (targetRelation && targetRelation.type === relationTypeMap[relationType] && target.__componentPath === path) {
+                  if (type === 'linked') {
+                    this.__mpxLinkRelationNodes(target, currentPath)
+                  } else if (type === 'unlinked') {
+                    this.__mpxRemoveRelationNodes(target, currentPath)
+                  }
+                  if (typeof targetRelation[type] === 'function') {
+                    targetRelation[type].call(target, this)
+                  }
+                  if (typeof relation[type] === 'function') {
+                    relation[type].call(this, target)
+                  }
+                  this.__relationNodesMap[path] = [target]
+                }
+              }
+            })
+          }
+        },
+        __mpxLinkRelationNodes (target, path) {
+          target.__relationNodesMap[path] = target.__relationNodesMap[path] || [] // 父级绑定子级
+          target.__relationNodesMap[path].push(this)
+        },
+        __mpxRemoveRelationNodes (target, path) {
+          const relationNodesMap = target.__relationNodesMap
+          const arr = relationNodesMap[path] || []
+          const index = arr.indexOf(this)
+          if (index !== -1) arr.splice(index, 1)
+        }
+      }
+    }
+  }
+}

package/src/platform/createApp.ios.js

@@ -7,6 +7,7 @@ import Mpx from '../index'
 import { createElement, memo, useRef, useEffect } from 'react'
 import * as ReactNative from 'react-native'
 import { Image } from 'react-native'
+import { initAppProvides } from './export/inject'
 
 const appHooksMap = makeMap(mergeLifecycle(LIFECYCLE).app)
 
@@ -35,6 +36,7 @@ export default function createApp (options) {
   const { NavigationContainer, createStackNavigator, SafeAreaProvider } = global.__navigationHelper
   // app选项目前不需要进行转换
   const { rawOptions, currentInject } = transferOptions(options, 'app', false)
+  initAppProvides(rawOptions.provide, rawOptions)
   const defaultOptions = filterOptions(spreadProp(rawOptions, 'methods'), appData)
   // 在页面script执行前填充getApp()
   global.getApp = function () {

package/src/platform/env/index.ios.js

@@ -1,3 +1,4 @@
+import { isFunction, isNumber, isString } from '@mpxjs/utils'
 import { createI18n } from '../builtInMixins/i18nMixin'
 
 export function init (Mpx) {
@@ -30,21 +31,30 @@ function initGlobalErrorHandling () {
     })
   }
 
+  function onUnhandledRejection (event) {
+    if (global.__mpxAppCbs && global.__mpxAppCbs.rejection && global.__mpxAppCbs.rejection.length) {
+      global.__mpxAppCbs.rejection.forEach((cb) => {
+        cb(event)
+      })
+    } else {
+      console.warn(`UNHANDLED PROMISE REJECTION ${(isNumber(event.id) || isString(event.id)) ? '(id:' + event.id + ')' : ''}: ${event.reason}\n`)
+    }
+  }
   const rejectionTrackingOptions = {
     allRejections: true,
     onUnhandled (id, error) {
-      if (global.__mpxAppCbs && global.__mpxAppCbs.rejection && global.__mpxAppCbs.rejection.length) {
-        global.__mpxAppCbs.rejection.forEach((cb) => {
-          cb(error, id)
-        })
-      } else {
-        console.warn(`UNHANDLED PROMISE REJECTION (id: ${id}): ${error}\n`)
-      }
+      onUnhandledRejection({ id, reason: error, promise: null })
     }
   }
 
-  if (global?.HermesInternal?.hasPromise?.()) {
-    global.HermesInternal?.enablePromiseRejectionTracker?.(rejectionTrackingOptions)
+  // 支持 core-js promise polyfill
+  const oldOnUnhandledRejection = global.onunhandledrejection
+  global.onunhandledrejection = function onunhandledrejection (event) {
+    onUnhandledRejection(event)
+    isFunction(oldOnUnhandledRejection) && oldOnUnhandledRejection.call(this, event)
+  }
+  if (global.HermesInternal?.hasPromise?.()) {
+    global.HermesInternal.enablePromiseRejectionTracker?.(rejectionTrackingOptions)
   } else {
     require('promise/setimmediate/rejection-tracking').enable(rejectionTrackingOptions)
   }

package/src/platform/env/index.web.js

@@ -38,7 +38,7 @@ function initGlobalErrorHandling () {
     window.addEventListener('unhandledrejection', (event) => {
       if (global.__mpxAppCbs && global.__mpxAppCbs.rejection && global.__mpxAppCbs.rejection.length) {
         global.__mpxAppCbs.rejection.forEach((cb) => {
-          cb(event.reason, event.promise)
+          cb(event)
         })
       } else {
         console.warn(`UNHANDLED PROMISE REJECTION: ${event.reason}\n`)

package/src/platform/export/inject.js

@@ -1,14 +1,8 @@
 import { callWithErrorHandling, isFunction, isObject, warn } from '@mpxjs/utils'
 import { currentInstance } from '../../core/proxy'
 
-const providesMap = {
-  /** 全局 scope */
-  __app: Object.create(null),
-  /** 页面 scope */
-  __pages: Object.create(null)
-}
-
-global.__mpxProvidesMap = providesMap
+/** 全局 scope */
+let appProvides = Object.create(null)
 
 /** @internal createApp() 初始化应用层 scope provide */
 export function initAppProvides (provideOpt, instance) {
@@ -17,22 +11,20 @@ export function initAppProvides (provideOpt, instance) {
       ? callWithErrorHandling(provideOpt.bind(instance), instance, 'createApp provide function')
       : provideOpt
     if (isObject(provided)) {
-      providesMap.__app = provided
+      appProvides = provided
     } else {
       warn('App provides must be an object or a function that returns an object.')
     }
   }
 }
 
-function resolvePageId (context) {
-  if (context && isFunction(context.getPageId)) {
-    return context.getPageId()
+function resolveProvides (vm) {
+  const provides = vm.provides
+  const parentProvides = vm.parent && vm.parent.provides
+  if (parentProvides === provides) {
+    return (vm.provides = Object.create(parentProvides))
   }
-}
-
-function resolvePageProvides (context) {
-  const pageId = resolvePageId(context)
-  return providesMap.__pages[pageId] || (providesMap.__pages[pageId] = Object.create(null))
+  return provides
 }
 
 export function provide (key, value) {
@@ -41,8 +33,7 @@ export function provide (key, value) {
     warn('provide() can only be used inside setup().')
     return
   }
-  // 小程序无法实现组件父级引用，所以 provide scope 设置为组件所在页面
-  const provides = resolvePageProvides(instance.target)
+  const provides = resolveProvides(instance)
   provides[key] = value
 }
 
@@ -52,11 +43,11 @@ export function inject (key, defaultValue, treatDefaultAsFactory = false) {
     warn('inject() can only be used inside setup()')
     return
   }
-  const provides = resolvePageProvides(instance.target)
-  if (key in provides) {
+  const provides = instance.parent && instance.parent.provides
+  if (provides && key in provides) {
     return provides[key]
-  } else if (key in providesMap.__app) {
-    return providesMap.__app[key]
+  } else if (key in appProvides) {
+    return appProvides[key]
   } else if (arguments.length > 1) {
     return treatDefaultAsFactory && isFunction(defaultValue)
       ? defaultValue.call(instance && instance.target)

package/src/platform/patch/getDefaultOptions.ios.js

@@ -1,4 +1,4 @@
-import { useEffect, useLayoutEffect, useSyncExternalStore, useRef, useMemo, useState, useCallback, createElement, memo, forwardRef, useImperativeHandle, useContext, Fragment, cloneElement } from 'react'
+import { useEffect, useLayoutEffect, useSyncExternalStore, useRef, useMemo, useState, useCallback, createElement, memo, forwardRef, useImperativeHandle, useContext, Fragment, cloneElement, createContext } from 'react'
 import * as ReactNative from 'react-native'
 import { ReactiveEffect } from '../../observer/effect'
 import { watch } from '../../observer/watch'
@@ -11,6 +11,8 @@ import { queueJob, hasPendingJob } from '../../observer/scheduler'
 import { createSelectorQuery, createIntersectionObserver } from '@mpxjs/api-proxy'
 import { IntersectionObserverContext, RouteContext, KeyboardAvoidContext } from '@mpxjs/webpack-plugin/lib/runtime/components/react/dist/context'
 
+const ProviderContext = createContext(null)
+
 function getSystemInfo () {
   const window = ReactNative.Dimensions.get('window')
   const screen = ReactNative.Dimensions.get('screen')
@@ -193,7 +195,7 @@ const instanceProto = {
   }
 }
 
-function createInstance ({ propsRef, type, rawOptions, currentInject, validProps, components, pageId, intersectionCtx }) {
+function createInstance ({ propsRef, type, rawOptions, currentInject, validProps, components, pageId, intersectionCtx, relation, parentProvides }) {
   const instance = Object.create(instanceProto, {
     dataset: {
       get () {
@@ -244,9 +246,33 @@ function createInstance ({ propsRef, type, rawOptions, currentInject, validProps
         return currentInject.getRefsData || noop
       },
       enumerable: false
+    },
+    __parentProvides: {
+      get () {
+        return parentProvides || null
+      },
+      enumerable: false
     }
   })
 
+  if (type === 'component') {
+    Object.defineProperty(instance, '__componentPath', {
+      get () {
+        return currentInject.componentPath || ''
+      },
+      enumerable: false
+    })
+  }
+
+  if (relation) {
+    Object.defineProperty(instance, '__relation', {
+      get () {
+        return relation
+      },
+      enumerable: false
+    })
+  }
+
   // bind this & assign methods
   if (rawOptions.methods) {
     Object.entries(rawOptions.methods).forEach(([key, method]) => {
@@ -374,21 +400,59 @@ function usePageStatus (navigation, pageId) {
   }, [navigation])
 }
 
+const RelationsContext = createContext(null)
+
+const checkRelation = (options) => {
+  const relations = options.relations || {}
+  let hasDescendantRelation = false
+  let hasAncestorRelation = false
+  Object.keys(relations).forEach((path) => {
+    const relation = relations[path]
+    const type = relation.type
+    if (['child', 'descendant'].includes(type)) {
+      hasDescendantRelation = true
+    } else if (['parent', 'ancestor'].includes(type)) {
+      hasAncestorRelation = true
+    }
+  })
+  return {
+    hasDescendantRelation,
+    hasAncestorRelation
+  }
+}
+
+const provideRelation = (instance, relation) => {
+  const componentPath = instance.__componentPath
+  if (relation) {
+    return Object.assign({}, relation, { [componentPath]: instance })
+  } else {
+    return {
+      [componentPath]: instance
+    }
+  }
+}
+
 export function getDefaultOptions ({ type, rawOptions = {}, currentInject }) {
   rawOptions = mergeOptions(rawOptions, type, false)
   const components = Object.assign({}, rawOptions.components, currentInject.getComponents())
   const validProps = Object.assign({}, rawOptions.props, rawOptions.properties)
+  const { hasDescendantRelation, hasAncestorRelation } = checkRelation(rawOptions)
   if (rawOptions.methods) rawOptions.methods = wrapMethodsWithErrorHandling(rawOptions.methods)
   const defaultOptions = memo(forwardRef((props, ref) => {
     const instanceRef = useRef(null)
     const propsRef = useRef(null)
     const intersectionCtx = useContext(IntersectionObserverContext)
     const pageId = useContext(RouteContext)
+    const parentProvides = useContext(ProviderContext)
+    let relation = null
+    if (hasDescendantRelation || hasAncestorRelation) {
+      relation = useContext(RelationsContext)
+    }
     propsRef.current = props
     let isFirst = false
     if (!instanceRef.current) {
       isFirst = true
-      instanceRef.current = createInstance({ propsRef, type, rawOptions, currentInject, validProps, components, pageId, intersectionCtx })
+      instanceRef.current = createInstance({ propsRef, type, rawOptions, currentInject, validProps, components, pageId, intersectionCtx, relation, parentProvides })
     }
     const instance = instanceRef.current
     useImperativeHandle(ref, () => {
@@ -473,15 +537,28 @@ export function getDefaultOptions ({ type, rawOptions = {}, currentInject }) {
       return proxy.finalMemoVersion
     }, [proxy.stateVersion, proxy.memoVersion])
 
-    const root = useMemo(() => proxy.effect.run(), [finalMemoVersion])
+    let root = useMemo(() => proxy.effect.run(), [finalMemoVersion])
     if (root && root.props.ishost) {
       // 对于组件未注册的属性继承到host节点上，如事件、样式和其他属性等
       const rootProps = getRootProps(props, validProps)
       rootProps.style = Object.assign({}, root.props.style, rootProps.style)
       // update root props
-      return cloneElement(root, rootProps)
+      root = cloneElement(root, rootProps)
+    }
+
+    const provides = proxy.provides
+    if (provides) {
+      root = createElement(ProviderContext.Provider, { value: provides }, root)
     }
-    return root
+
+    return hasDescendantRelation
+      ? createElement(RelationsContext.Provider,
+          {
+            value: provideRelation(instance, relation)
+          },
+          root
+        )
+      : root
   }))
 
   if (rawOptions.options?.isCustomText) {