@doubao-apps/taro-runtime 0.0.25 → 0.0.27

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

@@ -3,7 +3,15 @@ type TaroStartAccelerometerOption = Parameters<typeof Taro.startAccelerometer>[0
 type TaroStartAccelerometerResult = Awaited<ReturnType<typeof Taro.startAccelerometer>>;
 type TaroStopAccelerometerOption = Parameters<typeof Taro.stopAccelerometer>[0];
 type TaroStopAccelerometerResult = Awaited<ReturnType<typeof Taro.stopAccelerometer>>;
+type TaroAccelerometerChangeCallback = Parameters<typeof Taro.onAccelerometerChange>[0];
+type TaroAccelerometerChangeCallbackResult = Parameters<TaroAccelerometerChangeCallback>[0];
+type AccelerometerChangeCallbackResult = TaroAccelerometerChangeCallbackResult & {
+    timestamp: number;
+};
+type AccelerometerChangeCallback = (result: AccelerometerChangeCallbackResult) => void;
 export declare function startAccelerometer(option?: TaroStartAccelerometerOption): Promise<TaroStartAccelerometerResult>;
 export declare function stopAccelerometer(option?: TaroStopAccelerometerOption): Promise<TaroStopAccelerometerResult>;
+export declare function onAccelerometerChange(callback: AccelerometerChangeCallback): void;
+export declare function offAccelerometerChange(callback?: AccelerometerChangeCallback): void;
 export {};
 //# sourceMappingURL=accelerometer.d.ts.map

package/dist/api/device/accelerometer.js

@@ -1,5 +1,6 @@
 import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
 import { runCallbackApi } from '../utils.js';
+const accelerometerChangeCallbacks = new Map();
 export async function startAccelerometer(option) {
     return runCallbackApi('startAccelerometer', option, () => appFrameworkApi.startAccelerometer({
         interval: option?.interval
@@ -8,4 +9,34 @@ export async function startAccelerometer(option) {
 export async function stopAccelerometer(option) {
     return runCallbackApi('stopAccelerometer', option, () => appFrameworkApi.stopAccelerometer({}));
 }
+export function onAccelerometerChange(callback) {
+    if (typeof callback !== 'function' || accelerometerChangeCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appFrameworkApi.onAccelerometerChange((event) => {
+        callback({
+            x: event.x,
+            y: event.y,
+            z: event.z,
+            timestamp: event.timestamp
+        });
+    });
+    accelerometerChangeCallbacks.set(callback, unregister);
+}
+export function offAccelerometerChange(callback) {
+    if (typeof callback === 'function') {
+        const unregister = accelerometerChangeCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        accelerometerChangeCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    accelerometerChangeCallbacks.forEach((unregister) => unregister());
+    accelerometerChangeCallbacks.clear();
+}
 //# sourceMappingURL=accelerometer.js.map

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

@@ -1,6 +1,12 @@
 import type Taro from '@tarojs/taro';
 type TaroGetBatteryInfoOption = Parameters<typeof Taro.getBatteryInfo>[0];
 type TaroGetBatteryInfoResult = Awaited<ReturnType<typeof Taro.getBatteryInfo>>;
+type BatteryInfoChangeCallbackResult = {
+    isLowPowerModeEnabled: boolean;
+};
+type BatteryInfoChangeCallback = (result: BatteryInfoChangeCallbackResult) => void;
 export declare function getBatteryInfo(option?: TaroGetBatteryInfoOption): Promise<TaroGetBatteryInfoResult>;
+export declare function onBatteryInfoChange(callback: BatteryInfoChangeCallback): void;
+export declare function offBatteryInfoChange(callback?: BatteryInfoChangeCallback): void;
 export {};
 //# sourceMappingURL=battery.d.ts.map

package/dist/api/device/battery.js

@@ -1,5 +1,6 @@
 import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
 import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+const batteryInfoChangeCallbacks = new Map();
 function buildGetBatteryInfoResult(result) {
     return {
         isCharging: Boolean(result.isCharging),
@@ -10,4 +11,31 @@ function buildGetBatteryInfoResult(result) {
 export async function getBatteryInfo(option) {
     return runTaroApi('getBatteryInfo', option, async () => buildGetBatteryInfoResult(await appFrameworkApi.getBatteryInfo({})));
 }
+export function onBatteryInfoChange(callback) {
+    if (typeof callback !== 'function' || batteryInfoChangeCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appFrameworkApi.onBatteryInfoChange((event) => {
+        callback({
+            isLowPowerModeEnabled: Boolean(event.isLowPowerModeEnabled)
+        });
+    });
+    batteryInfoChangeCallbacks.set(callback, unregister);
+}
+export function offBatteryInfoChange(callback) {
+    if (typeof callback === 'function') {
+        const unregister = batteryInfoChangeCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        batteryInfoChangeCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    batteryInfoChangeCallbacks.forEach((unregister) => unregister());
+    batteryInfoChangeCallbacks.clear();
+}
 //# sourceMappingURL=battery.js.map

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/gyroscope.d.ts

@@ -3,7 +3,15 @@ type TaroStartGyroscopeOption = Parameters<typeof Taro.startGyroscope>[0];
 type TaroStartGyroscopeResult = Awaited<ReturnType<typeof Taro.startGyroscope>>;
 type TaroStopGyroscopeOption = Parameters<typeof Taro.stopGyroscope>[0];
 type TaroStopGyroscopeResult = Awaited<ReturnType<typeof Taro.stopGyroscope>>;
+type TaroGyroscopeChangeCallback = Parameters<typeof Taro.onGyroscopeChange>[0];
+type TaroGyroscopeChangeCallbackResult = Parameters<TaroGyroscopeChangeCallback>[0];
+type GyroscopeChangeCallbackResult = TaroGyroscopeChangeCallbackResult & {
+    timestamp: number;
+};
+type GyroscopeChangeCallback = (result: GyroscopeChangeCallbackResult) => void;
 export declare function startGyroscope(option: TaroStartGyroscopeOption): Promise<TaroStartGyroscopeResult>;
 export declare function stopGyroscope(option?: TaroStopGyroscopeOption): Promise<TaroStopGyroscopeResult>;
+export declare function onGyroscopeChange(callback: GyroscopeChangeCallback): void;
+export declare function offGyroscopeChange(callback?: GyroscopeChangeCallback): void;
 export {};
 //# sourceMappingURL=gyroscope.d.ts.map

package/dist/api/device/gyroscope.js

@@ -1,5 +1,6 @@
 import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
 import { runCallbackApi } from '../utils.js';
+const gyroscopeChangeCallbacks = new Map();
 export async function startGyroscope(option) {
     return runCallbackApi('startGyroscope', option, () => appFrameworkApi.startGyroscope({
         interval: option.interval
@@ -8,4 +9,34 @@ export async function startGyroscope(option) {
 export async function stopGyroscope(option) {
     return runCallbackApi('stopGyroscope', option, () => appFrameworkApi.stopGyroscope({}));
 }
+export function onGyroscopeChange(callback) {
+    if (typeof callback !== 'function' || gyroscopeChangeCallbacks.has(callback)) {
+        return;
+    }
+    const unregister = appFrameworkApi.onGyroscopeChange((event) => {
+        callback({
+            x: event.x,
+            y: event.y,
+            z: event.z,
+            timestamp: event.timestamp
+        });
+    });
+    gyroscopeChangeCallbacks.set(callback, unregister);
+}
+export function offGyroscopeChange(callback) {
+    if (typeof callback === 'function') {
+        const unregister = gyroscopeChangeCallbacks.get(callback);
+        if (!unregister) {
+            return;
+        }
+        unregister();
+        gyroscopeChangeCallbacks.delete(callback);
+        return;
+    }
+    if (callback !== undefined) {
+        return;
+    }
+    gyroscopeChangeCallbacks.forEach((unregister) => unregister());
+    gyroscopeChangeCallbacks.clear();
+}
 //# sourceMappingURL=gyroscope.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/dist/components/PickerView/index.jsx

@@ -1,42 +1,50 @@
-import { Children, cloneElement } from 'react';
 import { PickerView as DoubaoPickerView, PickerColumn as DoubaoPickerColumn } from '@byted-doubao-apps/components';
-import { buildOptionsFromRange, mapPickerViewProps, toPickerViewChangeEvent, warnUnsupportedPickerView } from './map.js';
+import { warnUnsupported } from '../base/warn-unsupported.js';
+import { buildOptionsFromChildren, buildOptionsFromRange, mapPickerViewColumnProps, mapPickerViewProps, resolveExplicitItemHeight, resolveItemHeightFromChildren, resolveSelectedIndexValue, toPickerViewChangeEvent } from './map.js';
+const PICKER_VIEW_COLUMN_TYPE = 'taro-picker-view-column';
 export function PickerView(props) {
-    const { value, onChange, children, ...rest } = props;
-    const { mapped, unsupported } = mapPickerViewProps(rest);
-    warnUnsupportedPickerView(unsupported);
-    // Collect ranges from child columns to compute indices on change
-    const ranges = [];
-    const childrenWithProps = Children.map(children, (child, index) => {
-        if (!child)
-            return child;
-        // We expect child to be <PickerViewColumn range={...} />
-        const range = child?.props?.range;
-        const options = buildOptionsFromRange(range);
-        ranges[index] = options;
-        const selectedIndex = Array.isArray(value) ? value[index] : undefined;
-        const selectedValue = selectedIndex != null && options[selectedIndex] ? options[selectedIndex].value : undefined;
-        return cloneElement(child, {
-            __mappedOptions: options,
-            __mappedValue: selectedValue
+    const { value, defaultValue, onChange, children, itemHeight: propItemHeight, ...rest } = props;
+    const { mapped, unsupported, indicatorItemHeight } = mapPickerViewProps(rest);
+    const explicitItemHeight = resolveExplicitItemHeight(propItemHeight);
+    const pickerViewId = typeof mapped.id === 'string' ? mapped.id : '';
+    warnUnsupported('PickerView', propItemHeight !== undefined && explicitItemHeight === undefined
+        ? [...unsupported, 'itemHeight must be a positive number']
+        : unsupported);
+    const columns = [];
+    toChildArray(children).forEach((child) => {
+        if (!isPickerViewColumnElement(child)) {
+            return;
+        }
+        const columnProps = child.props;
+        const { className, style, unsupported: columnUnsupported } = mapPickerViewColumnProps(columnProps);
+        warnUnsupported('PickerViewColumn', columnUnsupported);
+        columns.push({
+            options: Array.isArray(columnProps.range)
+                ? buildOptionsFromRange(columnProps.range)
+                : buildOptionsFromChildren(columnProps.children),
+            className,
+            style,
+            itemHeight: resolveItemHeightFromChildren(columnProps.children)
         });
     });
+    const resolvedItemHeight = explicitItemHeight ??
+        indicatorItemHeight ??
+        columns.find((column) => column.itemHeight !== undefined)?.itemHeight;
     const handleChange = (values, selectedOptions) => {
-        // Map selected values back to indices per column
-        const indices = values.map((val, idx) => {
-            const opts = ranges[idx] ?? [];
-            const found = opts.findIndex((opt) => opt.value === val);
-            return found >= 0 ? found : 0;
+        const indices = values.map((selectedValue, index) => {
+            if (typeof selectedValue === 'number') {
+                return selectedValue;
+            }
+            const optionValue = selectedOptions[index]?.value;
+            return typeof optionValue === 'number' ? optionValue : 0;
         });
-        onChange?.(toPickerViewChangeEvent(indices));
+        onChange?.(toPickerViewChangeEvent(indices, pickerViewId));
     };
-    return (<DoubaoPickerView {...mapped} onChange={onChange ? handleChange : undefined}>
-      {Children.map(childrenWithProps, (child) => {
-            const options = child?.props?.__mappedOptions;
-            const valueForColumn = child?.props?.__mappedValue;
-            const columnClassName = child?.props?.className;
-            const columnStyle = child?.props?.style;
-            return (<DoubaoPickerColumn options={options ?? []} value={valueForColumn} className={columnClassName} style={columnStyle}/>);
+    return (<DoubaoPickerView {...mapped} itemHeight={resolvedItemHeight} onChange={onChange ? handleChange : undefined}>
+      {columns.map(({ options, className, style }, index) => {
+            const valueForColumn = resolveSelectedIndexValue(value, index, options);
+            const defaultValueForColumn = resolveSelectedIndexValue(defaultValue, index, options);
+            return (<DoubaoPickerColumn key={index} options={options} value={valueForColumn} defaultValue={defaultValueForColumn} className={className} style={style}/>);
         })}
     </DoubaoPickerView>);
 }
@@ -44,4 +52,29 @@ export function PickerViewColumn(_props) {
     // This is a placeholder wrapper. Real rendering is performed by PickerView above after mapping.
     return null;
 }
+PickerViewColumn.__TARO_PICKER_VIEW_CHILD_TYPE = PICKER_VIEW_COLUMN_TYPE;
+function isPickerViewColumnElement(child) {
+    if (!isReactElement(child)) {
+        return false;
+    }
+    const childType = child.type;
+    return (childType.__TARO_PICKER_VIEW_CHILD_TYPE === PICKER_VIEW_COLUMN_TYPE ||
+        childType.displayName === 'PickerViewColumn' ||
+        childType.name === 'PickerViewColumn' ||
+        child.type === 'picker-view-column' ||
+        child.type === 'taro-picker-view-column-core');
+}
+function isReactElement(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        node.$$typeof === Symbol.for('react.element') &&
+        'type' in node &&
+        'props' in node);
+}
+function toChildArray(children) {
+    if (children === null || children === undefined || typeof children === 'boolean') {
+        return [];
+    }
+    return Array.isArray(children) ? children.flatMap(toChildArray) : [children];
+}
 //# sourceMappingURL=index.jsx.map

package/dist/components/PickerView/map.d.ts

@@ -1,36 +1,51 @@
 import type { CSSProperties } from '@lynx-js/types';
+import type { ReactNode } from 'react';
+import type { PickerViewProps as TaroPickerViewPropsBase } from '@tarojs/components';
 import type { PickerViewProps as LynxPickerViewProps, PickerColumnOption } from '@byted-doubao-apps/framework/components';
-export type TaroPickerViewProps = {
-    className?: string;
-    style?: CSSProperties;
-    value?: number[];
-    indicatorStyle?: CSSProperties;
-    maskStyle?: CSSProperties;
-    onChange?: (event: {
-        type: string;
-        timeStamp: number;
-        detail: {
-            value: number[];
-        };
-    }) => void;
-    children?: any;
+export type TaroPickerViewProps = TaroPickerViewPropsBase & {
+    children?: ReactNode;
 };
 export type TaroPickerViewColumnProps = {
+    children?: ReactNode;
     range?: Array<string | number>;
     className?: string;
     style?: CSSProperties;
 };
-export declare function toPickerViewChangeEvent(indices: number[]): {
+export type PickerViewChangeEvent = {
     type: string;
     timeStamp: number;
+    target: {
+        id: string;
+        tagName: string;
+        dataset: Record<string, unknown>;
+    };
+    currentTarget: {
+        id: string;
+        tagName: string;
+        dataset: Record<string, unknown>;
+    };
     detail: {
         value: number[];
     };
+    preventDefault: () => void;
+    stopPropagation: () => void;
 };
+export declare function toPickerViewChangeEvent(indices: number[], pickerViewId?: string): PickerViewChangeEvent;
 export declare function buildOptionsFromRange(range?: Array<string | number>): PickerColumnOption[];
-export declare function warnUnsupportedPickerView(unsupported: string[]): void;
+export declare function buildOptionsFromChildren(children?: ReactNode): PickerColumnOption[];
+export declare function resolveSelectedIndexValue(indices: number[] | undefined, columnIndex: number, options: PickerColumnOption[]): number | undefined;
 export declare function mapPickerViewProps(props: TaroPickerViewProps): {
-    mapped: Pick<LynxPickerViewProps, 'className' | 'style'>;
+    mapped: Pick<LynxPickerViewProps, 'className' | 'style'> & Record<string, unknown>;
+    unsupported: string[];
+    pickerViewId: string;
+    indicatorItemHeight: number | undefined;
+};
+export declare function mapPickerViewColumnProps(props: TaroPickerViewColumnProps): {
+    className?: string;
+    style?: CSSProperties;
     unsupported: string[];
 };
+export declare function resolveItemHeightFromChildren(children?: ReactNode): number | undefined;
+export declare function resolveExplicitItemHeight(itemHeight: unknown): number | undefined;
+export declare function resolveItemHeightFromIndicatorStyle(indicatorStyle: unknown): number | undefined;
 //# sourceMappingURL=map.d.ts.map

package/dist/components/PickerView/map.js

@@ -1,29 +1,201 @@
-export function toPickerViewChangeEvent(indices) {
+import { BASE_PROP_MAP } from '../base/prop-map.js';
+export function toPickerViewChangeEvent(indices, pickerViewId = '') {
     return {
         type: 'change',
         timeStamp: Date.now(),
-        detail: { value: indices }
+        target: {
+            id: pickerViewId,
+            tagName: 'picker-view',
+            dataset: {}
+        },
+        currentTarget: {
+            id: pickerViewId,
+            tagName: 'picker-view',
+            dataset: {}
+        },
+        detail: { value: indices },
+        preventDefault: () => { },
+        stopPropagation: () => { }
     };
 }
 export function buildOptionsFromRange(range) {
-    return (range ?? []).map((item) => ({ label: String(item), value: item }));
+    return (range ?? []).map((item, index) => ({ label: String(item), value: index }));
 }
-export function warnUnsupportedPickerView(unsupported) {
-    if (unsupported.length > 0) {
-        // Centralized warn helper exists for other components; keep inline minimal here
-        console.warn(`[PickerView] Unsupported props: ${unsupported.join(', ')}`);
+export function buildOptionsFromChildren(children) {
+    return toChildArray(children).map((child, index) => ({
+        label: extractText(child) || String(index),
+        value: index
+    }));
+}
+export function resolveSelectedIndexValue(indices, columnIndex, options) {
+    const selectedIndex = indices?.[columnIndex];
+    if (selectedIndex === undefined || options.length === 0) {
+        return undefined;
+    }
+    if (typeof selectedIndex !== 'number' || Number.isNaN(selectedIndex)) {
+        return undefined;
     }
+    return Math.min(Math.max(Math.trunc(selectedIndex), 0), options.length - 1);
 }
 export function mapPickerViewProps(props) {
+    const { value: _value, defaultValue: _defaultValue, children: _children, onChange: _onChange, indicatorStyle, indicatorClass, maskStyle, maskClass, immediateChange, onPickStart, onPickEnd, title, ariaLabel, ...rest } = props;
     const unsupported = [];
-    if (props.maskStyle)
+    const indicatorItemHeight = resolveItemHeightFromIndicatorStyle(indicatorStyle);
+    unsupported.push(...getUnsupportedIndicatorStyleWarnings(indicatorStyle, indicatorItemHeight));
+    if (indicatorClass !== undefined)
+        unsupported.push('indicatorClass');
+    if (maskStyle !== undefined)
         unsupported.push('maskStyle');
-    if (props.indicatorStyle)
-        unsupported.push('indicatorStyle');
-    const mapped = {
-        className: props.className,
-        style: props.style
+    if (maskClass !== undefined)
+        unsupported.push('maskClass');
+    if (immediateChange !== undefined)
+        unsupported.push('immediateChange');
+    if (onPickStart !== undefined)
+        unsupported.push('onPickStart');
+    if (onPickEnd !== undefined)
+        unsupported.push('onPickEnd');
+    if (title !== undefined)
+        unsupported.push('title');
+    if (ariaLabel !== undefined)
+        unsupported.push('ariaLabel');
+    const mapped = {};
+    Object.entries(rest).forEach(([key, value]) => {
+        const target = BASE_PROP_MAP[key];
+        if (target) {
+            mapped[target] = value;
+            return;
+        }
+        unsupported.push(key);
+    });
+    return {
+        mapped,
+        unsupported: dedupe(unsupported),
+        pickerViewId: resolveId(mapped.id),
+        indicatorItemHeight
+    };
+}
+export function mapPickerViewColumnProps(props) {
+    const { children: _children, range: _range, className, style, ...rest } = props;
+    return {
+        className,
+        style,
+        unsupported: Object.keys(rest)
     };
-    return { mapped, unsupported };
+}
+export function resolveItemHeightFromChildren(children) {
+    const firstHeight = toChildArray(children)
+        .map((child) => {
+        if (!isReactElement(child)) {
+            return undefined;
+        }
+        return parseStyleHeight(child.props.style);
+    })
+        .find((height) => height !== undefined);
+    return firstHeight;
+}
+export function resolveExplicitItemHeight(itemHeight) {
+    return typeof itemHeight === 'number' && Number.isFinite(itemHeight) && itemHeight > 0
+        ? itemHeight
+        : undefined;
+}
+export function resolveItemHeightFromIndicatorStyle(indicatorStyle) {
+    if (typeof indicatorStyle === 'string') {
+        return parseStyleHeightString(indicatorStyle);
+    }
+    return parseStyleHeight(indicatorStyle);
+}
+function hasRpxIndicatorHeight(indicatorStyle) {
+    if (typeof indicatorStyle === 'string') {
+        return /(?:^|;)\s*height\s*:\s*\d+(?:\.\d+)?rpx\s*(?:;|$)/.test(indicatorStyle);
+    }
+    if (!indicatorStyle || typeof indicatorStyle !== 'object' || Array.isArray(indicatorStyle)) {
+        return false;
+    }
+    const height = indicatorStyle.height;
+    return typeof height === 'string' && /^\d+(?:\.\d+)?rpx$/.test(height.trim());
+}
+function getUnsupportedIndicatorStyleWarnings(indicatorStyle, indicatorItemHeight) {
+    if (indicatorStyle === undefined) {
+        return [];
+    }
+    const unsupported = [];
+    if (hasUnsupportedIndicatorStyleFields(indicatorStyle)) {
+        unsupported.push('indicatorStyle only supports height');
+    }
+    if (hasRpxIndicatorHeight(indicatorStyle)) {
+        unsupported.push('indicatorStyle.height uses rpx, please use px or number');
+    }
+    else if (indicatorItemHeight === undefined) {
+        unsupported.push('indicatorStyle.height must be px or number');
+    }
+    return unsupported;
+}
+function hasUnsupportedIndicatorStyleFields(indicatorStyle) {
+    if (typeof indicatorStyle === 'string') {
+        return parseStyleDeclarationNames(indicatorStyle).some((name) => name !== 'height');
+    }
+    if (!indicatorStyle || typeof indicatorStyle !== 'object' || Array.isArray(indicatorStyle)) {
+        return false;
+    }
+    return Object.keys(indicatorStyle).some((name) => name !== 'height');
+}
+function parseStyleDeclarationNames(style) {
+    return style
+        .split(';')
+        .map((declaration) => declaration.trim())
+        .filter(Boolean)
+        .map((declaration) => declaration.split(':')[0]?.trim())
+        .filter((name) => Boolean(name));
+}
+function extractText(node) {
+    if (node === null || node === undefined || typeof node === 'boolean') {
+        return '';
+    }
+    if (typeof node === 'string' || typeof node === 'number') {
+        return String(node);
+    }
+    if (Array.isArray(node)) {
+        return node.map(extractText).join('');
+    }
+    if (isReactElement(node)) {
+        return extractText(node.props.children);
+    }
+    return '';
+}
+function isReactElement(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        node.$$typeof === Symbol.for('react.element') &&
+        'props' in node);
+}
+function toChildArray(children) {
+    if (children === null || children === undefined || typeof children === 'boolean') {
+        return [];
+    }
+    return Array.isArray(children) ? children.flatMap(toChildArray) : [children];
+}
+function resolveId(id) {
+    return typeof id === 'string' ? id : '';
+}
+function dedupe(items) {
+    return Array.from(new Set(items));
+}
+function parseStyleHeight(style) {
+    if (!style || typeof style !== 'object' || Array.isArray(style)) {
+        return undefined;
+    }
+    const height = style.height;
+    if (typeof height === 'number' && Number.isFinite(height)) {
+        return height;
+    }
+    if (typeof height !== 'string') {
+        return undefined;
+    }
+    const match = height.trim().match(/^(\d+(?:\.\d+)?)px$/);
+    return match ? Number(match[1]) : undefined;
+}
+function parseStyleHeightString(style) {
+    const match = style.match(/(?:^|;)\s*height\s*:\s*(\d+(?:\.\d+)?)px\s*(?:;|$)/);
+    return match ? Number(match[1]) : undefined;
 }
 //# sourceMappingURL=map.js.map

package/package.json

@@ -37,7 +37,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "0.0.25",
+  "version": "0.0.27",
   "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