@dcloudio/uni-quickapp-webview 2.0.0 → 2.0.1-32920211122002

package/dist/uni.mp.esm.js

@@ -1,4 +1,310 @@
-import { isArray, hasOwn, toNumber, isPlainObject, isObject, isFunction, extend, NOOP, camelize } from '@vue/shared';
+import { isPlainObject, hasOwn, isArray, extend, hyphenate, isObject, toNumber, isFunction, NOOP, camelize } from '@vue/shared';
+import { injectHook, ref } from 'vue';
+
+const encode = encodeURIComponent;
+function stringifyQuery(obj, encodeStr = encode) {
+    const res = obj
+        ? Object.keys(obj)
+            .map((key) => {
+            let val = obj[key];
+            if (typeof val === undefined || val === null) {
+                val = '';
+            }
+            else if (isPlainObject(val)) {
+                val = JSON.stringify(val);
+            }
+            return encodeStr(key) + '=' + encodeStr(val);
+        })
+            .filter((x) => x.length > 0)
+            .join('&')
+        : null;
+    return res ? `?${res}` : '';
+}
+
+function cache(fn) {
+    const cache = Object.create(null);
+    return (str) => {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+const invokeArrayFns = (fns, arg) => {
+    let ret;
+    for (let i = 0; i < fns.length; i++) {
+        ret = fns[i](arg);
+    }
+    return ret;
+};
+// lifecycle
+// App and Page
+const ON_SHOW = 'onShow';
+const ON_HIDE = 'onHide';
+//App
+const ON_LAUNCH = 'onLaunch';
+const ON_ERROR = 'onError';
+const ON_THEME_CHANGE = 'onThemeChange';
+const ON_PAGE_NOT_FOUND = 'onPageNotFound';
+const ON_UNHANDLE_REJECTION = 'onUnhandledRejection';
+//Page
+const ON_LOAD = 'onLoad';
+const ON_READY = 'onReady';
+const ON_UNLOAD = 'onUnload';
+const ON_RESIZE = 'onResize';
+const ON_TAB_ITEM_TAP = 'onTabItemTap';
+const ON_REACH_BOTTOM = 'onReachBottom';
+const ON_PULL_DOWN_REFRESH = 'onPullDownRefresh';
+const ON_ADD_TO_FAVORITES = 'onAddToFavorites';
+
+class EventChannel {
+    constructor(id, events) {
+        this.id = id;
+        this.listener = {};
+        this.emitCache = {};
+        if (events) {
+            Object.keys(events).forEach((name) => {
+                this.on(name, events[name]);
+            });
+        }
+    }
+    emit(eventName, ...args) {
+        const fns = this.listener[eventName];
+        if (!fns) {
+            return (this.emitCache[eventName] || (this.emitCache[eventName] = [])).push(args);
+        }
+        fns.forEach((opt) => {
+            opt.fn.apply(opt.fn, args);
+        });
+        this.listener[eventName] = fns.filter((opt) => opt.type !== 'once');
+    }
+    on(eventName, fn) {
+        this._addListener(eventName, 'on', fn);
+        this._clearCache(eventName);
+    }
+    once(eventName, fn) {
+        this._addListener(eventName, 'once', fn);
+        this._clearCache(eventName);
+    }
+    off(eventName, fn) {
+        const fns = this.listener[eventName];
+        if (!fns) {
+            return;
+        }
+        if (fn) {
+            for (let i = 0; i < fns.length;) {
+                if (fns[i].fn === fn) {
+                    fns.splice(i, 1);
+                    i--;
+                }
+                i++;
+            }
+        }
+        else {
+            delete this.listener[eventName];
+        }
+    }
+    _clearCache(eventName) {
+        const cacheArgs = this.emitCache[eventName];
+        if (cacheArgs) {
+            for (; cacheArgs.length > 0;) {
+                this.emit.apply(this, [eventName, ...cacheArgs.shift()]);
+            }
+        }
+    }
+    _addListener(eventName, type, fn) {
+        (this.listener[eventName] || (this.listener[eventName] = [])).push({
+            fn,
+            type,
+        });
+    }
+}
+
+const eventChannels = {};
+const eventChannelStack = [];
+function getEventChannel(id) {
+    if (id) {
+        const eventChannel = eventChannels[id];
+        delete eventChannels[id];
+        return eventChannel;
+    }
+    return eventChannelStack.shift();
+}
+
+function initBehavior(options) {
+    return Behavior(options);
+}
+function initVueIds(vueIds, mpInstance) {
+    if (!vueIds) {
+        return;
+    }
+    const ids = vueIds.split(',');
+    const len = ids.length;
+    if (len === 1) {
+        mpInstance._$vueId = ids[0];
+    }
+    else if (len === 2) {
+        mpInstance._$vueId = ids[0];
+        mpInstance._$vuePid = ids[1];
+    }
+}
+const EXTRAS = ['externalClasses'];
+function initExtraOptions(miniProgramComponentOptions, vueOptions) {
+    EXTRAS.forEach((name) => {
+        if (hasOwn(vueOptions, name)) {
+            miniProgramComponentOptions[name] = vueOptions[name];
+        }
+    });
+}
+function initWxsCallMethods(methods, wxsCallMethods) {
+    if (!isArray(wxsCallMethods)) {
+        return;
+    }
+    wxsCallMethods.forEach((callMethod) => {
+        methods[callMethod] = function (args) {
+            return this.$vm[callMethod](args);
+        };
+    });
+}
+function selectAllComponents(mpInstance, selector, $refs) {
+    const components = mpInstance.selectAllComponents(selector);
+    components.forEach((component) => {
+        const ref = component.dataset.ref;
+        $refs[ref] = component.$vm || component;
+    });
+}
+function initRefs(instance, mpInstance) {
+    Object.defineProperty(instance, 'refs', {
+        get() {
+            const $refs = {};
+            selectAllComponents(mpInstance, '.vue-ref', $refs);
+            const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for');
+            forComponents.forEach((component) => {
+                const ref = component.dataset.ref;
+                if (!$refs[ref]) {
+                    $refs[ref] = [];
+                }
+                $refs[ref].push(component.$vm || component);
+            });
+            return $refs;
+        },
+    });
+}
+function getTarget(obj, path) {
+    const parts = path.split('.');
+    let key = parts[0];
+    if (key.indexOf('__$n') === 0) {
+        //number index
+        key = parseInt(key.replace('__$n', ''));
+    }
+    if (!obj) {
+        obj = {};
+    }
+    if (parts.length === 1) {
+        return obj[key];
+    }
+    return getTarget(obj[key], parts.slice(1).join('.'));
+}
+
+function getValue(dataPath, target) {
+    return getTarget(target || this, dataPath);
+}
+function getClass(dynamicClass, staticClass) {
+    return renderClass(staticClass, dynamicClass);
+}
+function getStyle(dynamicStyle, staticStyle) {
+    if (!dynamicStyle && !staticStyle) {
+        return '';
+    }
+    var dynamicStyleObj = normalizeStyleBinding(dynamicStyle);
+    var styleObj = staticStyle
+        ? extend(staticStyle, dynamicStyleObj)
+        : dynamicStyleObj;
+    return Object.keys(styleObj)
+        .map(function (name) {
+        return hyphenate(name) + ':' + styleObj[name];
+    })
+        .join(';');
+}
+function toObject(arr) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
+    }
+    return res;
+}
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
+}
+var parseStyleText = cache(function parseStyleText(cssText) {
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            var tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
+});
+function isDef(v) {
+    return v !== undefined && v !== null;
+}
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    var res = '';
+    var stringified;
+    for (var i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res) {
+                res += ' ';
+            }
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    var res = '';
+    for (var key in value) {
+        if (value[key]) {
+            if (res) {
+                res += ' ';
+            }
+            res += key;
+        }
+    }
+    return res;
+}
 
 function setModel(target, key, value, modifiers) {
     if (isArray(modifiers)) {
@@ -50,7 +356,7 @@ const MP_METHODS = [
     'createSelectorQuery',
     'createIntersectionObserver',
     'selectAllComponents',
-    'selectComponent'
+    'selectComponent',
 ];
 function createEmitFn(oldEmit, ctx) {
     return function emit(event, ...args) {
@@ -77,18 +383,26 @@ function initBaseInstance(instance, options) {
     {
         instance.slots = {};
         if (isArray(options.slots) && options.slots.length) {
-            options.slots.forEach(name => {
+            options.slots.forEach((name) => {
                 instance.slots[name] = true;
             });
         }
     }
+    ctx.getOpenerEventChannel = function () {
+        if (!this.__eventChannel__) {
+            this.__eventChannel__ = new EventChannel();
+        }
+        return this.__eventChannel__;
+    };
+    ctx.$hasHook = hasHook;
+    ctx.$callHook = callHook;
     // $emit
     instance.emit = createEmitFn(instance.emit, ctx);
 }
 function initComponentInstance(instance, options) {
     initBaseInstance(instance, options);
     const ctx = instance.ctx;
-    MP_METHODS.forEach(method => {
+    MP_METHODS.forEach((method) => {
         ctx[method] = function (...args) {
             const mpInstance = ctx.$scope;
             if (mpInstance && mpInstance[method]) {
@@ -101,36 +415,58 @@ function initComponentInstance(instance, options) {
     ctx.__set_sync = setSync;
     ctx.__get_orig = getOrig;
     // TODO
-    // ctx.__get_style = getStyle
+    ctx.__get_value = getValue;
+    ctx.__get_class = getClass;
+    ctx.__get_style = getStyle;
     ctx.__map = map;
 }
 function initMocks(instance, mpInstance, mocks) {
     const ctx = instance.ctx;
-    mocks.forEach(mock => {
+    mocks.forEach((mock) => {
         if (hasOwn(mpInstance, mock)) {
             ctx[mock] = mpInstance[mock];
         }
     });
+}
+function hasHook(name) {
+    const hooks = this.$[name];
+    if (hooks && hooks.length) {
+        return true;
+    }
+    return false;
+}
+function callHook(name, args) {
+    if (name === 'mounted') {
+        callHook.call(this, 'bm'); // beforeMount
+        this.$.isMounted = true;
+        name = 'm';
+    }
+    else if (name === 'onLoad' && args && args.__id__) {
+        this.__eventChannel__ = getEventChannel(args.__id__);
+        delete args.__id__;
+    }
+    const hooks = this.$[name];
+    return hooks && invokeArrayFns(hooks, args);
 }
 
 const PAGE_HOOKS = [
-    'onLoad',
-    'onShow',
+    ON_LOAD,
+    ON_SHOW,
+    ON_HIDE,
+    ON_UNLOAD,
+    ON_RESIZE,
+    ON_TAB_ITEM_TAP,
+    ON_REACH_BOTTOM,
+    ON_PULL_DOWN_REFRESH,
+    ON_ADD_TO_FAVORITES,
     // 'onReady', // lifetimes.ready
-    'onHide',
-    'onUnload',
-    'onResize',
     // 'onPageScroll', // 影响性能，开发者手动注册
-    'onTabItemTap',
-    'onReachBottom',
-    'onPullDownRefresh',
     // 'onShareTimeline', // 右上角菜单，开发者手动注册
-    'onAddToFavorites'
     // 'onShareAppMessage' // 右上角菜单，开发者手动注册
 ];
 function findHooks(vueOptions, hooks = new Set()) {
     if (vueOptions) {
-        Object.keys(vueOptions).forEach(name => {
+        Object.keys(vueOptions).forEach((name) => {
             if (name.indexOf('on') === 0 && isFunction(vueOptions[name])) {
                 hooks.add(name);
             }
@@ -138,7 +474,7 @@ function findHooks(vueOptions, hooks = new Set()) {
         if (__VUE_OPTIONS_API__) {
             const { extends: extendsOptions, mixins } = vueOptions;
             if (mixins) {
-                mixins.forEach(mixin => findHooks(mixin, hooks));
+                mixins.forEach((mixin) => findHooks(mixin, hooks));
             }
             if (extendsOptions) {
                 findHooks(extendsOptions, hooks);
@@ -147,28 +483,35 @@ function findHooks(vueOptions, hooks = new Set()) {
     }
     return hooks;
 }
-function initHook(mpOptions, hook, excludes) {
+function initHook$1(mpOptions, hook, excludes) {
     if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) {
         mpOptions[hook] = function (args) {
             return this.$vm && this.$vm.$callHook(hook, args);
         };
     }
 }
-const EXCLUDE_HOOKS = ['onReady'];
+const EXCLUDE_HOOKS = [ON_READY];
 function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) {
-    hooks.forEach(hook => initHook(mpOptions, hook, excludes));
+    hooks.forEach((hook) => initHook$1(mpOptions, hook, excludes));
 }
 function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) {
-    findHooks(vueOptions).forEach(hook => initHook(mpOptions, hook, excludes));
+    findHooks(vueOptions).forEach((hook) => initHook$1(mpOptions, hook, excludes));
+}
+
+qa.appLaunchHooks = [];
+function injectAppLaunchHooks(appInstance) {
+    qa.appLaunchHooks.forEach((hook) => {
+        injectHook(ON_LAUNCH, hook, appInstance);
+    });
 }
 
 const HOOKS = [
-    'onShow',
-    'onHide',
-    'onError',
-    'onThemeChange',
-    'onPageNotFound',
-    'onUnhandledRejection'
+    ON_SHOW,
+    ON_HIDE,
+    ON_ERROR,
+    ON_THEME_CHANGE,
+    ON_PAGE_NOT_FOUND,
+    ON_UNHANDLE_REJECTION,
 ];
 function parseApp(instance, parseAppOptions) {
     const internalInstance = instance.$;
@@ -184,12 +527,14 @@ function parseApp(instance, parseAppOptions) {
             initBaseInstance(internalInstance, {
                 mpType: 'app',
                 mpInstance: this,
-                slots: []
+                slots: [],
             });
+            injectAppLaunchHooks(internalInstance);
             ctx.globalData = this.globalData;
-            instance.$callHook('onLaunch', options);
-        }
+            instance.$callHook(ON_LAUNCH, extend({ app: this }, options));
+        },
     };
+    initLocale(instance);
     const vueOptions = instance.$.type;
     initHooks(appOptions, HOOKS);
     initUnknownHooks(appOptions, vueOptions);
@@ -206,82 +551,16 @@ function initCreateApp(parseAppOptions) {
     return function createApp(vm) {
         return App(parseApp(vm, parseAppOptions));
     };
-}
-
-const encode = encodeURIComponent;
-function stringifyQuery(obj, encodeStr = encode) {
-    const res = obj
-        ? Object.keys(obj)
-            .map(key => {
-            let val = obj[key];
-            if (typeof val === undefined || val === null) {
-                val = '';
-            }
-            else if (isPlainObject(val)) {
-                val = JSON.stringify(val);
-            }
-            return encodeStr(key) + '=' + encodeStr(val);
-        })
-            .filter(x => x.length > 0)
-            .join('&')
-        : null;
-    return res ? `?${res}` : '';
-}
-
-function initBehavior(options) {
-    return Behavior(options);
-}
-function initVueIds(vueIds, mpInstance) {
-    if (!vueIds) {
-        return;
-    }
-    const ids = vueIds.split(',');
-    const len = ids.length;
-    if (len === 1) {
-        mpInstance._$vueId = ids[0];
-    }
-    else if (len === 2) {
-        mpInstance._$vueId = ids[0];
-        mpInstance._$vuePid = ids[1];
-    }
-}
-const EXTRAS = ['externalClasses'];
-function initExtraOptions(miniProgramComponentOptions, vueOptions) {
-    EXTRAS.forEach(name => {
-        if (hasOwn(vueOptions, name)) {
-            miniProgramComponentOptions[name] = vueOptions[name];
-        }
-    });
 }
-function initWxsCallMethods(methods, wxsCallMethods) {
-    if (!isArray(wxsCallMethods)) {
-        return;
-    }
-    wxsCallMethods.forEach((callMethod) => {
-        methods[callMethod] = function (args) {
-            return this.$vm[callMethod](args);
-        };
-    });
-}
-function initRefs(instance, mpInstance) {
-    Object.defineProperty(instance, 'refs', {
+function initLocale(appVm) {
+    const locale = ref(qa.getSystemInfoSync().language || 'zh-Hans');
+    Object.defineProperty(appVm, '$locale', {
         get() {
-            const $refs = {};
-            const components = mpInstance.selectAllComponents('.vue-ref');
-            components.forEach(component => {
-                const ref = component.dataset.ref;
-                $refs[ref] = component.$vm || component;
-            });
-            const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for');
-            forComponents.forEach(component => {
-                const ref = component.dataset.ref;
-                if (!$refs[ref]) {
-                    $refs[ref] = [];
-                }
-                $refs[ref].push(component.$vm || component);
-            });
-            return $refs;
-        }
+            return locale.value;
+        },
+        set(v) {
+            locale.value = v;
+        },
     });
 }
 
@@ -305,7 +584,7 @@ function initDefaultProps(isBehavior = false) {
     if (!isBehavior) {
         properties.vueId = {
             type: String,
-            value: ''
+            value: '',
         };
         // 小程序不能直接定义 $slots 的 props，所以通过 vueSlots 转换到 $slots
         properties.vueSlots = {
@@ -317,9 +596,9 @@ function initDefaultProps(isBehavior = false) {
                     $slots[slotName] = true;
                 });
                 this.setData({
-                    $slots
+                    $slots,
                 });
-            }
+            },
         };
     }
     return properties;
@@ -331,14 +610,14 @@ function createProperty(key, prop) {
 function initProps(mpComponentOptions, rawProps, isBehavior = false) {
     const properties = initDefaultProps(isBehavior);
     if (isArray(rawProps)) {
-        rawProps.forEach(key => {
+        rawProps.forEach((key) => {
             properties[key] = createProperty(key, {
-                type: null
+                type: null,
             });
         });
     }
     else if (isPlainObject(rawProps)) {
-        Object.keys(rawProps).forEach(key => {
+        Object.keys(rawProps).forEach((key) => {
             const opts = rawProps[key];
             if (isPlainObject(opts)) {
                 // title:{type:String,default:''}
@@ -350,14 +629,14 @@ function initProps(mpComponentOptions, rawProps, isBehavior = false) {
                 opts.type = parsePropType(key, type);
                 properties[key] = createProperty(key, {
                     type: PROP_TYPES.indexOf(type) !== -1 ? type : null,
-                    value
+                    value,
                 });
             }
             else {
                 // content:String
                 const type = parsePropType(key, opts);
                 properties[key] = createProperty(key, {
-                    type: PROP_TYPES.indexOf(type) !== -1 ? type : null
+                    type: PROP_TYPES.indexOf(type) !== -1 ? type : null,
                 });
             }
         });
@@ -369,8 +648,7 @@ function initData(vueOptions) {
     let data = vueOptions.data || {};
     if (typeof data === 'function') {
         try {
-            const appConfig = getApp().$vm.$.appContext
-                .config;
+            const appConfig = getApp().$vm.$.appContext.config;
             data = data.call(appConfig.globalProperties);
         }
         catch (e) {
@@ -401,7 +679,7 @@ function initBehaviors(vueOptions, initBehavior) {
     }
     const behaviors = [];
     if (isArray(vueBehaviors)) {
-        vueBehaviors.forEach(behavior => {
+        vueBehaviors.forEach((behavior) => {
             behaviors.push(behavior.replace('uni://', `${__PLATFORM_PREFIX__}://`));
             if (behavior === 'uni://form-field') {
                 if (isArray(vueProps)) {
@@ -411,24 +689,24 @@ function initBehaviors(vueOptions, initBehavior) {
                 else {
                     vueProps.name = {
                         type: String,
-                        default: ''
+                        default: '',
                     };
                     vueProps.value = {
                         type: [String, Number, Boolean, Array, Object, Date],
-                        default: ''
+                        default: '',
                     };
                 }
             }
         });
     }
-    if (isPlainObject(vueExtends) && vueExtends.props) {
+    if (vueExtends && vueExtends.props) {
         const behavior = {};
         initProps(behavior, vueExtends.props, true);
         behaviors.push(initBehavior(behavior));
     }
     if (isArray(vueMixins)) {
-        vueMixins.forEach(vueMixin => {
-            if (isPlainObject(vueMixin) && vueMixin.props) {
+        vueMixins.forEach((vueMixin) => {
+            if (vueMixin.props) {
                 const behavior = {};
                 initProps(behavior, vueMixin.props, true);
                 behaviors.push(initBehavior(behavior));
@@ -442,21 +720,9 @@ function applyOptions(componentOptions, vueOptions, initBehavior) {
     componentOptions.behaviors = initBehaviors(vueOptions, initBehavior);
 }
 
-function getValue(obj, path) {
-    const parts = path.split('.');
-    let key = parts[0];
-    if (key.indexOf('__$n') === 0) {
-        //number index
-        key = parseInt(key.replace('__$n', ''));
-    }
-    if (parts.length === 1) {
-        return obj[key];
-    }
-    return getValue(obj[key], parts.slice(1).join('.'));
-}
 function getExtraValue(instance, dataPathsArray) {
     let context = instance;
-    dataPathsArray.forEach(dataPathArray => {
+    dataPathsArray.forEach((dataPathArray) => {
         const dataPath = dataPathArray[0];
         const value = dataPathArray[2];
         if (dataPath || typeof value !== 'undefined') {
@@ -475,7 +741,7 @@ function getExtraValue(instance, dataPathsArray) {
                     vFor = dataPath.substr(3);
                 }
                 else {
-                    vFor = getValue(context, dataPath);
+                    vFor = getTarget(context, dataPath);
                 }
             }
             if (Number.isInteger(vFor)) {
@@ -486,13 +752,13 @@ function getExtraValue(instance, dataPathsArray) {
             }
             else {
                 if (isArray(vFor)) {
-                    context = vFor.find(vForItem => {
-                        return getValue(vForItem, propPath) === value;
+                    context = vFor.find((vForItem) => {
+                        return getTarget(vForItem, propPath) === value;
                     });
                 }
                 else if (isPlainObject(vFor)) {
-                    context = Object.keys(vFor).find(vForKey => {
-                        return getValue(vFor[vForKey], propPath) === value;
+                    context = Object.keys(vFor).find((vForKey) => {
+                        return getTarget(vFor[vForKey], propPath) === value;
                     });
                 }
                 else {
@@ -500,7 +766,7 @@ function getExtraValue(instance, dataPathsArray) {
                 }
             }
             if (valuePath) {
-                context = getValue(context, valuePath);
+                context = getTarget(context, valuePath);
             }
         }
     });
@@ -541,10 +807,10 @@ function processEventExtra(instance, extra, event) {
                     }
                     else if (dataPath.indexOf('$event.') === 0) {
                         // $event.target.value
-                        extraObj['$' + index] = getValue(event, dataPath.replace('$event.', ''));
+                        extraObj['$' + index] = getTarget(event, dataPath.replace('$event.', ''));
                     }
                     else {
-                        extraObj['$' + index] = getValue(instance, dataPath);
+                        extraObj['$' + index] = getTarget(instance, dataPath);
                     }
                 }
             }
@@ -581,7 +847,7 @@ function processEventArgs(instance, event, args = [], extra = [], isCustom, meth
     }
     const extraObj = processEventExtra(instance, extra, event);
     const ret = [];
-    args.forEach(arg => {
+    args.forEach((arg) => {
         if (arg === '$event') {
             if (methodName === '__set_model' && !isCustom) {
                 // input v-model value
@@ -623,7 +889,7 @@ function wrapper(event) {
         event.detail.markerId = event.markerId;
     }
     if (isPlainObject(event.detail)) {
-        event.target = Object.assign({}, event.target, event.detail);
+        event.target = extend({}, event.target, event.detail);
     }
     return event;
 }
@@ -681,7 +947,14 @@ function handleEvent(event) {
                         }
                         handler.once = true;
                     }
-                    ret.push(handler.apply(handlerCtx, processEventArgs(this.$vm, event, eventArray[1], eventArray[2], isCustom, methodName)));
+                    let params = processEventArgs(this.$vm, event, eventArray[1], eventArray[2], isCustom, methodName);
+                    params = Array.isArray(params) ? params : [];
+                    // 参数尾部增加原始事件对象用于复杂表达式内获取额外数据
+                    if (/=\s*\S+\.eventParams\s*\|\|\s*\S+\[['"]event-params['"]\]/.test(handler.toString())) {
+                        // eslint-disable-next-line no-sparse-arrays
+                        params = params.concat([, , , , , , , , , , event]);
+                    }
+                    ret.push(handler.apply(handlerCtx, params));
                 }
             });
         }
@@ -693,11 +966,11 @@ function handleEvent(event) {
     }
 }
 
-function parseComponent(vueOptions, { parse, mocks, isPage, initRelation, handleLink, initLifetimes }) {
+function parseComponent(vueOptions, { parse, mocks, isPage, initRelation, handleLink, initLifetimes, }) {
     vueOptions = vueOptions.default || vueOptions;
     const options = {
         multipleSlots: true,
-        addGlobalClass: true
+        addGlobalClass: true,
     };
     if (vueOptions.options) {
         extend(options, vueOptions.options);
@@ -714,12 +987,12 @@ function parseComponent(vueOptions, { parse, mocks, isPage, initRelation, handle
             },
             resize(size) {
                 this.$vm && this.$vm.$callHook('onPageResize', size);
-            }
+            },
         },
         methods: {
             __l: handleLink,
-            __e: handleEvent
-        }
+            __e: handleEvent,
+        },
     };
     if (__VUE_OPTIONS_API__) {
         applyOptions(mpComponentOptions, vueOptions, initBehavior);
@@ -759,15 +1032,15 @@ function parsePage(vueOptions, parseOptions) {
         isPage,
         initRelation,
         handleLink,
-        initLifetimes
+        initLifetimes,
     });
     const methods = miniProgramPageOptions.methods;
     methods.onLoad = function (query) {
         this.options = query;
         this.$page = {
-            fullPath: '/' + this.route + stringifyQuery(query)
+            fullPath: '/' + this.route + stringifyQuery(query),
         };
-        return this.$vm && this.$vm.$callHook('onLoad', query);
+        return this.$vm && this.$vm.$callHook(ON_LOAD, query);
     };
     initHooks(methods, PAGE_HOOKS);
     initUnknownHooks(methods, vueOptions);
@@ -792,7 +1065,7 @@ function initTriggerEvent(mpInstance) {
         return oldTriggerEvent.apply(mpInstance, [customize(event), ...args]);
     };
 }
-function initHook$1(name, options) {
+function initHook(name, options) {
     const oldHook = options[name];
     if (!oldHook) {
         options[name] = function () {
@@ -807,11 +1080,11 @@ function initHook$1(name, options) {
     }
 }
 Page = function (options) {
-    initHook$1('onLoad', options);
+    initHook(ON_LOAD, options);
     return MPPage(options);
 };
 Component = function (options) {
-    initHook$1('created', options);
+    initHook('created', options);
     return MPComponent(options);
 };
 
@@ -849,15 +1122,22 @@ function initProvide(instance) {
         provide(internalInstance, key, provides[key]);
     }
 }
-function inject(instance, key, defaultValue) {
+function inject(instance, key, defaultValue, treatDefaultAsFactory = false) {
     if (instance) {
-        const provides = instance.provides;
-        if (key in provides) {
+        // #2400
+        // to support `app.use` plugins,
+        // fallback to appContext's `provides` if the intance is at root
+        const provides = instance.parent == null
+            ? instance.vnode.appContext && instance.vnode.appContext.provides
+            : instance.parent.provides;
+        if (provides && key in provides) {
             // TS doesn't allow symbol as index type
             return provides[key];
         }
         else if (arguments.length > 1) {
-            return defaultValue;
+            return treatDefaultAsFactory && isFunction(defaultValue)
+                ? defaultValue()
+                : defaultValue;
         }
         else if ((process.env.NODE_ENV !== 'production')) {
             console.warn(`injection "${String(key)}" not found.`);
@@ -884,7 +1164,7 @@ function initInjections(instance) {
         for (const key in injectOptions) {
             const opt = injectOptions[key];
             if (isObject(opt)) {
-                ctx[key] = inject(internalInstance, opt.from, opt.default);
+                ctx[key] = inject(internalInstance, opt.from || key, opt.default, true /* treat default function as factory */);
             }
             else {
                 ctx[key] = inject(internalInstance, opt);
@@ -893,13 +1173,13 @@ function initInjections(instance) {
     }
 }
 
-function initLifetimes({ mocks, isPage, initRelation, vueOptions }) {
+function initLifetimes$1({ mocks, isPage, initRelation, vueOptions, }) {
     return {
         attached() {
             const properties = this.properties;
             initVueIds(properties.vueId, this);
             const relationOptions = {
-                vuePid: this._$vuePid
+                vuePid: this._$vuePid,
             };
             // 初始化 vue 实例
             const mpInstance = this;
@@ -909,7 +1189,7 @@ function initLifetimes({ mocks, isPage, initRelation, vueOptions }) {
             }
             this.$vm = $createComponent({
                 type: vueOptions,
-                props: properties
+                props: properties,
             }, {
                 mpType,
                 mpInstance,
@@ -919,14 +1199,14 @@ function initLifetimes({ mocks, isPage, initRelation, vueOptions }) {
                     initRefs(instance, mpInstance);
                     initMocks(instance, mpInstance, mocks);
                     initComponentInstance(instance, options);
-                }
+                },
             });
             // 处理父子关系
             initRelation(this, relationOptions);
         },
         detached() {
             this.$vm && $destroyComponent(this.$vm);
-        }
+        },
     };
 }
 
@@ -935,16 +1215,16 @@ function parse(componentOptions, { handleLink }) {
     componentOptions.methods.__l = handleLink;
 }
 
-function initLifetimes$1(lifetimesOptions) {
-    return extend(initLifetimes(lifetimesOptions), {
+function initLifetimes(lifetimesOptions) {
+    return extend(initLifetimes$1(lifetimesOptions), {
         ready() {
             if (this.$vm && lifetimesOptions.isPage(this)) {
-                if ( this.pageinstance) {
+                if (this.pageinstance) {
                     this.__webviewId__ = this.pageinstance.__pageId__;
                 }
-                this.$vm.$callSyncHook('created');
+                this.$vm.$callCreatedHook();
                 this.$vm.$callHook('mounted');
-                this.$vm.$callHook('onReady');
+                this.$vm.$callHook(ON_READY);
             }
             else {
                 this.is && console.warn(this.is + ' is not ready');
@@ -955,12 +1235,12 @@ function initLifetimes$1(lifetimesOptions) {
             // 清理
             const webviewId = this.__webviewId__;
             webviewId &&
-                Object.keys(instances).forEach(key => {
+                Object.keys(instances).forEach((key) => {
                     if (key.indexOf(webviewId + '_') === 0) {
                         delete instances[key];
                     }
                 });
-        }
+        },
     });
 }
 
@@ -976,10 +1256,10 @@ function initRelation(mpInstance) {
     instances[webviewId + '_' + nodeId] = mpInstance.$vm;
     mpInstance.triggerEvent('__l', {
         nodeId,
-        webviewId
+        webviewId,
     });
 }
-function handleLink({ detail: { nodeId, webviewId } }) {
+function handleLink({ detail: { nodeId, webviewId }, }) {
     const vm = instances[webviewId + '_' + nodeId];
     if (!vm) {
         return;
@@ -999,7 +1279,7 @@ function handleLink({ detail: { nodeId, webviewId } }) {
             initInjections(vm);
             initProvide(vm);
         }
-        vm.$callSyncHook('created');
+        vm.$callCreatedHook();
     };
     const mountedVm = function () {
         // 处理当前 vm 子
@@ -1009,7 +1289,7 @@ function handleLink({ detail: { nodeId, webviewId } }) {
             delete vm._$childVues;
         }
         vm.$callHook('mounted');
-        vm.$callHook('onReady');
+        vm.$callHook(ON_READY);
     };
     // 当 parentVm 已经 mounted 时，直接触发，否则延迟
     if (!parentVm || parentVm.$.isMounted) {
@@ -1019,33 +1299,37 @@ function handleLink({ detail: { nodeId, webviewId } }) {
     else {
         (parentVm._$childVues || (parentVm._$childVues = [])).push([
             createdVm,
-            mountedVm
+            mountedVm,
         ]);
     }
 }
 
 var parseComponentOptions = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  initRelation: initRelation,
-  handleLink: handleLink,
-  mocks: mocks,
-  isPage: isPage,
-  parse: parse,
-  initLifetimes: initLifetimes
+    __proto__: null,
+    initRelation: initRelation,
+    handleLink: handleLink,
+    mocks: mocks,
+    isPage: isPage,
+    parse: parse,
+    initLifetimes: initLifetimes$1
 });
 
 var parsePageOptions = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  mocks: mocks,
-  isPage: isPage,
-  initRelation: initRelation,
-  handleLink: handleLink,
-  parse: parse,
-  initLifetimes: initLifetimes$1
+    __proto__: null,
+    mocks: mocks,
+    isPage: isPage,
+    initRelation: initRelation,
+    handleLink: handleLink,
+    parse: parse,
+    initLifetimes: initLifetimes
 });
 
 const createApp = initCreateApp();
 const createPage = initCreatePage(parsePageOptions);
-const createComponent = initCreateComponent(parseComponentOptions);
+const createComponent = initCreateComponent(parseComponentOptions);
+qa.EventChannel = EventChannel;
+qa.createApp = createApp;
+qa.createPage = createPage;
+qa.createComponent = createComponent;
 
 export { createApp, createComponent, createPage };