@tarojs/taro-h5 3.3.18 → 3.3.19

package/dist/api/ad/index.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+export const createRewardedVideoAd = temporarilyNotSupport('createRewardedVideoAd');
+export const createInterstitialAd = temporarilyNotSupport('createInterstitialAd');

package/dist/api/ai/facial.js

@@ -0,0 +1,4 @@
+import { temporarilyNotSupport } from '../utils';
+export const stopFaceDetect = temporarilyNotSupport('stopFaceDetect');
+export const initFaceDetect = temporarilyNotSupport('initFaceDetect');
+export const faceDetect = temporarilyNotSupport('faceDetect');

package/dist/api/ai/index.js

@@ -0,0 +1,2 @@
+export * from './facial';
+export * from './visual';

package/dist/api/ai/visual.js

@@ -0,0 +1,2 @@
+import { temporarilyNotSupport } from '../utils';
+export const createVKSession = temporarilyNotSupport('createVKSession');

package/dist/api/alipay/index.js

@@ -0,0 +1,2 @@
+import { temporarilyNotSupport } from '../utils';
+export const getOpenUserInfo = temporarilyNotSupport('getOpenUserInfo');

package/dist/api/base/crypto.js

@@ -0,0 +1,2 @@
+import { temporarilyNotSupport } from '../utils';
+export const getUserCryptoManager = temporarilyNotSupport('getUserCryptoManager');

package/dist/api/base/debug.js

@@ -0,0 +1,4 @@
+import { temporarilyNotSupport } from '../utils';
+export const setEnableDebug = temporarilyNotSupport('setEnableDebug');
+export const getRealtimeLogManager = temporarilyNotSupport('getRealtimeLogManager');
+export const getLogManager = temporarilyNotSupport('getLogManager');

package/dist/api/base/index.js

@@ -0,0 +1,16 @@
+import { fromByteArray, toByteArray } from 'base64-js';
+import { temporarilyNotSupport } from '../utils';
+export const canIUse = temporarilyNotSupport('canIUse');
+export function arrayBufferToBase64(arrayBuffer) {
+    return fromByteArray(arrayBuffer);
+}
+export function base64ToArrayBuffer(base64) {
+    return toByteArray(base64);
+}
+export * from './system';
+export * from './update';
+export * from './weapp/life-cycle';
+export * from './weapp/app-event';
+export * from './debug';
+export * from './performance';
+export * from './crypto';

package/dist/api/base/performance.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+export const reportPerformance = temporarilyNotSupport('reportPerformance');
+export const getPerformance = temporarilyNotSupport('getPerformance');

package/dist/api/base/system/index.js

@@ -0,0 +1,2 @@
+export * from './info';
+export * from './network';

package/dist/api/base/system/info.js

@@ -0,0 +1,56 @@
+import MobileDetect from 'mobile-detect';
+import { MethodHandler } from '../../utils/handler';
+export const getSystemInfoSync = () => {
+    const md = new MobileDetect(navigator.userAgent);
+    const info = {
+        brand: md.mobile() || '',
+        model: md.mobile() || '',
+        system: md.os(),
+        pixelRatio: window.devicePixelRatio,
+        screenWidth: window.screen.width,
+        screenHeight: window.screen.height,
+        windowWidth: document.documentElement.clientWidth,
+        windowHeight: document.documentElement.clientHeight,
+        version: '',
+        statusBarHeight: NaN,
+        platform: navigator.platform,
+        language: navigator.language,
+        fontSizeSetting: NaN,
+        SDKVersion: '',
+        albumAuthorized: false,
+        benchmarkLevel: 0,
+        bluetoothEnabled: false,
+        cameraAuthorized: false,
+        enableDebug: false,
+        locationAuthorized: false,
+        locationEnabled: false,
+        microphoneAuthorized: false,
+        notificationAlertAuthorized: false,
+        notificationAuthorized: false,
+        notificationBadgeAuthorized: false,
+        notificationSoundAuthorized: false,
+        safeArea: {
+            bottom: 0,
+            height: 0,
+            left: 0,
+            right: 0,
+            top: 0,
+            width: 0
+        },
+        wifiEnabled: false
+    };
+    return info;
+};
+export const getSystemInfo = async (options = {}) => {
+    const { success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'getSystemInfo', success, fail, complete });
+    try {
+        const info = await getSystemInfoSync();
+        return handle.success(info);
+    }
+    catch (error) {
+        return handle.fail({
+            errMsg: error
+        });
+    }
+};

