@doubao-apps/taro-runtime 0.0.25 → 0.0.26

package/dist/api/device/compass.d.ts

@@ -3,7 +3,10 @@ type TaroStartCompassOption = Parameters<typeof Taro.startCompass>[0];
 type TaroStartCompassResult = Awaited<ReturnType<typeof Taro.startCompass>>;
 type TaroStopCompassOption = Parameters<typeof Taro.stopCompass>[0];
 type TaroStopCompassResult = Awaited<ReturnType<typeof Taro.stopCompass>>;
+type CompassChangeCallback = Parameters<typeof Taro.onCompassChange>[0];
 export declare function startCompass(option?: TaroStartCompassOption): Promise<TaroStartCompassResult>;
 export declare function stopCompass(option?: TaroStopCompassOption): Promise<TaroStopCompassResult>;
+export declare function onCompassChange(callback: CompassChangeCallback): void;
+export declare function offCompassChange(callback?: CompassChangeCallback): void;
 export {};
 //# sourceMappingURL=compass.d.ts.map

package/dist/api/device/compass.js

@@ -1,9 +1,37 @@
 import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
 import { runCallbackApi } from '../utils.js';
+const compassChangeCallbacks = new Map();
 export async function startCompass(option) {
     return runCallbackApi('startCompass', option, () => appFrameworkApi.startCompass({}));
 }
 export async function stopCompass(option) {
     return runCallbackApi('stopCompass', option, () => appFrameworkApi.stopCompass({}));
 }
