@doubao-apps/taro-runtime 0.0.24 → 0.0.25

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

@@ -0,0 +1,9 @@
+import type Taro from '@tarojs/taro';
+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>>;
+export declare function startAccelerometer(option?: TaroStartAccelerometerOption): Promise<TaroStartAccelerometerResult>;
+export declare function stopAccelerometer(option?: TaroStopAccelerometerOption): Promise<TaroStopAccelerometerResult>;
+export {};
+//# sourceMappingURL=accelerometer.d.ts.map

package/dist/api/device/accelerometer.js

@@ -0,0 +1,11 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+export async function startAccelerometer(option) {
+    return runCallbackApi('startAccelerometer', option, () => appFrameworkApi.startAccelerometer({
+        interval: option?.interval
+    }));
+}
+export async function stopAccelerometer(option) {
+    return runCallbackApi('stopAccelerometer', option, () => appFrameworkApi.stopAccelerometer({}));
+}
+//# sourceMappingURL=accelerometer.js.map

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

@@ -0,0 +1,6 @@
+import type Taro from '@tarojs/taro';
+type TaroCheckIsOpenAccessibilityOption = Taro.checkIsOpenAccessibility.Option;
+type TaroCheckIsOpenAccessibilityResult = Taro.checkIsOpenAccessibility.SuccessCallbackResult;
+export declare function checkIsOpenAccessibility(option?: TaroCheckIsOpenAccessibilityOption): Promise<TaroCheckIsOpenAccessibilityResult>;
+export {};
+//# sourceMappingURL=accessibility.d.ts.map

package/dist/api/device/accessibility.js

@@ -0,0 +1,12 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function buildCheckIsOpenAccessibilityResult(result) {
+    return {
+        open: Boolean(result.open),
+        ...buildOkCallbackResult('checkIsOpenAccessibility')
+    };
+}
+export async function checkIsOpenAccessibility(option) {
+    return runTaroApi('checkIsOpenAccessibility', option, async () => buildCheckIsOpenAccessibilityResult(await appFrameworkApi.checkIsOpenAccessibility({})));
+}
+//# sourceMappingURL=accessibility.js.map

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

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

package/dist/api/device/battery.js

@@ -0,0 +1,13 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function buildGetBatteryInfoResult(result) {
+    return {
+        isCharging: Boolean(result.isCharging),
+        level: typeof result.level === 'number' ? result.level : 0,
+        ...buildOkCallbackResult('getBatteryInfo')
+    };
+}
+export async function getBatteryInfo(option) {
+    return runTaroApi('getBatteryInfo', option, async () => buildGetBatteryInfoResult(await appFrameworkApi.getBatteryInfo({})));
+}
+//# sourceMappingURL=battery.js.map

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

@@ -0,0 +1,12 @@
+import type Taro from '@tarojs/taro';
+type TaroStartBeaconDiscoveryOption = Parameters<typeof Taro.startBeaconDiscovery>[0];
+type TaroStartBeaconDiscoveryResult = Awaited<ReturnType<typeof Taro.startBeaconDiscovery>>;
+type TaroStopBeaconDiscoveryOption = Parameters<typeof Taro.stopBeaconDiscovery>[0];
+type TaroStopBeaconDiscoveryResult = Awaited<ReturnType<typeof Taro.stopBeaconDiscovery>>;
+type TaroGetBeaconsOption = Parameters<typeof Taro.getBeacons>[0];
+type TaroGetBeaconsResult = Awaited<ReturnType<typeof Taro.getBeacons>>;
+export declare function startBeaconDiscovery(option: TaroStartBeaconDiscoveryOption): Promise<TaroStartBeaconDiscoveryResult>;
+export declare function stopBeaconDiscovery(option?: TaroStopBeaconDiscoveryOption): Promise<TaroStopBeaconDiscoveryResult>;
+export declare function getBeacons(option?: TaroGetBeaconsOption): Promise<TaroGetBeaconsResult>;
+export {};
+//# sourceMappingURL=beacon.d.ts.map

package/dist/api/device/beacon.js

@@ -0,0 +1,30 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function buildGetBeaconsResult(result) {
+    return {
+        beacons: Array.isArray(result.beacons) ? result.beacons : [],
+        ...buildOkCallbackResult('getBeacons')
+    };
+}
+function buildIBeaconOkResult(apiName) {
+    return buildOkCallbackResult(apiName);
+}
+export async function startBeaconDiscovery(option) {
+    return runTaroApi('startBeaconDiscovery', option, async () => {
+        await appFrameworkApi.startBeaconDiscovery({
+            uuids: option.uuids,
+            ignoreBluetoothAvailable: option.ignoreBluetoothAvailable
+        });
+        return buildIBeaconOkResult('startBeaconDiscovery');
+    });
+}
+export async function stopBeaconDiscovery(option) {
+    return runTaroApi('stopBeaconDiscovery', option, async () => {
+        await appFrameworkApi.stopBeaconDiscovery({});
+        return buildIBeaconOkResult('stopBeaconDiscovery');
+    });
+}
+export async function getBeacons(option) {
+    return runTaroApi('getBeacons', option, async () => buildGetBeaconsResult(await appFrameworkApi.getBeacons({})));
+}
+//# sourceMappingURL=beacon.js.map

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