package/dist/api/base/system/network.js

@@ -0,0 +1,52 @@
+import { MethodHandler } from '../../utils/handler';
+import { temporarilyNotSupport } from '../../utils';
+function getConnection() {
+    return navigator.connection || navigator.mozConnection || navigator.webkitConnection || navigator.msConnection;
+}
+export const getNetworkType = (options = {}) => {
+    const connection = getConnection();
+    const { success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'getNetworkType', success, fail, complete });
+    let networkType = 'unknown';
+    if (!connection) {
+        return handle.success({ networkType });
+    }
+    if (!isNaN(Number(connection.type))) {
+        switch (connection.type) {
+            case connection.WIFI:
+                networkType = 'wifi';
+                break;
+            case connection.CELL_3G:
+                networkType = '3g';
+                break;
+            case connection.CELL_2G:
+                networkType = '2g';
+                break;
+            default:
+                networkType = 'unknown';
+        }
+    }
+    else if (connection.type) {
+        networkType = connection.type;
+    }
+    else if (connection.effectiveType) {
+        networkType = connection.effectiveType;
+    }
+    return handle.success({ networkType });
+};
+export const onNetworkStatusChange = (cb) => {
+    const connection = getConnection();
+    if (connection) {
+        connection.addEventListener('change', function () {
+            getNetworkType()
+                .then(res => {
+                const { networkType } = res;
+                const isConnected = networkType !== 'none';
+                const obj = { isConnected, networkType };
+                cb(obj);
+            });
+        });
+    }
+};
+export const offNetworkStatusChange = temporarilyNotSupport('offNetworkStatusChange');
+export const getLocalIPAddress = temporarilyNotSupport('getLocalIPAddress');

package/dist/api/base/update.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+export const updateWeChatApp = temporarilyNotSupport('updateWeChatApp');
+export const getUpdateManager = temporarilyNotSupport('getUpdateManager');

package/dist/api/base/weapp/app-event.js

@@ -0,0 +1,17 @@
+import { temporarilyNotSupport } from '../../utils';
+export const onUnhandledRejection = temporarilyNotSupport('onUnhandledRejection');
+export const onThemeChange = temporarilyNotSupport('onThemeChange');
+export const onPageNotFound = temporarilyNotSupport('onPageNotFound');
+export const onError = temporarilyNotSupport('onError');
+export const onAudioInterruptionEnd = temporarilyNotSupport('onAudioInterruptionEnd');
+export const onAudioInterruptionBegin = temporarilyNotSupport('onAudioInterruptionBegin');
+export const onAppShow = temporarilyNotSupport('onAppShow');
+export const onAppHide = temporarilyNotSupport('onAppHide');
+export const offUnhandledRejection = temporarilyNotSupport('offUnhandledRejection');
+export const offThemeChange = temporarilyNotSupport('offThemeChange');
+export const offPageNotFound = temporarilyNotSupport('offPageNotFound');
+export const offError = temporarilyNotSupport('offError');
+export const offAudioInterruptionEnd = temporarilyNotSupport('offAudioInterruptionEnd');
+export const offAudioInterruptionBegin = temporarilyNotSupport('offAudioInterruptionBegin');
+export const offAppShow = temporarilyNotSupport('offAppShow');
+export const offAppHide = temporarilyNotSupport('offAppHide');

package/dist/api/base/weapp/life-cycle.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../../utils';
+export const getLaunchOptionsSync = temporarilyNotSupport('getLaunchOptionsSync');
+export const getEnterOptionsSync = temporarilyNotSupport('getEnterOptionsSync');

package/dist/api/canvas/CanvasContext.js

