@tarojs/plugin-platform-harmony-ets 3.7.0-alpha.27

package/dist/runtime.js

@@ -0,0 +1,4150 @@
+import { isFunction, isString, isArray, isObject, isNull, isNumber, isUndefined, queryToJson, PLATFORM_TYPE, singleQuote, internalComponents, mergeReconciler, mergeInternalComponents } from '@tarojs/shared';
+import _display from '@ohos.display';
+import { Current, window, getPageScrollerOrNode, findChildNodeWithDFS, setNodeEventCallbackAndTriggerComponentUpdate, AREA_CHANGE_EVENT_NAME, disconnectEvent, VISIBLE_CHANGE_EVENT_NAME, hooks } from '@tarojs/runtime';
+import { eventCenter, Events, History } from '@tarojs/runtime/dist/runtime.esm';
+import deviceInfo from '@ohos.deviceInfo';
+import i18n from '@ohos.i18n';
+import deviceMethod from '@system.device';
+import sensor from '@ohos.sensor';
+import batteryInfo, { BatteryChargeState } from '@ohos.batteryInfo';
+import pasteboard from '@ohos.pasteboard';
+import inputMethodEngine from '@ohos.inputMethodEngine';
+import network from '@system.network';
+import call from '@ohos.telephony.call';
+import brightness from '@system.brightness';
+import vibrator from '@ohos.vibrator';
+import document from '@ohos.document';
+import fileio from '@ohos.fileio';
+import zlib from '@ohos.zlib';
+import app from '@system.app';
+import file from '@system.file';
+import geoLocationManager from '@ohos.geoLocationManager';
+import mediaLibrary from '@ohos.multimedia.mediaLibrary';
+import picker from '@ohos.file.picker';
+import image from '@ohos.multimedia.image';
+import request$1 from '@ohos.request';
+import http from '@ohos.net.http';
+import webSocket from '@ohos.net.webSocket';
+import { pxTransformHelper } from '@tarojs/taro';
+import router from '@ohos.router';
+import bundleManager from '@ohos.bundle.bundleManager';
+import dataPreferences from '@ohos.data.preferences';
+import hilog from '@ohos.hilog';
+import matrix4 from '@ohos.matrix4';
+import prompt from '@ohos.prompt';
+
+class MethodHandler {
+    constructor({ name, success, fail, complete }) {
+        this.isHandlerError = false;
+        this.methodName = name;
+        this.__success = success;
+        this.__fail = fail;
+        this.__complete = complete;
+        this.isHandlerError = isFunction(this.__complete) || isFunction(this.__fail);
+    }
+    success(res = {}, promise = {}) {
+        if (!res.errMsg) {
+            res.errMsg = `${this.methodName}:ok`;
+        }
+        isFunction(this.__success) && this.__success(res);
+        isFunction(this.__complete) && this.__complete(res);
+        const { resolve = Promise.resolve.bind(Promise) } = promise;
+        return resolve(res);
+    }
+    fail(res = {}, promise = {}) {
+        if (!res.errMsg) {
+            res.errMsg = `${this.methodName}:fail`;
+        }
+        else {
+            res.errMsg = `${this.methodName}:fail ${res.errMsg}`;
+        }
+        isFunction(this.__fail) && this.__fail(res);
+        isFunction(this.__complete) && this.__complete(res);
+        const { resolve = Promise.resolve.bind(Promise), reject = Promise.reject.bind(Promise) } = promise;
+        return this.isHandlerError
+            ? resolve(res)
+            : reject(res);
+    }
+}
+class CallbackManager {
+    constructor() {
+        this.callbacks = [];
+        /** 添加回调 */
+        this.add = (opt) => {
+            if (opt)
+                this.callbacks.push(opt);
+        };
+        /** 移除回调 */
+        this.remove = (opt) => {
+            if (opt) {
+                let pos = -1;
+                this.callbacks.forEach((callback, k) => {
+                    if (callback === opt) {
+                        pos = k;
+                    }
+                });
+                if (pos > -1) {
+                    this.callbacks.splice(pos, 1);
+                }
+            }
+        };
+        /** 获取回调函数数量 */
+        this.count = () => {
+            return this.callbacks.length;
+        };
+        /** 触发回调 */
+        this.trigger = (...args) => {
+            this.callbacks.forEach(opt => {
+                if (isFunction(opt)) {
+                    opt(...args);
+                }
+                else {
+                    const { callback, ctx } = opt;
+                    isFunction(callback) && callback.call(ctx, ...args);
+                }
+            });
+        };
+    }
+}
+
+function shouldBeObject(target) {
+    if (target && typeof target === 'object')
+        return { flag: true };
+    return {
+        flag: false,
+        msg: getParameterError({
+            correct: 'Object',
+            wrong: target
+        })
+    };
+}
+function getParameterError({ name = '', para, correct, wrong, level = 'error' }) {
+    const parameter = para ? `parameter.${para}` : 'parameter';
+    const errorType = upperCaseFirstLetter(wrong === null ? 'Null' : typeof wrong);
+    return `${name ? `${name}:fail ` : ''}parameter ${level}: ${parameter} should be ${correct} instead of ${errorType}`;
+}
+function upperCaseFirstLetter(string) {
+    if (!isString(string))
+        return string;
+    string = string.replace(/^./, match => match.toUpperCase());
+    return string;
+}
+function getType(param) {
+    if (isNull(param)) {
+        return 'null';
+    }
+    else if (isArray(param)) {
+        return 'array';
+    }
+    else {
+        return typeof param;
+    }
+}
+function assertType(target, type, methodName, paramName) {
+    const correct = upperCaseFirstLetter(type);
+    if (correct !== upperCaseFirstLetter(getType(target))) {
+        const err = getParameterError({ name: methodName, para: paramName, correct, wrong: target });
+        throw new Error(err);
+    }
+}
+/**
+ * 用于校验方法的参数类型
+ * @param name 方法名称
+ * @param params [array|object] 当前参数
+ * @param schema [array|object] 参数类型规范
+ * @example
+ * ```js
+ * // 例子一：
+ * validateParams(methodA, [key], [string])
+ * // 例子二：
+ * validateParams(methodB, { key: 123 }, { key: number })
+ * ```
+ * @todo 校验可选参数
+ */
+const validateParams = function (name, params, schema) {
+    if (isArray(schema) && isString(schema[0])) {
+        schema.forEach((correctType, index) => assertType(params[index], correctType, name, `[${index}]`));
+    }
+    else if (isObject(schema)) {
+        const optionsSchema = schema;
+        assertType(params, 'object', name);
+        for (const key in optionsSchema) {
+            assertType(params[key], optionsSchema[key], name, key);
+        }
+    }
+};
+
+function object2String(obj) {
+    let str = '';
+    for (const item in obj) {
+        str = str + item + ':' + obj[item] + ' \n';
+    }
+    return str;
+}
+function temporarilyNotSupport(name, recommended) {
+    return (option = {}, ...args) => {
+        const { success, fail, complete } = option;
+        const handle = new MethodHandler({ name, success, fail, complete });
+        let errMsg = '暂时不支持 API';
+        if (recommended) {
+            errMsg += `, 请使用 ${recommended}`;
+        }
+        eventCenter.trigger('__taroNotSupport', {
+            name,
+            args: [option, ...args],
+            type: 'method',
+            category: 'temporarily',
+        });
+        if (process.env.NODE_ENV === 'production') {
+            console.warn(errMsg);
+            return handle.success({ errMsg });
+        }
+        else {
+            return handle.fail({ errMsg });
+        }
+    };
+}
+function permanentlyNotSupport(name = '') {
+    return (option = {}, ...args) => {
+        const { success, fail, complete } = option;
+        const handle = new MethodHandler({ name, success, fail, complete });
+        const errMsg = '不支持 API';
+        eventCenter.trigger('__taroNotSupport', {
+            name,
+            args: [option, ...args],
+            type: 'method',
+            category: 'permanently',
+        });
+        if (process.env.NODE_ENV === 'production') {
+            console.warn(errMsg);
+            return handle.success({ errMsg });
+        }
+        else {
+            return handle.fail({ errMsg });
+        }
+    };
+}
+/** @deprecated */
+function callCallbackSuccess(res, options) {
+    var _a, _b;
+    (_a = options === null || options === void 0 ? void 0 : options.success) === null || _a === void 0 ? void 0 : _a.call(options, res);
+    (_b = options === null || options === void 0 ? void 0 : options.complete) === null || _b === void 0 ? void 0 : _b.call(options, res);
+}
+/** @deprecated */
+function callCallbackFail(res, options) {
+    var _a, _b;
+    (_a = options === null || options === void 0 ? void 0 : options.fail) === null || _a === void 0 ? void 0 : _a.call(options, res);
+    (_b = options === null || options === void 0 ? void 0 : options.complete) === null || _b === void 0 ? void 0 : _b.call(options, res);
+}
+/** @deprecated */
+function callAsyncSuccess(resolve, res, options) {
+    var _a, _b;
+    (_a = options === null || options === void 0 ? void 0 : options.success) === null || _a === void 0 ? void 0 : _a.call(options, res);
+    (_b = options === null || options === void 0 ? void 0 : options.complete) === null || _b === void 0 ? void 0 : _b.call(options, res);
+    resolve(res);
+}
+/** @deprecated */
+function callAsyncFail(reject, res, options) {
+    var _a, _b;
+    (_a = options === null || options === void 0 ? void 0 : options.fail) === null || _a === void 0 ? void 0 : _a.call(options, res);
+    (_b = options === null || options === void 0 ? void 0 : options.complete) === null || _b === void 0 ? void 0 : _b.call(options, res);
+    reject(res);
+}
+
+// 设备信息,从 API Version 6 开始支持
+const display = _display.getDefaultDisplaySync();
+let device;
+deviceMethod.getInfo({
+    success: data => {
+        device = data;
+    }
+});
+/* 同步版本 */
+const getSystemInfoSync = function () {
+    const res = {};
+    res.SDKVersion = deviceInfo && deviceInfo.sdkApiVersion; // 客户端基础库版本 string
+    res.albumAuthorized = false; // 允许使用相册的开关（仅 iOS 有效） boolean
+    res.benchmarkLevel = null; // 设备性能等级 number
+    res.bluetoothEnabled = null; // 蓝牙的系统开关 boolean
+    res.brand = deviceInfo && deviceInfo.brand; // 设备品牌 string
+    res.cameraAuthorized = null; // 允许使用摄像头的开关 boolean
+    res.enableDebug = null; // 是否已打开调试 boolean
+    res.fontSizeSetting = null; // 用户字体大小（单位px） number
+    res.language = i18n && i18n.getSystemLanguage && i18n.getSystemLanguage(); // string
+    res.locationAuthorized = null; // 定位的开关 boolean
+    res.locationEnabled = null; // 地理位置的系统开关 boolean
+    res.microphoneAuthorized = null; // 麦克风的开关 boolean
+    res.model = deviceInfo && deviceInfo.deviceType; // 设备型号 string
+    res.notificationAuthorized = null; // 通知的开关 boolean
+    res.notificationAlertAuthorized = false; // 通知带有提醒的开关（仅 iOS 有效） boolean
+    res.notificationBadgeAuthorized = false; // 通知带有标记的开关（仅 iOS 有效） boolean
+    res.notificationSoundAuthorized = false; // 通知带有声音的开关（仅 iOS 有效）boolean
+    res.phoneCalendarAuthorized = null; // 使用日历的开关 boolean
+    res.wifiEnabled = false; // Wi-Fi 的系统开关 boolean
+    res.pixelRatio = null; // 设备像素比,number
+    res.platform = 'android'; // 客户端平台 string
+    res.safeArea = null; // 在竖屏正方向下的安全区域 General.SafeAreaResult
+    res.screenHeight = display && display.height; // 屏幕高度，单位px number
+    res.screenWidth = display && display.width; // 屏幕宽度，单位px number
+    res.statusBarHeight = null; // 状态栏的高度，单位px number
+    res.system = deviceInfo && deviceInfo.osFullName; // 操作系统及版本 string
+    res.theme = null; // 系统当前主题，取值为light或dark 'light' | 'dark'
+    res.windowWidth = device && device.windowWidth; // 可使用窗口宽度，单位px number
+    res.windowHeight = device && device.windowHeight; // 可使用窗口高度，单位px number
+    res.version = deviceInfo && deviceInfo.displayVersion; // 版本号 string
+    return res;
+};
+/* 异步版本 */
+const getSystemInfo = function (options) {
+    let res = {};
+    return new Promise((resolve, reject) => {
+        try {
+            res = getSystemInfoSync();
+            callAsyncSuccess(resolve, res, options);
+        }
+        catch (error) {
+            res = {
+                errMsg: `getSystemInfo:fail ${error && error.toString && error.toString()}`,
+                error: error
+            };
+            callAsyncFail(reject, res, options);
+        }
+    });
+};
+globalThis.getSystemInfoSync = getSystemInfoSync;
+
+const getUpdateManager = temporarilyNotSupport('getUpdateManager');
+
+const callbackManager$1 = new CallbackManager();
+let devicemotionListener;
+/**
+ * 停止监听加速度数据。
+ */
+const stopAccelerometer = ({ success, fail, complete } = {}) => {
+    const res = {};
+    const handle = new MethodHandler({ name: 'stopAccelerometer', success, fail, complete });
+    try {
+        sensor.off(sensor.SensorType.SENSOR_TYPE_ID_ACCELEROMETER, devicemotionListener);
+        return handle.success(res);
+    }
+    catch (e) {
+        res.errMsg = e.message;
+        return handle.fail(res);
+    }
+};
+const INTERVAL_MAP = {
+    game: {
+        interval: 20 * 1000 * 1000,
+        frequency: 50
+    },
+    ui: {
+        interval: 60 * 1000 * 1000,
+        frequency: 16.67
+    },
+    normal: {
+        interval: 200 * 1000 * 1000,
+        frequency: 5
+    }
+};
+/**
+ * 开始监听加速度数据。
+ */
+const startAccelerometer = ({ interval = 'normal', success, fail, complete } = {}) => {
+    const handle = new MethodHandler({ name: 'startAccelerometer', success, fail, complete });
+    try {
+        const intervalObj = INTERVAL_MAP[interval];
+        if (devicemotionListener) ;
+        sensor.on(sensor.SensorType.SENSOR_TYPE_ID_ACCELEROMETER, (data) => {
+            callbackManager$1.trigger({
+                x: (data === null || data === void 0 ? void 0 : data.x) || 0,
+                y: (data === null || data === void 0 ? void 0 : data.y) || 0,
+                z: (data === null || data === void 0 ? void 0 : data.z) || 0
+            });
+        }, {
+            interval: intervalObj.interval,
+        });
+        return handle.success();
+    }
+    catch (e) {
+        return handle.fail({ errMsg: e.message });
+    }
+};
+/**
+ * 监听加速度数据事件。频率根据 Taro.startAccelerometer() 的 interval 参数。可使用 Taro.stopAccelerometer() 停止监听。
+ */
+const onAccelerometerChange = callback => {
+    callbackManager$1.add(callback);
+};
+/**
+ * 取消监听加速度数据事件，参数为空，则取消所有的事件监听
+ */
+const offAccelerometerChange = callback => {
+    callbackManager$1.remove(callback);
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+// 电量
+const getBatteryInfoSync = () => ({
+    // @ts-ignore
+    isCharging: [BatteryChargeState.ENABLE, BatteryChargeState.FULL].includes(batteryInfo.chargingStatus),
+    level: batteryInfo.batterySOC
+});
+const getBatteryInfo = ({ success, fail, complete } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const handle = new MethodHandler({ name: 'getBatteryInfo', success, fail, complete });
+    try {
+        return handle.success(getBatteryInfoSync());
+    }
+    catch (error) {
+        return handle.fail({
+            errMsg: (error === null || error === void 0 ? void 0 : error.message) || error
+        });
+    }
+});
+
+// 从 API Version 6 开始支持
+/**
+ * 设置系统剪贴板的内容
+ */
+const setClipboardData = function (options) {
+    const { data, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'setClipboardData', success, fail, complete });
+    let res = {};
+    if (!isString(data)) {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'data',
+                correct: 'String',
+                wrong: data
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const systemPasteboard = pasteboard.getSystemPasteboard();
+        const pasteData = pasteboard.createPlainTextData(data);
+        systemPasteboard.setPasteData(pasteData, (error, data) => {
+            if (error) {
+                console.error('Failed to set PasteData. Cause: ' + JSON.stringify(error));
+                res = {
+                    errMsg: 'setClipboardData:fail,error: ' + object2String(error),
+                    error: error
+                };
+                callAsyncFail(reject, res, options);
+            }
+            else {
+                return handle.success({
+                    data,
+                }, { resolve, reject });
+            }
+        });
+    });
+};
+/**
+ * 获取系统剪贴板的内容
+ */
+const getClipboardData = function (options) {
+    const { success, fail, complete } = options || {};
+    const handle = new MethodHandler({ name: 'getClipboardData', success, fail, complete });
+    return new Promise((resolve, reject) => {
+        const systemPasteboard = pasteboard.getSystemPasteboard();
+        systemPasteboard.getPasteData((error, pasteData) => {
+            if (error) {
+                console.error('Failed to obtain PasteData. Cause: ' + JSON.stringify(error));
+                return handle.fail({
+                    errMsg: object2String(error),
+                }, { resolve, reject });
+            }
+            else {
+                return handle.success({
+                    data: pasteData.getPrimaryText(),
+                }, { resolve, reject });
+            }
+        });
+    });
+};
+
+const callbackManager = new CallbackManager();
+const resizeListener = (height) => {
+    callbackManager.trigger({
+        height,
+    });
+};
+let topWindow;
+const onKeyboardHeightChange = callback => {
+    callbackManager.add(callback);
+    if (callbackManager.count() === 1) {
+        Current.contextPromise
+            .then(context => {
+            const win = window.__ohos.getLastWindow(context);
+            win.then(mainWindow => {
+                topWindow = mainWindow;
+                topWindow.on('keyboardHeightChange', resizeListener);
+            });
+        });
+    }
+};
+const offKeyboardHeightChange = callback => {
+    callbackManager.remove(callback);
+    if (callbackManager.count() === 0) {
+        topWindow === null || topWindow === void 0 ? void 0 : topWindow.off('keyboardHeightChange', resizeListener);
+    }
+};
+// @ts-ignore
+let keyboardController;
+inputMethodEngine.getInputMethodAbility()
+    // FIXME 当前事件无效，等待鸿蒙方面沟通
+    .on('inputStart', (kbController) => {
+    keyboardController = kbController;
+});
+const hideKeyboard = function (options) {
+    const { success, fail, complete } = options || {};
+    const handle = new MethodHandler({ name: 'hideKeyboard', success, fail, complete });
+    return new Promise((resolve, reject) => {
+        keyboardController === null || keyboardController === void 0 ? void 0 : keyboardController.hide((err) => {
+            if (err) {
+                return handle.fail({
+                    errMsg: err,
+                }, { resolve, reject });
+            }
+            return handle.success({}, { resolve, reject });
+        });
+    });
+};
+const getSelectedTextRange = /* @__PURE__ */ temporarilyNotSupport('getSelectedTextRange');
+
+const onMemoryWarning = temporarilyNotSupport('onMemoryWarning');
+const offMemoryWarning = temporarilyNotSupport('offMemoryWarning');
+
+const getNetworkType = (options = {}) => {
+    const { success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'getNetworkType', success, fail, complete });
+    return new Promise((resolve, reject) => {
+        network.getType({
+            success: function (data) {
+                return handle.success({
+                    networkType: data.type || 'unknown',
+                    metered: data.metered
+                }, { resolve, reject });
+            },
+            fail: function (data, code) {
+                return handle.fail({
+                    errMsg: data || '',
+                    code
+                }, { resolve, reject });
+            },
+        });
+    });
+};
+const networkStatusManager = new CallbackManager();
+const networkStatusListener = (data, code = 0) => __awaiter(void 0, void 0, void 0, function* () {
+    if (code > 0) {
+        return networkStatusManager.trigger({ isConnected: false, networkType: 'none' });
+    }
+    const networkType = data.type || 'unknown';
+    const isConnected = networkType !== 'none';
+    const metered = !!data.metered;
+    const obj = { isConnected, networkType, metered };
+    networkStatusManager.trigger(obj);
+});
+/**
+ * 在最近的八次网络请求中, 出现下列三个现象之一则判定弱网。
+ * - 出现三次以上连接超时
+ * - 出现三次 rtt 超过 400
+ * - 出现三次以上的丢包
+ * > 弱网事件通知规则是: 弱网状态变化时立即通知, 状态不变时 30s 内最多通知一次。
+ */
+const onNetworkWeakChange = /* @__PURE__ */ temporarilyNotSupport('onNetworkWeakChange');
+const onNetworkStatusChange = callback => {
+    networkStatusManager.add(callback);
+    if (networkStatusManager.count() === 1) {
+        network.subscribe({
+            success: networkStatusListener,
+            fail: networkStatusListener,
+        });
+    }
+};
+const offNetworkWeakChange = /* @__PURE__ */ temporarilyNotSupport('offNetworkWeakChange');
+const offNetworkStatusChange = callback => {
+    networkStatusManager.remove(callback);
+    if (networkStatusManager.count() === 0) {
+        network.unsubscribe();
+    }
+};
+const getLocalIPAddress = /* @__PURE__ */ temporarilyNotSupport('getLocalIPAddress');
+
+// 从 API Version 7 开始支持。
+const makePhoneCall = (options) => {
+    // options must be an Object
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `makePhoneCall:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { phoneNumber, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'makePhoneCall', success, fail, complete });
+    if (!isString(phoneNumber)) {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'phoneNumber',
+                correct: 'String',
+                wrong: phoneNumber
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        call.makeCall(phoneNumber, err => {
+            if (err) {
+                console.error('Failed to makePhoneCall. Cause: ' + JSON.stringify(err));
+                return handle.fail({
+                    errMsg: object2String(err)
+                }, { resolve, reject });
+            }
+            else {
+                return handle.success({}, { resolve, reject });
+            }
+        });
+    });
+};
+
+// 从API Version 7 开始，该接口不再维护，推荐使用新接口'@ohos.brightness'
+// 但是 新接口 @ohos.brightness 没有 getValue
+// 屏幕
+const setVisualEffectOnCapture = /* @__PURE__ */ temporarilyNotSupport('setVisualEffectOnCapture');
+const setScreenBrightness = function (options) {
+    // options must be an Object
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `setScreenBrightness:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { value, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'setScreenBrightness', success, fail, complete });
+    if (!isNumber(value)) {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'value',
+                correct: 'Number',
+                wrong: value
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        brightness.setValue({
+            // FIXME 不生效
+            value: value >= 0 && value <= 1 ? value * 255 : value,
+            success: function () {
+                return handle.success({}, { resolve, reject });
+            },
+            fail: function (data, code) {
+                return handle.fail({
+                    errMsg: data || '',
+                    code
+                }, { resolve, reject });
+            }
+        });
+    });
+};
+const setKeepScreenOn = /* @__PURE__ */ temporarilyNotSupport('setKeepScreenOn');
+const onUserCaptureScreen = /* @__PURE__ */ temporarilyNotSupport('onUserCaptureScreen');
+const offUserCaptureScreen = /* @__PURE__ */ temporarilyNotSupport('offUserCaptureScreen');
+const getScreenBrightness = function (options) {
+    const { success, fail, complete } = options || {};
+    const handle = new MethodHandler({ name: 'getScreenBrightness', success, fail, complete });
+    return new Promise((resolve, reject) => {
+        brightness.getValue({
+            success: function (data) {
+                return handle.success({
+                    value: data.value
+                }, { resolve, reject });
+            },
+            fail: function (data, code) {
+                return handle.fail({
+                    errMsg: data || '',
+                    code
+                }, { resolve, reject });
+            }
+        });
+    });
+};
+const onScreenRecordingStateChanged = /* @__PURE__ */ temporarilyNotSupport('onScreenRecordingStateChanged');
+const offScreenRecordingStateChanged = /* @__PURE__ */ temporarilyNotSupport('offScreenRecordingStateChanged');
+const getScreenRecordingState = /* @__PURE__ */ temporarilyNotSupport('getScreenRecordingState');
+
+const VIBRATOR_LONG_TIME = 400;
+const VIBRATOR_SHORT_TIME = 15;
+function vibrateBaseGenerator(time) {
+    return (options) => {
+        return new Promise((resolve, reject) => {
+            vibrator.vibrate(time).then(() => {
+                const res = { errMsg: 'vibrateShort:ok' };
+                callAsyncSuccess(resolve, res, options);
+            }, (error) => {
+                const res = { errMsg: 'vibrateShort:fail' + error };
+                callAsyncFail(reject, res, options);
+            });
+        });
+    };
+}
+const vibrateLong = vibrateBaseGenerator(VIBRATOR_LONG_TIME);
+const vibrateShort = vibrateBaseGenerator(VIBRATOR_SHORT_TIME);
+
+/**
+ * HarmonyOS 文档：
+ * https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-fileio-0000001168366687
+ *
+ * WX 文档：
+ * https://developers.weixin.qq.com/miniprogram/dev/api/file/FileSystemManager.html
+ *
+ * Taro.js 文档
+ * https://taro-docs.jd.com/taro/docs/apis/files/FileSystemManager
+ *
+ * HarmonyOS 不支持接口：
+ * readCompressedFile
+ * readCompressedFileSync
+ * readdirSync
+ * readZipEntry
+ *
+ * HarmonyOS 差异性接口：
+ * readFile：encoding 仅支持 utf-8
+ * readFileSync：encoding 仅支持 utf-8
+ * write：encoding 仅支持 utf-8
+ * writeSync：encoding 仅支持 utf-8
+ * rmdirSync：recursive 参数无效（即不支持递归删除）
+ * statSync：recursive 参数无效（即不支持递归获取目录下的每个文件的 Stats 信息）
+ * getSavedFileList：返回值 fileList 中的每一项不包含 createTime 属性
+ */
+var _a;
+const rootDataPath = `/data/data/${((_a = app.getInfo()) === null || _a === void 0 ? void 0 : _a.appID) || 'app'}`;
+const rootSavedFilePath = `${rootDataPath}/files`;
+const pathSchema = {
+    path: 'String'
+};
+const copyFileSchema = {
+    srcPath: 'String',
+    destPath: 'String'
+};
+const filePathSchema$1 = {
+    filePath: 'String'
+};
+const dirPathSchema = {
+    dirPath: 'String'
+};
+const readSchema = {
+    fd: 'String',
+    arrayBuffer: 'Object'
+};
+const writeSchema = {
+    fd: 'String',
+    data: 'String'
+};
+const renameSchema = {
+    newPath: 'String',
+    oldPath: 'String'
+};
+const fdSchema = {
+    fd: 'String'
+};
+const saveFileSchema = {
+    tempFilePath: 'String'
+};
+const unzipSchema = {
+    targetPath: 'String',
+    zipFilePath: 'String'
+};
+function convertFilePathToUri(filePath) {
+    let uri = filePath.replace(/\/+/g, '/').replace(rootDataPath, 'internal:').replace('internal:/files', 'internal:/app');
+    uri = /\/$/.test(uri) ? uri : `${uri}/`;
+    return uri.replace(/\//g, '//');
+}
+function convertUriToFilePath(uri) {
+    return uri.replace(/\/+/g, '/').replace('internal:/app', 'internal:/files').replace('internal:', rootDataPath);
+}
+function convertDataToString(data) {
+    if (isString(data)) {
+        return data;
+    }
+    return String.fromCharCode.apply(null, new Uint8Array(data));
+}
+function convertReadOption(option) {
+    const result = {};
+    const { offset, length, position } = option;
+    if (isNumber(offset)) {
+        result.offset = offset;
+    }
+    if (isNumber(length)) {
+        result.length = length;
+    }
+    if (isNumber(position)) {
+        result.position = position;
+    }
+    return result;
+}
+function convertWriteOption(option) {
+    const result = {
+        encoding: 'utf-8'
+    };
+    const { offset, length, position } = option;
+    if (isNumber(offset)) {
+        result.offset = offset;
+    }
+    if (isNumber(length)) {
+        result.length = length;
+    }
+    if (isNumber(position)) {
+        result.position = position;
+    }
+    return result;
+}
+function convertReadFileOption(option) {
+    const result = {
+        encoding: 'utf-8'
+    };
+    const { position, length } = option;
+    if (isNumber(position)) {
+        result.position = position;
+    }
+    if (isNumber(length)) {
+        result.length = length;
+    }
+    return result;
+}
+function convertFd(fd) {
+    return parseInt(fd, 10);
+}
+/**
+ * HarmonyOS flag 详情参见：
+ * https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-fileio-0000001168366687#section1153565865716
+ */
+function convertOpenFlag(flag) {
+    if (typeof flag === 'string') {
+        switch (flag) {
+            case 'a':
+                return 0o1 | 0o100 | 0o2000;
+            case 'ax':
+                return 0o1 | 0o100 | 0o2000 | 0o200;
+            case 'a+':
+                return 0o2 | 0o100 | 0o2000;
+            case 'ax+':
+                return 0o2 | 0o100 | 0o2000 | 0o200;
+            case 'as':
+                return 0o1 | 0o100 | 0o2000 | 0o4010000;
+            case 'as+':
+                return 0o2 | 0o100 | 0o2000 | 0o4010000;
+            case 'r':
+                return 0o0;
+            case 'r+':
+                return 0o2;
+            case 'w':
+                return 0o1 | 0o100 | 0o1000;
+            case 'wx':
+                return 0o1 | 0o100 | 0o200;
+            case 'w+':
+                return 0o2 | 0o100 | 0o1000;
+            case 'wx+':
+                return 0o2 | 0o100 | 0o200;
+            default:
+                return 0o0;
+        }
+    }
+    else {
+        return 0o0;
+    }
+}
+function validateSavedFilePath(savedFilePath) {
+    if (savedFilePath.indexOf(rootSavedFilePath) !== 0) {
+        throw new Error(`The filePath should in ${rootSavedFilePath}`);
+    }
+}
+function parseSavedFilePath(srcPath, savedFilePath) {
+    if (isString(savedFilePath) && savedFilePath.length > 0) {
+        validateSavedFilePath(savedFilePath);
+        return savedFilePath;
+    }
+    return `${rootSavedFilePath}/${srcPath.split('/').pop()}`;
+}
+function isFileExist(filePath) {
+    try {
+        accessSync(filePath);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+function getDirFiles(dirPath) {
+    return new Promise((resolve, reject) => {
+        file.list({
+            uri: convertFilePathToUri(dirPath),
+            success: ({ fileList }) => {
+                resolve({
+                    files: fileList.filter(({ type }) => type.toLowerCase() === 'file').map(({ uri }) => convertUriToFilePath(uri)),
+                    dirs: fileList.filter(({ type }) => type.toLowerCase() === 'dir').map(({ uri }) => convertUriToFilePath(uri))
+                });
+            },
+            fail: (error) => {
+                reject(new Error(error));
+            }
+        });
+    });
+}
+const readCompressedFile = temporarilyNotSupport('readCompressedFile');
+function readCompressedFileSync(_) {
+    temporarilyNotSupport('readCompressedFileSync')(_);
+    return new ArrayBuffer(0);
+}
+function readdirSync(_) {
+    temporarilyNotSupport('readdirSync')(_);
+    return [];
+}
+const readZipEntry = temporarilyNotSupport('readZipEntry');
+function access(option) {
+    try {
+        validateParams('access', option, pathSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.access(option.path, (error) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess(undefined, option);
+        }
+    });
+}
+function accessSync(path) {
+    fileio.accessSync(path);
+}
+function mkdir(option) {
+    try {
+        validateParams('mkdir', option, dirPathSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    file.mkdir({
+        uri: convertFilePathToUri(option.dirPath),
+        recursive: option.recursive,
+        success: () => callCallbackSuccess(undefined, option),
+        fail: (error, code) => {
+            const res = { errMsg: `mkdir invoke failed, code: ${code}, error: ${error}` };
+            callCallbackFail(res, option);
+        }
+    });
+}
+function mkdirSync(dirPath, recursive) {
+    if (recursive === true) {
+        const pathParts = dirPath.split('/');
+        for (let index = 0; index < pathParts.length; index++) {
+            const filePath = pathParts.slice(0, index + 1).join('/');
+            if (filePath.length === 0 || isFileExist(filePath)) {
+                continue;
+            }
+            fileio.mkdirSync(filePath);
+        }
+    }
+    else {
+        fileio.mkdirSync(dirPath);
+    }
+}
+function rmdir(option) {
+    try {
+        validateParams('rmdir', option, dirPathSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    file.rmdir({
+        uri: convertFilePathToUri(option.dirPath),
+        recursive: option.recursive,
+        success: () => callCallbackSuccess(undefined, option),
+        fail: (error, code) => {
+            const res = { errMsg: `rmdir invoke failed, code: ${code}, error: ${error}` };
+            callCallbackFail(res, option);
+        }
+    });
+}
+function rmdirSync(dirPath, recursive) {
+    if (recursive === true) {
+        temporarilyNotSupport('rmdirSync recursive')(dirPath);
+    }
+    else {
+        fileio.rmdirSync(dirPath);
+    }
+}
+function readdir(option) {
+    try {
+        validateParams('readdir', option, dirPathSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    getDirFiles(option.dirPath).then(({ files, dirs }) => {
+        callCallbackSuccess({ files: [...files, ...dirs] }, option);
+    }).catch((error) => {
+        const res = { errMsg: error.message };
+        callCallbackFail(res, option);
+    });
+}
+function copyFile(option) {
+    try {
+        validateParams('copyFile', option, copyFileSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.copyFile(option.srcPath, option.destPath, 0, (error) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess(undefined, option);
+        }
+    });
+}
+function copyFileSync(srcPath, destPath) {
+    fileio.copyFileSync(srcPath, destPath, 0);
+}
+function open(option) {
+    try {
+        validateParams('open', option, filePathSchema$1);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    // 由于 HarmonyOS 异步方法 fileio.open 在【文件不存在则创建】模式下依旧抛出 No such file or directory 异常，
+    // 为保证接口的可用性，此处降级使用 fileio.openSync 方法。
+    const openPromise = new Promise((resolve, reject) => {
+        try {
+            const fd = fileio.openSync(option.filePath, convertOpenFlag(option.flag), 0o666);
+            resolve({ fd: fd.toString() });
+        }
+        catch (error) {
+            reject(new Error(error.message ? error.message : error));
+        }
+    });
+    openPromise.then((res) => callCallbackSuccess(res, option))
+        .catch((error) => callCallbackFail({ errMsg: error.message }, option));
+}
+function openSync(option) {
+    validateParams('openSync', option, filePathSchema$1);
+    return fileio.openSync(option.filePath, convertOpenFlag(option.flag), 0o666).toString();
+}
+function read(option) {
+    try {
+        validateParams('read', option, readSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.read(convertFd(option.fd), option.arrayBuffer, convertReadOption(option), (error, readOut) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess({ bytesRead: readOut.bytesRead, arrayBuffer: readOut.buffer }, option);
+        }
+    });
+}
+function readSync(option) {
+    validateParams('readSync', option, readSchema);
+    return {
+        bytesRead: fileio.readSync(convertFd(option.fd), option.arrayBuffer, convertReadOption(option)),
+        arrayBuffer: option.arrayBuffer
+    };
+}
+/**
+ * HarmonyOS encoding 目前仅支持 utf-8，详情参见：
+ * https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-fileio-0000001168366687#section17477155374810
+ */
+function readFile(option) {
+    try {
+        validateParams('readFile', option, filePathSchema$1);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.readText(option.filePath, convertReadFileOption(option), (error, data) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess({ data }, option);
+        }
+    });
+}
+/**
+ * HarmonyOS encoding 目前仅支持 utf-8，详情参见：
+ * https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-fileio-0000001168366687#section4147155065718
+ */
+function readFileSync(filePath, encoding, position, length) {
+    return fileio.readTextSync(filePath, convertReadFileOption({ filePath, encoding, length, position }));
+}
+/**
+ * HarmonyOS encoding 目前仅支持 utf-8，详情参见：
+ * https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-fileio-0000001168366687#section140547195118
+ */
+function write(option) {
+    const data = convertDataToString(option.data);
+    try {
+        validateParams('write', Object.assign(Object.assign({}, option), { data }), writeSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.write(convertFd(option.fd), data, convertWriteOption(option), (error, bytesWritten) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess({ bytesWritten }, option);
+        }
+    });
+}
+/**
+ * HarmonyOS encoding 目前仅支持 utf-8，详情参见：
+ * https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-fileio-0000001168366687#section144923345218
+ */
+function writeSync(option) {
+    const data = convertDataToString(option.data);
+    validateParams('writeSync', Object.assign(Object.assign({}, option), { data }), writeSchema);
+    return {
+        bytesWritten: fileio.writeSync(convertFd(option.fd), data, convertWriteOption(option))
+    };
+}
+function writeFileWithFlag(option, flag) {
+    open({
+        flag,
+        filePath: option.filePath,
+        success: ({ fd }) => {
+            const writePromise = new Promise((resolve) => {
+                write({
+                    fd,
+                    data: option.data,
+                    success: (res) => resolve({
+                        error: null,
+                        res
+                    }),
+                    fail: (res) => resolve({
+                        error: res,
+                        res: null
+                    })
+                });
+            });
+            writePromise.then(({ error, res }) => {
+                close({
+                    fd,
+                    success: () => {
+                        if (error === null) {
+                            callCallbackSuccess(res, option);
+                        }
+                        else {
+                            callCallbackFail(error, option);
+                        }
+                    },
+                    fail: (res) => callCallbackFail(res, option)
+                });
+            });
+        },
+        fail: (res) => callCallbackFail(res, option)
+    });
+}
+function writeFile(option) {
+    writeFileWithFlag(option, 'w');
+}
+function writeFileSyncWithFlag(filePath, data, flag) {
+    const fd = openSync({ filePath, flag });
+    writeSync({ fd, data });
+    closeSync({ fd });
+}
+function writeFileSync(filePath, data) {
+    writeFileSyncWithFlag(filePath, data, 'w');
+}
+function appendFile(option) {
+    writeFileWithFlag(option, 'a');
+}
+function appendFileSync(filePath, data) {
+    writeFileSyncWithFlag(filePath, data, 'a');
+}
+function rename(option) {
+    try {
+        validateParams('rename', option, renameSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.rename(option.oldPath, option.newPath, (error) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess(undefined, option);
+        }
+    });
+}
+function renameSync(oldPath, newPath) {
+    fileio.renameSync(oldPath, newPath);
+}
+function unlink(option) {
+    try {
+        validateParams('unlink', option, filePathSchema$1);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.unlink(option.filePath, (error) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess(undefined, option);
+        }
+    });
+}
+function unlinkSync(filePath) {
+    fileio.unlinkSync(filePath);
+}
+function fstat(option) {
+    try {
+        validateParams('fstat', option, fdSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.fstat(convertFd(option.fd), (error, stats) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            const res = {
+                mode: stats.mode.toString(),
+                size: stats.size,
+                lastAccessedTime: stats.atime,
+                lastModifiedTime: stats.mtime,
+                isDirectory: () => stats.isDirectory(),
+                isFile: () => stats.isFile()
+            };
+            callCallbackSuccess({ stats: res }, option);
+        }
+    });
+}
+function fstatSync(option) {
+    validateParams('fstatSync', option, fdSchema);
+    const stats = fileio.fstatSync(convertFd(option.fd));
+    return {
+        mode: stats.mode.toString(),
+        size: stats.size,
+        lastAccessedTime: stats.atime,
+        lastModifiedTime: stats.mtime,
+        isDirectory: () => stats.isDirectory(),
+        isFile: () => stats.isFile()
+    };
+}
+function statWithFd(fd) {
+    return new Promise((resolve) => {
+        fstat({
+            fd,
+            success: ({ stats }) => resolve({
+                stats,
+                error: null
+            }),
+            fail: (error) => resolve({
+                error,
+                stats: null
+            })
+        });
+    });
+}
+function statWithPath(path) {
+    return new Promise((resolve, reject) => {
+        open({
+            filePath: path,
+            flag: 'r',
+            success: ({ fd }) => {
+                statWithFd(fd).then(({ error, stats }) => {
+                    close({
+                        fd,
+                        success: () => {
+                            if (error === null) {
+                                resolve(stats);
+                            }
+                            else {
+                                reject(error);
+                            }
+                        },
+                        fail: (error) => reject(error)
+                    });
+                });
+            },
+            fail: (error) => reject(error)
+        });
+    });
+}
+function statWithRecursive(rootPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result = {};
+        const { files, dirs } = yield getDirFiles(rootPath);
+        for (const dir of dirs) {
+            result[dir] = yield statWithPath(dir);
+            result = Object.assign(Object.assign({}, result), (yield statWithRecursive(dir)));
+        }
+        for (const file of files) {
+            result[file] = yield statWithPath(file);
+        }
+        return result;
+    });
+}
+function stat(option) {
+    try {
+        validateParams('fstat', option, pathSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    const statPromise = option.recursive === true ? statWithRecursive(option.path) : statWithPath(option.path);
+    statPromise.then((stats) => {
+        callCallbackSuccess({ stats }, option);
+    }).catch((error) => {
+        const res = { errMsg: error.message ? error.message : error };
+        callCallbackFail(res, option);
+    });
+}
+function statSync(path, recursive) {
+    if (recursive === true) {
+        return temporarilyNotSupport('statSync recursive')(path);
+    }
+    const fd = openSync({ filePath: path, flag: 'r' });
+    const stats = fstatSync({ fd });
+    closeSync({ fd });
+    return stats;
+}
+function getFileInfo$1(option) {
+    statWithPath(option.filePath).then((stats) => {
+        callCallbackSuccess({ size: stats.size }, option);
+    }).catch((error) => {
+        const res = { errMsg: error.message ? error.message : error };
+        callCallbackFail(res, option);
+    });
+}
+function getSavedFileList$1(option) {
+    statWithRecursive(rootSavedFilePath).then((stats) => {
+        const fileList = Object.keys(stats).map((filePath) => {
+            const file = stats[filePath];
+            if (file.isFile()) {
+                return {
+                    filePath,
+                    size: file.size
+                };
+            }
+            return null;
+        }).filter((file) => file !== null);
+        callCallbackSuccess({ fileList }, option);
+    }).catch((error) => {
+        const res = { errMsg: error.message ? error.message : error };
+        callCallbackFail(res, option);
+    });
+}
+function ftruncate(option) {
+    var _a;
+    try {
+        validateParams('ftruncate', option, fdSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.ftruncate(convertFd(option.fd), (_a = option.length) !== null && _a !== void 0 ? _a : 0, (error) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess(undefined, option);
+        }
+    });
+}
+function ftruncateSync(option) {
+    var _a;
+    validateParams('ftruncateSync', option, fdSchema);
+    fileio.ftruncateSync(convertFd(option.fd), (_a = option.length) !== null && _a !== void 0 ? _a : 0);
+}
+function truncate(option) {
+    var _a;
+    try {
+        validateParams('truncate', option, filePathSchema$1);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.truncate(option.filePath, (_a = option.length) !== null && _a !== void 0 ? _a : 0, (error) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess(undefined, option);
+        }
+    });
+}
+function truncateSync(option) {
+    var _a;
+    validateParams('truncateSync', option, filePathSchema$1);
+    fileio.truncateSync(option.filePath, (_a = option.length) !== null && _a !== void 0 ? _a : 0);
+}
+function close(option) {
+    try {
+        validateParams('close', option, fdSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    fileio.close(convertFd(option.fd), (error) => {
+        if (error) {
+            const res = { errMsg: error.message ? error.message : error };
+            callCallbackFail(res, option);
+        }
+        else {
+            callCallbackSuccess(undefined, option);
+        }
+    });
+}
+function closeSync(option) {
+    validateParams('closeSync', option, fdSchema);
+    fileio.closeSync(convertFd(option.fd));
+}
+function saveFile$1(option) {
+    try {
+        validateParams('saveFile', option, saveFileSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    try {
+        const savedFilePath = parseSavedFilePath(option.tempFilePath, option.filePath);
+        rename({
+            oldPath: option.tempFilePath,
+            newPath: savedFilePath,
+            success: () => {
+                callCallbackSuccess({ savedFilePath }, option);
+            },
+            fail: (res) => {
+                callCallbackFail(res, option);
+            }
+        });
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+}
+function saveFileSync(tempFilePath, filePath) {
+    const savedFilePath = parseSavedFilePath(tempFilePath, filePath);
+    renameSync(tempFilePath, savedFilePath);
+    return savedFilePath;
+}
+function removeSavedFile$1(option) {
+    try {
+        validateParams('removeSavedFile', option, filePathSchema$1);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    try {
+        validateSavedFilePath(option.filePath);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    unlink(option);
+}
+function unzip(option) {
+    try {
+        validateParams('unzip', option, unzipSchema);
+    }
+    catch (error) {
+        const res = { errMsg: error.message };
+        return callCallbackFail(res, option);
+    }
+    zlib.unzipFile(option.zipFilePath, option.targetPath).then(() => {
+        callCallbackSuccess(undefined, option);
+    }).catch(error => {
+        const res = { errMsg: error.message ? error.message : error };
+        callCallbackFail(res, option);
+    });
+}
+function getFileSystemManager() {
+    return {
+        access,
+        accessSync,
+        appendFile,
+        appendFileSync,
+        close,
+        closeSync,
+        copyFile,
+        copyFileSync,
+        fstat,
+        fstatSync,
+        ftruncate,
+        ftruncateSync,
+        getFileInfo: getFileInfo$1,
+        getSavedFileList: getSavedFileList$1,
+        mkdir,
+        mkdirSync,
+        open,
+        openSync,
+        read,
+        readCompressedFile,
+        readCompressedFileSync,
+        readdir,
+        readdirSync,
+        readFile,
+        readFileSync,
+        readSync,
+        readZipEntry,
+        removeSavedFile: removeSavedFile$1,
+        rename,
+        renameSync,
+        rmdir,
+        rmdirSync,
+        saveFile: saveFile$1,
+        saveFileSync,
+        stat,
+        statSync,
+        truncate,
+        truncateSync,
+        unlink,
+        unlinkSync,
+        unzip,
+        write,
+        writeFile,
+        writeFileSync,
+        writeSync
+    };
+}
+
+/**
+ * HarmonyOS 文档：
+ * https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-fileio-0000001168366687
+ *
+ * WX 文档：
+ * https://developers.weixin.qq.com/miniprogram/dev/api/file/wx.saveFileToDisk.html
+ *
+ * Taro.js 文档
+ * https://taro-docs.jd.com/taro/docs/apis/files/saveFileToDisk
+ *
+ * HarmonyOS 不支持接口：
+ * saveFileToDisk
+ *
+ * HarmonyOS 差异性接口：
+ * openDocument：showMenu、type 选项无效
+ * getSavedFileList：返回值 fileList 中的每一项不包含 createTime 属性
+ * getSavedFileInfo：返回值不包含 createTime 属性
+ */
+const filePathSchema = {
+    filePath: 'String'
+};
+const saveFileToDisk = temporarilyNotSupport('saveFileToDisk');
+/**
+ * HarmonyOS 不支持 showMenu 选项，并且 type 目前仅支持 *，详情参见：
+ * https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-document-0000001168936589#section9616125953711
+ */
+function openDocument(option) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('access', option, filePathSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, option);
+        }
+        document.show(option.filePath, '*', (error) => {
+            if (error) {
+                const res = { errMsg: error.message ? error.message : error };
+                return callAsyncFail(reject, res, option);
+            }
+            else {
+                callAsyncSuccess(resolve, undefined, option);
+            }
+        });
+    });
+}
+function saveFile(option) {
+    return new Promise((resolve, reject) => {
+        const fileSystemManager = getFileSystemManager();
+        fileSystemManager.saveFile({
+            tempFilePath: option.tempFilePath,
+            filePath: option.filePath,
+            success: (res) => {
+                callAsyncSuccess(resolve, res, option);
+            },
+            fail: (res) => {
+                callAsyncFail(reject, res, option);
+            }
+        });
+    });
+}
+function removeSavedFile(option) {
+    return new Promise((resolve, reject) => {
+        const fileSystemManager = getFileSystemManager();
+        fileSystemManager.removeSavedFile({
+            filePath: option.filePath,
+            success: (res) => {
+                callAsyncSuccess(resolve, res, option);
+            },
+            fail: (res) => {
+                callAsyncFail(reject, res, option);
+            }
+        });
+    });
+}
+function getFileInfo(option) {
+    return new Promise((resolve, reject) => {
+        const fileSystemManager = getFileSystemManager();
+        fileSystemManager.getFileInfo({
+            filePath: option.filePath,
+            success: ({ size }) => {
+                var _a;
+                fileio.hash(option.filePath, (_a = option.digestAlgorithm) !== null && _a !== void 0 ? _a : 'md5').then((digest) => {
+                    callAsyncSuccess(resolve, { size, digest }, option);
+                }).catch((error) => {
+                    const res = { errMsg: error.message ? error.message : error };
+                    callAsyncFail(reject, res, option);
+                });
+            },
+            fail: (res) => {
+                callAsyncFail(reject, res, option);
+            }
+        });
+    });
+}
+function getSavedFileList(option) {
+    return new Promise((resolve, reject) => {
+        const fileSystemManager = getFileSystemManager();
+        fileSystemManager.getSavedFileList({
+            success: (res) => callAsyncSuccess(resolve, res, option),
+            fail: (res) => callAsyncFail(reject, res, option)
+        });
+    });
+}
+function getSavedFileInfo(option) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('getSavedFileInfo', option, filePathSchema);
+            validateSavedFilePath(option.filePath);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, option);
+        }
+        const fileSystemManager = getFileSystemManager();
+        fileSystemManager.getFileInfo({
+            filePath: option.filePath,
+            success: ({ size }) => callAsyncSuccess(resolve, { size }, option),
+            fail: (res) => callAsyncFail(reject, res, option)
+        });
+    });
+}
+
+const ENV_TYPE = {
+    WEAPP: 'WEAPP',
+    SWAN: 'SWAN',
+    ALIPAY: 'ALIPAY',
+    TT: 'TT',
+    QQ: 'QQ',
+    JD: 'JD',
+    WEB: 'WEB',
+    RN: 'RN',
+    HARMONY: 'HARMONY',
+    QUICKAPP: 'QUICKAPP'
+};
+function getEnv() {
+    return ENV_TYPE.HARMONY;
+}
+const getCurrentInstance = () => Current;
+const nextTick = (cb, ctx) => {
+    setTimeout(function () {
+        ctx ? cb.call(ctx) : cb();
+    }, 1);
+};
+const requirePlugin$1 = temporarilyNotSupport('requirePlugin');
+
+// HarmonyOS 文档: https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-geolocation-0000001199568865#section13752433138
+// WX 文档: https://developers.weixin.qq.com/miniprogram/dev/api/location/wx.onLocationChange.html
+// ✅ wx.offLocationChange
+// ✅ wx.getLocation
+// ✅ wx.onLocationChange
+// 不支持实现
+// ❌ wx.startLocationUpdateBackground
+// ❌ wx.onLocationChangeError
+// ❌ wx.offLocationChangeError
+// ❌ wx.openLocation 地图相关
+// ❌ wx.choosePoi 地图相关
+// ❌ wx.chooseLocation 地图相关
+// ❌ wx.stopLocationUpdate
+// ❌ wx.startLocationUpdate
+function formatLocation(location) {
+    const locationWX = {
+        latitude: location.latitude,
+        longitude: location.longitude,
+        altitude: location.altitude,
+        accuracy: location.accuracy,
+        speed: location.speed,
+        verticalAccuracy: 0,
+        horizontalAccuracy: 0 // OHOS 不支持返回此参数，直接设置为默认值
+    };
+    return locationWX;
+}
+// TODO：增加参数校验
+// const getLocationSchema = {
+//   type: 'String',
+//   altitude: 'Boolean',
+//   ishighAccuracy: 'Boolean',
+//   highAccuracyExpireTime: 'number'
+// }
+const getLocation = function (options = {}) {
+    return new Promise((resolve, reject) => {
+        /**
+         * ohos 有 priority, scenario, maxAccuracy, timeoutMs
+         * wx 有 type, altitude, isHighAccuracy, highAccuracyExpireTime
+         * 二者参数不一致
+         */
+        const { type, altitude, isHighAccuracy, highAccuracyExpireTime } = options;
+        const params = {
+            type,
+            altitude,
+            isHighAccuracy,
+            highAccuracyExpireTime
+        };
+        try {
+            return geoLocationManager.getCurrentLocation(params).then((location) => {
+                if (location.code !== 0) {
+                    callAsyncFail(reject, location, options);
+                }
+                else {
+                    const locationWX = formatLocation(location.data);
+                    callAsyncSuccess(resolve, locationWX, options);
+                }
+            }).catch(error => {
+                callAsyncFail(reject, error, options);
+            });
+        }
+        catch (error) {
+            callAsyncFail(reject, error, options);
+        }
+    });
+};
+const onLocationChange = function (callback) {
+    validateParams('onLocationChange', [callback], ['Function']);
+    const requestInfo = {};
+    geoLocationManager.on('locationChange', requestInfo, (location) => {
+        if (location) {
+            const locationWX = formatLocation(location);
+            callback(locationWX);
+        }
+    });
+};
+const offLocationChange = function (callback) {
+    validateParams('offLocationChange', [callback], ['Function']);
+    geoLocationManager.off('locationChange', (location) => {
+        const status = {
+            errCode: 200,
+            errMsg: location ? 'offLocationChange is off' : 'offLocationChange err'
+        };
+        if (callback) {
+            callback(status);
+        }
+    });
+};
+
+// HarmonyOS 文档链接：https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-media-0000001103383404
+// WX 文档链接：https://developers.weixin.qq.com/miniprogram/dev/api/media/image/wx.previewMedia.html
+// ✅ wx.previewMedia(Object object)
+// ✅ wx.chooseMedia
+const previewMediaSchema = {
+    sources: 'Array'
+};
+// TODO: 扩展支持预览video
+const previewMedia = function (options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('previewMedia', options, previewMediaSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { sources, current } = options;
+        const urls = [];
+        for (const s of sources) {
+            if (s.type === 'image') {
+                urls.push(s.url);
+            }
+        }
+        const previewImageOptions = {
+            images: urls,
+            index: current || 0
+        };
+        mediaLibrary.getMediaLibrary().startImagePreview(previewImageOptions.images, previewImageOptions.index).then((value) => {
+            callAsyncSuccess(resolve, value, options);
+        }).catch((error) => {
+            callAsyncFail(reject, error, options);
+        });
+    });
+};
+const chooseMedia = function (options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('chooseMedia', [options], ['Object']);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { count = 9, mediaType = ['image'] } = options;
+        // HarmonyOS不支持image和video同时选择
+        // TODO: 不支持视频拍摄，无现成组件，后续需要封装
+        const mediaSelectOptions = {
+            count,
+            type: mediaType[0]
+        };
+        mediaLibrary.getMediaLibrary().startMediaSelect(mediaSelectOptions).then((value) => {
+            callAsyncSuccess(resolve, value, options);
+        }).catch((error) => {
+            callAsyncFail(reject, error, options);
+        });
+    });
+};
+
+// HarmonyOS 图片模块首批接口从API version 7开始支持。
+// HarmonyOS 文档链接：https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-image-0000001122977382
+// WX 文档链接：https://developers.weixin.qq.com/miniprogram/dev/api/media/image/wx.saveImageToPhotosAlbum.html
+// ✅ wx.getImageInfo(Object object) API7以上支持
+// ✅ wx.compressImage(Object object) API7以上支持
+// ✅ wx.chooseImage(Object object)
+// ❌ wx.chooseMessageFile(Object object) HarmonyOS不支持
+// ❌ wx.saveImageToPhotosAlbum(Object object) api 9+ HarmonyOS不支持
+// ❌ wx.previewImage(Object object) api 9+ HarmonyOS不支持
+const getImageInfoSchema = {
+    url: 'String'
+};
+const compressImageSchema = {
+    url: 'String'
+};
+const chooseImageSchema = {
+    count: 'Number'
+};
+const photoSelectOptions = new picker.PhotoSelectOptions();
+const getImageInfo = function (options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('getImageInfo', options, getImageInfoSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { src } = options;
+        // FIX: 调试发现在版本api7中 source 为 undefined, 需鸿蒙侧确认
+        const source = image.createImageSource(src);
+        if (isNull(source)) {
+            const createImageSourceError = { errMsg: 'getImageInfo fail: createImageSource has failed.' };
+            callAsyncFail(reject, createImageSourceError, options);
+            return;
+        }
+        source.getImageInfo().then((value) => {
+            callAsyncSuccess(resolve, value, options);
+        }).catch((error) => {
+            callAsyncFail(reject, error, options);
+        });
+    });
+};
+const compressImage = function (options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('compressImage', options, compressImageSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { src, quality = 80 } = options;
+        const source = image.createImageSource(src);
+        if (isNull(source)) {
+            const createImageSourceError = { errMsg: 'compressImage fail: createImageSource has failed.' };
+            callAsyncFail(reject, createImageSourceError, options);
+            return;
+        }
+        const packer = image.createImagePacker(src);
+        if (isNull(packer)) {
+            const createImagePackerError = { errMsg: 'compressImage fail: createImagePacker has failed.' };
+            callAsyncFail(reject, createImagePackerError, options);
+        }
+        const packingOptionsOHOS = {
+            // TODO：需要获取文件名后缀
+            format: 'image/jpeg',
+            quality: quality
+        };
+        packer.packing(source, packingOptionsOHOS).then((value) => {
+            callAsyncSuccess(resolve, value, options);
+        }).catch((error) => {
+            callAsyncFail(reject, error, options);
+        });
+    });
+};
+const chooseImage = function (options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('chooseImage', options, chooseImageSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { count = 9 } = options;
+        const photoViewPicker = new picker.PhotoViewPicker();
+        photoSelectOptions.maxSelectNumber = count; // 选择媒体文件的最大数目
+        photoSelectOptions.MIMEType = picker.PhotoViewMIMETypes.IMAGE_TYPE; // 过滤选择媒体文件类型为IMAGE
+        photoViewPicker.select(photoSelectOptions).then((photoSelectResult) => {
+            callAsyncSuccess(resolve, { tempFilePaths: photoSelectResult.photoUris });
+        }).catch((error) => {
+            callAsyncFail(reject, error, options);
+        });
+    });
+};
+const previewImage = temporarilyNotSupport('previewImage');
+const saveImageToPhotosAlbum = temporarilyNotSupport('saveImageToPhotosAlbum');
+
+// HarmonyOS 文档链接：https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-media-0000001103383404
+// WX 文档链接：https://developers.weixin.qq.com/miniprogram/dev/api/media/video/wx.chooseVideo.html
+// ✅ wx.saveVideoToPhotosAlbum
+// ❌ wx.openVideoEditor
+// ❌ wx.getVideoInfo
+// ❌ wx.createVideoContext
+// ❌ wx.compressVideo
+// ✅ wx.chooseVideo
+// VideoContext
+//   ❌ VideoContext.exitBackgroundPlayback
+//   ❌ VideoContext.exitFullScreen
+//   ❌ VideoContext.exitPictureInPicture
+//   ❌ VideoContext.hideStatusBar
+//   ❌ VideoContext.pause
+//   ❌ VideoContext.play
+//   ❌ VideoContext.playbackRate
+//   ❌ VideoContext.requestBackgroundPlayback
+//   ❌ VideoContext.requestFullScreen
+//   ❌ VideoContext.seek
+//   ❌ VideoContext.sendDanmu
+//   ❌ VideoContext.showStatusBar
+//   ❌ VideoContext.stop
+const saveVideoToPhotosAlbumSchema = {
+    filePath: 'String'
+};
+// TODO: 1.返回属性补全
+// TODO: 2.只支持从相册选择，补充摄像头拍摄功能，需要HarmonyOS提供选择组件
+const chooseVideo = function (options = {}) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('chooseVideo', [options], ['Object']);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const chooseVideoOptionsOHOS = {
+            type: 'video',
+            count: 1
+        };
+        mediaLibrary.getMediaLibrary().startMediaSelect(chooseVideoOptionsOHOS).then((value) => {
+            callAsyncSuccess(resolve, { tempFilePaths: value });
+        }).catch((error) => {
+            callAsyncFail(reject, error, options);
+        });
+    });
+};
+const saveVideoToPhotosAlbum = function (options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('saveVideoToPhotosAlbum', options, saveVideoToPhotosAlbumSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { filePath } = options;
+        const saveVideoToPhotosAlbumOptions = {
+            src: filePath,
+            // TODO：需要获取文件名后缀，'video/mp4'、'video/3gpp'等
+            mimeType: 'video/mp4'
+        };
+        mediaLibrary.getMediaLibrary().storeMediaAsset(saveVideoToPhotosAlbumOptions).then((value) => {
+            callAsyncSuccess(resolve, value, options);
+        }).catch((error) => {
+            callAsyncFail(reject, error, options);
+        });
+    });
+};
+
+// 跳转
+const openEmbeddedMiniProgram = /* @__PURE__ */ temporarilyNotSupport('openEmbeddedMiniProgram');
+const navigateToMiniProgram = /* @__PURE__ */ temporarilyNotSupport('navigateToMiniProgram');
+const navigateBackMiniProgram = /* @__PURE__ */ temporarilyNotSupport('navigateBackMiniProgram');
+const exitMiniProgram = /* @__PURE__ */ temporarilyNotSupport('exitMiniProgram');
+const openBusinessView = /* @__PURE__ */ temporarilyNotSupport('openBusinessView');
+
+// HarmonyOS 文档链接：https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-request-0000001123753962#section455311474372
+// WX 文档链接：https://developers.weixin.qq.com/miniprogram/dev/api/network/download/wx.downloadFile.html
+// ✅ wx.downloadFile (BETA)7+,因为使用了 query 和 on('complete')
+// ✅ DownloadTask.abort
+// ✅ DownloadTask.offProgressUpdate
+// ✅ DownloadTask.onProgressUpdate
+// ❌ DownloadTask.onHeadersReceived 此接口 ohos 不支持
+// ❌ DownloadTask.offHeadersReceived 此接口 ohos 不支持
+const downloadFileSchema = {
+    url: 'String'
+};
+const downloadFile = function (options) {
+    let downloadTask = {};
+    const downloadTaskWX = new Promise((resolve, reject) => {
+        const { url, header, filePath } = options;
+        try {
+            validateParams('downloadFile', options, downloadFileSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const ohosParams = {
+            url
+        };
+        if (header)
+            ohosParams.header = header;
+        if (filePath)
+            ohosParams.filePath = filePath;
+        request$1.download(ohosParams).then((dataDownload) => {
+            downloadTask = dataDownload;
+            // TODO: 建议鸿蒙优化 complete 回调接口。
+            // ohos 的 complete 回调不返回任何下载信息，需要调用 query 查询后，在 complete 和 fail 中调用回调返回
+            downloadTask.query().then(dataQuery => {
+                downloadTask.on('complete', () => {
+                    dataQuery.status = dataQuery.statusCode;
+                    callAsyncSuccess(resolve, dataQuery, options);
+                });
+                downloadTask.on('fail', (err) => {
+                    const res = {
+                        errMsg: err
+                    };
+                    callAsyncFail(reject, res, options);
+                });
+            }).catch((err) => {
+                callAsyncFail(reject, err, options);
+            });
+        }).catch((err) => {
+            callAsyncFail(reject, err, options);
+        });
+    });
+    downloadTaskWX.abort = function () {
+        downloadTask.remove((err, data) => {
+            if (err) {
+                return err;
+            }
+            return data;
+        });
+    };
+    downloadTaskWX.offProgressUpdate = function offProgressUpdate(callback) {
+        validateParams('offProgressUpdate', [callback], ['Function']);
+        downloadTask.off('progress', (receivedSize, totalSize) => {
+            const totalBytesWritten = receivedSize * 1024;
+            const totalBytesExpectedToWrite = totalSize * 1024;
+            // TODO: 进度应该保留几位小数？暂时保留6位
+            const progress = +(receivedSize / totalSize).toFixed(6);
+            const progressParams = {
+                totalBytesWritten,
+                totalBytesExpectedToWrite,
+                progress,
+                errMsg: 'Cancel progress listening is done.'
+            };
+            callback(progressParams);
+        });
+    };
+    // wx 单位是 Bytes，ohos 单位是 KBytes
+    downloadTaskWX.onProgressUpdate = function (callback) {
+        validateParams('onProgressUpdate', [callback], ['Function']);
+        downloadTask.on('progress', (receivedSize, totalSize) => {
+            const totalBytesWritten = receivedSize * 1024;
+            const totalBytesExpectedToWrite = totalSize * 1024;
+            // TODO: 进度应该保留几位小数？暂时保留6位
+            const progress = +(receivedSize / totalSize).toFixed(6);
+            const progressParams = {
+                totalBytesWritten,
+                totalBytesExpectedToWrite,
+                progress
+            };
+            callback(progressParams);
+        });
+    };
+    return downloadTaskWX;
+};
+
+// HarmonyOS 文档链接：https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-net-http-0000001168304341
+// WX 文档链接：https://developers.weixin.qq.com/miniprogram/dev/api/network/request/wx.request.html
+// ✅ wx.request
+// ✅ RequestTask.abort
+// ✅ RequestTask.offHeadersReceived
+// ✅ RequestTask.onHeadersReceived
+const METHOD = ['OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'TRACE', 'CONNECT'];
+const requestSchema = {
+    url: 'String'
+};
+const request = function (options) {
+    let httpRequestOhos;
+    const requestTask = new Promise((resolve, reject) => {
+        try {
+            httpRequestOhos = http.createHttp();
+        }
+        catch (error) {
+            const res = { errMsg: error };
+            return callAsyncFail(reject, res, options);
+        }
+        const { url, method, header = {}, timeout, dataType, data } = options;
+        try {
+            validateParams('send', options, requestSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const keyOfContentType = Object.keys(header).find(item => item.toLowerCase() === 'content-type');
+        if (!keyOfContentType) {
+            header['Content-Type'] = 'application/json';
+        }
+        // 检查 Header 是否有 Referer
+        if (isUndefined(header.Referer)) {
+            const error = { errMsg: 'request fail parameter error: the header doesn‘t support Referer property' };
+            callAsyncFail(reject, error, options);
+        }
+        // 检查 method 是否正确
+        if (method) {
+            if (!METHOD.includes(method)) {
+                const error = { errMsg: `request fail parameter error: the method value should be one of the ${METHOD.join(',')}` };
+                callAsyncFail(reject, error, options);
+            }
+        }
+        const requestParamsOHOS = {
+            method,
+            header,
+            extraData: data,
+            readTimeout: timeout,
+            connectTimeout: timeout
+        };
+        httpRequestOhos.request(url, requestParamsOHOS).then((requestData) => {
+            const reswx = {
+                data: dataType === 'json' && isString(requestData.result) ? JSON.parse(requestData.result) : requestData.result,
+                statusCode: requestData.responseCode,
+                header: requestData.header
+            };
+            callAsyncSuccess(resolve, reswx, options);
+        }).catch(error => {
+            callAsyncFail(reject, error, options);
+        });
+    });
+    requestTask.abort = function () {
+        httpRequestOhos.destroy();
+    };
+    requestTask.onHeadersReceived = function (callback) {
+        validateParams('onHeadersReceived', [callback], ['Function']);
+        httpRequestOhos.on('headerReceive', (err, res) => {
+            callback(!err ? res : err);
+        });
+    };
+    requestTask.offHeadersReceived = function (callback) {
+        validateParams('offHeadersReceived', [callback], ['Function']);
+        httpRequestOhos.off('headerReceive', (err, res) => {
+            callback(!err ? res : err);
+        });
+    };
+    return requestTask;
+};
+
+// HarmonyOS 文档链接：https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-request-0000001123753962#section455311474372
+// WX 文档链接：https://developers.weixin.qq.com/miniprogram/dev/api/network/upload/wx.uploadFile.html
+// ✅ wx.uploadFile
+// ✅ UploadTask.abort
+// ✅ UploadTask.offHeadersReceived (BETA)7+
+// ✅ UploadTask.offProgressUpdate
+// ✅ UploadTask.onHeadersReceived(BETA)7+
+// ✅ UploadTask.onProgressUpdate
+const uploadSchema = {
+    url: 'String'
+    // filePath: 'String',
+    // name: 'String'
+};
+// wx 只支持 HTTP POST 请求，OHOS 支持 POST 和 PUT 请求
+// OHOS 不支持 wx 的 timeout，但是支持 file 文件列表上传，wx 是单文件上传
+const uploadFile = function (options) {
+    let uploadTask = {};
+    const UploadTaskWX = new Promise((resolve, reject) => {
+        let timer;
+        const { url, filePath, name, header, formData, timeout } = options;
+        try {
+            validateParams('uploadFile', options, uploadSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const file = {
+            url: filePath,
+            name
+        };
+        const files = [file];
+        const ohosParams = {
+            url,
+            files,
+            method: 'POST',
+            header
+        };
+        if (formData) {
+            const rData = [];
+            Object.keys(formData).forEach((key) => {
+                const rDataEle = {
+                    name: key,
+                    value: formData[key]
+                };
+                rData.push(rDataEle);
+            });
+            ohosParams.data = rData;
+        }
+        if (!isUndefined(timeout)) {
+            timer = setTimeout(() => {
+                const err = {
+                    errMsg: 'uploadFile request timeout, please try again later.'
+                };
+                callAsyncFail(reject, err, options);
+            }, timeout);
+        }
+        request$1.upload(ohosParams).then((dataUpload) => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            uploadTask = dataUpload;
+            callAsyncSuccess(resolve, UploadTaskWX, options);
+        }).catch((err) => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            callAsyncFail(reject, err, options);
+        });
+    });
+    UploadTaskWX.abort = function () {
+        uploadTask.remove((err, result) => {
+            if (err || result) {
+                return err || result;
+            }
+            return result;
+        });
+    };
+    UploadTaskWX.onHeadersReceived = function (callback) {
+        validateParams('onHeadersReceived', [callback], ['Function']);
+        uploadTask.on('headerReceive', (headers) => {
+            callback(headers);
+        });
+    };
+    UploadTaskWX.offHeadersReceived = function (callback) {
+        validateParams('offHeadersReceived', [callback], ['Function']);
+        uploadTask.off('headerReceive', (headers) => {
+            callback(headers);
+        });
+    };
+    // wx 单位是 Bytes，ohos 单位是 KBytes
+    UploadTaskWX.onProgressUpdate = function (callback) {
+        validateParams('onProgressUpdate', [callback], ['Function']);
+        uploadTask.on('progress', (uploadSize, totalSize) => {
+            const totalBytesSent = uploadSize * 1024;
+            const totalBytesExpectedToSend = totalSize * 1024;
+            // TODO: 进度应该保留几位小数？暂时保留6位
+            const progress = +(uploadSize / totalSize).toFixed(6);
+            const progressParams = {
+                totalBytesSent,
+                totalBytesExpectedToSend,
+                progress
+            };
+            callback(progressParams);
+        });
+    };
+    UploadTaskWX.offProgressUpdate = function (callback) {
+        validateParams('offProgressUpdate', [callback], ['Function']);
+        uploadTask.off('progress', (uploadSize, totalSize) => {
+            const totalBytesSent = uploadSize * 1024;
+            const totalBytesExpectedToSend = totalSize * 1024;
+            // TODO: 进度应该保留几位小数？暂时保留6位
+            const progress = +(uploadSize / totalSize).toFixed(6);
+            const progressParams = {
+                totalBytesSent,
+                totalBytesExpectedToSend,
+                progress,
+                errMsg: 'Cancel progress listening is done.'
+            };
+            callback(progressParams);
+        });
+    };
+    return UploadTaskWX;
+};
+
+// OpenHarmony 不支持全局操作 WebSocket
+// HarmonyOS 文档链接：https://developer.harmonyos.com/cn/docs/documentation/doc-references/js-apis-net-websocket-0000001168304641
+// WX 文档链接：https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.sendSocketMessage.html
+// ✅ wx.connectSocket
+// ✅ SocketTask
+// ✅ SocketTask.close
+// ✅ SocketTask.onClose
+// ✅ SocketTask.onError
+// ✅ SocketTask.onMessage
+// ✅ SocketTask.onOpen
+// ✅ SocketTask.send
+// ❌ wx.sendSocketMessage
+// ❌ wx.onSocketOpen
+// ❌ wx.onSocketMessage
+// ❌ wx.onSocketError
+// ❌ wx.onSocketClose
+// ❌ wx.closeSocket
+const connectSocketSchema = {
+    url: 'String'
+};
+// const closetSocketSchema = {
+//   code: 'Number',
+//   reason: 'String'
+// }
+const sendSocketSchema = {
+    data: 'String'
+};
+const connectSocket = function (options) {
+    let ws;
+    const SocketTaskWX = new Promise((resolve, reject) => {
+        ws = webSocket.createWebSocket();
+        const { url, header } = options;
+        try {
+            validateParams('uploadFile', options, connectSocketSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        ws.connect(url, { header }).then((value) => {
+            callAsyncSuccess(resolve, value, options);
+        }).catch((err) => {
+            callAsyncFail(reject, err, options);
+        });
+    });
+    SocketTaskWX.close = function (closeOptions) {
+        return new Promise((resolve, reject) => {
+            // TODO: 检验非必须参数
+            // try {
+            //   validateParams('close', options, closeSocketSchema)
+            // } catch (error) {
+            //   const res = { errMsg: error.message }
+            //   return callAsyncFail(reject, res, options)
+            // }
+            ws.close(closeOptions).then(value => {
+                callAsyncSuccess(resolve, value, closeOptions);
+            }, error => {
+                callAsyncFail(reject, error, closeOptions);
+            });
+        });
+    };
+    SocketTaskWX.onClose = function (onCloseCallback) {
+        validateParams('onClose', [onCloseCallback], ['Function']);
+        ws.on('close', (err, value) => {
+            onCloseCallback(!err ? value : err);
+        });
+    };
+    SocketTaskWX.onError = function (onErrorCallback) {
+        validateParams('onError', [onErrorCallback], ['Function']);
+        ws.on('error', (err) => {
+            onErrorCallback(err);
+        });
+    };
+    SocketTaskWX.onMessage = function (onMessageCallback) {
+        validateParams('onMessage', [onMessageCallback], ['Function']);
+        ws.on('onMessage', (err, value) => {
+            onMessageCallback(!err ? value : err);
+        });
+    };
+    SocketTaskWX.onOpen = function (onOpenCallback) {
+        validateParams('onOpen', [onOpenCallback], ['Function']);
+        ws.on('open', (err, value) => {
+            // TODO：返回数据字段完全不一样，无法兼容，暂不处理
+            // wx:{header, profile}, ohos:{err, value:{status, message}}
+            onOpenCallback(!err ? value : err);
+        });
+    };
+    SocketTaskWX.send = function (sendOptions) {
+        return new Promise((resolve, reject) => {
+            const { data } = sendOptions;
+            try {
+                validateParams('send', sendOptions, sendSocketSchema);
+            }
+            catch (error) {
+                const res = { errMsg: error.message };
+                return callAsyncFail(reject, res, options);
+            }
+            ws.send(data).then(value => {
+                callAsyncSuccess(resolve, value, sendOptions);
+            }, error => {
+                callAsyncFail(reject, error, sendOptions);
+            });
+        });
+    };
+    return SocketTaskWX;
+};
+
+/**
+ * 用户相关API， Harmony ACE API 6
+ *
+ * 1. 华为账号场景介绍文档 @see https://developer.huawei.com/consumer/cn/doc/development/HMSCore-Guides/harmonyos-js-login-0000001151310900
+ * 2. 华为账号API参考 @see https://developer.huawei.com/consumer/cn/doc/development/HMSCore-References/harmonyos-js-overview-0000001063532145
+ */
+// import hmsJSAccount from '@hmscore/hms-jsb-account'
+/**
+ * 通过Scope数组获取已登录的对应帐号信息(依赖login行为)
+ * @param options
+ */
+const getUserInfo = temporarilyNotSupport('getUserInfo');
+// export function getUserInfo (options) {
+//   const { success, fail, complete } = options
+//   const res: Record<string, any> = {}
+//   // const result = hmsJSAccount.HuaweiIdAuthManager.getAuthResultWithScopes([hmsJSAccount.PROFILE])
+//   const result = null
+//   if (result) {
+//     res.data = { userInfo: generateUserInfo(result) }
+//     isFunction(success) && success(res)
+//   } else {
+//     res.errorMsg = 'getUserInfo result data is null'
+//     isFunction(fail) && fail(res)
+//   }
+//   isFunction(complete) && complete(res)
+// }
+/**
+ * 获取用户信息
+ */
+const getUserProfile = temporarilyNotSupport('getUserProfile');
+// export const getUserProfile = (_options) => {
+//   return new Promise((resolve, reject) => {
+//     const res: Record<string, any> = {}
+//     hmsJSAccount.HuaweiIdAuthManager.addAuthScopes([hmsJSAccount.PROFILE])
+//       .then(result => {
+//         if (result) {
+//           res.data = { userInfo: generateUserInfo(result) }
+//           callAsyncSuccess(resolve, res, options)
+//         } else {
+//           res.errorMsg = 'getUserProfile result data is null'
+//           callAsyncFail(reject, res, options)
+//         }
+//       })
+//       .catch(error => {
+//         callAsyncFail(reject, error, options)
+//       })
+//   })
+// }
+/**
+ * 提前向用户发起授权请求
+ */
+const authorize = temporarilyNotSupport('authorize');
+/**
+ * 获取用户的当前设置
+ */
+const getSetting = temporarilyNotSupport('getSetting');
+/**
+ * 调起客户端小程序设置界面
+ */
+const openSetting = temporarilyNotSupport('openSetting');
+// function generateUserInfo (hmsAuthInfo) {
+//   const userInfo = {
+//     nickName: String,
+//     avatarUrl: String,
+//     gender: Number,
+//     country: String
+//   }
+//   if (hmsAuthInfo) {
+//     userInfo.nickName = hmsAuthInfo.displayName
+//     userInfo.avatarUrl = hmsAuthInfo.photoUriString
+//     userInfo.gender = hmsAuthInfo.gender
+//     userInfo.country = hmsAuthInfo.country
+//   }
+//   return userInfo
+// }
+
+const login = temporarilyNotSupport('login');
+const getAccountInfoSync = temporarilyNotSupport('getAccountInfoSync');
+const requestSubscribeMessage = temporarilyNotSupport('requestSubscribeMessage');
+
+// TODO
+const getCurrentPages = () => [];
+const pageScrollTo = (options) => {
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const taro = Current.taro;
+        const page = taro.getCurrentInstance().page;
+        const res = { errMsg: 'pageScrollTo:ok' };
+        const error = { errMsg: 'pageScrollTo:fail' };
+        const { scrollTop, selector = '', duration = 300, offsetTop = 0 } = options;
+        if (scrollTop && selector) {
+            console.warn('"scrollTop" 或 "selector" 建议只设一个值，全部设置会忽略selector');
+        }
+        let scrollValue = -1;
+        let scroller = page.scroller;
+        const currentPageNode = getPageScrollerOrNode(page.node, page);
+        if (scrollTop || typeof scrollTop === 'number') {
+            scrollValue = scrollTop;
+        }
+        else if (selector) {
+            const node = findChildNodeWithDFS(currentPageNode, selector);
+            if (!node || !node._instance)
+                return;
+            const instance = node._instance;
+            const id = node === null || node === void 0 ? void 0 : node._nid;
+            // 获取 areaInfo，需要先调用 setNodeEventCallbackAndTriggerComponentUpdate 更新一次组件并获取组件信息
+            yield setNodeEventCallbackAndTriggerComponentUpdate(node, AREA_CHANGE_EVENT_NAME, null, true);
+            const { areaInfo } = ((_a = instance === null || instance === void 0 ? void 0 : instance.nodeInfoMap) === null || _a === void 0 ? void 0 : _a[id]) || {};
+            let parent = node === null || node === void 0 ? void 0 : node.parentNode;
+            while (!!parent && parent !== currentPageNode) {
+                if ((_b = parent === null || parent === void 0 ? void 0 : parent._instance) === null || _b === void 0 ? void 0 : _b.scroller) {
+                    scroller = parent._instance.scroller;
+                    break;
+                }
+                parent = parent === null || parent === void 0 ? void 0 : parent.parentNode;
+            }
+            scroller = getPageScrollerOrNode(scroller, page);
+            const { yOffset } = scroller.currentOffset();
+            if (areaInfo) {
+                scrollValue = areaInfo.globalPosition.y + yOffset + pxTransformHelper(offsetTop, 'px', true);
+            }
+        }
+        const { xOffset } = scroller.currentOffset();
+        if (scrollValue === -1) {
+            return callAsyncFail(reject, { errMsg: 'pageScrollTo:fail, 请检查传入的 scrollTop 或 selector 是否合法' }, options);
+        }
+        try {
+            scroller.scrollTo({
+                xOffset,
+                yOffset: scrollValue,
+                animation: {
+                    duration: duration,
+                    // @ts-ignore
+                    curve: Curve.Linear
+                }
+            });
+            setTimeout(() => {
+                callAsyncSuccess(resolve, res, options);
+            }, duration);
+        }
+        catch (_) {
+            callAsyncFail(reject, error, options);
+        }
+    }));
+};
+
+const launchOptions = {
+    path: '',
+    query: {},
+    scene: 0,
+    shareTicket: '',
+    referrerInfo: {}
+};
+function initLaunchOptions(options = {}) {
+    Object.assign(launchOptions, options);
+}
+eventCenter.once('__taroRouterLaunch', initLaunchOptions);
+const TARO_TABBAR_PAGE_PATH = 'taro_tabbar';
+function isTabPage(url) {
+    var _a, _b;
+    return (_b = (_a = window.__taroAppConfig.tabBar) === null || _a === void 0 ? void 0 : _a.list) === null || _b === void 0 ? void 0 : _b.some(item => item.pagePath === url);
+}
+function parseURL(raw = '') {
+    const [urlStr, queryStr = ''] = raw.split('?');
+    const query = queryToJson(queryStr);
+    let url = urlStr.replace(/^\//, '');
+    if (isTabPage(url)) {
+        query.$page = url;
+        url = TARO_TABBAR_PAGE_PATH;
+    }
+    return [url, query];
+}
+// 生命周期
+const getLaunchOptionsSync = () => launchOptions;
+const getEnterOptionsSync = () => launchOptions;
+const getRouterFunc = (method) => {
+    const methodName = method === 'navigateTo' ? 'pushUrl' : 'replaceUrl';
+    return function (options) {
+        const [url, params = {}] = parseURL(options.url);
+        return new Promise((resolve, reject) => {
+            router[methodName]({
+                url,
+                params
+            }, (error) => {
+                const res = { errMsg: `${method}:ok` };
+                if (error) {
+                    const { code, message } = error;
+                    res.code = code;
+                    res.errMsg = `${method}:failed, ${message}`;
+                    callAsyncFail(reject, res, options);
+                    return;
+                }
+                callAsyncSuccess(resolve, res, options);
+            });
+        });
+    };
+};
+const navigateTo = getRouterFunc('navigateTo');
+const redirectTo = getRouterFunc('redirectTo');
+function navigateBack(options) {
+    return new Promise(resolve => {
+        if (!(options === null || options === void 0 ? void 0 : options.url)) {
+            router.back();
+        }
+        else {
+            const [url] = parseURL(options.url);
+            router.back({ url });
+        }
+        const res = { errMsg: 'navigateBack:ok' };
+        callAsyncSuccess(resolve, res, options);
+    });
+}
+const reLaunch = (options) => {
+    return new Promise(resolve => {
+        redirectTo({ url: options.url });
+        router.clear();
+        const res = { errMsg: 'reLaunch:ok' };
+        callAsyncSuccess(resolve, res, options);
+    });
+};
+const switchTab = (options) => {
+    return new Promise((resolve, reject) => {
+        var _a;
+        const stack = AppStorage.prop('__TARO_PAGE_STACK').get();
+        const [url, params] = parseURL(options.url);
+        if (url !== TARO_TABBAR_PAGE_PATH) {
+            const res = { errMsg: 'switchTab:failed' };
+            callAsyncFail(reject, res, options);
+            return;
+        }
+        if (((_a = stack[stack.length - 1]) === null || _a === void 0 ? void 0 : _a.path) === url) {
+            // Note: 当前为 Tab 页时，触发 switch 事件
+            eventCenter.trigger('__taroSwitchTab', { url, params });
+            router.getLength() > 1 && router.clear();
+        }
+        else if (stack.some(item => item.path === url)) {
+            // Note: 寻找路由栈中的 Tab 页，如果找到，则使用 navigateBack
+            router.back({ url, params });
+            router.getLength() > 1 && router.clear();
+        }
+        else {
+            // Note: 未找到页面时，使用 reLaunch
+            reLaunch({ url: options.url });
+        }
+        const res = { errMsg: 'switchTab:ok' };
+        callAsyncSuccess(resolve, res, options);
+    });
+};
+const getLength = () => {
+    return router.getLength();
+};
+const getState = () => {
+    return router.getState();
+};
+
+const preferencesPromise = Current.contextPromise
+    .then((context) => {
+    return bundleManager
+        .getBundleInfoForSelf(bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_APPLICATION)
+        .then(data => {
+        return dataPreferences
+            .getPreferences(context, `${data.appInfo.uid}Store`);
+    });
+})
+    .catch((error) => {
+    hilog.error(0x0000, 'TaroFailedTag', 'Failed to load the storage. Cause: %{public}s', error.code ? JSON.stringify(error) : error.message || error);
+});
+function getItem(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const preferences = yield preferencesPromise;
+            const item = yield preferences.get(key, null);
+            return { result: true, data: item };
+        }
+        catch (error) {
+            return { result: false };
+        }
+    });
+}
+const storageSchema = {
+    key: 'String'
+};
+function getStorage(options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('getStorage', options, storageSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        getItem(options.key).then(({ result, data }) => {
+            const res = { errMsg: 'getStorage:ok' };
+            if (result) {
+                res.data = data;
+                callAsyncSuccess(resolve, res, options);
+            }
+            else {
+                res.errMsg = 'getStorage:fail data not found';
+                callAsyncFail(reject, res, options);
+            }
+        });
+    });
+}
+function setStorage(options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('setStorage', options, storageSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { key, data } = options;
+        const res = { errMsg: 'setStorage:ok' };
+        preferencesPromise.then((preferences) => __awaiter(this, void 0, void 0, function* () {
+            yield preferences.put(key, data);
+            yield preferences.flush();
+            callAsyncSuccess(resolve, res, options);
+        }));
+    });
+}
+function removeStorage(options) {
+    return new Promise((resolve, reject) => {
+        try {
+            validateParams('removeStorage', options, storageSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { key } = options;
+        preferencesPromise.then((preferences) => __awaiter(this, void 0, void 0, function* () {
+            yield preferences.delete(key);
+            yield preferences.flush();
+            const res = { errMsg: 'removeStorage:ok' };
+            callAsyncSuccess(resolve, res, options);
+        }));
+    });
+}
+function clearStorage(options) {
+    return new Promise(resolve => {
+        preferencesPromise.then((preferences) => __awaiter(this, void 0, void 0, function* () {
+            yield preferences.clear();
+            yield preferences.flush();
+            const res = { errMsg: 'clearStorage:ok' };
+            callAsyncSuccess(resolve, res, options);
+        }));
+    });
+}
+const getStorageSync = temporarilyNotSupport('getStorageSync', 'getStorage');
+const setStorageSync = temporarilyNotSupport('setStorageSync', 'setStorage');
+const clearStorageSync = temporarilyNotSupport('clearStorageSync', 'clearStorage');
+const removeStorageSync = temporarilyNotSupport('removeStorageSync', 'removeStorage');
+
+// eslint-disable-next-line import/no-duplicates
+const toggleTabBar = function (type) {
+    return function (options) {
+        return new Promise((resolve, reject) => {
+            var _a, _b;
+            const taro = Current.taro;
+            const page = taro.getCurrentInstance().page;
+            const currentData = ((_a = page._data) === null || _a === void 0 ? void 0 : _a.taroTabBar) || page.tabBar;
+            const res = { errMsg: `${type}TabBar:ok` };
+            const error = { errMsg: `${type}TabBar:fail not TabBar page` };
+            if (!currentData) {
+                callAsyncFail(reject, error, options);
+            }
+            else {
+                const isShow = type === 'show';
+                const event = isShow ? '__taroShowTabBar' : '__taroHideTabBar';
+                eventCenter.trigger(event, {
+                    animation: options === null || options === void 0 ? void 0 : options.animation,
+                });
+                (_b = page.$set) === null || _b === void 0 ? void 0 : _b.call(page, 'isShowTaroTabBar', isShow);
+                callAsyncSuccess(resolve, res, options);
+            }
+        });
+    };
+};
+const showTabBar = toggleTabBar('show');
+const hideTabBar = toggleTabBar('hide');
+const setTabBarStyle = function (options = {}) {
+    return new Promise((resolve, reject) => {
+        var _a, _b;
+        const taro = Current.taro;
+        const page = taro.getCurrentInstance().page;
+        const currentData = ((_a = page._data) === null || _a === void 0 ? void 0 : _a.taroTabBar) || page.tabBar;
+        const res = { errMsg: 'setTabBarStyle:ok' };
+        const error = { errMsg: 'setTabBarStyle:fail not TabBar page' };
+        if (!currentData) {
+            callAsyncFail(reject, error, options);
+        }
+        else {
+            const data = Object.assign({}, currentData);
+            if (options.color)
+                data.color = options.color;
+            if (options.selectedColor)
+                data.selectedColor = options.selectedColor;
+            if (options.backgroundColor)
+                data.backgroundColor = options.backgroundColor;
+            if (options.borderStyle)
+                data.borderStyle = options.borderStyle;
+            eventCenter.trigger('__taroSetTabBarStyle', options);
+            (_b = page.$set) === null || _b === void 0 ? void 0 : _b.call(page, 'taroTabBar', data);
+            callAsyncSuccess(resolve, res, options);
+        }
+    });
+};
+const setTabBarItem = function (options) {
+    return new Promise((resolve, reject) => {
+        var _a, _b;
+        const taro = Current.taro;
+        const page = taro.getCurrentInstance().page;
+        const currentData = ((_a = page._data) === null || _a === void 0 ? void 0 : _a.taroTabBar) || page.tabBar;
+        const res = { errMsg: 'setTabBarItem:ok' };
+        const error = { errMsg: 'setTabBarItem:fail not TabBar page' };
+        if (!currentData) {
+            callAsyncFail(reject, error, options);
+        }
+        else {
+            const index = options.index;
+            const item = Object.assign({}, currentData.list[index]);
+            if (options.text)
+                item.text = options.text;
+            if (options.iconPath)
+                item.iconPath = options.iconPath;
+            if (options.selectedIconPath)
+                item.selectedIconPath = options.selectedIconPath;
+            const list = [
+                ...currentData.list.slice(0, index),
+                item,
+                ...currentData.list.slice(index + 1)
+            ];
+            const data = Object.assign({}, currentData, { list });
+            eventCenter.trigger('__taroSetTabBarItem', options);
+            (_b = page.$set) === null || _b === void 0 ? void 0 : _b.call(page, 'taroTabBar', data);
+            callAsyncSuccess(resolve, res, options);
+        }
+    });
+};
+function showTabBarRedDot(options) {
+    const res = { errMsg: 'showTabBarRedDot:ok' };
+    return new Promise((resolve) => {
+        eventCenter.trigger('__taroShowTabBarRedDotHandler', {
+            index: (options === null || options === void 0 ? void 0 : options.index) || 0,
+        });
+        callAsyncSuccess(resolve, res, options);
+    });
+}
+function hideTabBarRedDot(options) {
+    const res = { errMsg: 'hideTabBarRedDot:ok' };
+    return new Promise((resolve) => {
+        eventCenter.trigger('__taroHideTabBarRedDotHandler', {
+            index: (options === null || options === void 0 ? void 0 : options.index) || 0,
+        });
+        callAsyncSuccess(resolve, res, options);
+    });
+}
+function setTabBarBadge(options) {
+    const res = { errMsg: 'setTabBarBadge:ok' };
+    return new Promise((resolve) => {
+        const text = (options === null || options === void 0 ? void 0 : options.text) || '';
+        eventCenter.trigger('__taroSetTabBarBadge', {
+            index: (options === null || options === void 0 ? void 0 : options.index) || 0,
+            text: text.replace(/[\u0391-\uFFE5]/g, 'aa').length > 4 ? '...' : text,
+        });
+        callAsyncSuccess(resolve, res, options);
+    });
+}
+function removeTabBarBadge(options) {
+    const res = { errMsg: 'removeTabBarBadge:ok' };
+    return new Promise((resolve) => {
+        eventCenter.trigger('__taroRemoveTabBarBadge', {
+            index: (options === null || options === void 0 ? void 0 : options.index) || 0,
+        });
+        callAsyncSuccess(resolve, res, options);
+    });
+}
+
+class Animation {
+    constructor({ duration = 400, delay = 0, timingFunction = 'linear', transformOrigin = '50% 50% 0', unit = 'px' } = {}) {
+        // 组合动画
+        this.steps = [];
+        // 属性组合
+        this.rule = {};
+        this.unit = unit;
+        this.setDefault(duration, delay, timingFunction, transformOrigin);
+    }
+    // 设置默认值
+    setDefault(duration, delay, timingFunction, transformOrigin) {
+        this.DEFAULT = { duration, delay, timingFunction, transformOrigin };
+    }
+    export() {
+        const actions = this.steps.slice();
+        this.steps = [];
+        this.rule = {};
+        return {
+            actions
+        };
+    }
+    step(arg = {}) {
+        const { DEFAULT } = this;
+        const { duration = DEFAULT.duration, delay = DEFAULT.delay, timingFunction = DEFAULT.timingFunction, transformOrigin = DEFAULT.transformOrigin } = arg;
+        this.steps.push({
+            duration,
+            delay,
+            timingFunction,
+            transformOrigin,
+            rule: Object.assign({}, this.rule)
+        });
+        return this;
+    }
+    matrix(a, b, c, d, tx, ty) {
+        this.rule.transform = matrix4.init([a, b, c, d, tx, ty]);
+        return this;
+    }
+    matrix3d(a1, b1, c1, d1, a2, b2, c2, d2, a3, b3, c3, d3, a4, b4, c4, d4) {
+        this.rule.transform = matrix4.init([a1, b1, c1, d1, a2, b2, c2, d2, a3, b3, c3, d3, a4, b4, c4, d4]);
+        return this;
+    }
+    rotate(angle) {
+        this.rule.rotate = { x: 0, y: 0, z: 1, angle };
+        return this;
+    }
+    rotate3d(x, y, z, angle) {
+        this.rule.rotate = { x, y, z, angle };
+        return this;
+    }
+    rotateX(angle) {
+        this.rule.rotate = { x: 1, y: 0, z: 0, angle };
+        return this;
+    }
+    rotateY(angle) {
+        this.rule.rotate = { x: 0, y: 1, z: 0, angle };
+        return this;
+    }
+    rotateZ(angle) {
+        this.rule.rotate = { x: 0, y: 0, z: 1, angle };
+        return this;
+    }
+    scale(sx, sy) {
+        this.rule.scale = { x: sx, y: sy };
+        return this;
+    }
+    scale3d(sx, sy, sz) {
+        this.rule.scale = { x: sx, y: sy, z: sz };
+        return this;
+    }
+    scaleX(scale) {
+        this.rule.scale = { x: scale };
+        return this;
+    }
+    scaleY(scale) {
+        this.rule.scale = { y: scale };
+        return this;
+    }
+    scaleZ(scale) {
+        this.rule.scale = { z: scale };
+        return this;
+    }
+    skew(ax, ay) {
+        this.rule.skew = { x: ax, y: ay };
+        return this;
+    }
+    skewX(angle) {
+        this.rule.skew = { x: angle };
+        return this;
+    }
+    skewY(angle) {
+        this.rule.skew = { y: angle };
+        return this;
+    }
+    translate(tx, ty) {
+        this.rule.translate = { x: tx, y: ty };
+        return this;
+    }
+    translate3d(tx, ty, tz) {
+        this.rule.translate = { x: tx, y: ty, z: tz };
+        return this;
+    }
+    translateX(translation) {
+        this.rule.translate = { x: translation };
+        return this;
+    }
+    translateY(translation) {
+        this.rule.translate = { y: translation };
+        return this;
+    }
+    translateZ(translation) {
+        this.rule.translate = { z: translation };
+        return this;
+    }
+    opacity(value) {
+        this.rule.opacity = value;
+        return this;
+    }
+    backgroundColor(value) {
+        this.rule.backgroundColor = value;
+        return this;
+    }
+    width(value) {
+        this.rule.size = Object.assign(Object.assign({}, this.rule.size), { width: value });
+        return this;
+    }
+    height(value) {
+        this.rule.size = Object.assign(Object.assign({}, this.rule.size), { height: value });
+        return this;
+    }
+    left(value) {
+        temporarilyNotSupport('animation.left:' + value)(value);
+        return this;
+    }
+    right(value) {
+        temporarilyNotSupport('animation.right:' + value)(value);
+        return this;
+    }
+    top(value) {
+        temporarilyNotSupport('animation.top:' + value)(value);
+        return this;
+    }
+    bottom(value) {
+        temporarilyNotSupport('animation.bottom:' + value)(value);
+        return this;
+    }
+}
+
+// import window from '@ohos.window'
+// import { Current } from '@tarojs/runtime'
+// import { callAsyncFail, callAsyncSuccess } from '../utils'
+// const windowClassPromise = (Current as any).contextPromise
+//   .then(context => {
+//     return window.getTopWindow(context)
+//   })
+function setBackgroundColor(options) {
+    const { success, fail, complete } = options || {};
+    const handle = new MethodHandler({ name: 'setBackgroundColor', success, fail, complete });
+    return new Promise((resolve, reject) => {
+        eventCenter.trigger('__taroPageStyle', {
+            backgroundColor: options.backgroundColor || options.backgroundColorTop || options.backgroundColorBottom,
+        });
+        return handle.success({}, { resolve, reject });
+        // windowClassPromise.then(windowClass => {
+        //   windowClass.setBackgroundColor(color).then(() => {
+        //     const res = { errMsg: 'setBackgroundColor:ok' }
+        //     callAsyncSuccess(resolve, res, options)
+        //   }, (error) => {
+        //     const res = { errMsg: 'setBackgroundColor:fail' + error }
+        //     callAsyncFail(reject, res, options)
+        //   })
+        // })
+    });
+}
+
+const resCallback = (res) => {
+    return { errMsg: `${res}:ok` };
+};
+const showToastSchema = {
+    title: 'String',
+    duration: 'Number',
+    bottom: 'String'
+};
+function showToast(options) {
+    return new Promise((resolve, reject) => {
+        const _default = {
+            title: '',
+            duration: 1500,
+            bottom: '50%'
+        };
+        options = Object.assign(Object.assign({}, _default), options);
+        try {
+            validateParams('showToast', options, showToastSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        prompt.showToast({
+            message: options.title,
+            duration: options.duration,
+            bottom: options.bottom
+        });
+        callAsyncSuccess(resolve, resCallback('showToast'), options);
+    });
+}
+function showModal(options) {
+    const _default = {
+        title: '',
+        content: '',
+        showCancel: true,
+        cancelText: '取消',
+        cancelColor: '#000000',
+        confirmText: '确定',
+        confirmColor: '#3CC51F'
+    };
+    options = Object.assign(Object.assign({}, _default), options);
+    const { title, content, cancelText, confirmText, cancelColor, confirmColor, showCancel } = options;
+    const buttons = [];
+    if (cancelText !== '' && showCancel) {
+        buttons.push({
+            text: cancelText,
+            color: cancelColor
+        });
+    }
+    if (confirmText !== '') {
+        buttons.push({
+            text: confirmText,
+            color: confirmColor
+        });
+    }
+    return new Promise(resolve => {
+        const modalOptions = {
+            title,
+            message: content,
+            buttons: buttons,
+            success: (data) => {
+                if (data.index === 1 || !showCancel) {
+                    callAsyncSuccess(resolve, Object.assign(Object.assign({}, resCallback('showModal')), { confirm: true, cancel: false, content: null }), options);
+                }
+                else {
+                    callAsyncSuccess(resolve, Object.assign(Object.assign({}, resCallback('showModal')), { confirm: false, cancel: true }), options);
+                }
+            },
+            // 鸿蒙没有失败方法，只有取消
+            cancel: (_) => {
+                callAsyncSuccess(resolve, Object.assign(Object.assign({}, resCallback('showModal')), { confirm: false, cancel: true }), options);
+            }
+        };
+        prompt.showDialog(modalOptions);
+    });
+}
+const showActionSheetSchema = {
+    title: 'String',
+    itemList: 'Array'
+};
+function showActionSheet(options) {
+    return new Promise((resolve, reject) => {
+        const _default = {
+            title: '',
+            itemList: [],
+            itemColor: '#000000'
+        };
+        options = Object.assign(Object.assign({}, _default), options);
+        try {
+            validateParams('showActionSheet', options, showActionSheetSchema);
+        }
+        catch (error) {
+            const res = { errMsg: error.message };
+            return callAsyncFail(reject, res, options);
+        }
+        const { title, itemList, itemColor } = options;
+        const buttons = itemList.map(res => {
+            return {
+                text: res,
+                color: itemColor
+            };
+        });
+        const actionSheetOptions = {
+            title,
+            buttons,
+            success: (data) => {
+                callAsyncSuccess(resolve, Object.assign(Object.assign({}, data), resCallback('showActionSheet')), options);
+            },
+            // 取消方法，并非失败
+            fail: (data) => {
+                callAsyncFail(reject, Object.assign(Object.assign({}, data), { errMsg: data.errMsg.replace('showActionMenu', 'showActionSheet') }), options);
+            }
+        };
+        prompt.showActionMenu(actionSheetOptions);
+    });
+}
+function hideToast(options) {
+    return new Promise(resolve => {
+        prompt.showToast({
+            message: '关闭中',
+            duration: 10,
+            bottom: '9999px'
+        });
+        callAsyncSuccess(resolve, resCallback('hideToast'), options);
+    });
+}
+const showLoading = temporarilyNotSupport('showLoading');
+const hideLoading = temporarilyNotSupport('hideLoading');
+
+const setNavigationBarTitle = function (options) {
+    return new Promise(resolve => {
+        var _a;
+        const taro = Current.taro;
+        const page = taro.getCurrentInstance().page;
+        const res = { errMsg: 'setNavigationBarTitle:ok' };
+        (_a = page.$set) === null || _a === void 0 ? void 0 : _a.call(page, 'taroNavBar.title', options.title);
+        callAsyncSuccess(resolve, res, options);
+    });
+};
+const setNavigationBarColor = function (options) {
+    return new Promise(resolve => {
+        var _a, _b;
+        const taro = Current.taro;
+        const page = taro.getCurrentInstance().page;
+        const { frontColor, backgroundColor } = options;
+        const res = { errMsg: 'setNavigationBarColor:ok' };
+        (_a = page.$set) === null || _a === void 0 ? void 0 : _a.call(page, 'taroNavBar.textStyle', frontColor);
+        (_b = page.$set) === null || _b === void 0 ? void 0 : _b.call(page, 'taroNavBar.background', backgroundColor);
+        callAsyncSuccess(resolve, res, options);
+    });
+};
+const showNavigationBarLoading = temporarilyNotSupport('showNavigationBarLoading');
+const hideNavigationBarLoading = temporarilyNotSupport('hideNavigationBarLoading');
+const hideHomeButton = temporarilyNotSupport('hideHomeButton');
+
+const startPullDownRefresh = function (options) {
+    return new Promise(resolve => {
+        var _a;
+        const taro = Current.taro;
+        const page = taro.getCurrentInstance().page;
+        if (page.isRefreshing instanceof Array) {
+            const index = page.tabBarCurrentIndex || 0;
+            page.isRefreshing[index] = true;
+        }
+        else {
+            page.isRefreshing = true;
+        }
+        const res = { errMsg: 'startPullDownRefresh:ok' };
+        (_a = page.$set) === null || _a === void 0 ? void 0 : _a.call(page, 'isRefreshing', true);
+        callAsyncSuccess(resolve, res, options);
+    });
+};
+const stopPullDownRefresh = function (options) {
+    return new Promise(resolve => {
+        var _a;
+        const taro = Current.taro;
+        const page = taro.getCurrentInstance().page;
+        if (page.isRefreshing instanceof Array) {
+            const index = page.tabBarCurrentIndex || 0;
+            page.isRefreshing[index] = false;
+        }
+        else {
+            page.isRefreshing = false;
+        }
+        const res = { errMsg: 'stopPullDownRefresh:ok' };
+        (_a = page.$set) === null || _a === void 0 ? void 0 : _a.call(page, 'isRefreshing', false);
+        callAsyncSuccess(resolve, res, options);
+    });
+};
+
+const createAnimation = (option) => {
+    return new Animation(option);
+};
+const getMenuButtonBoundingClientRect = temporarilyNotSupport('getMenuButtonBoundingClientRect');
+
+// @ts-ignore
+class IntersectionObserver {
+    constructor(component, options = {}) {
+        // 选项
+        this._options = {
+            thresholds: [0],
+            initialRatio: 0,
+            observeAll: false
+        };
+        const taro = Current.taro;
+        const page = taro.getCurrentInstance().page;
+        const currentPage = getPageScrollerOrNode(page.node, page);
+        this._component = component || currentPage;
+        Object.assign(this._options, options);
+    }
+    disconnect() {
+        var _a, _b, _c;
+        if (this._observerNodes) {
+            if (this._observerNodes instanceof Array) {
+                this._observerNodes.forEach((n) => {
+                    var _a, _b, _c;
+                    disconnectEvent(n, VISIBLE_CHANGE_EVENT_NAME);
+                    if (n._instance) {
+                        // @ts-ignore
+                        (_c = (_b = (_a = n._instance) === null || _a === void 0 ? void 0 : _a.nodeInfoMap) === null || _b === void 0 ? void 0 : _b[n._nid]) === null || _c === void 0 ? void 0 : _c.thresholds = null;
+                    }
+                });
+            }
+            else {
+                disconnectEvent(this._observerNodes, VISIBLE_CHANGE_EVENT_NAME);
+                // @ts-ignore
+                if (this._observerNodes._instance) {
+                    // @ts-ignore
+                    (_c = (_b = (_a = this._observerNodes._instance) === null || _a === void 0 ? void 0 : _a.nodeInfoMap) === null || _b === void 0 ? void 0 : _b[this._observerNodes._nid]) === null || _c === void 0 ? void 0 : _c.thresholds = null;
+                }
+            }
+        }
+    }
+    observe(targetSelector, callback) {
+        const { observeAll, thresholds } = this._options;
+        const node = findChildNodeWithDFS(this._component, targetSelector, observeAll);
+        this._observerNodes = node;
+        if (node) {
+            if (node instanceof Array) {
+                node.forEach(n => {
+                    // @ts-ignore
+                    n.awaitAppear.then(() => {
+                        var _a, _b, _c;
+                        // @ts-ignore
+                        (_c = (_b = (_a = n._instance) === null || _a === void 0 ? void 0 : _a.nodeInfoMap) === null || _b === void 0 ? void 0 : _b[n._nid]) === null || _c === void 0 ? void 0 : _c.thresholds = thresholds;
+                        setNodeEventCallbackAndTriggerComponentUpdate(n, VISIBLE_CHANGE_EVENT_NAME, (isVisible, currentRatio) => {
+                            callback(this.handleResult(isVisible, currentRatio));
+                        });
+                    });
+                });
+            }
+            else {
+                // @ts-ignore
+                node.awaitAppear.then(() => {
+                    var _a, _b, _c;
+                    // @ts-ignore
+                    (_c = (_b = (_a = node._instance) === null || _a === void 0 ? void 0 : _a.nodeInfoMap) === null || _b === void 0 ? void 0 : _b[node._nid]) === null || _c === void 0 ? void 0 : _c.thresholds = thresholds;
+                    setNodeEventCallbackAndTriggerComponentUpdate(node, VISIBLE_CHANGE_EVENT_NAME, (isVisible, currentRatio) => {
+                        callback(this.handleResult(isVisible, currentRatio));
+                    });
+                });
+            }
+        }
+    }
+    relativeTo() {
+        temporarilyNotSupport('relativeTo')();
+        return this;
+    }
+    relativeToViewport() {
+        temporarilyNotSupport('relativeToViewport')();
+        return this;
+    }
+    // @ts-ignore
+    handleResult(isVisible, currentRatio) {
+        const result = {
+            intersectionRatio: currentRatio,
+            // TODO 未做，等待能拿到element的info信息
+            boundingClientRect: {
+                left: 0,
+                right: 0,
+                top: 0,
+                bottom: 0,
+                height: 0,
+                width: 0
+            },
+            // TODO 未做，等待能拿到element和监听_component的info信息做运算
+            intersectionRect: {
+                left: 0,
+                right: 0,
+                top: 0,
+                bottom: 0,
+                height: 0,
+                width: 0
+            },
+            // TODO 未做，等待能拿到element和监听_component的info信息做运算
+            relativeRect: { left: 0, right: 0, top: 0, bottom: 0 },
+            time: new Date().getTime()
+        };
+        return result;
+    }
+}
+
+class NodesRef {
+    constructor(selector, querySelectorQuery, single) {
+        this._component = querySelectorQuery._component;
+        this._selector = selector;
+        this._selectorQuery = querySelectorQuery;
+        this._single = single;
+    }
+    context(cb) {
+        const { _selector, _component, _single, _selectorQuery } = this;
+        _selectorQuery._push(_selector, _component, _single, { context: !0 }, cb);
+        return _selectorQuery;
+    }
+    node(cb) {
+        const { _selector, _component, _single, _selectorQuery } = this;
+        _selectorQuery._push(_selector, _component, _single, { nodeCanvasType: !0, node: !0 }, cb);
+        return _selectorQuery;
+    }
+    boundingClientRect(cb) {
+        const { _selector, _component, _single, _selectorQuery } = this;
+        _selectorQuery._push(_selector, _component, _single, { id: !0, dataset: !0, rect: !0, size: !0 }, cb);
+        return _selectorQuery;
+    }
+    scrollOffset(cb) {
+        const { _selector, _component, _single, _selectorQuery } = this;
+        _selectorQuery._push(_selector, _component, _single, { id: !0, dataset: !0, scrollOffset: !0 }, cb);
+        return _selectorQuery;
+    }
+    fields(fields, cb) {
+        const { _selector, _component, _single, _selectorQuery } = this;
+        const { id, dataset, rect, size, scrollOffset, properties = [], computedStyle = [] } = fields;
+        _selectorQuery._push(_selector, _component, _single, {
+            id,
+            dataset,
+            rect,
+            size,
+            scrollOffset,
+            properties,
+            computedStyle
+        }, cb);
+        return _selectorQuery;
+    }
+}
+
+let arr = [];
+// 深度搜索 rootDom 下的所有节点，存放在 arr 中
+function traversalDFSDom(rootDom) {
+    if (!rootDom)
+        return;
+    arr.push(rootDom);
+    if (rootDom.childNodes.length === 0)
+        return;
+    for (let i = 0; i < rootDom.childNodes.length; i++) {
+        traversalDFSDom(rootDom.childNodes[i]);
+    }
+}
+// 从 arr 中寻找所有符合 selector 的节点
+function parseHandler(selector, selectAll) {
+    var _a;
+    const domList = [];
+    if (arr.length === 0)
+        return null;
+    let selectedId, clsList;
+    switch (selector.charAt(0)) {
+        case '#': // id selector
+            selectedId = selector.substring(1);
+            for (let i = 0; i < arr.length; i++) {
+                if (arr[i].id === selectedId) {
+                    domList.push(arr[i]);
+                    if (!selectAll) {
+                        break;
+                    }
+                }
+            }
+            break;
+        case '.':
+            clsList = selector.split('.').filter((item) => item !== '');
+            if (clsList.length === 0)
+                break;
+            for (let i = 0; i < arr.length; i++) {
+                for (let j = 0; j < clsList.length; j++) {
+                    if ((_a = arr[i].className) === null || _a === void 0 ? void 0 : _a.includes(clsList[j])) {
+                        domList.push(arr[i]);
+                        if (!selectAll) {
+                            break;
+                        }
+                    }
+                }
+            }
+            break;
+        default:
+            console.warn('unSupport selector');
+            break;
+    }
+    if (selectAll) {
+        return domList;
+    }
+    else if (domList.length > 0) {
+        return [domList[0]];
+    }
+    return [];
+}
+// 从 TaroNode 里找到对应的 fields 内容
+function filter(fields, dom) {
+    var _a, _b;
+    if (!dom)
+        return null;
+    const { id, 
+    // dataset,
+    rect, size, scrollOffset, properties = [], computedStyle = [], nodeCanvasType, node, context } = fields;
+    const res = {};
+    if (nodeCanvasType && node) { // Node节点获取处理
+        const typeName = dom.nodeName;
+        res.node = {
+            id: dom.id,
+            $taroElement: dom
+        };
+        if (/^canvas/i.test(typeName)) {
+            // harmony todo canvas attr type
+            const canvasType = dom._attrs.type || '';
+            res.nodeCanvasType = canvasType;
+            if (/^(2d|webgl)/i.test(canvasType) && dom) {
+                res.node = dom;
+            }
+            else {
+                res.node = null;
+            }
+        }
+        else {
+            // TODO https://developers.weixin.qq.com/miniprogram/dev/component/scroll-view.html
+            // if (/^taro-scroll-view-core/i.test(tagName))
+            res.nodeCanvasType = '';
+            res.node = dom;
+        }
+        return res;
+    }
+    if (id)
+        res.id = dom.id;
+    // TODO harmony dataset
+    // if (dataset) res.dataset = Object.assign({}, dom.dataset)
+    if (rect || size) {
+        const id = dom === null || dom === void 0 ? void 0 : dom._nid;
+        const { areaInfo } = ((_b = (_a = dom === null || dom === void 0 ? void 0 : dom._instance) === null || _a === void 0 ? void 0 : _a.nodeInfoMap) === null || _b === void 0 ? void 0 : _b[id]) || {};
+        if (areaInfo) {
+            if (rect) {
+                res.top = vp2px(areaInfo.globalPosition.y);
+                res.left = vp2px(areaInfo.globalPosition.x);
+                res.right = vp2px(areaInfo.globalPosition.x + areaInfo.width);
+                res.bottom = vp2px(areaInfo.globalPosition.y + areaInfo.height);
+            }
+            if (size) {
+                res.width = vp2px(areaInfo.width);
+                res.height = vp2px(areaInfo.height);
+            }
+        }
+    }
+    if (scrollOffset) {
+        const scroller = dom._instance.scroller;
+        if (scroller) {
+            const { xOffset, yOffset } = scroller.currentOffset();
+            res.scrollLeft = vp2px(xOffset);
+            res.scrollTop = vp2px(yOffset);
+        }
+    }
+    if (properties.length) {
+        properties.forEach(prop => {
+            const attrs = dom._attrs;
+            if (attrs[prop])
+                res[prop] = attrs[prop];
+        });
+    }
+    if (computedStyle.length) {
+        const styles = dom._st;
+        computedStyle.forEach(key => {
+            const value = styles[key];
+            if (value)
+                res[key] = value;
+        });
+    }
+    return res;
+}
+function querySelector(selector, selectAll) {
+    if (typeof selector === 'string') {
+        return parseHandler(selector, selectAll);
+    }
+    return null;
+}
+function queryBat(queue, cb) {
+    const result = [];
+    const taro = Current.taro;
+    const page = taro.getCurrentInstance().page;
+    const element = getPageScrollerOrNode(page.node, page);
+    if (element == null)
+        return null;
+    arr = [];
+    traversalDFSDom(element);
+    queue.forEach(item => {
+        const { selector, single, fields } = item;
+        const nodeList = querySelector(selector, !single);
+        result.push(nodeList.map(dom => {
+            // eslint-disable-next-line no-async-promise-executor
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                yield setNodeEventCallbackAndTriggerComponentUpdate(dom, AREA_CHANGE_EVENT_NAME, null, true);
+                resolve(filter(fields, dom));
+            }));
+        }));
+    });
+    Promise.all(result.map(item => {
+        return Promise.all(item);
+    })).then(data => {
+        cb(data);
+    });
+}
+class SelectorQuery {
+    constructor() {
+        /**
+         * 设置选择器的选取范围
+         * @param component 指定组件
+         * @return selectQuery 返回查询对象
+         */
+        this.in = (_) => {
+            this._component = null;
+            console.warn('暂不支持 in 操作');
+            // this._component = component
+            return this;
+        };
+        this._queue = [];
+        this._queueCb = [];
+        // this._component
+    }
+    /**
+     * 在当前页面下选择第一个匹配选择器selector的节点
+     * @param selector
+     * @return nodesRef 返回一个NodesRef 对象实例，可以用于获取节点信息
+     */
+    select(selector) {
+        return new NodesRef(selector, this, true);
+    }
+    /**
+     * 在当前页面下选择匹配选择器selector的所有节点
+     * @param selector
+     */
+    selectAll(selector) {
+        return new NodesRef(selector, this, false);
+    }
+    /**
+     * 选择显示区域。可用于获取显示区域的尺寸、滚动位置等信息
+     */
+    selectViewport() {
+        return new NodesRef('.taro_page', this, true);
+    }
+    exec(cb) {
+        queryBat(this._queue, res => {
+            const _queueCb = this._queueCb;
+            res.forEach((item, index) => {
+                const cb = _queueCb[index];
+                typeof cb === 'function' && cb.call(this, item);
+            });
+            typeof cb === 'function' && cb.call(this, res);
+        });
+        return this;
+    }
+    _push(selector, component, single, fields, callback = null) {
+        this._queue.push({
+            component,
+            selector,
+            single,
+            fields
+        });
+        this._queueCb.push(callback);
+    }
+}
+
+const createSelectorQuery = () => {
+    return new SelectorQuery();
+};
+const createIntersectionObserver = (component, options) => {
+    return new IntersectionObserver(component, options);
+};
+
+var apis = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ENV_TYPE: ENV_TYPE,
+  Events: Events,
+  History: History,
+  authorize: authorize,
+  chooseImage: chooseImage,
+  chooseMedia: chooseMedia,
+  chooseVideo: chooseVideo,
+  clearStorage: clearStorage,
+  clearStorageSync: clearStorageSync,
+  compressImage: compressImage,
+  connectSocket: connectSocket,
+  createAnimation: createAnimation,
+  createIntersectionObserver: createIntersectionObserver,
+  createSelectorQuery: createSelectorQuery,
+  downloadFile: downloadFile,
+  eventCenter: eventCenter,
+  exitMiniProgram: exitMiniProgram,
+  getAccountInfoSync: getAccountInfoSync,
+  getBatteryInfo: getBatteryInfo,
+  getBatteryInfoSync: getBatteryInfoSync,
+  getClipboardData: getClipboardData,
+  getCurrentInstance: getCurrentInstance,
+  getCurrentPages: getCurrentPages,
+  getEnterOptionsSync: getEnterOptionsSync,
+  getEnv: getEnv,
+  getFileInfo: getFileInfo,
+  getFileSystemManager: getFileSystemManager,
+  getImageInfo: getImageInfo,
+  getLaunchOptionsSync: getLaunchOptionsSync,
+  getLength: getLength,
+  getLocalIPAddress: getLocalIPAddress,
+  getLocation: getLocation,
+  getMenuButtonBoundingClientRect: getMenuButtonBoundingClientRect,
+  getNetworkType: getNetworkType,
+  getSavedFileInfo: getSavedFileInfo,
+  getSavedFileList: getSavedFileList,
+  getScreenBrightness: getScreenBrightness,
+  getScreenRecordingState: getScreenRecordingState,
+  getSelectedTextRange: getSelectedTextRange,
+  getSetting: getSetting,
+  getState: getState,
+  getStorage: getStorage,
+  getStorageSync: getStorageSync,
+  getSystemInfo: getSystemInfo,
+  getSystemInfoSync: getSystemInfoSync,
+  getUpdateManager: getUpdateManager,
+  getUserInfo: getUserInfo,
+  getUserProfile: getUserProfile,
+  hideHomeButton: hideHomeButton,
+  hideKeyboard: hideKeyboard,
+  hideLoading: hideLoading,
+  hideNavigationBarLoading: hideNavigationBarLoading,
+  hideTabBar: hideTabBar,
+  hideTabBarRedDot: hideTabBarRedDot,
+  hideToast: hideToast,
+  login: login,
+  makePhoneCall: makePhoneCall,
+  navigateBack: navigateBack,
+  navigateBackMiniProgram: navigateBackMiniProgram,
+  navigateTo: navigateTo,
+  navigateToMiniProgram: navigateToMiniProgram,
+  nextTick: nextTick,
+  offAccelerometerChange: offAccelerometerChange,
+  offKeyboardHeightChange: offKeyboardHeightChange,
+  offLocationChange: offLocationChange,
+  offMemoryWarning: offMemoryWarning,
+  offNetworkStatusChange: offNetworkStatusChange,
+  offNetworkWeakChange: offNetworkWeakChange,
+  offScreenRecordingStateChanged: offScreenRecordingStateChanged,
+  offUserCaptureScreen: offUserCaptureScreen,
+  onAccelerometerChange: onAccelerometerChange,
+  onKeyboardHeightChange: onKeyboardHeightChange,
+  onLocationChange: onLocationChange,
+  onMemoryWarning: onMemoryWarning,
+  onNetworkStatusChange: onNetworkStatusChange,
+  onNetworkWeakChange: onNetworkWeakChange,
+  onScreenRecordingStateChanged: onScreenRecordingStateChanged,
+  onUserCaptureScreen: onUserCaptureScreen,
+  openBusinessView: openBusinessView,
+  openDocument: openDocument,
+  openEmbeddedMiniProgram: openEmbeddedMiniProgram,
+  openSetting: openSetting,
+  pageScrollTo: pageScrollTo,
+  previewImage: previewImage,
+  previewMedia: previewMedia,
+  reLaunch: reLaunch,
+  redirectTo: redirectTo,
+  removeSavedFile: removeSavedFile,
+  removeStorage: removeStorage,
+  removeStorageSync: removeStorageSync,
+  removeTabBarBadge: removeTabBarBadge,
+  request: request,
+  requestSubscribeMessage: requestSubscribeMessage,
+  requirePlugin: requirePlugin$1,
+  saveFile: saveFile,
+  saveFileToDisk: saveFileToDisk,
+  saveImageToPhotosAlbum: saveImageToPhotosAlbum,
+  saveVideoToPhotosAlbum: saveVideoToPhotosAlbum,
+  setBackgroundColor: setBackgroundColor,
+  setClipboardData: setClipboardData,
+  setKeepScreenOn: setKeepScreenOn,
+  setNavigationBarColor: setNavigationBarColor,
+  setNavigationBarTitle: setNavigationBarTitle,
+  setScreenBrightness: setScreenBrightness,
+  setStorage: setStorage,
+  setStorageSync: setStorageSync,
+  setTabBarBadge: setTabBarBadge,
+  setTabBarItem: setTabBarItem,
+  setTabBarStyle: setTabBarStyle,
+  setVisualEffectOnCapture: setVisualEffectOnCapture,
+  showActionSheet: showActionSheet,
+  showLoading: showLoading,
+  showModal: showModal,
+  showNavigationBarLoading: showNavigationBarLoading,
+  showTabBar: showTabBar,
+  showTabBarRedDot: showTabBarRedDot,
+  showToast: showToast,
+  startAccelerometer: startAccelerometer,
+  startPullDownRefresh: startPullDownRefresh,
+  stopAccelerometer: stopAccelerometer,
+  stopPullDownRefresh: stopPullDownRefresh,
+  switchTab: switchTab,
+  uploadFile: uploadFile,
+  vibrateLong: vibrateLong,
+  vibrateShort: vibrateShort
+});
+
+Object.assign({}, apis);
+const requirePlugin = /* @__PURE__ */ permanentlyNotSupport('requirePlugin');
+function initNativeApi(taro) {
+    Current.taro = taro;
+    taro.requirePlugin = requirePlugin;
+    taro.getApp = getApp$1;
+    taro.pxTransform = pxTransform;
+    taro.initPxTransform = initPxTransform;
+    taro.canIUseWebp = canIUseWebp;
+    taro.getAppInfo = getAppInfo;
+    if (hooks.isExist('initNativeApi')) {
+        hooks.call('initNativeApi', taro);
+    }
+}
+const defaultDesignWidth = 750;
+const defaultDesignRatio = {
+    640: 2.34 / 2,
+    750: 1,
+    828: 1.81 / 2
+};
+const defaultBaseFontSize = 20;
+const defaultUnitPrecision = 5;
+const defaultTargetUnit = 'vp';
+function getApp$1() {
+    return Current.app;
+}
+function initPxTransform({ designWidth = defaultDesignWidth, deviceRatio = defaultDesignRatio, baseFontSize = defaultBaseFontSize, unitPrecision = defaultUnitPrecision, targetUnit = defaultTargetUnit }) {
+    const taro = Current.taro;
+    if (taro) {
+        taro.config || (taro.config = {});
+        const config = taro.config;
+        config.designWidth = designWidth;
+        config.deviceRatio = deviceRatio;
+        config.baseFontSize = baseFontSize;
+        config.targetUnit = targetUnit;
+        config.unitPrecision = unitPrecision;
+    }
+}
+_display.getDefaultDisplaySync();
+function pxTransform(size) {
+    var _a;
+    const config = ((_a = Current.taro) === null || _a === void 0 ? void 0 : _a.config) || {};
+    const targetUnit = config.targetUnit || defaultTargetUnit;
+    let val = size;
+    switch (targetUnit) {
+        case 'vp':
+            val = px2vp(size);
+            break;
+        // NOTE: 鸿蒙环境下 style 会自动完成设计稿转换，无需在方法内二次调整
+    }
+    return val + config.targetUnit;
+}
+function canIUseWebp() {
+    return true;
+}
+function getAppInfo() {
+    var _a;
+    const config = (_a = Current.taro) === null || _a === void 0 ? void 0 : _a.config;
+    return {
+        platform: process.env.TARO_PLATFORM || PLATFORM_TYPE.HARMONY,
+        taroVersion: process.env.TARO_VERSION || 'unknown',
+        designWidth: config === null || config === void 0 ? void 0 : config.designWidth,
+    };
+}
+
+const components = {
+    Checkbox: {
+        'group-id': '',
+        cn: ''
+    },
+    Span: {},
+    Tabs: {
+        index: '0',
+        vertical: 'false',
+        bindchange: ''
+    },
+    TabBar: {
+        mode: singleQuote('scrollable')
+    },
+    TabContent: {
+        scrollable: 'true'
+    },
+    List: {
+        scrollpage: 'false',
+        cachedcount: '0',
+        scrollbar: 'off',
+        scrolleffect: singleQuote('spring'),
+        indexer: 'false',
+        indexercircle: '',
+        indexermulti: 'false',
+        indexerbubble: 'true',
+        divider: 'false',
+        shapemode: singleQuote('default'),
+        itemscale: 'true',
+        itemcenter: 'false',
+        updateeffect: 'false',
+        chainanimation: 'false',
+        scrollvibrate: 'true',
+        initialindex: '0',
+        initialoffset: '0',
+        selected: '',
+        bindindexerchange: '',
+        bindscroll: '',
+        bindscrollbottom: '',
+        bindscrolltop: '',
+        bindscrollend: '',
+        bindscrolltouchup: '',
+        bindrequestitem: ''
+    },
+    ListItem: {
+        type: singleQuote('default'),
+        primary: 'false',
+        section: '',
+        sticky: singleQuote('none'),
+        stickyradius: singleQuote('1000px'),
+        clickeffect: 'true',
+        bindsticky: ''
+    },
+    Switch: {
+        showtext: 'false',
+        texton: singleQuote('On'),
+        textoff: singleQuote('Off')
+    },
+    Textarea: {
+        headericon: '',
+        showcounter: 'false',
+        menuoptions: '[]',
+        softkeyboardenabled: 'true',
+        bindtranslate: '',
+        bindshare: '',
+        bindsearch: '',
+        bindoptionselect: '',
+        bindselectchange: ''
+    },
+    Progress: {
+        'active-color': singleQuote('#09BB07'),
+        'background-color': singleQuote('#EBEBEB'),
+        type: singleQuote('horizontal'),
+        'font-size': singleQuote('25px'),
+        secondarypercent: '0',
+        clockwise: 'true'
+    },
+    Slider: {
+        showsteps: 'false',
+        showtips: 'false'
+    },
+    Input: {
+        'placeholder-color': singleQuote('#99000000')
+    },
+    Video: {
+        speed: '1',
+        bindloadedmetadata: '',
+        bindprogress: '',
+        bindtap: ''
+    },
+    Image: {
+        alt: ''
+    },
+    Radio: {
+        'group-id': ''
+    },
+    Picker: {
+        selected: '',
+        hours: '',
+        containsecond: 'false',
+        vibrate: 'true',
+        lunar: 'false',
+        lunarswitch: 'false'
+    },
+    PickerView: {
+        mode: '',
+        range: '',
+        selected: '',
+        hours: '',
+        indicatorprefix: '',
+        indicatorsuffix: '',
+        containsecond: 'false',
+        vibrate: 'true',
+        lunar: 'false',
+        lunarswitch: 'false',
+        bindcolumnchange: '',
+        cn: ''
+    }
+};
+
+const BUBBLE_EVENTS = new Set([
+    'touchStart',
+    'touchMove',
+    'touchEnd',
+    'touchCancel',
+    'click',
+    'longTap'
+]);
+const hostConfig = {
+    initNativeApi,
+    modifyTaroEvent(event, node) {
+        const comps = Object.keys(internalComponents).map(c => c.toLowerCase());
+        const tagName = node.tagName.toLowerCase();
+        if (event.type === 'click' && comps.includes(tagName)) {
+            event.type = 'tap';
+        }
+        // getters & setters
+        const { mpEvent } = event;
+        // Note: Harmony ACE API 8 开发板该方法不存在
+        const getOwnPropertyDescriptors = typeof Object.getOwnPropertyDescriptors === 'function' ? Object.getOwnPropertyDescriptors : (arg = {}) => (Object.assign({}, arg));
+        // eslint-disable-next-line no-proto
+        const mpEventDescs = Object.assign(Object.assign({}, (getOwnPropertyDescriptors(mpEvent) || {})), (getOwnPropertyDescriptors(mpEvent.__proto__) || {}));
+        const descs = {};
+        for (const key in mpEventDescs) {
+            const item = mpEventDescs[key];
+            if ((item.get || item.set) && key !== 'type') {
+                descs[key] = item;
+            }
+        }
+        Object.defineProperties(event, descs);
+    },
+    getPathIndex(indexOfNode) {
+        return indexOfNode;
+    },
+    getSpecialNodes() {
+        return [];
+    },
+    getMiniLifecycle(config) {
+        config.app[0] = 'onCreate';
+        config.page[0] = 'onInit';
+        config.page[1] = 'onDestroy';
+        config.page[5] = [
+            'onActive',
+            'onInactive',
+            'onBackPress',
+            'onNewRequest',
+            'onStartContinuation',
+            'onSaveData',
+            'onRestoreData',
+            'onCompleteContinuation',
+            'onPullDownRefresh'
+        ];
+        return config;
+    },
+    modifyPageObject(config) {
+        const originOnInit = config.onInit;
+        config.onInit = function () {
+            // 对接小程序规范的 setData 到 harmony 规范的 $set
+            this.setData = function (normalUpdate, cb) {
+                Object.keys(normalUpdate).forEach(path => {
+                    this.$set(path, normalUpdate[path]);
+                });
+                cb();
+            };
+            // 处理路由参数
+            const options = {};
+            Object.keys(this._data).forEach(key => {
+                if (!/^root\b/.test(key) && !/^\$i18n\b/.test(key)) {
+                    options[key] = this._data[key];
+                }
+            });
+            // 调用 onInit
+            originOnInit.call(this, options);
+            // 手动记录路由堆栈
+            const app = getApp();
+            const pagePath = this.$taroPath.split('?')[0];
+            if (!app.pageStack) {
+                app.pageStack = [];
+            }
+            app.pageStack.push(pagePath);
+            // 根据 page.config 初始化 navbar
+            const appConfig = app.config;
+            const pageConfig = this.config;
+            const window = Object.assign({}, appConfig.window, pageConfig);
+            this.$set('taroNavBar', {
+                background: window.navigationBarBackgroundColor || '#000000',
+                textStyle: window.navigationBarTextStyle || 'white',
+                title: window.navigationBarTitleText || '',
+                style: window.navigationStyle || 'default'
+            });
+            // 初始化下拉刷新组件
+            this.$set('enablePullDownRefresh', Boolean(window.enablePullDownRefresh));
+            this.$set('isRefreshing', false);
+            // 根据 app.config 初始化 tabbar
+            if (appConfig.tabBar) {
+                const list = appConfig.tabBar.list;
+                for (const idx in list) {
+                    const item = list[idx];
+                    if (item.pagePath === pagePath) {
+                        this.$set('selected', idx);
+                        this.$set('isShowTaroTabBar', true);
+                        this.$set('taroTabBar', appConfig.tabBar);
+                        break;
+                    }
+                }
+            }
+        };
+        const originOnPullDownRefresh = config.onPullDownRefresh;
+        config.onPullDownRefresh = function (e) {
+            this.$set('isRefreshing', e.refreshing);
+            // 调用 onPullDownRefresh
+            originOnPullDownRefresh.call(this);
+        };
+        const originOnDestroy = config.onDestroy;
+        config.onDestroy = function () {
+            // 页面销毁时 执行路由堆栈 出栈
+            const app = getApp();
+            if (isArray(app.pageStack)) {
+                // 不能用 pop，因为 onInit 会比 onDestroy 先触发，考虑一种情况：
+                // current stack: [A, B], action: redirectTo C
+                // [C onInit], push C, stack: [A, B, C]
+                // [B onDestroy], pop C, stack: [A, B]
+                // 可见 pop 会导致路由栈错误，上述例子中正确的路由栈应该是 [A, C]，而不是 [A, B]
+                const pagePath = this.$taroPath.split('?')[0];
+                const stack = app.pageStack;
+                const len = stack.length;
+                let targetIdx = -1;
+                for (let i = 0; i < len; i++) {
+                    if (stack[i] === pagePath)
+                        targetIdx = i;
+                }
+                targetIdx >= 0 && stack.splice(targetIdx, 1);
+            }
+            // 调用 OnDestroy
+            originOnDestroy.call(this);
+        };
+        config.data = { root: { cn: [] } };
+    },
+    isBubbleEvents(eventName) {
+        return BUBBLE_EVENTS.has(eventName);
+    }
+};
+
+mergeReconciler(hostConfig);
+mergeInternalComponents(components);
+//# sourceMappingURL=runtime.js.map