@@ -0,0 +1,60 @@
+import type Taro from '@tarojs/taro';
+type TaroOpenBluetoothAdapterOption = Parameters<typeof Taro.openBluetoothAdapter>[0];
+type TaroOpenBluetoothAdapterResult = Awaited<ReturnType<typeof Taro.openBluetoothAdapter>>;
+type TaroStartBluetoothDevicesDiscoveryOption = Parameters<typeof Taro.startBluetoothDevicesDiscovery>[0];
+type TaroStartBluetoothDevicesDiscoveryResult = Awaited<ReturnType<typeof Taro.startBluetoothDevicesDiscovery>>;
+type TaroStopBluetoothDevicesDiscoveryOption = Parameters<typeof Taro.stopBluetoothDevicesDiscovery>[0];
+type TaroStopBluetoothDevicesDiscoveryResult = Awaited<ReturnType<typeof Taro.stopBluetoothDevicesDiscovery>>;
+type TaroGetBluetoothAdapterStateOption = Parameters<typeof Taro.getBluetoothAdapterState>[0];
+type TaroGetBluetoothAdapterStateResult = Awaited<ReturnType<typeof Taro.getBluetoothAdapterState>>;
+type TaroGetBluetoothDevicesOption = Parameters<typeof Taro.getBluetoothDevices>[0];
+type TaroGetBluetoothDevicesResult = Awaited<ReturnType<typeof Taro.getBluetoothDevices>>;
+type TaroGetConnectedBluetoothDevicesOption = Parameters<typeof Taro.getConnectedBluetoothDevices>[0];
+type TaroGetConnectedBluetoothDevicesResult = Awaited<ReturnType<typeof Taro.getConnectedBluetoothDevices>>;
+type TaroMakeBluetoothPairOption = Parameters<typeof Taro.makeBluetoothPair>[0];
+type TaroMakeBluetoothPairResult = Awaited<ReturnType<typeof Taro.makeBluetoothPair>>;
+type TaroIsBluetoothDevicePairedOption = Parameters<typeof Taro.isBluetoothDevicePaired>[0];
+type TaroIsBluetoothDevicePairedResult = Awaited<ReturnType<typeof Taro.isBluetoothDevicePaired>>;
+type TaroCloseBluetoothAdapterOption = Parameters<typeof Taro.closeBluetoothAdapter>[0];
+type TaroCloseBluetoothAdapterResult = Awaited<ReturnType<typeof Taro.closeBluetoothAdapter>>;
+type TaroCreateBLEConnectionOption = Parameters<typeof Taro.createBLEConnection>[0];
+type TaroCreateBLEConnectionResult = Awaited<ReturnType<typeof Taro.createBLEConnection>>;
+type TaroCloseBLEConnectionOption = Parameters<typeof Taro.closeBLEConnection>[0];
+type TaroCloseBLEConnectionResult = Awaited<ReturnType<typeof Taro.closeBLEConnection>>;
+type TaroGetBLEDeviceServicesOption = Parameters<typeof Taro.getBLEDeviceServices>[0];
+type TaroGetBLEDeviceServicesResult = Awaited<ReturnType<typeof Taro.getBLEDeviceServices>>;
+type TaroGetBLEDeviceCharacteristicsOption = Parameters<typeof Taro.getBLEDeviceCharacteristics>[0];
+type TaroGetBLEDeviceCharacteristicsResult = Awaited<ReturnType<typeof Taro.getBLEDeviceCharacteristics>>;
+type TaroGetBLEDeviceRSSIOption = Parameters<typeof Taro.getBLEDeviceRSSI>[0];
+type TaroGetBLEDeviceRSSIResult = Awaited<ReturnType<typeof Taro.getBLEDeviceRSSI>>;
+type TaroGetBLEMTUOption = Parameters<typeof Taro.getBLEMTU>[0];
+type TaroGetBLEMTUResult = Awaited<ReturnType<typeof Taro.getBLEMTU>>;
+type TaroNotifyBLECharacteristicValueChangeOption = Parameters<typeof Taro.notifyBLECharacteristicValueChange>[0];
+type TaroNotifyBLECharacteristicValueChangeResult = Awaited<ReturnType<typeof Taro.notifyBLECharacteristicValueChange>>;
+type TaroReadBLECharacteristicValueOption = Parameters<typeof Taro.readBLECharacteristicValue>[0];
+type TaroReadBLECharacteristicValueResult = Awaited<ReturnType<typeof Taro.readBLECharacteristicValue>>;
+type TaroSetBLEMTUOption = Parameters<typeof Taro.setBLEMTU>[0];
+type TaroSetBLEMTUResult = Awaited<ReturnType<typeof Taro.setBLEMTU>>;
+type TaroWriteBLECharacteristicValueOption = Parameters<typeof Taro.writeBLECharacteristicValue>[0];
+type TaroWriteBLECharacteristicValueResult = Awaited<ReturnType<typeof Taro.writeBLECharacteristicValue>>;
+export declare function openBluetoothAdapter(option?: TaroOpenBluetoothAdapterOption): Promise<TaroOpenBluetoothAdapterResult>;
+export declare function startBluetoothDevicesDiscovery(option: TaroStartBluetoothDevicesDiscoveryOption): Promise<TaroStartBluetoothDevicesDiscoveryResult>;
+export declare function stopBluetoothDevicesDiscovery(option?: TaroStopBluetoothDevicesDiscoveryOption): Promise<TaroStopBluetoothDevicesDiscoveryResult>;
+export declare function getBluetoothAdapterState(option?: TaroGetBluetoothAdapterStateOption): Promise<TaroGetBluetoothAdapterStateResult>;
+export declare function getBluetoothDevices(option?: TaroGetBluetoothDevicesOption): Promise<TaroGetBluetoothDevicesResult>;
+export declare function getConnectedBluetoothDevices(option: TaroGetConnectedBluetoothDevicesOption): Promise<TaroGetConnectedBluetoothDevicesResult>;
+export declare function makeBluetoothPair(option: TaroMakeBluetoothPairOption): Promise<TaroMakeBluetoothPairResult>;
+export declare function isBluetoothDevicePaired(option: TaroIsBluetoothDevicePairedOption): Promise<TaroIsBluetoothDevicePairedResult>;
+export declare function closeBluetoothAdapter(option?: TaroCloseBluetoothAdapterOption): Promise<TaroCloseBluetoothAdapterResult>;
+export declare function createBLEConnection(option: TaroCreateBLEConnectionOption): Promise<TaroCreateBLEConnectionResult>;
+export declare function closeBLEConnection(option: TaroCloseBLEConnectionOption): Promise<TaroCloseBLEConnectionResult>;
+export declare function getBLEDeviceServices(option: TaroGetBLEDeviceServicesOption): Promise<TaroGetBLEDeviceServicesResult>;
+export declare function getBLEDeviceCharacteristics(option: TaroGetBLEDeviceCharacteristicsOption): Promise<TaroGetBLEDeviceCharacteristicsResult>;
+export declare function getBLEDeviceRSSI(option: TaroGetBLEDeviceRSSIOption): Promise<TaroGetBLEDeviceRSSIResult>;
+export declare function getBLEMTU(option: TaroGetBLEMTUOption): Promise<TaroGetBLEMTUResult>;
+export declare function notifyBLECharacteristicValueChange(option: TaroNotifyBLECharacteristicValueChangeOption): Promise<TaroNotifyBLECharacteristicValueChangeResult>;
+export declare function readBLECharacteristicValue(option: TaroReadBLECharacteristicValueOption): Promise<TaroReadBLECharacteristicValueResult>;
+export declare function setBLEMTU(option: TaroSetBLEMTUOption): Promise<TaroSetBLEMTUResult>;
+export declare function writeBLECharacteristicValue(option: TaroWriteBLECharacteristicValueOption): Promise<TaroWriteBLECharacteristicValueResult>;
+export {};
+//# sourceMappingURL=bluetooth.d.ts.map