@@ -0,0 +1,182 @@
+const TextBaseLineMap = {
+    top: 'top',
+    bottom: 'bottom',
+    middle: 'middle',
+    normal: 'alphabetic'
+};
+export class CanvasContext {
+    constructor() {
+        this.actions = [];
+        this.arc = this.enqueueActions(this.ctx.arc);
+        this.arcTo = this.enqueueActions(this.ctx.arcTo);
+        this.beginPath = this.enqueueActions(this.ctx.beginPath);
+        this.bezierCurveTo = this.enqueueActions(this.ctx.bezierCurveTo);
+        this.clearRect = this.enqueueActions(this.ctx.clearRect);
+        this.clip = this.enqueueActions(this.ctx.clip);
+        this.closePath = this.enqueueActions(this.ctx.closePath);
+        this.fill = this.enqueueActions(this.ctx.fill);
+        this.fillRect = this.enqueueActions(this.ctx.fillRect);
+        this.fillText = this.enqueueActions(this.ctx.fillText);
+        this.lineTo = this.enqueueActions(this.ctx.lineTo);
+        this.moveTo = this.enqueueActions(this.ctx.moveTo);
+        this.quadraticCurveTo = this.enqueueActions(this.ctx.quadraticCurveTo);
+        this.rect = this.enqueueActions(this.ctx.rect);
+        this.restore = this.enqueueActions(this.ctx.restore);
+        this.rotate = this.enqueueActions(this.ctx.rotate);
+        this.save = this.enqueueActions(this.ctx.save);
+        this.scale = this.enqueueActions(this.ctx.scale);
+        this.setTransform = this.enqueueActions(this.ctx.setTransform);
+        this.stroke = this.enqueueActions(this.ctx.stroke);
+        this.strokeRect = this.enqueueActions(this.ctx.strokeRect);
+        this.strokeText = this.enqueueActions(this.ctx.strokeText);
+        this.transform = this.enqueueActions(this.ctx.transform);
+        this.translate = this.enqueueActions(this.ctx.translate);
+    }
+    set ctx(e) {
+        this.__raw__ = e;
+    }
+    get ctx() {
+        return this.__raw__;
+    }
+    emptyActions() {
+        this.actions.length = 0;
+    }
+    enqueueActions(func) {
+        return (...args) => {
+            this.actions.push({
+                func,
+                args
+            });
+        };
+    }
+    set fillStyle(e) { this.enqueueActions(() => { this.ctx.fillStyle = e; }); }
+    get fillStyle() { return this.ctx.fillStyle; }
+    set font(e) { this.ctx.font = e; }
+    get font() { return this.ctx.font; }
+    set globalAlpha(e) { this.enqueueActions(() => { this.ctx.globalAlpha = e; }); }
+    get globalAlpha() { return this.ctx.globalAlpha; }
+    set globalCompositeOperation(e) { this.enqueueActions(() => { this.ctx.globalCompositeOperation = e; }); }
+    get globalCompositeOperation() { return this.ctx.globalCompositeOperation; }
+    set lineCap(e) { this.enqueueActions(() => { this.ctx.lineCap = e; }); }
+    get lineCap() { return this.ctx.lineCap; }
+    set lineDashOffset(e) { this.enqueueActions(() => { this.ctx.lineDashOffset = e; }); }
+    get lineDashOffset() { return this.ctx.lineDashOffset; }
+    set lineJoin(e) { this.enqueueActions(() => { this.ctx.lineJoin = e; }); }
+    get lineJoin() { return this.ctx.lineJoin; }
+    set lineWidth(e) { this.enqueueActions(() => { this.ctx.lineWidth = e; }); }
+    get lineWidth() { return this.ctx.lineWidth; }
+    set miterLimit(e) { this.enqueueActions(() => { this.ctx.miterLimit = e; }); }
+    get miterLimit() { return this.ctx.miterLimit; }
+    set shadowBlur(e) { this.enqueueActions(() => { this.ctx.shadowBlur = e; }); }
+    get shadowBlur() { return this.ctx.shadowBlur; }
+    set shadowColor(e) { this.enqueueActions(() => { this.ctx.shadowColor = e; }); }
+    get shadowColor() { return this.ctx.shadowColor; }
+    set shadowOffsetX(e) { this.enqueueActions(() => { this.ctx.shadowOffsetX = e; }); }
+    get shadowOffsetX() { return this.ctx.shadowOffsetX; }
+    set shadowOffsetY(e) { this.enqueueActions(() => { this.ctx.shadowOffsetY = e; }); }
+    get shadowOffsetY() { return this.ctx.shadowOffsetY; }
+    set strokeStyle(e) { this.enqueueActions(() => { this.ctx.strokeStyle = e; }); }
+    get strokeStyle() { return this.ctx.strokeStyle; }
+    set textAlign(e) { this.ctx.textAlign = e; }
+    get textAlign() { return this.ctx.textAlign; }
+    set textBaseline(e) { this.ctx.textBaseline = e; }
+    get textBaseline() { return this.ctx.textBaseline; }
+    set direction(e) { this.ctx.direction = e; }
+    get direction() { return this.ctx.direction; }
+    set imageSmoothingEnabled(e) { this.enqueueActions(() => { this.ctx.imageSmoothingEnabled = e; }); }
+    get imageSmoothingEnabled() { return this.ctx.imageSmoothingEnabled; }
+    set imageSmoothingQuality(e) { this.enqueueActions(() => { this.ctx.imageSmoothingQuality = e; }); }
+    get imageSmoothingQuality() { return this.ctx.imageSmoothingQuality; }
+    set filter(e) { this.enqueueActions(() => { this.ctx.filter = e; }); }
+    get filter() { return this.ctx.filter; }
+    createPattern(image, repetition) {
+        return this.createPattern(image, repetition);
+    }
+    async draw(reserve, callback) {
+        try {
+            if (!reserve) {
+                this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+            }
+            for (const { func, args } of this.actions) {
+                await func.apply(this.ctx, args);
+            }
+            this.emptyActions();
+            callback && callback();
+        }
+        catch (e) {
+            throw {
+                errMsg: e.message
+            };
+        }
+    }
+    drawImage(imageResource, ...extra) {
+        this.enqueueActions(() => {
+            if (typeof imageResource === 'string') {
+                const img = new Image();
+                img.src = imageResource;
+                return new Promise((resolve, reject) => {
+                    img.onload = () => {
+                        this.ctx.drawImage(img, ...extra);
+                        resolve();
+                    };
+                    img.onerror = reject;
+                });
+            }
+            this.ctx.drawImage(imageResource, ...extra);
+        });
+    }
+    setFillStyle(color) {
+        this.enqueueActions(() => { this.ctx.fillStyle = color; });
+    }
+    setFontSize(fontSize) {
+        this.font = `${fontSize}px`;
+    }
+    setGlobalAlpha(alpha) {
+        this.globalAlpha = alpha;
+    }
+    setLineCap(lineCap) {
+        this.lineCap = lineCap;
+    }
+    setLineDash(pattern, offset) {
+        this.enqueueActions(() => {
+            this.ctx.setLineDash(pattern);
+            this.ctx.lineDashOffset = offset;
+        });
+    }
+    setLineJoin(lineJoin) {
+        this.lineJoin = lineJoin;
+    }
+    setLineWidth(lineWidth) {
+        this.lineWidth = lineWidth;
+    }
+    setMiterLimit(miterLimit) {
+        this.miterLimit = miterLimit;
+    }
+    setShadow(offsetX, offsetY, blur, color) {
+        this.enqueueActions(() => {
+            this.ctx.shadowOffsetX = offsetX;
+            this.ctx.shadowOffsetY = offsetY;
+            this.ctx.shadowColor = color;
+            this.ctx.shadowBlur = blur;
+        });
+    }
+    setStrokeStyle(color) {
+        this.enqueueActions(() => { this.ctx.strokeStyle = color; });
+    }
+    setTextAlign(align) {
+        this.textAlign = align;
+    }
+    setTextBaseline(textBaseline) {
+        this.textBaseline = TextBaseLineMap[textBaseline] || 'alphabetic';
+    }
+    measureText(text) {
+        return this.measureText(text);
+    }
+    createCircularGradient(x, y, r) {
+        const radialGradient = this.ctx.createRadialGradient(x, y, 0, x, y, r);
+        return radialGradient;
+    }
+    createLinearGradient(x0, y0, x1, y1) {
+        return this.createLinearGradient(x0, y0, x1, y1);
+    }
+}

