@dcloudio/uni-mp-baidu 2.0.0 → 2.0.1-32920211122002

package/dist/uni.api.esm.js

@@ -1,75 +1,197 @@
-import { isArray, isPromise, isFunction, isPlainObject, hasOwn, isString } from '@vue/shared';
+import { isArray, hasOwn, isString, isPlainObject, isObject, capitalize, toRawType, makeMap, isPromise, isFunction, extend } from '@vue/shared';
+import { injectHook } from 'vue';
 
-const API_TYPE_SYNC = 1;
-function validateProtocol(_name, _args, _protocol) {
-    return true;
+//App
+const ON_LAUNCH = 'onLaunch';
+
+const eventChannels = {};
+const eventChannelStack = [];
+let id = 0;
+function initEventChannel(events, cache = true) {
+    id++;
+    const eventChannel = new swan.EventChannel(id, events);
+    if (cache) {
+        eventChannels[id] = eventChannel;
+        eventChannelStack.push(eventChannel);
+    }
+    return eventChannel;
 }
-function formatApiArgs(args, options) {
-    if (!options) {
-        return args;
+function getEventChannel(id) {
+    if (id) {
+        const eventChannel = eventChannels[id];
+        delete eventChannels[id];
+        return eventChannel;
     }
+    return eventChannelStack.shift();
 }
-function createApi({ type, name, options }, fn, protocol) {
-    return function (...args) {
-        if (type === API_TYPE_SYNC) {
-            if (!((process.env.NODE_ENV !== 'production') && protocol && !validateProtocol())) {
-                return fn.apply(null, formatApiArgs(args, options));
-            }
-        }
-    };
-}
+const navigateTo = {
+    args(fromArgs) {
+        const id = initEventChannel(fromArgs.events).id;
+        if (fromArgs.url) {
+            fromArgs.url =
+                fromArgs.url +
+                    (fromArgs.url.indexOf('?') === -1 ? '?' : '&') +
+                    '__id__=' +
+                    id;
+        }
+    },
+    returnValue(fromRes) {
+        fromRes.eventChannel = getEventChannel();
+    },
+};
 
-const Upx2pxProtocol = [
-    {
-        name: 'upx',
-        type: [Number, String],
-        required: true
+swan.appLaunchHooks = [];
+function onAppLaunch(hook) {
+    const app = getApp({ allowDefault: true });
+    if (app && app.$vm) {
+        return injectHook(ON_LAUNCH, hook, app.$vm.$);
     }
-];
+    swan.appLaunchHooks.push(hook);
+}
 
-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 getBaseSystemInfo() {
+  return swan.getSystemInfoSync()
+}
+
+function validateProtocolFail(name, msg) {
+    console.warn(`${name}: ${msg}`);
 }
-const upx2px = createApi({ type: API_TYPE_SYNC, name: 'upx2px' }, (number, newDeviceWidth) => {
-    if (deviceWidth === 0) {
-        checkDeviceWidth();
+function validateProtocol(name, data, protocol, onFail) {
+    if (!onFail) {
+        onFail = validateProtocolFail;
     }
-    number = Number(number);
-    if (number === 0) {
-        return 0;
+    for (const key in protocol) {
+        const errMsg = validateProp(key, data[key], protocol[key], !hasOwn(data, key));
+        if (isString(errMsg)) {
+            onFail(name, errMsg);
+        }
     }
-    let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth);
-    if (result < 0) {
-        result = -result;
+}
+function validateProtocols(name, args, protocol, onFail) {
+    if (!protocol) {
+        return;
     }
-    result = Math.floor(result + EPS);
-    if (result === 0) {
-        if (deviceDPR === 1 || !isIOS) {
-            result = 1;
+    if (!isArray(protocol)) {
+        return validateProtocol(name, args[0] || Object.create(null), protocol, onFail);
+    }
+    const len = protocol.length;
+    const argsLen = args.length;
+    for (let i = 0; i < len; i++) {
+        const opts = protocol[i];
+        const data = Object.create(null);
+        if (argsLen > i) {
+            data[opts.name] = args[i];
         }
-        else {
-            result = 0.5;
+        validateProtocol(name, data, { [opts.name]: opts }, onFail);
+    }
+}
+function validateProp(name, value, prop, isAbsent) {
+    if (!isPlainObject(prop)) {
+        prop = { type: prop };
+    }
+    const { type, required, validator } = prop;
+    // required!
+    if (required && isAbsent) {
+        return 'Missing required args: "' + name + '"';
+    }
+    // missing but optional
+    if (value == null && !required) {
+        return;
+    }
+    // type check
+    if (type != null) {
+        let isValid = false;
+        const types = isArray(type) ? type : [type];
+        const expectedTypes = [];
+        // value is valid as long as one of the specified types match
+        for (let i = 0; i < types.length && !isValid; i++) {
+            const { valid, expectedType } = assertType(value, types[i]);
+            expectedTypes.push(expectedType || '');
+            isValid = valid;
+        }
+        if (!isValid) {
+            return getInvalidTypeMessage(name, value, expectedTypes);
         }
     }
-    return number < 0 ? -result : result;
-}, Upx2pxProtocol);
+    // custom validator
+    if (validator) {
+        return validator(value);
+    }
+}
+const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol');
+function assertType(value, type) {
+    let valid;
+    const expectedType = getType(type);
+    if (isSimpleType(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = isArray(value);
+    }
+    else {
+        {
+            valid = value instanceof type;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid args: type check failed for args "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    const expectedValue = styleValue(value, expectedType);
+    const receivedValue = styleValue(value, receivedType);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${expectedValue}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${receivedValue}.`;
+    }
+    return message;
+}
+function getType(ctor) {
+    const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
+    return match ? match[1] : '';
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+function isExplicable(type) {
+    const explicitTypes = ['string', 'number', 'boolean'];
+    return explicitTypes.some((elem) => type.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
+}
 
-var HOOKS;
-(function (HOOKS) {
-    HOOKS["INVOKE"] = "invoke";
-    HOOKS["SUCCESS"] = "success";
-    HOOKS["FAIL"] = "fail";
-    HOOKS["COMPLETE"] = "complete";
-    HOOKS["RETURN_VALUE"] = "returnValue";
-})(HOOKS || (HOOKS = {}));
+const HOOK_SUCCESS = 'success';
+const HOOK_FAIL = 'fail';
+const HOOK_COMPLETE = 'complete';
 const globalInterceptors = {};
 const scopedInterceptors = {};
 function wrapperHook(hook) {
@@ -92,7 +214,7 @@ function queue(hooks, data) {
             if (res === false) {
                 return {
                     then() { },
-                    catch() { }
+                    catch() { },
                 };
             }
         }
@@ -101,11 +223,11 @@ function queue(hooks, data) {
         then(callback) {
             return callback(data);
         },
-        catch() { }
+        catch() { },
     });
 }
 function wrapperOptions(interceptors, options = {}) {
-    [HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => {
+    [HOOK_SUCCESS, HOOK_FAIL, HOOK_COMPLETE].forEach((name) => {
         const hooks = interceptors[name];
         if (!isArray(hooks)) {
             return;
@@ -128,21 +250,21 @@ function wrapperReturnValue(method, returnValue) {
     if (interceptor && isArray(interceptor.returnValue)) {
         returnValueHooks.push(...interceptor.returnValue);
     }
-    returnValueHooks.forEach(hook => {
+    returnValueHooks.forEach((hook) => {
         returnValue = hook(returnValue) || returnValue;
     });
     return returnValue;
 }
 function getApiInterceptorHooks(method) {
     const interceptor = Object.create(null);
-    Object.keys(globalInterceptors).forEach(hook => {
+    Object.keys(globalInterceptors).forEach((hook) => {
         if (hook !== 'returnValue') {
             interceptor[hook] = globalInterceptors[hook].slice();
         }
     });
     const scopedInterceptor = scopedInterceptors[method];
     if (scopedInterceptor) {
-        Object.keys(scopedInterceptor).forEach(hook => {
+        Object.keys(scopedInterceptor).forEach((hook) => {
             if (hook !== 'returnValue') {
                 interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]);
             }
@@ -155,7 +277,7 @@ function invokeApi(method, api, options, ...params) {
     if (interceptor && Object.keys(interceptor).length) {
         if (isArray(interceptor.invoke)) {
             const res = queue(interceptor.invoke, options);
-            return res.then(options => {
+            return res.then((options) => {
                 return api(wrapperOptions(interceptor, options), ...params);
             });
         }
@@ -166,17 +288,128 @@ function invokeApi(method, api, options, ...params) {
     return api(options, ...params);
 }
 
+function handlePromise(promise) {
+    if (__UNI_FEATURE_PROMISE__) {
+        return promise
+            .then((data) => {
+            return [null, data];
+        })
+            .catch((err) => [err]);
+    }
+    return promise;
+}
+
+function formatApiArgs(args, options) {
+    const params = args[0];
+    if (!options ||
+        (!isPlainObject(options.formatArgs) && isPlainObject(params))) {
+        return;
+    }
+    const formatArgs = options.formatArgs;
+    const keys = Object.keys(formatArgs);
+    for (let i = 0; i < keys.length; i++) {
+        const name = keys[i];
+        const formatterOrDefaultValue = formatArgs[name];
+        if (isFunction(formatterOrDefaultValue)) {
+            const errMsg = formatterOrDefaultValue(args[0][name], params);
+            if (isString(errMsg)) {
+                return errMsg;
+            }
+        }
+        else {
+            // defaultValue
+            if (!hasOwn(params, name)) {
+                params[name] = formatterOrDefaultValue;
+            }
+        }
+    }
+}
+function beforeInvokeApi(name, args, protocol, options) {
+    if ((process.env.NODE_ENV !== 'production')) {
+        validateProtocols(name, args, protocol);
+    }
+    if (options && options.beforeInvoke) {
+        const errMsg = options.beforeInvoke(args);
+        if (isString(errMsg)) {
+            return errMsg;
+        }
+    }
+    const errMsg = formatApiArgs(args, options);
+    if (errMsg) {
+        return errMsg;
+    }
+}
+function wrapperSyncApi(name, fn, protocol, options) {
+    return (...args) => {
+        const errMsg = beforeInvokeApi(name, args, protocol, options);
+        if (errMsg) {
+            throw new Error(errMsg);
+        }
+        return fn.apply(null, args);
+    };
+}
+function defineSyncApi(name, fn, protocol, options) {
+    return wrapperSyncApi(name, fn, (process.env.NODE_ENV !== 'production') ? protocol : undefined, options);
+}
+
+const API_UPX2PX = 'upx2px';
+const Upx2pxProtocol = [
+    {
+        name: 'upx',
+        type: [Number, String],
+        required: true,
+    },
+];
+
+const EPS = 1e-4;
+const BASE_DEVICE_WIDTH = 750;
+let isIOS = false;
+let deviceWidth = 0;
+let deviceDPR = 0;
+function checkDeviceWidth() {
+    const { platform, pixelRatio, windowWidth } = getBaseSystemInfo();
+    deviceWidth = windowWidth;
+    deviceDPR = pixelRatio;
+    isIOS = platform === 'ios';
+}
+const upx2px = defineSyncApi(API_UPX2PX, (number, newDeviceWidth) => {
+    if (deviceWidth === 0) {
+        checkDeviceWidth();
+    }
+    number = Number(number);
+    if (number === 0) {
+        return 0;
+    }
+    let width = newDeviceWidth || deviceWidth;
+    let result = (number / BASE_DEVICE_WIDTH) * width;
+    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;
+}, Upx2pxProtocol);
+
+const API_ADD_INTERCEPTOR = 'addInterceptor';
+const API_REMOVE_INTERCEPTOR = 'removeInterceptor';
 const AddInterceptorProtocol = [
     {
         name: 'method',
         type: [String, Object],
-        required: true
-    }
+        required: true,
+    },
 ];
 const RemoveInterceptorProtocol = AddInterceptorProtocol;
 
 function mergeInterceptorHook(interceptors, interceptor) {
-    Object.keys(interceptor).forEach(hook => {
+    Object.keys(interceptor).forEach((hook) => {
         if (isFunction(interceptor[hook])) {
             interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]);
         }
@@ -186,7 +419,7 @@ function removeInterceptorHook(interceptors, interceptor) {
     if (!interceptors || !interceptor) {
         return;
     }
-    Object.keys(interceptor).forEach(hook => {
+    Object.keys(interceptor).forEach((hook) => {
         if (isFunction(interceptor[hook])) {
             removeHook(interceptors[hook], interceptor[hook]);
         }
@@ -220,7 +453,7 @@ function removeHook(hooks, hook) {
         hooks.splice(index, 1);
     }
 }
-const addInterceptor = createApi({ type: API_TYPE_SYNC, name: 'addInterceptor' }, (method, interceptor) => {
+const addInterceptor = defineSyncApi(API_ADD_INTERCEPTOR, (method, interceptor) => {
     if (typeof method === 'string' && isPlainObject(interceptor)) {
         mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor);
     }
@@ -228,7 +461,7 @@ const addInterceptor = createApi({ type: API_TYPE_SYNC, name: 'addInterceptor' }
         mergeInterceptorHook(globalInterceptors, method);
     }
 }, AddInterceptorProtocol);
-const removeInterceptor = createApi({ type: API_TYPE_SYNC, name: 'removeInterceptor' }, (method, interceptor) => {
+const removeInterceptor = defineSyncApi(API_REMOVE_INTERCEPTOR, (method, interceptor) => {
     if (typeof method === 'string') {
         if (isPlainObject(interceptor)) {
             removeInterceptorHook(scopedInterceptors[method], interceptor);
@@ -240,9 +473,118 @@ const removeInterceptor = createApi({ type: API_TYPE_SYNC, name: 'removeIntercep
     else if (isPlainObject(method)) {
         removeInterceptorHook(globalInterceptors, method);
     }
-}, RemoveInterceptorProtocol);
+}, RemoveInterceptorProtocol);
+const interceptors = {};
+
+const API_ON = '$on';
+const OnProtocol = [
+    {
+        name: 'event',
+        type: String,
+        required: true,
+    },
+    {
+        name: 'callback',
+        type: Function,
+        required: true,
+    },
+];
+const API_ONCE = '$once';
+const OnceProtocol = OnProtocol;
+const API_OFF = '$off';
+const OffProtocol = [
+    {
+        name: 'event',
+        type: [String, Array],
+    },
+    {
+        name: 'callback',
+        type: Function,
+    },
+];
+const API_EMIT = '$emit';
+const EmitProtocol = [
+    {
+        name: 'event',
+        type: String,
+        required: true,
+    },
+];
+
+const E = function () {
+    // Keep this empty so it's easier to inherit from
+    // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
+};
+E.prototype = {
+    on: function (name, callback, ctx) {
+        var e = this.e || (this.e = {});
+        (e[name] || (e[name] = [])).push({
+            fn: callback,
+            ctx: ctx,
+        });
+        return this;
+    },
+    once: function (name, callback, ctx) {
+        var self = this;
+        function listener() {
+            self.off(name, listener);
+            callback.apply(ctx, arguments);
+        }
+        listener._ = callback;
+        return this.on(name, listener, ctx);
+    },
+    emit: function (name) {
+        var data = [].slice.call(arguments, 1);
+        var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+        var i = 0;
+        var len = evtArr.length;
+        for (i; i < len; i++) {
+            evtArr[i].fn.apply(evtArr[i].ctx, data);
+        }
+        return this;
+    },
+    off: function (name, callback) {
+        var e = this.e || (this.e = {});
+        var evts = e[name];
+        var liveEvents = [];
+        if (evts && callback) {
+            for (var i = 0, len = evts.length; i < len; i++) {
+                if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+                    liveEvents.push(evts[i]);
+            }
+        }
+        // Remove event from queue to prevent memory leak
+        // Suggested by https://github.com/lazd
+        // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
+        liveEvents.length ? (e[name] = liveEvents) : delete e[name];
+        return this;
+    },
+};
+var Emitter = E;
+
+const emitter = new Emitter();
+const $on = defineSyncApi(API_ON, (name, callback) => {
+    emitter.on(name, callback);
+    return () => emitter.off(name, callback);
+}, OnProtocol);
+const $once = defineSyncApi(API_ONCE, (name, callback) => {
+    emitter.once(name, callback);
+    return () => emitter.off(name, callback);
+}, OnceProtocol);
+const $off = defineSyncApi(API_OFF, (name, callback) => {
+    if (!name) {
+        emitter.e = {};
+        return;
+    }
+    if (!Array.isArray(name))
+        name = [name];
+    name.forEach((n) => emitter.off(n, callback));
+}, OffProtocol);
+const $emit = defineSyncApi(API_EMIT, (name, ...args) => {
+    emitter.emit(name, ...args);
+}, EmitProtocol);
 
-const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/;
+const SYNC_API_RE = /^\$|getLocale|setLocale|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'];
@@ -258,16 +600,6 @@ function isSyncApi(name) {
 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;
@@ -278,7 +610,7 @@ function shouldPromise(name) {
 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(() => {
+        return this.then((value) => promise.resolve(onfinally && onfinally()).then(() => value), (reason) => promise.resolve(onfinally && onfinally()).then(() => {
             throw reason;
         }));
     };
@@ -290,17 +622,17 @@ function promisify(name, api) {
     if (!isFunction(api)) {
         return api;
     }
-    return function promiseApi(options = {}, ...params) {
+    return function promiseApi(options = {}) {
         if (isFunction(options.success) ||
             isFunction(options.fail) ||
             isFunction(options.complete)) {
-            return wrapperReturnValue(name, invokeApi(name, api, options, ...params));
+            return wrapperReturnValue(name, invokeApi(name, api, options));
         }
         return wrapperReturnValue(name, handlePromise(new Promise((resolve, reject) => {
-            invokeApi(name, api, Object.assign({}, options, {
+            invokeApi(name, api, extend({}, options, {
                 success: resolve,
-                fail: reject
-            }), ...params);
+                fail: reject,
+            }));
         })));
     };
 }
@@ -396,7 +728,51 @@ function initWrapper(protocols) {
     };
 }
 
-const baseApis = { upx2px, addInterceptor, removeInterceptor };
+const getLocale = () => {
+    // 优先使用 $locale
+    const app = getApp({ allowDefault: true });
+    if (app && app.$vm) {
+        return app.$vm.$locale;
+    }
+    return swan.getSystemInfoSync().language || 'zh-Hans';
+};
+const setLocale = (locale) => {
+    const app = getApp();
+    if (!app) {
+        return false;
+    }
+    const oldLocale = app.$vm.$locale;
+    if (oldLocale !== locale) {
+        app.$vm.$locale = locale;
+        onLocaleChangeCallbacks.forEach((fn) => fn({ locale }));
+        return true;
+    }
+    return false;
+};
+const onLocaleChangeCallbacks = [];
+const onLocaleChange = (fn) => {
+    if (onLocaleChangeCallbacks.indexOf(fn) === -1) {
+        onLocaleChangeCallbacks.push(fn);
+    }
+};
+if (typeof global !== 'undefined') {
+    global.getLocale = getLocale;
+}
+
+const baseApis = {
+    $on,
+    $off,
+    $once,
+    $emit,
+    upx2px,
+    interceptors,
+    addInterceptor,
+    removeInterceptor,
+    onAppLaunch,
+    getLocale,
+    setLocale,
+    onLocaleChange,
+};
 function initUni(api, protocols) {
     const wrapper = initWrapper(protocols);
     const UniProxyHandlers = {
@@ -413,25 +789,25 @@ function initUni(api, protocols) {
             // 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 }) {
+    return function getProvider({ service, success, fail, complete, }) {
         let res;
         if (providers[service]) {
             res = {
                 errMsg: 'getProvider:ok',
                 service,
-                provider: providers[service]
+                provider: providers[service],
             };
             isFunction(success) && success(res);
         }
         else {
             res = {
-                errMsg: 'getProvider:fail:服务[' + service + ']不存在'
+                errMsg: 'getProvider:fail:服务[' + service + ']不存在',
             };
             isFunction(fail) && fail(res);
         }
@@ -439,6 +815,26 @@ function initGetProvider(providers) {
     };
 }
 
+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 redirectTo = {};
+
 const previewImage = {
     args(fromArgs, toArgs) {
         let currentIndex = parseInt(fromArgs.current);
@@ -468,44 +864,16 @@ const previewImage = {
         }
         return {
             indicator: false,
-            loop: 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 redirectTo = {};
-const createCanvasContext = {
-    returnValue(fromRes, toRes) {
-        const measureText = fromRes.measureText;
-        toRes.measureText = function (text, callback) {
-            const textMetrics = measureText.call(this, text);
-            if (typeof callback === 'function') {
-                setTimeout(() => callback(textMetrics), 0);
-            }
-            return textMetrics;
-        };
-    }
+    },
 };
 
 const getProvider = initGetProvider({
     oauth: ['baidu'],
     share: ['baidu'],
     payment: ['baidu'],
-    push: ['baidu']
+    push: ['baidu'],
 });
 function requestPayment(params) {
     let parseError = false;
@@ -520,7 +888,7 @@ function requestPayment(params) {
     if (parseError) {
         params.fail &&
             params.fail({
-                errMsg: 'requestPayment:fail: 参数 orderInfo 数据结构不正确，参考：https://uniapp.dcloud.io/api/plugins/payment?id=orderinfo'
+                errMsg: 'requestPayment:fail: 参数 orderInfo 数据结构不正确，参考：https://uniapp.dcloud.io/api/plugins/payment?id=orderinfo',
             });
     }
     else {
@@ -529,9 +897,9 @@ function requestPayment(params) {
 }
 
 var shims = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getProvider: getProvider,
-  requestPayment: requestPayment
+    __proto__: null,
+    getProvider: getProvider,
+    requestPayment: requestPayment
 });
 
 function createTodoMethod(contextName, methodName) {
@@ -549,78 +917,78 @@ const request = {
             dataType(type) {
                 return {
                     name: 'dataType',
-                    value: type === 'json' ? type : 'string'
+                    value: type === 'json' ? type : 'string',
                 };
-            }
+            },
         };
-    }
+    },
 };
 const connectSocket = {
     args: {
-        method: false
-    }
+        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
-    }
+        scanType: false,
+    },
 };
 const navigateToMiniProgram = {
     name: 'navigateToSmartProgram',
     args: {
         appId: 'appKey',
-        envVersion: false
-    }
+        envVersion: false,
+    },
 };
 const navigateBackMiniProgram = {
-    name: 'navigateBackSmartProgram'
+    name: 'navigateBackSmartProgram',
 };
 const showShareMenu = {
-    name: 'openShare'
+    name: 'openShare',
 };
 const getAccountInfoSync = {
     name: 'getEnvInfoSync',
     returnValue(fromRes, toRes) {
         toRes.miniProgram = {
-            appId: fromRes.appKey
+            appId: fromRes.appKey,
         };
         toRes.plugin = {
             appId: '',
-            version: fromRes.sdkVersion
+            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,
-  redirectTo: redirectTo,
-  previewImage: previewImage,
-  getSystemInfo: getSystemInfo,
-  getSystemInfoSync: getSystemInfoSync,
-  createCanvasContext: createCanvasContext
+    __proto__: null,
+    request: request,
+    connectSocket: connectSocket,
+    getRecorderManager: getRecorderManager,
+    getBackgroundAudioManager: getBackgroundAudioManager,
+    scanCode: scanCode,
+    navigateToMiniProgram: navigateToMiniProgram,
+    navigateBackMiniProgram: navigateBackMiniProgram,
+    showShareMenu: showShareMenu,
+    getAccountInfoSync: getAccountInfoSync,
+    redirectTo: redirectTo,
+    navigateTo: navigateTo,
+    previewImage: previewImage,
+    getSystemInfo: getSystemInfo,
+    getSystemInfoSync: getSystemInfoSync
 });
 
 var index = initUni(shims, protocols);
 
-export default index;
+export { index as default };