package/dist/api/device/bluetooth.js

@@ -0,0 +1,187 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runCallbackApi, runTaroApi } from '../utils.js';
+function toNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function mapBluetoothDevice(device) {
+    return {
+        RSSI: device.rssi,
+        advertisData: device.advertisingData,
+        advertisServiceUUIDs: device.advertisingServiceUuids,
+        deviceId: device.deviceId,
+        localName: device.localName,
+        name: device.name,
+        serviceData: device.serviceData ?? {},
+        connectable: typeof device.connectable === 'boolean' ? device.connectable : undefined
+    };
+}
+function buildBluetoothAdapterStateResult(result) {
+    return {
+        available: Boolean(result.available),
+        discovering: Boolean(result.discovering),
+        ...buildOkCallbackResult('getBluetoothAdapterState')
+    };
+}
+function buildBluetoothDevicesResult(result) {
+    return {
+        devices: Array.isArray(result.devices) ? result.devices.map(mapBluetoothDevice) : [],
+        ...buildOkCallbackResult('getBluetoothDevices')
+    };
+}
+function buildConnectedBluetoothDevicesResult(result) {
+    return {
+        devices: Array.isArray(result.devices) ? result.devices : [],
+        ...buildOkCallbackResult('getConnectedBluetoothDevices')
+    };
+}
+function buildBLEDeviceServicesResult(result) {
+    return {
+        services: Array.isArray(result.services) ? result.services : [],
+        ...buildOkCallbackResult('getBLEDeviceServices')
+    };
+}
+function buildBLEDeviceCharacteristicsResult(result) {
+    return {
+        characteristics: Array.isArray(result.characteristics) ? result.characteristics : [],
+        ...buildOkCallbackResult('getBLEDeviceCharacteristics')
+    };
+}
+function buildBLEDeviceRSSIResult(result) {
+    return {
+        RSSI: result.rssi ?? 0,
+        ...buildOkCallbackResult('getBLEDeviceRSSI')
+    };
+}
+function buildBLEMTUResult(result) {
+    return {
+        mtu: typeof result.mtu === 'number' ? result.mtu : 0,
+        ...buildOkCallbackResult('getBLEMTU')
+    };
+}
+function buildSetBLEMTUResult(result) {
+    return {
+        mtu: result.mtu,
+        ...buildOkCallbackResult('setBLEMTU')
+    };
+}
+function buildBluetoothOkResult(apiName) {
+    return buildOkCallbackResult(apiName);
+}
+export async function openBluetoothAdapter(option) {
+    const params = option?.mode ? { mode: option.mode } : {};
+    return runCallbackApi('openBluetoothAdapter', option, () => appFrameworkApi.openBluetoothAdapter(params));
+}
+export async function startBluetoothDevicesDiscovery(option) {
+    const { success: _success, fail: _fail, complete: _complete, ...params } = option;
+    return runCallbackApi('startBluetoothDevicesDiscovery', option, () => appFrameworkApi.startBluetoothDevicesDiscovery(params));
+}
+export async function stopBluetoothDevicesDiscovery(option) {
+    return runCallbackApi('stopBluetoothDevicesDiscovery', option, () => appFrameworkApi.stopBluetoothDevicesDiscovery({}));
+}
+export async function getBluetoothAdapterState(option) {
+    return runTaroApi('getBluetoothAdapterState', option, async () => buildBluetoothAdapterStateResult(await appFrameworkApi.getBluetoothAdapterState({})));
+}
+export async function getBluetoothDevices(option) {
+    return runTaroApi('getBluetoothDevices', option, async () => buildBluetoothDevicesResult(await appFrameworkApi.getBluetoothDevices({})));
+}
+export async function getConnectedBluetoothDevices(option) {
+    return runTaroApi('getConnectedBluetoothDevices', option, async () => buildConnectedBluetoothDevicesResult(await appFrameworkApi.getConnectedBluetoothDevices({ services: option.services })));
+}
+export async function makeBluetoothPair(option) {
+    const timeout = toNumber(option.timeout);
+    return runCallbackApi('makeBluetoothPair', option, () => appFrameworkApi.makeBluetoothPair({
+        deviceId: option.deviceId,
+        pin: option.pin,
+        ...(timeout !== undefined ? { timeout } : {})
+    }));
+}
+export async function isBluetoothDevicePaired(option) {
+    return runCallbackApi('isBluetoothDevicePaired', option, () => appFrameworkApi.isBluetoothDevicePaired({ deviceId: option.deviceId }));
+}
+export async function closeBluetoothAdapter(option) {
+    return runCallbackApi('closeBluetoothAdapter', option, () => appFrameworkApi.closeBluetoothAdapter({}));
+}
+export async function createBLEConnection(option) {
+    const timeout = toNumber(option.timeout);
+    return runTaroApi('createBLEConnection', option, async () => {
+        await appFrameworkApi.createBLEConnection({
+            deviceId: option.deviceId,
+            ...(timeout !== undefined ? { timeout } : {})
+        });
+        return buildBluetoothOkResult('createBLEConnection');
+    });
+}
+export async function closeBLEConnection(option) {
+    return runTaroApi('closeBLEConnection', option, async () => {
+        await appFrameworkApi.closeBLEConnection({ deviceId: option.deviceId });
+        return buildBluetoothOkResult('closeBLEConnection');
+    });
+}
+export async function getBLEDeviceServices(option) {
+    return runTaroApi('getBLEDeviceServices', option, async () => buildBLEDeviceServicesResult(await appFrameworkApi.getBLEDeviceServices({ deviceId: option.deviceId })));
+}
+export async function getBLEDeviceCharacteristics(option) {
+    return runTaroApi('getBLEDeviceCharacteristics', option, async () => buildBLEDeviceCharacteristicsResult(await appFrameworkApi.getBLEDeviceCharacteristics({
+        deviceId: option.deviceId,
+        serviceId: option.serviceId
+    })));
+}
+export async function getBLEDeviceRSSI(option) {
+    return runTaroApi('getBLEDeviceRSSI', option, async () => buildBLEDeviceRSSIResult(await appFrameworkApi.getBLEDeviceRSSI({ deviceId: option.deviceId })));
+}
+export async function getBLEMTU(option) {
+    return runTaroApi('getBLEMTU', option, async () => buildBLEMTUResult(await appFrameworkApi.getBLEMTU({
+        deviceId: option.deviceId,
+        writeType: option.writeType
+    })));
+}
+export async function notifyBLECharacteristicValueChange(option) {
+    return runTaroApi('notifyBLECharacteristicValueChange', option, async () => {
+        await appFrameworkApi.notifyBLECharacteristicValueChange({
+            deviceId: option.deviceId,
+            serviceId: option.serviceId,
+            characteristicId: option.characteristicId,
+            state: option.state,
+            type: option.type
+        });
+        return buildBluetoothOkResult('notifyBLECharacteristicValueChange');
+    });
+}
+export async function readBLECharacteristicValue(option) {
+    return runTaroApi('readBLECharacteristicValue', option, async () => {
+        await appFrameworkApi.readBLECharacteristicValue({
+            deviceId: option.deviceId,
+            serviceId: option.serviceId,
+            characteristicId: option.characteristicId
+        });
+        return buildBluetoothOkResult('readBLECharacteristicValue');
+    });
+}
+export async function setBLEMTU(option) {
+    return runTaroApi('setBLEMTU', option, async () => buildSetBLEMTUResult(await appFrameworkApi.setBLEMTU({
+        deviceId: option.deviceId,
+        mtu: option.mtu
+    })));
+}
+export async function writeBLECharacteristicValue(option) {
+    return runTaroApi('writeBLECharacteristicValue', option, async () => {
+        await appFrameworkApi.writeBLECharacteristicValue({
+            deviceId: option.deviceId,
+            serviceId: option.serviceId,
+            characteristicId: option.characteristicId,
+            value: option.value,
+            writeType: option.writeType
+        });
+        return buildBluetoothOkResult('writeBLECharacteristicValue');
+    });
+}
+//# sourceMappingURL=bluetooth.js.map

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