package/dist/api/canvas/canvasGetImageData.js

@@ -0,0 +1,21 @@
+import { MethodHandler } from '../utils/handler';
+import { findDOM } from '../utils';
+export const canvasGetImageData = ({ canvasId, success, fail, complete, x, y, width, height }, inst) => {
+    const handle = new MethodHandler({ name: 'canvasGetImageData', success, fail, complete });
+    const el = findDOM(inst);
+    const canvas = el === null || el === void 0 ? void 0 : el.querySelector(`canvas[canvas-id="${canvasId}"]`);
+    try {
+        const ctx = canvas === null || canvas === void 0 ? void 0 : canvas.getContext('2d');
+        const data = ctx === null || ctx === void 0 ? void 0 : ctx.getImageData(x, y, width, height);
+        return handle.success({
+            width,
+            height,
+            data
+        });
+    }
+    catch (e) {
+        return handle.fail({
+            errMsg: e.message
+        });
+    }
+};

package/dist/api/canvas/canvasPutImageData.js

@@ -0,0 +1,17 @@
+import { MethodHandler } from '../utils/handler';
+import { findDOM } from '../utils';
+export const canvasPutImageData = ({ canvasId, data, x, y, success, fail, complete }, inst) => {
+    const handle = new MethodHandler({ name: 'canvasPutImageData', success, fail, complete });
+    const el = findDOM(inst);
+    const canvas = el === null || el === void 0 ? void 0 : el.querySelector(`canvas[canvas-id="${canvasId}"]`);
+    try {
+        const ctx = canvas.getContext('2d');
+        ctx === null || ctx === void 0 ? void 0 : ctx.putImageData(data, x, y);
+        return handle.success();
+    }
+    catch (e) {
+        return handle.fail({
+            errMsg: e.message
+        });
+    }
+};

