Merge branch 'dev' of https://github.com/dcloudio/uni-app into alpha

docs/api/request/request.md

@@ -42,6 +42,7 @@
 |data|Object/String/ArrayBuffer|开发者服务器返回的数据|
 |statusCode|Number|开发者服务器返回的 HTTP 状态码|
 |header|Object|开发者服务器返回的 HTTP Response Header|
+|cookies|``Array.<string>``|开发者服务器返回的 cookies，格式为字符串数组|
 
 **data 数据说明**
 

lib/apis.js

@@ -110,6 +110,8 @@ const device = [
   'getBLEDeviceCharacteristics',
   'createBLEConnection',
   'closeBLEConnection',
+  'setBLEMTU',
+  'getBLEDeviceRSSI',
   'onBeaconServiceChange',
   'onBeaconUpdate',
   'getBeacons',

lib/modules.json

@@ -114,6 +114,8 @@
     "uni.getBLEDeviceCharacteristics": true,
     "uni.createBLEConnection": true,
     "uni.closeBLEConnection": true,
+    "uni.setBLEMTU": true,
+    "uni.getBLEDeviceRSSI": true,
     "uni.onBeaconServiceChange": true,
     "uni.onBeaconUpdate": true,
     "uni.getBeacons": true,

packages/uni-mp-alipay/lib/uni.compiler.js

@@ -126,7 +126,7 @@ module.exports = {
           Identifier (path) {
             const node = path.node
             const name = node.name
-            if (names.includes(name) && path.key !== 'key' && path.key !== 'property' && !(path.scope && path.scope.hasBinding(name))) {
+            if (names.includes(name) && path.key !== 'key' && (path.key !== 'property' || path.parent.computed) && !(path.scope && path.scope.hasBinding(name))) {
               path.replaceWithSourceString(`${paramName}.${name}`)
             }
           }

packages/uni-mp-baidu/dist/uni.api.esm.js

+import { isArray, isPromise, isFunction, isPlainObject, hasOwn, isString } from '@vue/shared';
+
+const EPS = 1e-4;
+const BASE_DEVICE_WIDTH = 750;
+let isIOS = false;
+let deviceWidth = 0;
+let deviceDPR = 0;
+function checkDeviceWidth() {
+    const { platform, pixelRatio, windowWidth } = swan.getSystemInfoSync();
+    deviceWidth = windowWidth;
+    deviceDPR = pixelRatio;
+    isIOS = platform === 'ios';
+}
+function upx2px(number, newDeviceWidth) {
+    if (deviceWidth === 0) {
+        checkDeviceWidth();
+    }
+    number = Number(number);
+    if (number === 0) {
+        return 0;
+    }
+    let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth);
+    if (result < 0) {
+        result = -result;
+    }
+    result = Math.floor(result + EPS);
+    if (result === 0) {
+        if (deviceDPR === 1 || !isIOS) {
+            result = 1;
+        }
+        else {
+            result = 0.5;
+        }
+    }
+    return number < 0 ? -result : result;
+}
+
+var HOOKS;
+(function (HOOKS) {
+    HOOKS["INVOKE"] = "invoke";
+    HOOKS["SUCCESS"] = "success";
+    HOOKS["FAIL"] = "fail";
+    HOOKS["COMPLETE"] = "complete";
+    HOOKS["RETURN_VALUE"] = "returnValue";
+})(HOOKS || (HOOKS = {}));
+const globalInterceptors = {};
+const scopedInterceptors = {};
+function wrapperHook(hook) {
+    return function (data) {
+        return hook(data) || data;
+    };
+}
+function queue(hooks, data) {
+    let promise = false;
+    for (let i = 0; i < hooks.length; i++) {
+        const hook = hooks[i];
+        if (promise) {
+            promise = Promise.resolve(wrapperHook(hook));
+        }
+        else {
+            const res = hook(data);
+            if (isPromise(res)) {
+                promise = Promise.resolve(res);
+            }
+            if (res === false) {
+                return {
+                    then() { },
+                    catch() { }
+                };
+            }
+        }
+    }
+    return (promise || {
+        then(callback) {
+            return callback(data);
+        },
+        catch() { }
+    });
+}
+function wrapperOptions(interceptors, options = {}) {
+    [HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => {
+        const hooks = interceptors[name];
+        if (!isArray(hooks)) {
+            return;
+        }
+        const oldCallback = options[name];
+        options[name] = function callbackInterceptor(res) {
+            queue(hooks, res).then((res) => {
+                return (isFunction(oldCallback) && oldCallback(res)) || res;
+            });
+        };
+    });
+    return options;
+}
+function wrapperReturnValue(method, returnValue) {
+    const returnValueHooks = [];
+    if (isArray(globalInterceptors.returnValue)) {
+        returnValueHooks.push(...globalInterceptors.returnValue);
+    }
+    const interceptor = scopedInterceptors[method];
+    if (interceptor && isArray(interceptor.returnValue)) {
+        returnValueHooks.push(...interceptor.returnValue);
+    }
+    returnValueHooks.forEach(hook => {
+        returnValue = hook(returnValue) || returnValue;
+    });
+    return returnValue;
+}
+function getApiInterceptorHooks(method) {
+    const interceptor = Object.create(null);
+    Object.keys(globalInterceptors).forEach(hook => {
+        if (hook !== 'returnValue') {
+            interceptor[hook] = globalInterceptors[hook].slice();
+        }
+    });
+    const scopedInterceptor = scopedInterceptors[method];
+    if (scopedInterceptor) {
+        Object.keys(scopedInterceptor).forEach(hook => {
+            if (hook !== 'returnValue') {
+                interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]);
+            }
+        });
+    }
+    return interceptor;
+}
+function invokeApi(method, api, options, ...params) {
+    const interceptor = getApiInterceptorHooks(method);
+    if (interceptor && Object.keys(interceptor).length) {
+        if (isArray(interceptor.invoke)) {
+            const res = queue(interceptor.invoke, options);
+            return res.then(options => {
+                return api(wrapperOptions(interceptor, options), ...params);
+            });
+        }
+        else {
+            return api(wrapperOptions(interceptor, options), ...params);
+        }
+    }
+    return api(options, ...params);
+}
+
+function mergeInterceptorHook(interceptors, interceptor) {
+    Object.keys(interceptor).forEach(hook => {
+        if (isFunction(interceptor[hook])) {
+            interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]);
+        }
+    });
+}
+function removeInterceptorHook(interceptors, interceptor) {
+    if (!interceptors || !interceptor) {
+        return;
+    }
+    Object.keys(interceptor).forEach(hook => {
+        if (isFunction(interceptor[hook])) {
+            removeHook(interceptors[hook], interceptor[hook]);
+        }
+    });
+}
+function mergeHook(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+function removeHook(hooks, hook) {
+    if (!hooks) {
+        return;
+    }
+    const index = hooks.indexOf(hook);
+    if (index !== -1) {
+        hooks.splice(index, 1);
+    }
+}
+function addInterceptor(method, interceptor) {
+    if (typeof method === 'string' && isPlainObject(interceptor)) {
+        mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor);
+    }
+    else if (isPlainObject(method)) {
+        mergeInterceptorHook(globalInterceptors, method);
+    }
+}
+function removeInterceptor(method, interceptor) {
+    if (typeof method === 'string') {
+        if (isPlainObject(interceptor)) {
+            removeInterceptorHook(scopedInterceptors[method], interceptor);
+        }
+        else {
+            delete scopedInterceptors[method];
+        }
+    }
+    else if (isPlainObject(method)) {
+        removeInterceptorHook(globalInterceptors, method);
+    }
+}
+
+const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/;
+const CONTEXT_API_RE = /^create|Manager$/;
+// Context例外情况
+const CONTEXT_API_RE_EXC = ['createBLEConnection'];
+// 同步例外情况
+const ASYNC_API = ['createBLEConnection'];
+const CALLBACK_API_RE = /^on|^off/;
+function isContextApi(name) {
+    return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1;
+}
+function isSyncApi(name) {
+    return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1;
+}
+function isCallbackApi(name) {
+    return CALLBACK_API_RE.test(name) && name !== 'onPush';
+}
+function handlePromise(promise) {
+    if (!__UNI_PROMISE_API__) {
+        return promise;
+    }
+    return promise
+        .then(data => {
+        return [null, data];
+    })
+        .catch(err => [err]);
+}
+function shouldPromise(name) {
+    if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) {
+        return false;
+    }
+    return true;
+}
+/* eslint-disable no-extend-native */
+if (!Promise.prototype.finally) {
+    Promise.prototype.finally = function (onfinally) {
+        const promise = this.constructor;
+        return this.then(value => promise.resolve(onfinally && onfinally()).then(() => value), reason => promise.resolve(onfinally && onfinally()).then(() => {
+            throw reason;
+        }));
+    };
+}
+function promisify(name, api) {
+    if (!shouldPromise(name)) {
+        return api;
+    }
+    if (!isFunction(api)) {
+        return api;
+    }
+    return function promiseApi(options = {}, ...params) {
+        if (isFunction(options.success) ||
+            isFunction(options.fail) ||
+            isFunction(options.complete)) {
+            return wrapperReturnValue(name, invokeApi(name, api, options, ...params));
+        }
+        return wrapperReturnValue(name, handlePromise(new Promise((resolve, reject) => {
+            invokeApi(name, api, Object.assign({}, options, {
+                success: resolve,
+                fail: reject
+            }), ...params);
+        })));
+    };
+}
+
+const CALLBACKS = ['success', 'fail', 'cancel', 'complete'];
+function initWrapper(protocols) {
+    function processCallback(methodName, method, returnValue) {
+        return function (res) {
+            return method(processReturnValue(methodName, res, returnValue));
+        };
+    }
+    function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) {
+        if (isPlainObject(fromArgs)) {
+            // 一般 api 的参数解析
+            const toArgs = (keepFromArgs === true ? fromArgs : {}); // returnValue 为 false 时，说明是格式化返回值，直接在返回值对象上修改赋值
+            if (isFunction(argsOption)) {
+                argsOption = argsOption(fromArgs, toArgs) || {};
+            }
+            for (const key in fromArgs) {
+                if (hasOwn(argsOption, key)) {
+                    let keyOption = argsOption[key];
+                    if (isFunction(keyOption)) {
+                        keyOption = keyOption(fromArgs[key], fromArgs, toArgs);
+                    }
+                    if (!keyOption) {
+                        // 不支持的参数
+                        console.warn(`百度小程序 ${methodName} 暂不支持 ${key}`);
+                    }
+                    else if (isString(keyOption)) {
+                        // 重写参数 key
+                        toArgs[keyOption] = fromArgs[key];
+                    }
+                    else if (isPlainObject(keyOption)) {
+                        // {name:newName,value:value}可重新指定参数 key:value
+                        toArgs[keyOption.name ? keyOption.name : key] = keyOption.value;
+                    }
+                }
+                else if (CALLBACKS.indexOf(key) !== -1) {
+                    const callback = fromArgs[key];
+                    if (isFunction(callback)) {
+                        toArgs[key] = processCallback(methodName, callback, returnValue);
+                    }
+                }
+                else {
+                    if (!keepFromArgs && !hasOwn(toArgs, key)) {
+                        toArgs[key] = fromArgs[key];
+                    }
+                }
+            }
+            return toArgs;
+        }
+        else if (isFunction(fromArgs)) {
+            fromArgs = processCallback(methodName, fromArgs, returnValue);
+        }
+        return fromArgs;
+    }
+    function processReturnValue(methodName, res, returnValue, keepReturnValue = false) {
+        if (isFunction(protocols.returnValue)) {
+            // 处理通用 returnValue
+            res = protocols.returnValue(methodName, res);
+        }
+        return processArgs(methodName, res, returnValue, {}, keepReturnValue);
+    }
+    return function wrapper(methodName, method) {
+        if (!hasOwn(protocols, methodName)) {
+            return method;
+        }
+        const protocol = protocols[methodName];
+        if (!protocol) {
+            // 暂不支持的 api
+            return function () {
+                console.error(`百度小程序 暂不支持${methodName}`);
+            };
+        }
+        return function (arg1, arg2) {
+            // 目前 api 最多两个参数
+            let options = protocol;
+            if (isFunction(protocol)) {
+                options = protocol(arg1);
+            }
+            arg1 = processArgs(methodName, arg1, options.args, options.returnValue);
+            const args = [arg1];
+            if (typeof arg2 !== 'undefined') {
+                args.push(arg2);
+            }
+            const returnValue = swan[options.name || methodName].apply(swan, args);
+            if (isSyncApi(methodName)) {
+                // 同步 api
+                return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName));
+            }
+            return returnValue;
+        };
+    };
+}
+
+const baseApis = { upx2px, addInterceptor, removeInterceptor };
+function initUni(api, protocols) {
+    const wrapper = initWrapper(protocols);
+    const UniProxyHandlers = {
+        get(target, key) {
+            if (hasOwn(target, key)) {
+                return target[key];
+            }
+            if (hasOwn(api, key)) {
+                return promisify(key, api[key]);
+            }
+            if (hasOwn(baseApis, key)) {
+                return promisify(key, baseApis[key]);
+            }
+            // event-api
+            // provider-api?
+            return promisify(key, wrapper(key, swan[key]));
+        }
+    };
+    return new Proxy({}, UniProxyHandlers);
+}
+
+function initGetProvider(providers) {
+    return function getProvider({ service, success, fail, complete }) {
+        let res;
+        if (providers[service]) {
+            res = {
+                errMsg: 'getProvider:ok',
+                service,
+                provider: providers[service]
+            };
+            isFunction(success) && success(res);
+        }
+        else {
+            res = {
+                errMsg: 'getProvider:fail:服务[' + service + ']不存在'
+            };
+            isFunction(fail) && fail(res);
+        }
+        isFunction(complete) && complete(res);
+    };
+}
+
+const previewImage = {
+    args(fromArgs, toArgs) {
+        let currentIndex = parseInt(fromArgs.current);
+        if (isNaN(currentIndex)) {
+            return;
+        }
+        const urls = fromArgs.urls;
+        if (!isArray(urls)) {
+            return;
+        }
+        const len = urls.length;
+        if (!len) {
+            return;
+        }
+        if (currentIndex < 0) {
+            currentIndex = 0;
+        }
+        else if (currentIndex >= len) {
+            currentIndex = len - 1;
+        }
+        if (currentIndex > 0) {
+            toArgs.current = urls[currentIndex];
+            toArgs.urls = urls.filter((item, index) => index < currentIndex ? item !== urls[currentIndex] : true);
+        }
+        else {
+            toArgs.current = urls[0];
+        }
+        return {
+            indicator: false,
+            loop: false
+        };
+    }
+};
+function addSafeAreaInsets(fromRes, toRes) {
+    if (fromRes.safeArea) {
+        const safeArea = fromRes.safeArea;
+        toRes.safeAreaInsets = {
+            top: safeArea.top,
+            left: safeArea.left,
+            right: fromRes.windowWidth - safeArea.right,
+            bottom: fromRes.windowHeight - safeArea.bottom
+        };
+    }
+}
+const getSystemInfo = {
+    returnValue: addSafeAreaInsets
+};
+const getSystemInfoSync = getSystemInfo;
+
+const getProvider = initGetProvider({
+    oauth: ['baidu'],
+    share: ['baidu'],
+    payment: ['baidu'],
+    push: ['baidu']
+});
+function requestPayment(params) {
+    let parseError = false;
+    if (typeof params.orderInfo === 'string') {
+        try {
+            params.orderInfo = JSON.parse(params.orderInfo);
+        }
+        catch (e) {
+            parseError = true;
+        }
+    }
+    if (parseError) {
+        params.fail &&
+            params.fail({
+                errMsg: 'requestPayment:fail: 参数 orderInfo 数据结构不正确，参考：https://uniapp.dcloud.io/api/plugins/payment?id=orderinfo'
+            });
+    }
+    else {
+        swan.requestPolymerPayment(params);
+    }
+}
+
+var shims = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getProvider: getProvider,
+  requestPayment: requestPayment
+});
+
+function createTodoMethod(contextName, methodName) {
+    return function unsupported() {
+        console.error(`百度小程序 ${contextName}暂不支持${methodName}`);
+    };
+}
+const request = {
+    args() {
+        // TODO
+        // data 不支持 ArrayBuffer
+        // method 不支持 TRACE, CONNECT
+        return {
+            method: 'method',
+            dataType(type) {
+                return {
+                    name: 'dataType',
+                    value: type === 'json' ? type : 'string'
+                };
+            }
+        };
+    }
+};
+const connectSocket = {
+    args: {
+        method: false
+    }
+};
+const getRecorderManager = {
+    returnValue(fromRes, toRes) {
+        toRes.onFrameRecorded = createTodoMethod('RecorderManager', 'onFrameRecorded');
+    }
+};
+const getBackgroundAudioManager = {
+    returnValue(fromRes, toRes) {
+        toRes.onPrev = createTodoMethod('BackgroundAudioManager', 'onPrev');
+        toRes.onNext = createTodoMethod('BackgroundAudioManager', 'onNext');
+    }
+};
+const scanCode = {
+    args: {
+        onlyFromCamera: false,
+        scanType: false
+    }
+};
+const navigateToMiniProgram = {
+    name: 'navigateToSmartProgram',
+    args: {
+        appId: 'appKey',
+        envVersion: false
+    }
+};
+const navigateBackMiniProgram = {
+    name: 'navigateBackSmartProgram'
+};
+const showShareMenu = {
+    name: 'openShare'
+};
+const getAccountInfoSync = {
+    name: 'getEnvInfoSync',
+    returnValue(fromRes, toRes) {
+        toRes.miniProgram = {
+            appId: fromRes.appKey
+        };
+        toRes.plugin = {
+            appId: '',
+            version: fromRes.sdkVersion
+        };
+    }
+};
+
+var protocols = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  request: request,
+  connectSocket: connectSocket,
+  getRecorderManager: getRecorderManager,
+  getBackgroundAudioManager: getBackgroundAudioManager,
+  scanCode: scanCode,
+  navigateToMiniProgram: navigateToMiniProgram,
+  navigateBackMiniProgram: navigateBackMiniProgram,
+  showShareMenu: showShareMenu,
+  getAccountInfoSync: getAccountInfoSync,
+  previewImage: previewImage,
+  getSystemInfo: getSystemInfo,
+  getSystemInfoSync: getSystemInfoSync
+});
+
+var index = initUni(shims, protocols);
+
+export default index;