@@ -0,0 +1,9 @@
+import type Taro from '@tarojs/taro';
+type TaroAddPhoneCalendarOption = Parameters<typeof Taro.addPhoneCalendar>[0];
+type TaroAddPhoneCalendarResult = Awaited<ReturnType<typeof Taro.addPhoneCalendar>>;
+type TaroAddPhoneRepeatCalendarOption = Parameters<typeof Taro.addPhoneRepeatCalendar>[0];
+type TaroAddPhoneRepeatCalendarResult = Awaited<ReturnType<typeof Taro.addPhoneRepeatCalendar>>;
+export declare function addPhoneCalendar(option: TaroAddPhoneCalendarOption): Promise<TaroAddPhoneCalendarResult>;
+export declare function addPhoneRepeatCalendar(option: TaroAddPhoneRepeatCalendarOption): Promise<TaroAddPhoneRepeatCalendarResult>;
+export {};
+//# sourceMappingURL=calendar.d.ts.map

package/dist/api/device/calendar.js

@@ -0,0 +1,45 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+function toNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+export async function addPhoneCalendar(option) {
+    const endTime = toNumber(option.endTime);
+    const params = {
+        title: option.title,
+        startTime: option.startTime,
+        ...(option.allDay !== undefined ? { allDay: option.allDay } : {}),
+        ...(option.description !== undefined ? { description: option.description } : {}),
+        ...(option.location !== undefined ? { location: option.location } : {}),
+        ...(endTime !== undefined ? { endTime } : {}),
+        ...(option.alarm !== undefined ? { alarm: option.alarm } : {}),
+        ...(option.alarmOffset !== undefined ? { alarmOffset: option.alarmOffset } : {})
+    };
+    return runCallbackApi('addPhoneCalendar', option, () => appFrameworkApi.addPhoneCalendar(params));
+}
+export async function addPhoneRepeatCalendar(option) {
+    const endTime = toNumber(option.endTime);
+    const params = {
+        title: option.title,
+        startTime: option.startTime,
+        ...(option.allDay !== undefined ? { allDay: option.allDay } : {}),
+        ...(option.description !== undefined ? { description: option.description } : {}),
+        ...(option.location !== undefined ? { location: option.location } : {}),
+        ...(endTime !== undefined ? { endTime } : {}),
+        ...(option.alarm !== undefined ? { alarm: option.alarm } : {}),
+        ...(option.alarmOffset !== undefined ? { alarmOffset: option.alarmOffset } : {}),
+        ...(option.repeatInterval !== undefined ? { repeatInterval: option.repeatInterval } : {}),
+        ...(option.repeatEndTime !== undefined ? { repeatEndTime: option.repeatEndTime } : {})
+    };
+    return runCallbackApi('addPhoneRepeatCalendar', option, () => appFrameworkApi.addPhoneRepeatCalendar(params));
+}
+//# sourceMappingURL=calendar.js.map

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

@@ -0,0 +1,16 @@
+export * from './accessibility.js';
+export * from './accelerometer.js';
+export * from './battery.js';
+export * from './calendar.js';
+export * from './clipboard.js';
+export * from './compass.js';
+export * from './contact.js';
+export * from './crypto.js';
+export * from './device-motion.js';
+export * from './gyroscope.js';
+export * from './keyboard.js';
+export * from './network.js';
+export * from './scan.js';
+export * from './screen.js';
+export * from './vibration.js';
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/api/device/capabilities.js

@@ -0,0 +1,16 @@
+export * from './accessibility.js';
+export * from './accelerometer.js';
+export * from './battery.js';
+export * from './calendar.js';
+export * from './clipboard.js';
+export * from './compass.js';
+export * from './contact.js';
+export * from './crypto.js';
+export * from './device-motion.js';
+export * from './gyroscope.js';
+export * from './keyboard.js';
+export * from './network.js';
+export * from './scan.js';
+export * from './screen.js';
+export * from './vibration.js';
+//# sourceMappingURL=capabilities.js.map

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

@@ -0,0 +1,6 @@
+import type Taro from '@tarojs/taro';
+type TaroGetClipboardDataOption = Parameters<typeof Taro.getClipboardData>[0];
+type TaroGetClipboardDataResult = Awaited<ReturnType<typeof Taro.getClipboardData>>;
+export declare function getClipboardData(option?: TaroGetClipboardDataOption): Promise<TaroGetClipboardDataResult>;
+export {};
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/api/device/clipboard.js