package/dist/api/canvas/canvasToTempFilePath.js

@@ -0,0 +1,18 @@
+import { findDOM } from '../utils';
+import { MethodHandler } from '../utils/handler';
+export const canvasToTempFilePath = ({ canvasId, fileType, quality, success, fail, complete }, inst) => {
+    const handle = new MethodHandler({ name: 'canvasToTempFilePath', success, fail, complete });
+    const el = findDOM(inst);
+    const canvas = el === null || el === void 0 ? void 0 : el.querySelector(`canvas[canvas-id="${canvasId}"]`);
+    try {
+        const dataURL = canvas === null || canvas === void 0 ? void 0 : canvas.toDataURL(`image/${fileType || 'png'}`, quality);
+        return handle.success({
+            tempFilePath: dataURL
+        });
+    }
+    catch (e) {
+        return handle.fail({
+            errMsg: e.message
+        });
+    }
+};

package/dist/api/canvas/createCanvasContext.js

@@ -0,0 +1,13 @@
+import { findDOM } from '../utils';
+import { CanvasContext } from './CanvasContext';
+export const createCanvasContext = (canvasId, inst) => {
+    const context = new CanvasContext();
+    const el = findDOM(inst);
+    const canvas = el === null || el === void 0 ? void 0 : el.querySelector(`canvas[canvas-id="${canvasId}"]`);
+    const ctx = canvas === null || canvas === void 0 ? void 0 : canvas.getContext('2d');
+    if (!ctx)
+        return context;
+    context.canvas = canvas;
+    context.ctx = ctx;
+    return context;
+};

package/dist/api/canvas/index.js

@@ -0,0 +1,7 @@
+import { temporarilyNotSupport } from '../utils';
+export const createOffscreenCanvas = temporarilyNotSupport('createOffscreenCanvas');
+export * from './createCanvasContext';
+export * from './canvasToTempFilePath';
+export * from './canvasPutImageData';
+export * from './canvasGetImageData';
+export const drawCanvas = temporarilyNotSupport('drawCanvas');