+export function onCompassChange(callback) {
+    if (typeof callback !== 'function' || compassChangeCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appFrameworkApi.onCompassChange((event) => {
+        callback({
+            direction: event.direction
+        });
+    });
+    compassChangeCallbacks.set(callback, unregister);
+}
+export function offCompassChange(callback) {
+    if (typeof callback === 'function') {
+        const unregister = compassChangeCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        compassChangeCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    compassChangeCallbacks.forEach((unregister) => unregister());
+    compassChangeCallbacks.clear();
+}
 //# sourceMappingURL=compass.js.map

package/dist/api/device/index.d.ts

@@ -11,7 +11,6 @@ export * from './contact.js';
 export * from './crypto.js';
 export * from './device-motion.js';
 export * from './gyroscope.js';
-export * from './hce.js';
 export * from './keyboard.js';
 export * from './network.js';
 export * from './scan.js';

package/dist/api/device/index.js

@@ -11,7 +11,6 @@ export * from './contact.js';
 export * from './crypto.js';
 export * from './device-motion.js';
 export * from './gyroscope.js';
-export * from './hce.js';
 export * from './keyboard.js';
 export * from './network.js';
 export * from './scan.js';

package/dist/api/device/screen.d.ts

@@ -5,8 +5,11 @@ type TaroSetScreenBrightnessOption = Parameters<typeof Taro.setScreenBrightness>
 type TaroSetScreenBrightnessResult = Awaited<ReturnType<typeof Taro.setScreenBrightness>>;
 type TaroSetKeepScreenOnOption = Parameters<typeof Taro.setKeepScreenOn>[0];
 type TaroSetKeepScreenOnResult = Awaited<ReturnType<typeof Taro.setKeepScreenOn>>;
+type UserCaptureScreenCallback = (result: TaroGeneral.CallbackResult) => void;
 export declare function setVisualEffectOnCapture(option: TaroSetVisualEffectOnCaptureOption): Promise<TaroSetVisualEffectOnCaptureResult>;
 export declare function setScreenBrightness(option: TaroSetScreenBrightnessOption): Promise<TaroSetScreenBrightnessResult>;
 export declare function setKeepScreenOn(option: TaroSetKeepScreenOnOption): Promise<TaroSetKeepScreenOnResult>;
+export declare function onUserCaptureScreen(callback: UserCaptureScreenCallback): void;
+export declare function offUserCaptureScreen(callback?: UserCaptureScreenCallback): void;
 export {};
 //# sourceMappingURL=screen.d.ts.map

package/dist/api/device/screen.js

@@ -1,5 +1,6 @@
 import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
-import { runCallbackApi } from '../utils.js';
+import { buildOkCallbackResult, runCallbackApi } from '../utils.js';
+const userCaptureScreenCallbacks = new Map();
 export async function setVisualEffectOnCapture(option) {
     return runCallbackApi('setVisualEffectOnCapture', option, () => appFrameworkApi.setVisualEffectOnCapture({
         visualEffect: option.visualEffect
@@ -15,4 +16,29 @@ export async function setKeepScreenOn(option) {
         keepScreenOn: option.keepScreenOn
     }));
 }
+export function onUserCaptureScreen(callback) {
+    if (typeof callback !== 'function' || userCaptureScreenCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appFrameworkApi.onUserCaptureScreen(() => {
+        callback(buildOkCallbackResult('onUserCaptureScreen'));
+    });
+    userCaptureScreenCallbacks.set(callback, unregister);
+}
+export function offUserCaptureScreen(callback) {
+    if (typeof callback === 'function') {
+        const unregister = userCaptureScreenCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        userCaptureScreenCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    userCaptureScreenCallbacks.forEach((unregister) => unregister());
+    userCaptureScreenCallbacks.clear();
+}
 //# sourceMappingURL=screen.js.map

package/dist/api/device/wireless.d.ts

@@ -1,4 +1,3 @@
 export * from './beacon.js';
-export * from './hce.js';
 export * from './wifi.js';
 //# sourceMappingURL=wireless.d.ts.map

package/dist/api/device/wireless.js

@@ -1,4 +1,3 @@
 export * from './beacon.js';
-export * from './hce.js';
 export * from './wifi.js';
 //# sourceMappingURL=wireless.js.map

package/dist/api/index.d.ts

@@ -1,11 +1,13 @@
 export { getEnv, ENV_TYPE } from './base/index.js';
 export * from './device/index.js';
 export * from './device/index.js';
+export * from './media/index.js';
 export { request } from './request/index.js';
 export { exitMiniProgram, navigateBack, navigateTo, getCurrentPages, reLaunch, redirectTo } from './router/index.js';
 export { setStorage, setStorageSync, getStorage, getStorageSync, removeStorage, removeStorageSync, clearStorage, clearStorageSync, getStorageInfo, getStorageInfoSync } from './storage/index.js';
 export * from './system/index.js';
 export { getLocation } from './location/index.js';
+export { disableAlertBeforeUnload, enableAlertBeforeUnload, hideLoading, hideToast, showActionSheet, showLoading, showModal } from './interaction/index.js';
 export { showToast } from './show-toast/index.js';
 export { createMapContext } from './map/index.js';
 export { createSelectorQuery } from './create-selector-query/index.js';

package/dist/api/index.js

@@ -1,11 +1,13 @@
 export { getEnv, ENV_TYPE } from './base/index.js';
 export * from './device/index.js';
 export * from './device/index.js';
+export * from './media/index.js';
 export { request } from './request/index.js';
 export { exitMiniProgram, navigateBack, navigateTo, getCurrentPages, reLaunch, redirectTo } from './router/index.js';
 export { setStorage, setStorageSync, getStorage, getStorageSync, removeStorage, removeStorageSync, clearStorage, clearStorageSync, getStorageInfo, getStorageInfoSync } from './storage/index.js';
 export * from './system/index.js';
 export { getLocation } from './location/index.js';
+export { disableAlertBeforeUnload, enableAlertBeforeUnload, hideLoading, hideToast, showActionSheet, showLoading, showModal } from './interaction/index.js';
 export { showToast } from './show-toast/index.js';
 export { createMapContext } from './map/index.js';
 export { createSelectorQuery } from './create-selector-query/index.js';

package/dist/api/interaction/index.d.ts

@@ -0,0 +1,24 @@
+import type Taro from '@tarojs/taro';
+type TaroShowModalOption = NonNullable<Parameters<typeof Taro.showModal>[0]>;
+type TaroShowModalResult = Awaited<ReturnType<typeof Taro.showModal>>;
+type TaroShowLoadingOption = Parameters<typeof Taro.showLoading>[0];
+type TaroShowLoadingResult = Awaited<ReturnType<typeof Taro.showLoading>>;
+type TaroHideToastOption = Parameters<typeof Taro.hideToast>[0];
+type TaroHideToastResult = ReturnType<typeof Taro.hideToast>;
+type TaroHideLoadingOption = Parameters<typeof Taro.hideLoading>[0];
+type TaroHideLoadingResult = ReturnType<typeof Taro.hideLoading>;
+type TaroShowActionSheetOption = Parameters<typeof Taro.showActionSheet>[0];
+type TaroShowActionSheetResult = Awaited<ReturnType<typeof Taro.showActionSheet>>;
+type TaroEnableAlertBeforeUnloadOption = Parameters<typeof Taro.enableAlertBeforeUnload>[0];
+type TaroEnableAlertBeforeUnloadResult = ReturnType<typeof Taro.enableAlertBeforeUnload>;
+type TaroDisableAlertBeforeUnloadOption = Parameters<typeof Taro.disableAlertBeforeUnload>[0];
+type TaroDisableAlertBeforeUnloadResult = ReturnType<typeof Taro.disableAlertBeforeUnload>;
+export declare function showModal(option?: TaroShowModalOption): Promise<TaroShowModalResult>;
+export declare function showLoading(option?: TaroShowLoadingOption): Promise<TaroShowLoadingResult>;
+export declare function hideToast(option?: TaroHideToastOption): TaroHideToastResult;
+export declare function hideLoading(option?: TaroHideLoadingOption): TaroHideLoadingResult;
+export declare function showActionSheet(option: TaroShowActionSheetOption): Promise<TaroShowActionSheetResult>;
+export declare function enableAlertBeforeUnload(option: TaroEnableAlertBeforeUnloadOption): TaroEnableAlertBeforeUnloadResult;
+export declare function disableAlertBeforeUnload(option?: TaroDisableAlertBeforeUnloadOption): TaroDisableAlertBeforeUnloadResult;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/api/interaction/index.js

@@ -0,0 +1,74 @@
+import { disableAlertBeforeUnload as appDisableAlertBeforeUnload, enableAlertBeforeUnload as appEnableAlertBeforeUnload, hideLoading as appHideLoading, hideToast as appHideToast, showActionSheet as appShowActionSheet, showLoading as appShowLoading, showModal as appShowModal } from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runCallbackApi, runTaroApi } from '../utils.js';
+function runVoidCallbackApi(apiName, callbacks, run) {
+    const task = runCallbackApi(apiName, callbacks, run);
+    void task.catch(() => undefined);
+    return task;
+}
+function buildShowModalParams(option) {
+    const params = {
+        content: typeof option?.content === 'string' ? option.content : ''
+    };
+    if (typeof option?.title === 'string') {
+        params.title = option.title;
+    }
+    if (typeof option?.showCancel === 'boolean') {
+        params.showCancel = option.showCancel;
+    }
+    if (typeof option?.cancelText === 'string') {
+        params.cancelText = option.cancelText;
+    }
+    if (typeof option?.confirmText === 'string') {
+        params.confirmText = option.confirmText;
+    }
+    return params;
+}
+function buildShowModalResult(result) {
+    return {
+        confirm: result.action === 'confirm',
+        cancel: result.action === 'cancel',
+        ...buildOkCallbackResult('showModal')
+    };
+}
+function buildShowActionSheetParams(option) {
+    const params = {
+        itemList: Array.isArray(option.itemList) ? option.itemList.filter((item) => typeof item === 'string') : []
+    };
+    if (typeof option.itemColor === 'string') {
+        params.itemColor = option.itemColor;
+    }
+    return params;
+}
+function buildShowActionSheetResult(result) {
+    return {
+        tapIndex: typeof result.tapIndex === 'number' ? result.tapIndex : 0,
+        ...buildOkCallbackResult('showActionSheet')
+    };
+}
+function buildEnableAlertBeforeUnloadParams(option) {
+    return {
+        message: typeof option.message === 'string' ? option.message : ''
+    };
+}
+export async function showModal(option) {
+    return runTaroApi('showModal', option, async () => buildShowModalResult(await appShowModal(buildShowModalParams(option))));
+}
+export async function showLoading(option) {
+    return runCallbackApi('showLoading', option, () => appShowLoading({}));
+}
+export function hideToast(option) {
+    return runVoidCallbackApi('hideToast', option, () => appHideToast(option));
+}
+export function hideLoading(option) {
+    return runVoidCallbackApi('hideLoading', option, () => appHideLoading(option));
+}
+export async function showActionSheet(option) {
+    return runTaroApi('showActionSheet', option, async () => buildShowActionSheetResult(await appShowActionSheet(buildShowActionSheetParams(option))));
+}
+export function enableAlertBeforeUnload(option) {
+    return runVoidCallbackApi('enableAlertBeforeUnload', option, () => appEnableAlertBeforeUnload(buildEnableAlertBeforeUnloadParams(option)));
+}
+export function disableAlertBeforeUnload(option) {
+    return runVoidCallbackApi('disableAlertBeforeUnload', option, () => appDisableAlertBeforeUnload({}));
+}
+//# sourceMappingURL=index.js.map

package/dist/api/media/image.d.ts

@@ -0,0 +1,18 @@
+import type Taro from '@tarojs/taro';
+type TaroSaveImageToPhotosAlbumOption = Parameters<typeof Taro.saveImageToPhotosAlbum>[0];
+type TaroSaveImageToPhotosAlbumResult = Awaited<ReturnType<typeof Taro.saveImageToPhotosAlbum>>;
+type TaroPreviewImageOption = Parameters<typeof Taro.previewImage>[0];
+type TaroPreviewImageResult = Awaited<ReturnType<typeof Taro.previewImage>>;
+type TaroGetImageInfoOption = Parameters<typeof Taro.getImageInfo>[0];
+type TaroGetImageInfoResult = Awaited<ReturnType<typeof Taro.getImageInfo>>;
+type TaroChooseImageOption = Parameters<typeof Taro.chooseImage>[0];
+type TaroChooseImageResult = Awaited<ReturnType<typeof Taro.chooseImage>>;
+type TaroCompressImageOption = Parameters<typeof Taro.compressImage>[0];
+type TaroCompressImageResult = Awaited<ReturnType<typeof Taro.compressImage>>;
+export declare function saveImageToPhotosAlbum(option: TaroSaveImageToPhotosAlbumOption): Promise<TaroSaveImageToPhotosAlbumResult>;
+export declare function previewImage(option: TaroPreviewImageOption): Promise<TaroPreviewImageResult>;
+export declare function getImageInfo(option: TaroGetImageInfoOption): Promise<TaroGetImageInfoResult>;
+export declare function chooseImage(option?: TaroChooseImageOption): Promise<TaroChooseImageResult>;
+export declare function compressImage(option: TaroCompressImageOption): Promise<TaroCompressImageResult>;
+export {};
+//# sourceMappingURL=image.d.ts.map

package/dist/api/media/image.js

@@ -0,0 +1,62 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runCallbackApi, runTaroApi } from '../utils.js';
+function buildGetImageInfoResult(result, src) {
+    return {
+        height: result.height ?? 0,
+        orientation: result.orientation ?? 'up',
+        path: result.path ?? src,
+        type: result.type ?? '',
+        width: result.width ?? 0,
+        ...buildOkCallbackResult('getImageInfo')
+    };
+}
+function buildChooseImageResult(result) {
+    const tempFiles = result.tempFiles ?? result.tempFilePaths.map((path) => ({ path, size: 0 }));
+    const tempFilePaths = result.tempFilePaths ?? tempFiles.map((file) => file.path);
+    return {
+        tempFilePaths,
+        tempFiles,
+        ...buildOkCallbackResult('chooseImage')
+    };
+}
+function buildCompressImageResult(result) {
+    return {
+        tempFilePath: result.tempFilePath ?? '',
+        ...buildOkCallbackResult('compressImage')
+    };
+}
+export async function saveImageToPhotosAlbum(option) {
+    return runCallbackApi('saveImageToPhotosAlbum', option, () => appFrameworkApi.saveImageToPhotosAlbum({
+        filePath: option.filePath
+    }));
+}
+export async function previewImage(option) {
+    return runCallbackApi('previewImage', option, () => appFrameworkApi.previewImage({
+        urls: option.urls,
+        current: option.current,
+        showmenu: option.showmenu,
+        referrerPolicy: option.referrerPolicy
+    }));
+}
+export async function getImageInfo(option) {
+    return runTaroApi('getImageInfo', option, async () => buildGetImageInfoResult(await appFrameworkApi.getImageInfo({
+        src: option.src
+    }), option.src));
+}
+export async function chooseImage(option = {}) {
+    return runTaroApi('chooseImage', option, async () => buildChooseImageResult(await appFrameworkApi.chooseImage({
+        count: option.count,
+        sizeType: option.sizeType,
+        sourceType: option.sourceType,
+        imageId: option.imageId
+    })));
+}
+export async function compressImage(option) {
+    return runTaroApi('compressImage', option, async () => buildCompressImageResult(await appFrameworkApi.compressImage({
+        src: option.src,
+        quality: option.quality,
+        compressedWidth: option.compressedWidth,
+        compressedHeight: option.compressedHeight
+    })));
+}
+//# sourceMappingURL=image.js.map

package/dist/api/media/index.d.ts

@@ -0,0 +1,2 @@
+export * from './image.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/media/index.js

@@ -0,0 +1,2 @@
+export * from './image.js';
+//# sourceMappingURL=index.js.map

package/dist/api/system/index.d.ts

@@ -9,16 +9,21 @@ type TaroGetScreenBrightnessOption = Parameters<typeof taroGetScreenBrightness>[
 type TaroGetScreenBrightnessResult = Awaited<ReturnType<typeof taroGetScreenBrightness>>;
 type TaroSetClipboardDataOption = Parameters<typeof Taro.setClipboardData>[0];
 type TaroSetClipboardDataResult = Awaited<ReturnType<typeof Taro.setClipboardData>>;
+type TaroMenuButtonBoundingClientRect = ReturnType<typeof Taro.getMenuButtonBoundingClientRect>;
 type KeyboardHeightChangeCallback = Parameters<typeof Taro.onKeyboardHeightChange>[0];
+type NetworkStatusChangeCallback = Parameters<typeof Taro.onNetworkStatusChange>[0];
 export declare function getSystemSetting(): Taro.getSystemSetting.Result;
 export declare function getAppAuthorizeSetting(): Taro.getAppAuthorizeSetting.Result;
 export declare function getDeviceInfo(): Taro.getDeviceInfo.Result;
 export declare function getAppBaseInfo(): Taro.getAppBaseInfo.Result;
 export declare function getWindowInfo(): Taro.getWindowInfo.Result;
+export declare function getMenuButtonBoundingClientRect(): TaroMenuButtonBoundingClientRect;
 export declare function makePhoneCall(option: TaroMakePhoneCallOption): Promise<TaroMakePhoneCallResult>;
 export declare function getNetworkType(option?: TaroGetNetworkTypeOption): Promise<TaroGetNetworkTypeResult>;
 export declare function getScreenBrightness(option?: TaroGetScreenBrightnessOption): Promise<TaroGetScreenBrightnessResult>;
 export declare function setClipboardData(option: TaroSetClipboardDataOption): Promise<TaroSetClipboardDataResult>;
 export declare function onKeyboardHeightChange(callback: KeyboardHeightChangeCallback): void;
+export declare function onNetworkStatusChange(callback: NetworkStatusChangeCallback): void;
+export declare function offNetworkStatusChange(callback?: NetworkStatusChangeCallback): void;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/api/system/index.js

@@ -1,5 +1,6 @@
-import { getAppBaseInfoSync, getWindowInfoSync, makePhoneCall as appMakePhoneCall, getNetworkType as appGetNetworkType, getScreenBrightness as appGetScreenBrightness, setClipboardData as appSetClipboardData, onKeyboardHeightChange as appOnKeyboardHeightChange } from '@byted-doubao-apps/framework/api';
+import { getAppBaseInfoSync, getMenuButtonBoundingClientRect as appGetMenuButtonBoundingClientRect, getSystemSetting as appGetSystemSetting, getWindowInfoSync, makePhoneCall as appMakePhoneCall, getNetworkType as appGetNetworkType, onNetworkStatusChange as appOnNetworkStatusChange, getScreenBrightness as appGetScreenBrightness, setClipboardData as appSetClipboardData, onKeyboardHeightChange as appOnKeyboardHeightChange } from '@byted-doubao-apps/framework/api';
 import { buildFailCallbackResult, emitFailure, runCallbackApi, runTaroApi } from '../utils.js';
+const networkStatusChangeCallbacks = new Map();
 function buildVibrateShortParams(option) {
     if (option?.type === 'heavy' || option?.type === 'medium' || option?.type === 'light') {
         return { type: option.type };
@@ -7,7 +8,21 @@ function buildVibrateShortParams(option) {
     return { type: 'medium' };
 }
 export function getSystemSetting() {
-    return {};
+    const result = appGetSystemSetting();
+    const systemSetting = {};
+    if (typeof result.bluetoothEnabled === 'boolean') {
+        systemSetting.bluetoothEnabled = result.bluetoothEnabled;
+    }
+    if (typeof result.locationEnabled === 'boolean') {
+        systemSetting.locationEnabled = result.locationEnabled;
+    }
+    if (typeof result.wifiEnabled === 'boolean') {
+        systemSetting.wifiEnabled = result.wifiEnabled;
+    }
+    if (result.deviceOrientation === 'portrait' || result.deviceOrientation === 'landscape') {
+        systemSetting.deviceOrientation = result.deviceOrientation;
+    }
+    return systemSetting;
 }
 export function getAppAuthorizeSetting() {
     return {
@@ -41,6 +56,9 @@ export function getAppBaseInfo() {
 export function getWindowInfo() {
     return getWindowInfoSync();
 }
+export function getMenuButtonBoundingClientRect() {
+    return appGetMenuButtonBoundingClientRect();
+}
 export async function makePhoneCall(option) {
     const { phoneNumber } = option;
     if (typeof phoneNumber !== 'string' || phoneNumber.length === 0) {
@@ -102,4 +120,33 @@ export function onKeyboardHeightChange(callback) {
         });
     });
 }
+export function onNetworkStatusChange(callback) {
+    if (typeof callback !== 'function' || networkStatusChangeCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appOnNetworkStatusChange((event) => {
+        callback({
+            isConnected: event.isConnected,
+            networkType: event.networkType,
+            errMsg: 'onNetworkStatusChange:ok'
+        });
+    });
+    networkStatusChangeCallbacks.set(callback, unregister);
+}
+export function offNetworkStatusChange(callback) {
+    if (typeof callback === 'function') {
+        const unregister = networkStatusChangeCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        networkStatusChangeCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    networkStatusChangeCallbacks.forEach((unregister) => unregister());
+    networkStatusChangeCallbacks.clear();
+}
 //# sourceMappingURL=index.js.map

package/package.json

@@ -37,7 +37,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "0.0.25",
+  "version": "0.0.26",
   "scripts": {
     "dev": "npm run build -- -w",
     "build": "rimraf dist bundle && tsc -p tsconfig.build.json",

package/dist/api/device/hce.d.ts

@@ -1,11 +0,0 @@
-import type Taro from '@tarojs/taro';
-type TaroStartHCEOption = Taro.startHCE.Option;
-type TaroStopHCEOption = Taro.stopHCE.Option;
-type TaroSendHCEMessageOption = Taro.sendHCEMessage.Option;
-type TaroGetHCEStateOption = Taro.getHCEState.Option;
-export declare function startHCE(option: TaroStartHCEOption): Promise<TaroGeneral.CallbackResult>;
-export declare function stopHCE(option?: TaroStopHCEOption): Promise<TaroGeneral.CallbackResult>;
-export declare function sendHCEMessage(option: TaroSendHCEMessageOption): Promise<TaroGeneral.CallbackResult>;
-export declare function getHCEState(option?: TaroGetHCEStateOption): Promise<TaroGeneral.CallbackResult>;
-export {};
-//# sourceMappingURL=hce.d.ts.map

package/dist/api/device/hce.js

@@ -1,19 +0,0 @@
-import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
-import { runCallbackApi } from '../utils.js';
-export async function startHCE(option) {
-    return runCallbackApi('startHCE', option, () => appFrameworkApi.startHCE({
-        aidList: option.aid_list
-    }));
-}
-export async function stopHCE(option) {
-    return runCallbackApi('stopHCE', option, () => appFrameworkApi.stopHCE({}));
-}
-export async function sendHCEMessage(option) {
-    return runCallbackApi('sendHCEMessage', option, () => appFrameworkApi.sendHCEMessage({
-        data: option.data
-    }));
-}
-export async function getHCEState(option) {
-    return runCallbackApi('getHCEState', option, () => appFrameworkApi.getHCEState({}));
-}
-//# sourceMappingURL=hce.js.map