@@ -0,0 +1,12 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function buildGetClipboardDataResult(result) {
+    return {
+        data: result.data ?? '',
+        ...buildOkCallbackResult('getClipboardData')
+    };
+}
+export async function getClipboardData(option) {
+    return runTaroApi('getClipboardData', option, async () => buildGetClipboardDataResult(await appFrameworkApi.getClipboardData({})));
+}
+//# sourceMappingURL=clipboard.js.map

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

@@ -0,0 +1,9 @@
+import type Taro from '@tarojs/taro';
+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>>;
+export declare function startCompass(option?: TaroStartCompassOption): Promise<TaroStartCompassResult>;
+export declare function stopCompass(option?: TaroStopCompassOption): Promise<TaroStopCompassResult>;
+export {};
+//# sourceMappingURL=compass.d.ts.map

package/dist/api/device/compass.js

@@ -0,0 +1,9 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+export async function startCompass(option) {
+    return runCallbackApi('startCompass', option, () => appFrameworkApi.startCompass({}));
+}
+export async function stopCompass(option) {
+    return runCallbackApi('stopCompass', option, () => appFrameworkApi.stopCompass({}));
+}
+//# sourceMappingURL=compass.js.map

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

@@ -0,0 +1,11 @@
+import type Taro from '@tarojs/taro';
+type TaroChooseContactOption = Parameters<typeof Taro.chooseContact>[0];
+type TaroChooseContactResult = Omit<Taro.chooseContact.SuccessCallbackResult, 'phoneNumberList'> & {
+    phoneNumberList: string[];
+};
+type TaroAddPhoneContactOption = Parameters<typeof Taro.addPhoneContact>[0];
+type TaroAddPhoneContactResult = Awaited<ReturnType<typeof Taro.addPhoneContact>>;
+export declare function chooseContact(option: TaroChooseContactOption): Promise<TaroChooseContactResult>;
+export declare function addPhoneContact(option: TaroAddPhoneContactOption): Promise<TaroAddPhoneContactResult>;
+export {};
+//# sourceMappingURL=contact.d.ts.map

package/dist/api/device/contact.js

@@ -0,0 +1,18 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runCallbackApi, runTaroApi } from '../utils.js';
+function buildChooseContactResult(result) {
+    return {
+        phoneNumber: result.phoneNumber ?? '',
+        displayName: result.displayName ?? '',
+        phoneNumberList: Array.isArray(result.phoneNumberList) ? result.phoneNumberList : [],
+        ...buildOkCallbackResult('chooseContact')
+    };
+}
+export async function chooseContact(option) {
+    return runTaroApi('chooseContact', option, async () => buildChooseContactResult(await appFrameworkApi.chooseContact({})));
+}
+export async function addPhoneContact(option) {
+    const { success: _success, fail: _fail, complete: _complete, ...params } = option;
+    return runCallbackApi('addPhoneContact', option, () => appFrameworkApi.addPhoneContact(params));
+}
+//# sourceMappingURL=contact.js.map

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

@@ -0,0 +1,6 @@
+import type Taro from '@tarojs/taro';
+type TaroGetRandomValuesOption = Parameters<typeof Taro.getRandomValues>[0];
+type TaroGetRandomValuesResult = Awaited<ReturnType<typeof Taro.getRandomValues>>;
+export declare function getRandomValues(option: TaroGetRandomValuesOption): Promise<TaroGetRandomValuesResult>;
+export {};
+//# sourceMappingURL=crypto.d.ts.map

package/dist/api/device/crypto.js

@@ -0,0 +1,14 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function buildGetRandomValuesResult(result) {
+    return {
+        randomValues: result.randomValues ?? new ArrayBuffer(0),
+        ...buildOkCallbackResult('getRandomValues')
+    };
+}
+export async function getRandomValues(option) {
+    return runTaroApi('getRandomValues', option, async () => buildGetRandomValuesResult(await appFrameworkApi.getRandomValues({
+        length: option.length
+    })));
+}
+//# sourceMappingURL=crypto.js.map

package/dist/api/device/device-motion.d.ts

@@ -0,0 +1,7 @@
+import type Taro from '@tarojs/taro';
+type TaroStartDeviceMotionListeningOption = Taro.startDeviceMotionListening.Option;
+type TaroStopDeviceMotionListeningOption = Taro.stopDeviceMotionListening.Option;
+export declare function startDeviceMotionListening(option: TaroStartDeviceMotionListeningOption): Promise<TaroGeneral.CallbackResult>;
+export declare function stopDeviceMotionListening(option?: TaroStopDeviceMotionListeningOption): Promise<TaroGeneral.CallbackResult>;
+export {};
+//# sourceMappingURL=device-motion.d.ts.map

package/dist/api/device/device-motion.js

@@ -0,0 +1,11 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+export async function startDeviceMotionListening(option) {
+    return runCallbackApi('startDeviceMotionListening', option, () => appFrameworkApi.startDeviceMotionListening({
+        interval: option.interval
+    }));
+}
+export async function stopDeviceMotionListening(option) {
+    return runCallbackApi('stopDeviceMotionListening', option, () => appFrameworkApi.stopDeviceMotionListening({}));
+}
+//# sourceMappingURL=device-motion.js.map

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

@@ -0,0 +1,9 @@
+import type Taro from '@tarojs/taro';
+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>>;
+export declare function startGyroscope(option: TaroStartGyroscopeOption): Promise<TaroStartGyroscopeResult>;
+export declare function stopGyroscope(option?: TaroStopGyroscopeOption): Promise<TaroStopGyroscopeResult>;
+export {};
+//# sourceMappingURL=gyroscope.d.ts.map

package/dist/api/device/gyroscope.js

@@ -0,0 +1,11 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+export async function startGyroscope(option) {
+    return runCallbackApi('startGyroscope', option, () => appFrameworkApi.startGyroscope({
+        interval: option.interval
+    }));
+}
+export async function stopGyroscope(option) {
+    return runCallbackApi('stopGyroscope', option, () => appFrameworkApi.stopGyroscope({}));
+}
+//# sourceMappingURL=gyroscope.js.map

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,19 @@
+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

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