package/dist/api/cloud/index.js

@@ -0,0 +1,14 @@
+import { temporarilyNotSupport } from '../utils';
+export class cloud {
+    constructor() {
+        this.init = temporarilyNotSupport('cloud.init');
+        this.CloudID = temporarilyNotSupport('cloud.CloudID');
+        this.callFunction = temporarilyNotSupport('cloud.callFunction');
+        this.uploadFile = temporarilyNotSupport('cloud.uploadFile');
+        this.downloadFile = temporarilyNotSupport('cloud.downloadFile');
+        this.getTempFileURL = temporarilyNotSupport('cloud.getTempFileURL');
+        this.deleteFile = temporarilyNotSupport('cloud.deleteFile');
+        this.database = temporarilyNotSupport('cloud.database');
+        this.callContainer = temporarilyNotSupport('cloud.callContainer');
+    }
+}

package/dist/api/data-analysis/index.js

@@ -0,0 +1,5 @@
+import { temporarilyNotSupport } from '../utils';
+export const reportMonitor = temporarilyNotSupport('reportMonitor');
+export const reportAnalytics = temporarilyNotSupport('reportAnalytics');
+export const reportEvent = temporarilyNotSupport('reportEvent');
+export const getExptInfoSync = temporarilyNotSupport('getExptInfoSync');

package/dist/api/device/accelerometer.js

@@ -0,0 +1,71 @@
+import { CallbackManager, MethodHandler } from '../utils/handler';
+const callbackManager = new CallbackManager();
+let devicemotionListener;
+export const stopAccelerometer = ({ success, fail, complete } = {}) => {
+    const res = {};
+    const handle = new MethodHandler({ name: 'stopAccelerometer', success, fail, complete });
+    try {
+        window.removeEventListener('devicemotion', devicemotionListener, true);
+        return handle.success(res);
+    }
+    catch (e) {
+        res.errMsg = e.message;
+        return handle.fail(res);
+    }
+};
+const INTERVAL_MAP = {
+    game: {
+        interval: 20,
+        frequency: 50
+    },
+    ui: {
+        interval: 60,
+        frequency: 16.67
+    },
+    normal: {
+        interval: 200,
+        frequency: 5
+    }
+};
+const getDevicemotionListener = interval => {
+    let lock;
+    let timer;
+    return evt => {
+        if (lock)
+            return;
+        lock = true;
+        timer && clearTimeout(timer);
+        callbackManager.trigger({
+            x: evt.acceleration.x || 0,
+            y: evt.acceleration.y || 0,
+            z: evt.acceleration.z || 0
+        });
+        timer = setTimeout(() => { lock = false; }, interval);
+    };
+};
+export const startAccelerometer = ({ interval = 'normal', success, fail, complete } = {}) => {
+    const handle = new MethodHandler({ name: 'startAccelerometer', success, fail, complete });
+    try {
+        if (window.DeviceMotionEvent) {
+            const intervalObj = INTERVAL_MAP[interval];
+            if (devicemotionListener) {
+                stopAccelerometer();
+            }
+            devicemotionListener = getDevicemotionListener(intervalObj.interval);
+            window.addEventListener('devicemotion', devicemotionListener, true);
+        }
+        else {
+            throw new Error('accelerometer is not supported');
+        }
+        return handle.success();
+    }
+    catch (e) {
+        return handle.fail({ errMsg: e.message });
+    }
+};
+export const onAccelerometerChange = callback => {
+    callbackManager.add(callback);
+};
+export const offAccelerometerChange = callback => {
+    callbackManager.remove(callback);
+};

package/dist/api/device/accessibility.js

@@ -0,0 +1,2 @@
+import { temporarilyNotSupport } from '../utils';
+export const checkIsOpenAccessibility = temporarilyNotSupport('checkIsOpenAccessibility');