packages/uni-mp-qq/dist/uni.api.esm.js

+import { isArray, isPromise, isFunction, isPlainObject, hasOwn, isString } from '@vue/shared';
+
+const EPS = 1e-4;
+const BASE_DEVICE_WIDTH = 750;
+let isIOS = false;
+let deviceWidth = 0;
+let deviceDPR = 0;
+function checkDeviceWidth() {
+    const { platform, pixelRatio, windowWidth } = qq.getSystemInfoSync();
+    deviceWidth = windowWidth;
+    deviceDPR = pixelRatio;
+    isIOS = platform === 'ios';
+}
+function upx2px(number, newDeviceWidth) {
+    if (deviceWidth === 0) {
+        checkDeviceWidth();
+    }
+    number = Number(number);
+    if (number === 0) {
+        return 0;
+    }
+    let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth);
+    if (result < 0) {
+        result = -result;
+    }
+    result = Math.floor(result + EPS);
+    if (result === 0) {
+        if (deviceDPR === 1 || !isIOS) {
+            result = 1;
+        }
+        else {
+            result = 0.5;
+        }
+    }
+    return number < 0 ? -result : result;
+}
+
+var HOOKS;
+(function (HOOKS) {
+    HOOKS["INVOKE"] = "invoke";
+    HOOKS["SUCCESS"] = "success";
+    HOOKS["FAIL"] = "fail";
+    HOOKS["COMPLETE"] = "complete";
+    HOOKS["RETURN_VALUE"] = "returnValue";
+})(HOOKS || (HOOKS = {}));
+const globalInterceptors = {};
+const scopedInterceptors = {};
+function wrapperHook(hook) {
+    return function (data) {
+        return hook(data) || data;
+    };
+}
+function queue(hooks, data) {
+    let promise = false;
+    for (let i = 0; i < hooks.length; i++) {
+        const hook = hooks[i];
+        if (promise) {
+            promise = Promise.resolve(wrapperHook(hook));
+        }
+        else {
+            const res = hook(data);
+            if (isPromise(res)) {
+                promise = Promise.resolve(res);
+            }
+            if (res === false) {
+                return {
+                    then() { },
+                    catch() { }
+                };
+            }
+        }
+    }
+    return (promise || {
+        then(callback) {
+            return callback(data);
+        },
+        catch() { }
+    });
+}
+function wrapperOptions(interceptors, options = {}) {
+    [HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => {
+        const hooks = interceptors[name];
+        if (!isArray(hooks)) {
+            return;
+        }
+        const oldCallback = options[name];
+        options[name] = function callbackInterceptor(res) {
+            queue(hooks, res).then((res) => {
+                return (isFunction(oldCallback) && oldCallback(res)) || res;
+            });
+        };
+    });
+    return options;
+}
+function wrapperReturnValue(method, returnValue) {
+    const returnValueHooks = [];
+    if (isArray(globalInterceptors.returnValue)) {
+        returnValueHooks.push(...globalInterceptors.returnValue);
+    }
+    const interceptor = scopedInterceptors[method];
+    if (interceptor && isArray(interceptor.returnValue)) {
+        returnValueHooks.push(...interceptor.returnValue);
+    }
+    returnValueHooks.forEach(hook => {
+        returnValue = hook(returnValue) || returnValue;
+    });
+    return returnValue;
+}
+function getApiInterceptorHooks(method) {
+    const interceptor = Object.create(null);
+    Object.keys(globalInterceptors).forEach(hook => {
+        if (hook !== 'returnValue') {
+            interceptor[hook] = globalInterceptors[hook].slice();
+        }
+    });
+    const scopedInterceptor = scopedInterceptors[method];
+    if (scopedInterceptor) {
+        Object.keys(scopedInterceptor).forEach(hook => {
+            if (hook !== 'returnValue') {
+                interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]);
+            }
+        });
+    }
+    return interceptor;
+}
+function invokeApi(method, api, options, ...params) {
+    const interceptor = getApiInterceptorHooks(method);
+    if (interceptor && Object.keys(interceptor).length) {
+        if (isArray(interceptor.invoke)) {
+            const res = queue(interceptor.invoke, options);
+            return res.then(options => {
+                return api(wrapperOptions(interceptor, options), ...params);
+            });
+        }
+        else {
+            return api(wrapperOptions(interceptor, options), ...params);
+        }
+    }
+    return api(options, ...params);
+}
+
+function mergeInterceptorHook(interceptors, interceptor) {
+    Object.keys(interceptor).forEach(hook => {
+        if (isFunction(interceptor[hook])) {
+            interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]);
+        }
+    });
+}
+function removeInterceptorHook(interceptors, interceptor) {
+    if (!interceptors || !interceptor) {
+        return;
+    }
+    Object.keys(interceptor).forEach(hook => {
+        if (isFunction(interceptor[hook])) {
+            removeHook(interceptors[hook], interceptor[hook]);
+        }
+    });
+}
+function mergeHook(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+function removeHook(hooks, hook) {
+    if (!hooks) {
+        return;
+    }
+    const index = hooks.indexOf(hook);
+    if (index !== -1) {
+        hooks.splice(index, 1);
+    }
+}
+function addInterceptor(method, interceptor) {
+    if (typeof method === 'string' && isPlainObject(interceptor)) {
+        mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor);
+    }
+    else if (isPlainObject(method)) {
+        mergeInterceptorHook(globalInterceptors, method);
+    }
+}
+function removeInterceptor(method, interceptor) {
+    if (typeof method === 'string') {
+        if (isPlainObject(interceptor)) {
+            removeInterceptorHook(scopedInterceptors[method], interceptor);
+        }
+        else {
+            delete scopedInterceptors[method];
+        }
+    }
+    else if (isPlainObject(method)) {
+        removeInterceptorHook(globalInterceptors, method);
+    }
+}
+
+const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/;
+const CONTEXT_API_RE = /^create|Manager$/;
+// Context例外情况
+const CONTEXT_API_RE_EXC = ['createBLEConnection'];
+// 同步例外情况
+const ASYNC_API = ['createBLEConnection'];
+const CALLBACK_API_RE = /^on|^off/;
+function isContextApi(name) {
+    return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1;
+}
+function isSyncApi(name) {
+    return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1;
+}
+function isCallbackApi(name) {
+    return CALLBACK_API_RE.test(name) && name !== 'onPush';
+}
+function handlePromise(promise) {
+    if (!__UNI_PROMISE_API__) {
+        return promise;
+    }
+    return promise
+        .then(data => {
+        return [null, data];
+    })
+        .catch(err => [err]);
+}
+function shouldPromise(name) {
+    if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) {
+        return false;
+    }
+    return true;
+}
+/* eslint-disable no-extend-native */
+if (!Promise.prototype.finally) {
+    Promise.prototype.finally = function (onfinally) {
+        const promise = this.constructor;
+        return this.then(value => promise.resolve(onfinally && onfinally()).then(() => value), reason => promise.resolve(onfinally && onfinally()).then(() => {
+            throw reason;
+        }));
+    };
+}
+function promisify(name, api) {
+    if (!shouldPromise(name)) {
+        return api;
+    }
+    if (!isFunction(api)) {
+        return api;
+    }
+    return function promiseApi(options = {}, ...params) {
+        if (isFunction(options.success) ||
+            isFunction(options.fail) ||
+            isFunction(options.complete)) {
+            return wrapperReturnValue(name, invokeApi(name, api, options, ...params));
+        }
+        return wrapperReturnValue(name, handlePromise(new Promise((resolve, reject) => {
+            invokeApi(name, api, Object.assign({}, options, {
+                success: resolve,
+                fail: reject
+            }), ...params);
+        })));
+    };
+}
+
+const CALLBACKS = ['success', 'fail', 'cancel', 'complete'];
+function initWrapper(protocols) {
+    function processCallback(methodName, method, returnValue) {
+        return function (res) {
+            return method(processReturnValue(methodName, res, returnValue));
+        };
+    }
+    function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) {
+        if (isPlainObject(fromArgs)) {
+            // 一般 api 的参数解析
+            const toArgs = (keepFromArgs === true ? fromArgs : {}); // returnValue 为 false 时，说明是格式化返回值，直接在返回值对象上修改赋值
+            if (isFunction(argsOption)) {
+                argsOption = argsOption(fromArgs, toArgs) || {};
+            }
+            for (const key in fromArgs) {
+                if (hasOwn(argsOption, key)) {
+                    let keyOption = argsOption[key];
+                    if (isFunction(keyOption)) {
+                        keyOption = keyOption(fromArgs[key], fromArgs, toArgs);
+                    }
+                    if (!keyOption) {
+                        // 不支持的参数
+                        console.warn(`QQ小程序 ${methodName} 暂不支持 ${key}`);
+                    }
+                    else if (isString(keyOption)) {
+                        // 重写参数 key
+                        toArgs[keyOption] = fromArgs[key];
+                    }
+                    else if (isPlainObject(keyOption)) {
+                        // {name:newName,value:value}可重新指定参数 key:value
+                        toArgs[keyOption.name ? keyOption.name : key] = keyOption.value;
+                    }
+                }
+                else if (CALLBACKS.indexOf(key) !== -1) {
+                    const callback = fromArgs[key];
+                    if (isFunction(callback)) {
+                        toArgs[key] = processCallback(methodName, callback, returnValue);
+                    }
+                }
+                else {
+                    if (!keepFromArgs && !hasOwn(toArgs, key)) {
+                        toArgs[key] = fromArgs[key];
+                    }
+                }
+            }
+            return toArgs;
+        }
+        else if (isFunction(fromArgs)) {
+            fromArgs = processCallback(methodName, fromArgs, returnValue);
+        }
+        return fromArgs;
+    }
+    function processReturnValue(methodName, res, returnValue, keepReturnValue = false) {
+        if (isFunction(protocols.returnValue)) {
+            // 处理通用 returnValue
+            res = protocols.returnValue(methodName, res);
+        }
+        return processArgs(methodName, res, returnValue, {}, keepReturnValue);
+    }
+    return function wrapper(methodName, method) {
+        if (!hasOwn(protocols, methodName)) {
+            return method;
+        }
+        const protocol = protocols[methodName];
+        if (!protocol) {
+            // 暂不支持的 api
+            return function () {
+                console.error(`QQ小程序 暂不支持${methodName}`);
+            };
+        }
+        return function (arg1, arg2) {
+            // 目前 api 最多两个参数
+            let options = protocol;
+            if (isFunction(protocol)) {
+                options = protocol(arg1);
+            }
+            arg1 = processArgs(methodName, arg1, options.args, options.returnValue);
+            const args = [arg1];
+            if (typeof arg2 !== 'undefined') {
+                args.push(arg2);
+            }
+            const returnValue = qq[options.name || methodName].apply(qq, args);
+            if (isSyncApi(methodName)) {
+                // 同步 api
+                return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName));
+            }
+            return returnValue;
+        };
+    };
+}
+
+const baseApis = { upx2px, addInterceptor, removeInterceptor };
+function initUni(api, protocols) {
+    const wrapper = initWrapper(protocols);
+    const UniProxyHandlers = {
+        get(target, key) {
+            if (hasOwn(target, key)) {
+                return target[key];
+            }
+            if (hasOwn(api, key)) {
+                return promisify(key, api[key]);
+            }
+            if (hasOwn(baseApis, key)) {
+                return promisify(key, baseApis[key]);
+            }
+            // event-api
+            // provider-api?
+            return promisify(key, wrapper(key, qq[key]));
+        }
+    };
+    return new Proxy({}, UniProxyHandlers);
+}
+
+function initGetProvider(providers) {
+    return function getProvider({ service, success, fail, complete }) {
+        let res;
+        if (providers[service]) {
+            res = {
+                errMsg: 'getProvider:ok',
+                service,
+                provider: providers[service]
+            };
+            isFunction(success) && success(res);
+        }
+        else {
+            res = {
+                errMsg: 'getProvider:fail:服务[' + service + ']不存在'
+            };
+            isFunction(fail) && fail(res);
+        }
+        isFunction(complete) && complete(res);
+    };
+}
+
+const previewImage = {
+    args(fromArgs, toArgs) {
+        let currentIndex = parseInt(fromArgs.current);
+        if (isNaN(currentIndex)) {
+            return;
+        }
+        const urls = fromArgs.urls;
+        if (!isArray(urls)) {
+            return;
+        }
+        const len = urls.length;
+        if (!len) {
+            return;
+        }
+        if (currentIndex < 0) {
+            currentIndex = 0;
+        }
+        else if (currentIndex >= len) {
+            currentIndex = len - 1;
+        }
+        if (currentIndex > 0) {
+            toArgs.current = urls[currentIndex];
+            toArgs.urls = urls.filter((item, index) => index < currentIndex ? item !== urls[currentIndex] : true);
+        }
+        else {
+            toArgs.current = urls[0];
+        }
+        return {
+            indicator: false,
+            loop: false
+        };
+    }
+};
+function addSafeAreaInsets(fromRes, toRes) {
+    if (fromRes.safeArea) {
+        const safeArea = fromRes.safeArea;
+        toRes.safeAreaInsets = {
+            top: safeArea.top,
+            left: safeArea.left,
+            right: fromRes.windowWidth - safeArea.right,
+            bottom: fromRes.windowHeight - safeArea.bottom
+        };
+    }
+}
+const getSystemInfo = {
+    returnValue: addSafeAreaInsets
+};
+const getSystemInfoSync = getSystemInfo;
+
+const getProvider = initGetProvider({
+    oauth: ['qq'],
+    share: ['qq'],
+    payment: ['qqpay'],
+    push: ['qq']
+});
+
+var shims = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getProvider: getProvider
+});
+
+var protocols = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  previewImage: previewImage,
+  getSystemInfo: getSystemInfo,
+  getSystemInfoSync: getSystemInfoSync
+});
+
+var index = initUni(shims, protocols);
+
+export default index;