@@ -0,0 +1,21 @@
+export * from './sms.js';
+export * from './accessibility.js';
+export * from './accelerometer.js';
+export * from './battery.js';
+export * from './beacon.js';
+export * from './bluetooth.js';
+export * from './calendar.js';
+export * from './clipboard.js';
+export * from './compass.js';
+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';
+export * from './screen.js';
+export * from './vibration.js';
+export * from './wifi.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/device/index.js

@@ -0,0 +1,21 @@
+export * from './sms.js';
+export * from './accessibility.js';
+export * from './accelerometer.js';
+export * from './battery.js';
+export * from './beacon.js';
+export * from './bluetooth.js';
+export * from './calendar.js';
+export * from './clipboard.js';
+export * from './compass.js';
+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';
+export * from './screen.js';
+export * from './vibration.js';
+export * from './wifi.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,9 @@
+import type Taro from '@tarojs/taro';
+type TaroHideKeyboardOption = Parameters<typeof Taro.hideKeyboard>[0];
+type TaroHideKeyboardResult = Awaited<ReturnType<typeof Taro.hideKeyboard>>;
+type TaroGetSelectedTextRangeOption = Parameters<typeof Taro.getSelectedTextRange>[0];
+type TaroGetSelectedTextRangeResult = Awaited<ReturnType<typeof Taro.getSelectedTextRange>>;
+export declare function hideKeyboard(option?: TaroHideKeyboardOption): Promise<TaroHideKeyboardResult>;
+export declare function getSelectedTextRange(option?: TaroGetSelectedTextRangeOption): Promise<TaroGetSelectedTextRangeResult>;
+export {};
+//# sourceMappingURL=keyboard.d.ts.map

package/dist/api/device/keyboard.js

@@ -0,0 +1,16 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runCallbackApi, runTaroApi } from '../utils.js';
+function buildGetSelectedTextRangeResult(result) {
+    return {
+        start: typeof result.start === 'number' ? result.start : 0,
+        end: typeof result.end === 'number' ? result.end : 0,
+        ...buildOkCallbackResult('getSelectedTextRange')
+    };
+}
+export async function hideKeyboard(option) {
+    return runCallbackApi('hideKeyboard', option, () => appFrameworkApi.hideKeyboard({}));
+}
+export async function getSelectedTextRange(option) {
+    return runTaroApi('getSelectedTextRange', option, async () => buildGetSelectedTextRangeResult(await appFrameworkApi.getSelectedTextRange({})));
+}
+//# sourceMappingURL=keyboard.js.map

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

@@ -0,0 +1,6 @@
+import type Taro from '@tarojs/taro';
+type TaroGetLocalIPAddressOption = Parameters<typeof Taro.getLocalIPAddress>[0];
+type TaroGetLocalIPAddressResult = Awaited<ReturnType<typeof Taro.getLocalIPAddress>>;
+export declare function getLocalIPAddress(option?: TaroGetLocalIPAddressOption): Promise<TaroGetLocalIPAddressResult>;
+export {};
+//# sourceMappingURL=network.d.ts.map

package/dist/api/device/network.js

@@ -0,0 +1,13 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function buildGetLocalIPAddressResult(result) {
+    return {
+        localip: result.localIp ?? '',
+        netmask: result.netmask,
+        ...buildOkCallbackResult('getLocalIPAddress')
+    };
+}
+export async function getLocalIPAddress(option) {
+    return runTaroApi('getLocalIPAddress', option, async () => buildGetLocalIPAddressResult(await appFrameworkApi.getLocalIPAddress({})));
+}
+//# sourceMappingURL=network.js.map

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

@@ -0,0 +1,6 @@
+import type Taro from '@tarojs/taro';
+type TaroScanCodeOption = Parameters<typeof Taro.scanCode>[0];
+type TaroScanCodeResult = Awaited<ReturnType<typeof Taro.scanCode>>;
+export declare function scanCode(option: TaroScanCodeOption): Promise<TaroScanCodeResult>;
+export {};
+//# sourceMappingURL=scan.d.ts.map

package/dist/api/device/scan.js

@@ -0,0 +1,19 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function buildScanCodeResult(result) {
+    return {
+        charSet: result.characterSet ?? '',
+        path: result.path ?? '',
+        rawData: result.rawData ?? '',
+        result: result.result ?? '',
+        scanType: result.scanType ?? 'QR_CODE',
+        ...buildOkCallbackResult('scanCode')
+    };
+}
+export async function scanCode(option) {
+    return runTaroApi('scanCode', option, async () => buildScanCodeResult(await appFrameworkApi.scanCode({
+        onlyFromCamera: option.onlyFromCamera,
+        scanType: option.scanType
+    })));
+}
+//# sourceMappingURL=scan.js.map

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

@@ -0,0 +1,12 @@
+import type Taro from '@tarojs/taro';
+type TaroSetVisualEffectOnCaptureOption = Parameters<typeof Taro.setVisualEffectOnCapture>[0];
+type TaroSetVisualEffectOnCaptureResult = Awaited<ReturnType<typeof Taro.setVisualEffectOnCapture>>;
+type TaroSetScreenBrightnessOption = Parameters<typeof Taro.setScreenBrightness>[0];
+type TaroSetScreenBrightnessResult = Awaited<ReturnType<typeof Taro.setScreenBrightness>>;
+type TaroSetKeepScreenOnOption = Parameters<typeof Taro.setKeepScreenOn>[0];
+type TaroSetKeepScreenOnResult = Awaited<ReturnType<typeof Taro.setKeepScreenOn>>;
+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 {};
+//# sourceMappingURL=screen.d.ts.map

package/dist/api/device/screen.js

@@ -0,0 +1,18 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+export async function setVisualEffectOnCapture(option) {
+    return runCallbackApi('setVisualEffectOnCapture', option, () => appFrameworkApi.setVisualEffectOnCapture({
+        visualEffect: option.visualEffect
+    }));
+}
+export async function setScreenBrightness(option) {
+    return runCallbackApi('setScreenBrightness', option, () => appFrameworkApi.setScreenBrightness({
+        value: option.value
+    }));
+}
+export async function setKeepScreenOn(option) {
+    return runCallbackApi('setKeepScreenOn', option, () => appFrameworkApi.setKeepScreenOn({
+        keepScreenOn: option.keepScreenOn
+    }));
+}
+//# sourceMappingURL=screen.js.map

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