package/dist/api/device/battery.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+export const getBatteryInfoSync = temporarilyNotSupport('getBatteryInfoSync');
+export const getBatteryInfo = temporarilyNotSupport('getBatteryInfo');

package/dist/api/device/bluetooth-ble.js

@@ -0,0 +1,17 @@
+import { temporarilyNotSupport } from '../utils';
+export const writeBLECharacteristicValue = temporarilyNotSupport('writeBLECharacteristicValue');
+export const setBLEMTU = temporarilyNotSupport('setBLEMTU');
+export const readBLECharacteristicValue = temporarilyNotSupport('readBLECharacteristicValue');
+export const onBLEMTUChange = temporarilyNotSupport('onBLEMTUChange');
+export const onBLEConnectionStateChange = temporarilyNotSupport('onBLEConnectionStateChange');
+export const onBLECharacteristicValueChange = temporarilyNotSupport('onBLECharacteristicValueChange');
+export const offBLEMTUChange = temporarilyNotSupport('offBLEMTUChange');
+export const offBLEConnectionStateChange = temporarilyNotSupport('offBLEConnectionStateChange');
+export const offBLECharacteristicValueChange = temporarilyNotSupport('offBLECharacteristicValueChange');
+export const notifyBLECharacteristicValueChange = temporarilyNotSupport('notifyBLECharacteristicValueChange');
+export const getBLEMTU = temporarilyNotSupport('getBLEMTU');
+export const getBLEDeviceServices = temporarilyNotSupport('getBLEDeviceServices');
+export const getBLEDeviceRSSI = temporarilyNotSupport('getBLEDeviceRSSI');
+export const getBLEDeviceCharacteristics = temporarilyNotSupport('getBLEDeviceCharacteristics');
+export const createBLEConnection = temporarilyNotSupport('createBLEConnection');
+export const closeBLEConnection = temporarilyNotSupport('closeBLEConnection');

package/dist/api/device/bluetooth-peripheral.js

@@ -0,0 +1,4 @@
+import { temporarilyNotSupport } from '../utils';
+export const onBLEPeripheralConnectionStateChanged = temporarilyNotSupport('onBLEPeripheralConnectionStateChanged');
+export const offBLEPeripheralConnectionStateChanged = temporarilyNotSupport('offBLEPeripheralConnectionStateChanged');
+export const createBLEPeripheralServer = temporarilyNotSupport('createBLEPeripheralServer');

package/dist/api/device/bluetooth.js

@@ -0,0 +1,14 @@
+import { temporarilyNotSupport } from '../utils';
+export const stopBluetoothDevicesDiscovery = temporarilyNotSupport('stopBluetoothDevicesDiscovery');
+export const startBluetoothDevicesDiscovery = temporarilyNotSupport('startBluetoothDevicesDiscovery');
+export const openBluetoothAdapter = temporarilyNotSupport('openBluetoothAdapter');
+export const onBluetoothDeviceFound = temporarilyNotSupport('onBluetoothDeviceFound');
+export const onBluetoothAdapterStateChange = temporarilyNotSupport('onBluetoothAdapterStateChange');
+export const offBluetoothDeviceFound = temporarilyNotSupport('offBluetoothDeviceFound');
+export const offBluetoothAdapterStateChange = temporarilyNotSupport('offBluetoothAdapterStateChange');
+export const makeBluetoothPair = temporarilyNotSupport('makeBluetoothPair');
+export const isBluetoothDevicePaired = temporarilyNotSupport('isBluetoothDevicePaired');
+export const getConnectedBluetoothDevices = temporarilyNotSupport('getConnectedBluetoothDevices');
+export const getBluetoothDevices = temporarilyNotSupport('getBluetoothDevices');
+export const getBluetoothAdapterState = temporarilyNotSupport('getBluetoothAdapterState');
+export const closeBluetoothAdapter = temporarilyNotSupport('closeBluetoothAdapter');

package/dist/api/device/calendar.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+export const addPhoneRepeatCalendar = temporarilyNotSupport('addPhoneRepeatCalendar');
+export const addPhoneCalendar = temporarilyNotSupport('addPhoneCalendar');