packages/uni-mp-toutiao/dist/uni.api.esm.js

+import { isArray, isPromise, isFunction, isPlainObject, hasOwn, isString } from '@vue/shared';
+
+const EPS = 1e-4;
+const BASE_DEVICE_WIDTH = 750;
+let isIOS = false;
+let deviceWidth = 0;
+let deviceDPR = 0;
+function checkDeviceWidth() {
+    const { platform, pixelRatio, windowWidth } = tt.getSystemInfoSync();
+    deviceWidth = windowWidth;
+    deviceDPR = pixelRatio;
+    isIOS = platform === 'ios';
+}
+function upx2px(number, newDeviceWidth) {
+    if (deviceWidth === 0) {
+        checkDeviceWidth();
+    }
+    number = Number(number);
+    if (number === 0) {
+        return 0;
+    }
+    let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth);
+    if (result < 0) {
+        result = -result;
+    }
+    result = Math.floor(result + EPS);
+    if (result === 0) {
+        if (deviceDPR === 1 || !isIOS) {
+            result = 1;
+        }
+        else {
+            result = 0.5;
+        }
+    }
+    return number < 0 ? -result : result;
+}
+
+var HOOKS;
+(function (HOOKS) {
+    HOOKS["INVOKE"] = "invoke";
+    HOOKS["SUCCESS"] = "success";
+    HOOKS["FAIL"] = "fail";
+    HOOKS["COMPLETE"] = "complete";
+    HOOKS["RETURN_VALUE"] = "returnValue";
+})(HOOKS || (HOOKS = {}));
+const globalInterceptors = {};
+const scopedInterceptors = {};
+function wrapperHook(hook) {
+    return function (data) {
+        return hook(data) || data;
+    };
+}
+function queue(hooks, data) {
+    let promise = false;
+    for (let i = 0; i < hooks.length; i++) {
+        const hook = hooks[i];
+        if (promise) {
+            promise = Promise.resolve(wrapperHook(hook));
+        }
+        else {
+            const res = hook(data);
+            if (isPromise(res)) {
+                promise = Promise.resolve(res);
+            }
+            if (res === false) {
+                return {
+                    then() { },
+                    catch() { }
+                };
+            }
+        }
+    }
+    return (promise || {
+        then(callback) {
+            return callback(data);
+        },
+        catch() { }
+    });
+}
+function wrapperOptions(interceptors, options = {}) {
+    [HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => {
+        const hooks = interceptors[name];
+        if (!isArray(hooks)) {
+            return;
+        }
+        const oldCallback = options[name];
+        options[name] = function callbackInterceptor(res) {
+            queue(hooks, res).then((res) => {
+                return (isFunction(oldCallback) && oldCallback(res)) || res;
+            });
+        };
+    });
+    return options;
+}
+function wrapperReturnValue(method, returnValue) {
+    const returnValueHooks = [];
+    if (isArray(globalInterceptors.returnValue)) {
+        returnValueHooks.push(...globalInterceptors.returnValue);
+    }
+    const interceptor = scopedInterceptors[method];
+    if (interceptor && isArray(interceptor.returnValue)) {
+        returnValueHooks.push(...interceptor.returnValue);
+    }
+    returnValueHooks.forEach(hook => {
+        returnValue = hook(returnValue) || returnValue;
+    });
+    return returnValue;
+}
+function getApiInterceptorHooks(method) {
+    const interceptor = Object.create(null);
+    Object.keys(globalInterceptors).forEach(hook => {
+        if (hook !== 'returnValue') {
+            interceptor[hook] = globalInterceptors[hook].slice();
+        }
+    });
+    const scopedInterceptor = scopedInterceptors[method];
+    if (scopedInterceptor) {
+        Object.keys(scopedInterceptor).forEach(hook => {
+            if (hook !== 'returnValue') {
+                interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]);
+            }
+        });
+    }
+    return interceptor;
+}
+function invokeApi(method, api, options, ...params) {
+    const interceptor = getApiInterceptorHooks(method);
+    if (interceptor && Object.keys(interceptor).length) {
+        if (isArray(interceptor.invoke)) {
+            const res = queue(interceptor.invoke, options);
+            return res.then(options => {
+                return api(wrapperOptions(interceptor, options), ...params);
+            });
+        }
+        else {
+            return api(wrapperOptions(interceptor, options), ...params);
+        }
+    }
+    return api(options, ...params);
+}
+
+function mergeInterceptorHook(interceptors, interceptor) {
+    Object.keys(interceptor).forEach(hook => {
+        if (isFunction(interceptor[hook])) {
+            interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]);
+        }
+    });
+}
+function removeInterceptorHook(interceptors, interceptor) {
+    if (!interceptors || !interceptor) {
+        return;
+    }
+    Object.keys(interceptor).forEach(hook => {
+        if (isFunction(interceptor[hook])) {
+            removeHook(interceptors[hook], interceptor[hook]);
+        }
+    });
+}
+function mergeHook(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+function removeHook(hooks, hook) {
+    if (!hooks) {
+        return;
+    }
+    const index = hooks.indexOf(hook);
+    if (index !== -1) {
+        hooks.splice(index, 1);
+    }
+}
+function addInterceptor(method, interceptor) {
+    if (typeof method === 'string' && isPlainObject(interceptor)) {
+        mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor);
+    }
+    else if (isPlainObject(method)) {
+        mergeInterceptorHook(globalInterceptors, method);
+    }
+}
+function removeInterceptor(method, interceptor) {
+    if (typeof method === 'string') {
+        if (isPlainObject(interceptor)) {
+            removeInterceptorHook(scopedInterceptors[method], interceptor);
+        }
+        else {
+            delete scopedInterceptors[method];
+        }
+    }
+    else if (isPlainObject(method)) {
+        removeInterceptorHook(globalInterceptors, method);
+    }
+}
+
+const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/;
+const CONTEXT_API_RE = /^create|Manager$/;
+// Context例外情况
+const CONTEXT_API_RE_EXC = ['createBLEConnection'];
+// 同步例外情况
+const ASYNC_API = ['createBLEConnection'];
+const CALLBACK_API_RE = /^on|^off/;
+function isContextApi(name) {
+    return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1;
+}
+function isSyncApi(name) {
+    return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1;
+}
+function isCallbackApi(name) {
+    return CALLBACK_API_RE.test(name) && name !== 'onPush';
+}
+function handlePromise(promise) {
+    if (!__UNI_PROMISE_API__) {
+        return promise;
+    }
+    return promise
+        .then(data => {
+        return [null, data];
+    })
+        .catch(err => [err]);
+}
+function shouldPromise(name) {
+    if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) {
+        return false;
+    }
+    return true;
+}
+/* eslint-disable no-extend-native */
+if (!Promise.prototype.finally) {
+    Promise.prototype.finally = function (onfinally) {
+        const promise = this.constructor;
+        return this.then(value => promise.resolve(onfinally && onfinally()).then(() => value), reason => promise.resolve(onfinally && onfinally()).then(() => {
+            throw reason;
+        }));
+    };
+}
+function promisify(name, api) {
+    if (!shouldPromise(name)) {
+        return api;
+    }
+    if (!isFunction(api)) {
+        return api;
+    }
+    return function promiseApi(options = {}, ...params) {
+        if (isFunction(options.success) ||
+            isFunction(options.fail) ||
+            isFunction(options.complete)) {
+            return wrapperReturnValue(name, invokeApi(name, api, options, ...params));
+        }
+        return wrapperReturnValue(name, handlePromise(new Promise((resolve, reject) => {
+            invokeApi(name, api, Object.assign({}, options, {
+                success: resolve,
+                fail: reject
+            }), ...params);
+        })));
+    };
+}
+
+const CALLBACKS = ['success', 'fail', 'cancel', 'complete'];
+function initWrapper(protocols) {
+    function processCallback(methodName, method, returnValue) {
+        return function (res) {
+            return method(processReturnValue(methodName, res, returnValue));
+        };
+    }
+    function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) {
+        if (isPlainObject(fromArgs)) {
+            // 一般 api 的参数解析
+            const toArgs = (keepFromArgs === true ? fromArgs : {}); // returnValue 为 false 时，说明是格式化返回值，直接在返回值对象上修改赋值
+            if (isFunction(argsOption)) {
+                argsOption = argsOption(fromArgs, toArgs) || {};
+            }
+            for (const key in fromArgs) {
+                if (hasOwn(argsOption, key)) {
+                    let keyOption = argsOption[key];
+                    if (isFunction(keyOption)) {
+                        keyOption = keyOption(fromArgs[key], fromArgs, toArgs);
+                    }
+                    if (!keyOption) {
+                        // 不支持的参数
+                        console.warn(`字节跳动小程序 ${methodName} 暂不支持 ${key}`);
+                    }
+                    else if (isString(keyOption)) {
+                        // 重写参数 key
+                        toArgs[keyOption] = fromArgs[key];
+                    }
+                    else if (isPlainObject(keyOption)) {
+                        // {name:newName,value:value}可重新指定参数 key:value
+                        toArgs[keyOption.name ? keyOption.name : key] = keyOption.value;
+                    }
+                }
+                else if (CALLBACKS.indexOf(key) !== -1) {
+                    const callback = fromArgs[key];
+                    if (isFunction(callback)) {
+                        toArgs[key] = processCallback(methodName, callback, returnValue);
+                    }
+                }
+                else {
+                    if (!keepFromArgs && !hasOwn(toArgs, key)) {
+                        toArgs[key] = fromArgs[key];
+                    }
+                }
+            }
+            return toArgs;
+        }
+        else if (isFunction(fromArgs)) {
+            fromArgs = processCallback(methodName, fromArgs, returnValue);
+        }
+        return fromArgs;
+    }
+    function processReturnValue(methodName, res, returnValue, keepReturnValue = false) {
+        if (isFunction(protocols.returnValue)) {
+            // 处理通用 returnValue
+            res = protocols.returnValue(methodName, res);
+        }
+        return processArgs(methodName, res, returnValue, {}, keepReturnValue);
+    }
+    return function wrapper(methodName, method) {
+        if (!hasOwn(protocols, methodName)) {
+            return method;
+        }
+        const protocol = protocols[methodName];
+        if (!protocol) {
+            // 暂不支持的 api
+            return function () {
+                console.error(`字节跳动小程序 暂不支持${methodName}`);
+            };
+        }
+        return function (arg1, arg2) {
+            // 目前 api 最多两个参数
+            let options = protocol;
+            if (isFunction(protocol)) {
+                options = protocol(arg1);
+            }
+            arg1 = processArgs(methodName, arg1, options.args, options.returnValue);
+            const args = [arg1];
+            if (typeof arg2 !== 'undefined') {
+                args.push(arg2);
+            }
+            const returnValue = tt[options.name || methodName].apply(tt, args);
+            if (isSyncApi(methodName)) {
+                // 同步 api
+                return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName));
+            }
+            return returnValue;
+        };
+    };
+}
+
+const baseApis = { upx2px, addInterceptor, removeInterceptor };
+function initUni(api, protocols) {
+    const wrapper = initWrapper(protocols);
+    const UniProxyHandlers = {
+        get(target, key) {
+            if (hasOwn(target, key)) {
+                return target[key];
+            }
+            if (hasOwn(api, key)) {
+                return promisify(key, api[key]);
+            }
+            if (hasOwn(baseApis, key)) {
+                return promisify(key, baseApis[key]);
+            }
+            // event-api
+            // provider-api?
+            return promisify(key, wrapper(key, tt[key]));
+        }
+    };
+    return new Proxy({}, UniProxyHandlers);
+}
+
+function initGetProvider(providers) {
+    return function getProvider({ service, success, fail, complete }) {
+        let res;
+        if (providers[service]) {
+            res = {
+                errMsg: 'getProvider:ok',
+                service,
+                provider: providers[service]
+            };
+            isFunction(success) && success(res);
+        }
+        else {
+            res = {
+                errMsg: 'getProvider:fail:服务[' + service + ']不存在'
+            };
+            isFunction(fail) && fail(res);
+        }
+        isFunction(complete) && complete(res);
+    };
+}
+
+const previewImage = {
+    args(fromArgs, toArgs) {
+        let currentIndex = parseInt(fromArgs.current);
+        if (isNaN(currentIndex)) {
+            return;
+        }
+        const urls = fromArgs.urls;
+        if (!isArray(urls)) {
+            return;
+        }
+        const len = urls.length;
+        if (!len) {
+            return;
+        }
+        if (currentIndex < 0) {
+            currentIndex = 0;
+        }
+        else if (currentIndex >= len) {
+            currentIndex = len - 1;
+        }
+        if (currentIndex > 0) {
+            toArgs.current = urls[currentIndex];
+            toArgs.urls = urls.filter((item, index) => index < currentIndex ? item !== urls[currentIndex] : true);
+        }
+        else {
+            toArgs.current = urls[0];
+        }
+        return {
+            indicator: false,
+            loop: false
+        };
+    }
+};
+
+const getProvider = initGetProvider({
+    oauth: ['toutiao'],
+    share: ['toutiao'],
+    payment: ['toutiao'],
+    push: ['toutiao']
+});
+
+var shims = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getProvider: getProvider
+});
+
+const chooseImage = {
+    args: {
+        sizeType: false
+    }
+};
+const connectSocket = {
+    args: {
+        method: false
+    }
+};
+const chooseVideo = {
+    args: {
+        camera: false
+    }
+};
+const scanCode = {
+    args: {
+        onlyFromCamera: false,
+        scanType: false
+    }
+};
+const startAccelerometer = {
+    args: {
+        interval: false
+    }
+};
+const showToast = {
+    args: {
+        image: false,
+        mask: false
+    }
+};
+const showLoading = {
+    args: {
+        mask: false
+    }
+};
+const showModal = {
+    args: {
+        cancelColor: false,
+        confirmColor: false
+    }
+};
+const showActionSheet = {
+    args: {
+        itemColor: false
+    }
+};
+const login = {
+    args: {
+        scopes: false,
+        timeout: false
+    }
+};
+const getUserInfo = {
+    args: {
+        lang: false,
+        timeout: false
+    }
+};
+const requestPayment = {
+    name: tt.pay ? 'pay' : 'requestPayment',
+    args: {
+        orderInfo: tt.pay ? 'orderInfo' : 'data'
+    }
+};
+const getFileInfo = {
+    args: {
+        digestAlgorithm: false
+    }
+};
+
+var protocols = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  chooseImage: chooseImage,
+  connectSocket: connectSocket,
+  chooseVideo: chooseVideo,
+  scanCode: scanCode,
+  startAccelerometer: startAccelerometer,
+  showToast: showToast,
+  showLoading: showLoading,
+  showModal: showModal,
+  showActionSheet: showActionSheet,
+  login: login,
+  getUserInfo: getUserInfo,
+  requestPayment: requestPayment,
+  getFileInfo: getFileInfo,
+  previewImage: previewImage
+});
+
+var index = initUni(shims, protocols);
+
+export default index;