@@ -0,0 +1,6 @@
+import type Taro from '@tarojs/taro';
+type TaroSendSmsOption = Taro.sendSms.Option;
+type TaroSendSmsResult = TaroGeneral.CallbackResult;
+export declare function sendSms(option?: TaroSendSmsOption): Promise<TaroSendSmsResult>;
+export {};
+//# sourceMappingURL=sms.d.ts.map

package/dist/api/device/sms.js

@@ -0,0 +1,16 @@
+import { sendSms as appSendSms } from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+function buildFrameworkParams(option) {
+    const params = {};
+    if (typeof option?.phoneNumber === 'string') {
+        params.phoneNumber = option.phoneNumber;
+    }
+    if (typeof option?.content === 'string') {
+        params.message = option.content;
+    }
+    return params;
+}
+export async function sendSms(option = {}) {
+    return runCallbackApi('sendSms', option, () => appSendSms(buildFrameworkParams(option)));
+}
+//# sourceMappingURL=sms.js.map

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

@@ -0,0 +1,9 @@
+import type Taro from '@tarojs/taro';
+type TaroVibrateShortOption = Parameters<typeof Taro.vibrateShort>[0];
+type TaroVibrateShortResult = Awaited<ReturnType<typeof Taro.vibrateShort>>;
+type TaroVibrateLongOption = Parameters<typeof Taro.vibrateLong>[0];
+type TaroVibrateLongResult = Awaited<ReturnType<typeof Taro.vibrateLong>>;
+export declare function vibrateShort(option?: TaroVibrateShortOption): Promise<TaroVibrateShortResult>;
+export declare function vibrateLong(option?: TaroVibrateLongOption): Promise<TaroVibrateLongResult>;
+export {};
+//# sourceMappingURL=vibration.d.ts.map

package/dist/api/device/vibration.js

@@ -0,0 +1,11 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+export async function vibrateShort(option) {
+    return runCallbackApi('vibrateShort', option, () => appFrameworkApi.vibrateShort({
+        type: option?.type
+    }));
+}
+export async function vibrateLong(option) {
+    return runCallbackApi('vibrateLong', option, () => appFrameworkApi.vibrateLong({}));
+}
+//# sourceMappingURL=vibration.js.map

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

@@ -0,0 +1,21 @@
+import type Taro from '@tarojs/taro';
+type TaroStartWifiOption = Parameters<typeof Taro.startWifi>[0];
+type TaroStartWifiResult = Awaited<ReturnType<typeof Taro.startWifi>>;
+type TaroStopWifiOption = Parameters<typeof Taro.stopWifi>[0];
+type TaroStopWifiResult = Awaited<ReturnType<typeof Taro.stopWifi>>;
+type TaroSetWifiListOption = Parameters<typeof Taro.setWifiList>[0];
+type TaroSetWifiListResult = Awaited<ReturnType<typeof Taro.setWifiList>>;
+type TaroConnectWifiOption = Parameters<typeof Taro.connectWifi>[0];
+type TaroConnectWifiResult = Awaited<ReturnType<typeof Taro.connectWifi>>;
+type TaroGetConnectedWifiOption = Parameters<typeof Taro.getConnectedWifi>[0];
+type TaroGetConnectedWifiResult = Taro.getConnectedWifi.SuccessCallbackResult;
+type TaroGetWifiListOption = Parameters<typeof Taro.getWifiList>[0];
+type TaroGetWifiListResult = Awaited<ReturnType<typeof Taro.getWifiList>>;
+export declare function startWifi(option?: TaroStartWifiOption): Promise<TaroStartWifiResult>;
+export declare function stopWifi(option?: TaroStopWifiOption): Promise<TaroStopWifiResult>;
+export declare function setWifiList(option: TaroSetWifiListOption): Promise<TaroSetWifiListResult>;
+export declare function connectWifi(option: TaroConnectWifiOption): Promise<TaroConnectWifiResult>;
+export declare function getConnectedWifi(option?: TaroGetConnectedWifiOption): Promise<TaroGetConnectedWifiResult>;
+export declare function getWifiList(option?: TaroGetWifiListOption): Promise<TaroGetWifiListResult>;
+export {};
+//# sourceMappingURL=wifi.d.ts.map

package/dist/api/device/wifi.js

@@ -0,0 +1,70 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function mapWifiInfo(wifi) {
+    return {
+        SSID: wifi?.ssid ?? '',
+        BSSID: wifi?.bssid ?? '',
+        secure: typeof wifi?.secure === 'boolean' ? wifi.secure : false,
+        signalStrength: typeof wifi?.signalStrength === 'number' ? wifi.signalStrength : 0,
+        frequency: typeof wifi?.frequency === 'number' ? wifi.frequency : undefined
+    };
+}
+function buildGetConnectedWifiResult(result) {
+    return {
+        wifi: mapWifiInfo(result.wifi),
+        ...buildOkCallbackResult('getConnectedWifi')
+    };
+}
+function buildWifiOkResult(apiName) {
+    return buildOkCallbackResult(apiName);
+}
+export async function startWifi(option) {
+    return runTaroApi('startWifi', option, async () => {
+        await appFrameworkApi.startWifi({});
+        return buildWifiOkResult('startWifi');
+    });
+}
+export async function stopWifi(option) {
+    return runTaroApi('stopWifi', option, async () => {
+        await appFrameworkApi.stopWifi({});
+        return buildWifiOkResult('stopWifi');
+    });
+}
+export async function setWifiList(option) {
+    return runTaroApi('setWifiList', option, async () => {
+        await appFrameworkApi.setWifiList({
+            wifiList: Array.isArray(option.wifiList)
+                ? option.wifiList.map((item) => ({
+                    ssid: item.SSID,
+                    bssid: item.BSSID,
+                    password: item.password
+                }))
+                : []
+        });
+        return buildWifiOkResult('setWifiList');
+    });
+}
+export async function connectWifi(option) {
+    return runTaroApi('connectWifi', option, async () => {
+        await appFrameworkApi.connectWifi({
+            ssid: option.SSID,
+            password: option.password,
+            bssid: option.BSSID,
+            manual: option.maunal,
+            partialInfo: option.partialInfo
+        });
+        return buildWifiOkResult('connectWifi');
+    });
+}
+export async function getConnectedWifi(option) {
+    return runTaroApi('getConnectedWifi', option, async () => buildGetConnectedWifiResult(await appFrameworkApi.getConnectedWifi({
+        partialInfo: option?.partialInfo
+    })));
+}
+export async function getWifiList(option) {
+    return runTaroApi('getWifiList', option, async () => {
+        await appFrameworkApi.getWifiList({});
+        return buildWifiOkResult('getWifiList');
+    });
+}
+//# sourceMappingURL=wifi.js.map

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

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

package/dist/api/device/wireless.js

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

package/dist/api/index.d.ts

@@ -1,8 +1,10 @@
 export { getEnv, ENV_TYPE } from './base/index.js';
+export * from './device/index.js';
+export * from './device/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 { getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo, makePhoneCall, getNetworkType, onKeyboardHeightChange } from './system/index.js';
+export * from './system/index.js';
 export { getLocation } from './location/index.js';
 export { showToast } from './show-toast/index.js';
 export { createMapContext } from './map/index.js';

package/dist/api/index.js

@@ -1,8 +1,10 @@
 export { getEnv, ENV_TYPE } from './base/index.js';
+export * from './device/index.js';
+export * from './device/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 { getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo, makePhoneCall, getNetworkType, onKeyboardHeightChange } from './system/index.js';
+export * from './system/index.js';
 export { getLocation } from './location/index.js';
 export { showToast } from './show-toast/index.js';
 export { createMapContext } from './map/index.js';

package/dist/api/system/index.js

@@ -1,5 +1,11 @@
 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 { buildFailCallbackResult, emitFailure, runCallbackApi, runTaroApi } from '../utils.js';
+function buildVibrateShortParams(option) {
+    if (option?.type === 'heavy' || option?.type === 'medium' || option?.type === 'light') {
+        return { type: option.type };
+    }
+    return { type: 'medium' };
+}
 export function getSystemSetting() {
     return {};
 }

package/dist/api/utils.d.ts

@@ -15,7 +15,7 @@ export declare function runAsyncApi<TSuccess, TFail, TComplete = TSuccess | TFai
 export declare function normalizeErrorMessage(error: unknown, fallbackMessage?: string): string;
 export declare function buildOkCallbackResult(apiName: string): TaroGeneral.CallbackResult;
 export declare function buildFailCallbackResult(apiName: string, error: unknown, fallbackMessage?: string): TaroGeneral.CallbackResult;
-export declare function runCallbackApi(apiName: string, callbacks: Partial<CallbackHooks<TaroGeneral.CallbackResult>> | undefined, run: () => MaybePromise<unknown>): Promise<TaroGeneral.CallbackResult>;
-export declare function runTaroApi<TSuccess, TComplete = TSuccess>(apiName: string, callbacks: Partial<CallbackHooks<TSuccess, TaroGeneral.CallbackResult, TComplete>> | undefined, run: () => MaybePromise<TSuccess>, buildCompleteResult?: (result: TSuccess) => TComplete): Promise<TSuccess>;
+export declare function runCallbackApi(apiName: string, callbacks: unknown, run: () => MaybePromise<unknown>): Promise<TaroGeneral.CallbackResult>;
+export declare function runTaroApi<TSuccess, TComplete = TSuccess>(apiName: string, callbacks: unknown, run: () => MaybePromise<TSuccess>, buildCompleteResult?: (result: TSuccess) => TComplete): Promise<TSuccess>;
 export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/api/utils.js

@@ -45,18 +45,14 @@ export function buildFailCallbackResult(apiName, error, fallbackMessage) {
     return buildCallbackResult(apiName, 'fail', normalizeErrorMessage(error, fallbackMessage));
 }
 export function runCallbackApi(apiName, callbacks, run) {
-    return runAsyncApi({
-        callbacks,
-        run: async () => {
-            await run();
-            return buildOkCallbackResult(apiName);
-        },
-        buildFailResult: (error) => buildFailCallbackResult(apiName, error)
+    return runTaroApi(apiName, callbacks, async () => {
+        await run();
+        return buildOkCallbackResult(apiName);
     });
 }
 export function runTaroApi(apiName, callbacks, run, buildCompleteResult) {
     return runAsyncApi({
-        callbacks,
+        callbacks: callbacks,
         run,
         buildFailResult: (error) => buildFailCallbackResult(apiName, error),
         buildCompleteResult

package/dist/components/Map/index.jsx

@@ -12,6 +12,10 @@ function DoubaoAppsMap(props) {
     const [activeCalloutMarkerId, setActiveCalloutMarkerId] = useState(undefined);
     const [imperativeAddedMarkers, setImperativeAddedMarkers] = useState([]);
     const [imperativeRemovedMarkerIds, setImperativeRemovedMarkerIds] = useState([]);
+    const rawMapStyle = props.mapStyle;
+    const passedThroughMapStyle = typeof rawMapStyle === 'string' ? rawMapStyle : undefined;
+    const unsupportedRest = { ...rest };
+    delete unsupportedRest.mapStyle;
     const resolvedCenter = useMemo(() => ({
         latitude,
         longitude
@@ -85,7 +89,7 @@ function DoubaoAppsMap(props) {
         resolvedMapStyle,
         includePadding,
         includePoints,
-        rest,
+        rest: unsupportedRest,
         resolvedSetting,
         resolvedMarkers,
         polyline,
@@ -131,7 +135,7 @@ function DoubaoAppsMap(props) {
     const renderMarkers = composeMarkers(resolvedMarkers, imperativeAddedMarkers, imperativeRemovedMarkerIds);
     return (<map className={className || ''} ref={mapRef} style={mergeMapStyle(style, hidden)} 
     // @ts-expect-error
-    enableNativeInteraction={rest.enableNativeInteraction} mapStyle={resolvedMapStyle} 
+    enableNativeInteraction={rest.enableNativeInteraction} mapStyle={passedThroughMapStyle ?? resolvedMapStyle} 
     // @ts-ignore
     center={longitude !== undefined && latitude !== undefined ? resolvedCenter : undefined} scale={resolvedScale} minScale={resolvedMinScale} maxScale={resolvedMaxScale} rotate={resolvedRotate} showScale={resolvedShowScale} enableTilt={resolvedEnableTilt} enableScale={resolvedEnableScale} enableDrag={resolvedEnableDrag} enableRotate={resolvedEnableRotate} polyline={resolvePolylines(polyline)} circles={resolveNativeCircles(circles)} polygons={resolveNativePolygons(resolvedPolygons)} onClick={(detail) => {
             const event = toCommonEvent({ point: detail.point }, 'tap', mapId);

package/package.json

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