packages/uni-mp-weixin/dist/uni.api.esm.js

@@ -223,6 +223,9 @@ function isCallbackApi(name) {
     return CALLBACK_API_RE.test(name) && name !== 'onPush';
 }
 function handlePromise(promise) {
+    if (!__UNI_PROMISE_API__) {
+        return promise;
+    }
     return promise
         .then(data => {
         return [null, data];
@@ -288,7 +291,7 @@ function initWrapper(protocols) {
                     }
                     if (!keyOption) {
                         // 不支持的参数
-                        console.warn(`__MP_TITLE__ ${methodName}暂不支持${key}`);
+                        console.warn(`微信小程序 ${methodName} 暂不支持 ${key}`);
                     }
                     else if (isString(keyOption)) {
                         // 重写参数 key
@@ -306,7 +309,7 @@ function initWrapper(protocols) {
                     }
                 }
                 else {
-                    if (!keepFromArgs) {
+                    if (!keepFromArgs && !hasOwn(toArgs, key)) {
                         toArgs[key] = fromArgs[key];
                     }
                 }
@@ -333,7 +336,7 @@ function initWrapper(protocols) {
         if (!protocol) {
             // 暂不支持的 api
             return function () {
-                console.error(`__MP_TITLE__ 暂不支持${methodName}`);
+                console.error(`微信小程序 暂不支持${methodName}`);
             };
         }
         return function (arg1, arg2) {
@@ -379,8 +382,29 @@ function initUni(api, protocols) {
     return new Proxy({}, UniProxyHandlers);
 }
 
+function initGetProvider(providers) {
+    return function getProvider({ service, success, fail, complete }) {
+        let res;
+        if (providers[service]) {
+            res = {
+                errMsg: 'getProvider:ok',
+                service,
+                provider: providers[service]
+            };
+            isFunction(success) && success(res);
+        }
+        else {
+            res = {
+                errMsg: 'getProvider:fail:服务[' + service + ']不存在'
+            };
+            isFunction(fail) && fail(res);
+        }
+        isFunction(complete) && complete(res);
+    };
+}
+
 const previewImage = {
-    args(fromArgs) {
+    args(fromArgs, toArgs) {
         let currentIndex = parseInt(fromArgs.current);
         if (isNaN(currentIndex)) {
             return;
@@ -400,11 +424,11 @@ const previewImage = {
             currentIndex = len - 1;
         }
         if (currentIndex > 0) {
-            fromArgs.current = urls[currentIndex];
-            fromArgs.urls = urls.filter((item, index) => index < currentIndex ? item !== urls[currentIndex] : true);
+            toArgs.current = urls[currentIndex];
+            toArgs.urls = urls.filter((item, index) => index < currentIndex ? item !== urls[currentIndex] : true);
         }
         else {
-            fromArgs.current = urls[0];
+            toArgs.current = urls[0];
         }
         return {
             indicator: false,
@@ -412,15 +436,14 @@ const previewImage = {
         };
     }
 };
-
-function addSafeAreaInsets(result) {
-    if (result.safeArea) {
-        const safeArea = result.safeArea;
-        result.safeAreaInsets = {
+function addSafeAreaInsets(fromRes, toRes) {
+    if (fromRes.safeArea) {
+        const safeArea = fromRes.safeArea;
+        toRes.safeAreaInsets = {
             top: safeArea.top,
             left: safeArea.left,
-            right: result.windowWidth - safeArea.right,
-            bottom: result.windowHeight - safeArea.bottom
+            right: fromRes.windowWidth - safeArea.right,
+            bottom: fromRes.windowHeight - safeArea.bottom
         };
     }
 }
@@ -429,13 +452,25 @@ const getSystemInfo = {
 };
 const getSystemInfoSync = getSystemInfo;
 
+const getProvider = initGetProvider({
+    oauth: ['weixin'],
+    share: ['weixin'],
+    payment: ['wxpay'],
+    push: ['weixin']
+});
+
+var shims = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getProvider: getProvider
+});
+
 var protocols = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  previewImage: previewImage,
   getSystemInfo: getSystemInfo,
-  getSystemInfoSync: getSystemInfoSync,
-  previewImage: previewImage
+  getSystemInfoSync: getSystemInfoSync
 });
 
-var index = initUni({}, protocols);
+var index = initUni(shims, protocols);
 
 export default index;

packages/uni-template-compiler/__tests__/compiler.spec.js

@@ -326,6 +326,12 @@ describe('mp:compiler', () => {
       '<input @input="onInput($event, 2+2);">',
       '<input data-event-opts="{{[[\'input\',[[\'onInput\',[\'$event\',2+2]]]]]}}" bindinput="__e"/>'
     )
+    // v-for
+    assertCodegen(
+      '<view v-for="(item,index) in list" :key="index"><view @click="$test.test(item)">test</view></view>',
+      '<block wx:for="{{list}}" wx:for-item="item" wx:for-index="index" wx:key="index"><view><view data-event-opts="{{[[\'tap\',[[\'e0\',[\'$event\']]]]]}}" data-event-params="{{[{item}]}}" bindtap="__e">test</view></view></block>',
+      'with(this){if(!_isMounted){e0=function($event,item){var _temp=arguments[arguments.length-1].currentTarget.dataset,_temp2=(_temp.eventParams||_temp["event-params"])[0],item=_temp2.item;var _temp,_temp2;return $test.test(item)}}}'
+    )
     // tricky symbols in args
     //         assertCodegen(
     //             `<input @input="onInput(');[\\'());');">`,

packages/uni-template-compiler/lib/constants.js

@@ -62,6 +62,7 @@ module.exports = {
   VAR_FILTER: 'F',
   ATTR_DATA_EVENT_OPTS: 'data-event-opts',
   ATTR_DATA_COM_TYPE: 'data-com-type',
+  ATTR_DATA_EVENT_PARAMS: 'data-event-params',
   INTERNAL_GET_ORIG,
   INTERNAL_GET_CLASS,
   INTERNAL_GET_STYLE,

packages/uni-template-compiler/lib/script/traverse/member-expr.js

@@ -4,15 +4,6 @@ function isMatch (name, forItem, forIndex) {
   return name === forItem || name === forIndex
 }
 
-function getIdentifierName (element) {
-  if (t.isMemberExpression(element)) {
-    return getIdentifierName(element.object)
-  } else if (t.isCallExpression(element)) {
-    return getIdentifierName(element.callee)
-  }
-  return element.name && element.name.split('.')[0]
-}
-
 function findScoped (path, state) {
   if (!path) {
     return state
@@ -23,30 +14,17 @@ function findScoped (path, state) {
       forIndex
     } = scoped
     let match = false
-    if (path.isIdentifier() || path.isMemberExpression()) {
-      match = isMatch(getIdentifierName(path.node), forItem, forIndex)
-    } else {
     path.traverse({
       noScope: true,
       Identifier (path) {
-          if (!match) {
+        if (!match && path.key !== 'key' && (path.key !== 'property' || path.parent.computed)) {
           match = isMatch(path.node.name, forItem, forIndex)
           if (match) {
             path.stop()
           }
         }
-        },
-        MemberExpression (path) {
-          if (!match) {
-            match = isMatch(getIdentifierName(path.node), forItem, forIndex)
-            if (match) {
-              path.stop()
-            }
-            path.skip()
-          }
       }
     })
-    }
     return match
   })
   if (!scoped && state.scoped.length > 1) {

packages/uni-template-compiler/lib/script/traverse/visitor.js

@@ -132,7 +132,7 @@ function checkUsingGlobalComponents (name, globalUsingComponents, state) {
 }
 
 module.exports = {
-  noScope: true,
+  noScope: false,
   MemberExpression (path) {
     if ( // t.m(123)
       t.isIdentifier(path.node.object) &&

packages/vue-cli-plugin-uni/lib/chain-webpack.js

@@ -90,8 +90,12 @@ module.exports = function chainWebpack (platformOptions, vueOptions, api) {
 
     platformOptions.chainWebpack(webpackConfig, vueOptions, api)
     // define
+    const deferredCreated = process.env.UNI_PLATFORM === 'mp-toutiao' ||
+      process.env.UNI_PLATFORM === 'quickapp-webview'
     const defines = {
-      __FEATURE_OPTIONS__: JSON.stringify(process.env.UNI_USING_VUE3_OPTIONS === 'true'),
+      __UNI_PROMISE_API__: JSON.stringify(process.env.UNI_USING_PROMISE_API === 'true'),
+      __VUE_OPTIONS_API__: JSON.stringify(process.env.UNI_USING_VUE3_OPTIONS_API === 'true'),
+      __VUE_CREATED_DEFERRED__: JSON.stringify(deferredCreated),
       'process.env.UNI_ENV': JSON.stringify(process.env.UNI_PLATFORM),
       'process.env.UNI_CLOUD_PROVIDER': process.env.UNI_CLOUD_PROVIDER,
       'process.env.HBX_USER_TOKEN': JSON.stringify(process.env.HBX_USER_TOKEN || ''),

packages/webpack-uni-pages-loader/lib/platforms/h5.js

@@ -14,6 +14,8 @@ const {
   addPageUsingComponents
 } = require('@dcloudio/uni-cli-shared/lib/pages')
 
+const compilerVersion = require('@dcloudio/webpack-uni-pages-loader/package.json')['uni-app'].compilerVersion
+
 const PLATFORMS = getPlatforms()
 
 const removePlatformStyle = function (style) {
@@ -401,6 +403,7 @@ import Vue from 'vue'
 global['____${h5.appid}____'] = true;
 delete global['____${h5.appid}____'];
 global.__uniConfig = ${JSON.stringify(pagesJson)};
+global.__uniConfig.compilerVersion = '${compilerVersion}';
 global.__uniConfig.router = ${JSON.stringify(h5.router)};
 global.__uniConfig.publicPath = ${JSON.stringify(h5.publicPath)};
 global.__uniConfig['async'] = ${JSON.stringify(h5.async)};