@doubao-apps/taro-runtime 0.0.18 → 0.0.19

package/dist/api/location/index.js

@@ -0,0 +1,77 @@
+import { getLocation as appGetLocation } from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runTaroApi } from '../utils.js';
+function resolveMode(option) {
+    if (typeof option.mode === 'number') {
+        return option.mode;
+    }
+    if (option.isHighAccuracy === true) {
+        return 2;
+    }
+    if (option.isHighAccuracy === false) {
+        return 0;
+    }
+    return undefined;
+}
+function resolveTimeoutMs(option) {
+    if (typeof option.timeoutMs === 'number') {
+        return option.timeoutMs;
+    }
+    if (typeof option.highAccuracyExpireTime === 'number') {
+        return option.highAccuracyExpireTime;
+    }
+    return undefined;
+}
+function resolveMaxCacheMs(option) {
+    if (typeof option.maxCacheMs === 'number') {
+        return option.maxCacheMs;
+    }
+    if (typeof option.cacheTimeout === 'number') {
+        return option.cacheTimeout;
+    }
+    return undefined;
+}
+function buildFrameworkParams(option) {
+    const params = {};
+    const mode = resolveMode(option);
+    const timeoutMs = resolveTimeoutMs(option);
+    const maxCacheMs = resolveMaxCacheMs(option);
+    if (typeof mode === 'number') {
+        params.mode = mode;
+    }
+    if (typeof timeoutMs === 'number') {
+        params.timeoutMs = timeoutMs;
+    }
+    if (typeof maxCacheMs === 'number') {
+        params.maxCacheMs = maxCacheMs;
+    }
+    if (typeof option.source === 'string') {
+        params.source = option.source;
+    }
+    return params;
+}
+function normalizeNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    return 0;
+}
+function buildSuccessResult(response) {
+    const accuracy = normalizeNumber(response.accuracy);
+    return {
+        latitude: normalizeNumber(response.latitude),
+        longitude: normalizeNumber(response.longitude),
+        speed: normalizeNumber(response.speed),
+        accuracy,
+        altitude: 0,
+        horizontalAccuracy: accuracy,
+        verticalAccuracy: 0,
+        ...buildOkCallbackResult('getLocation')
+    };
+}
+export async function getLocation(option = {}) {
+    return runTaroApi('getLocation', option, async () => {
+        const response = await appGetLocation(buildFrameworkParams(option));
+        return buildSuccessResult(response);
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/api/map/index.js

@@ -1,3 +1,4 @@
+import { buildFailCallbackResult, buildOkCallbackResult, emitFailure, emitSuccess, normalizeErrorMessage } from '../utils.js';
 import { getMapController, MAP_CONTEXT_METHOD_TO_COMPONENT_METHOD } from '../../internal/map-context/index.js';
 export function createMapContext(mapId, _component) {
     return {
@@ -27,7 +28,7 @@ export function createMapContext(mapId, _component) {
                 return rejectMethod('includePoints', resolvedOption, 'points is required');
             }
             return runWithController(mapId, 'includePoints', resolvedOption, (controller) => {
-                controller[MAP_CONTEXT_METHOD_TO_COMPONENT_METHOD.includePoints](resolvedOption.points, normalizePadding(resolvedOption.padding));
+                controller[MAP_CONTEXT_METHOD_TO_COMPONENT_METHOD.includePoints](resolvedOption.points, resolvedOption.padding);
                 return undefined;
             });
         },
@@ -51,8 +52,27 @@ export function createMapContext(mapId, _component) {
         toScreenLocation: createUnsupportedMethod('toScreenLocation'),
         fromScreenLocation: createUnsupportedMethod('fromScreenLocation'),
         openMapApp: createUnsupportedMethod('openMapApp'),
-        addMarkers: createUnsupportedMethod('addMarkers'),
-        removeMarkers: createUnsupportedMethod('removeMarkers'),
+        addMarkers: (option) => {
+            const resolvedOption = option ?? {};
+            if (!Array.isArray(resolvedOption.markers)) {
+                return rejectMethod('addMarkers', resolvedOption, 'markers is required');
+            }
+            return runWithController(mapId, 'addMarkers', resolvedOption, (controller) => {
+                controller.addMarkers(resolvedOption.markers, resolvedOption.clear === true);
+                return undefined;
+            });
+        },
+        removeMarkers: (option) => {
+            const resolvedOption = option ?? {};
+            if (!Array.isArray(resolvedOption.markerIds) ||
+                resolvedOption.markerIds.some((markerId) => typeof markerId !== 'number' || Number.isNaN(markerId))) {
+                return rejectMethod('removeMarkers', resolvedOption, 'markerIds is required');
+            }
+            return runWithController(mapId, 'removeMarkers', resolvedOption, (controller) => {
+                controller.removeMarkers(resolvedOption.markerIds);
+                return undefined;
+            });
+        },
         initMarkerCluster: createUnsupportedMethod('initMarkerCluster'),
         on: () => {
             console.warn('[doubao-apps/taro-runtime] MapContext.on is not supported yet.');
@@ -71,40 +91,18 @@ async function runWithController(mapId, method, option, run) {
         const result = await run(controller);
         const payload = {
             ...(result && typeof result === 'object' ? result : {}),
-            errMsg: `${method}:ok`
+            ...buildOkCallbackResult(method)
         };
-        option?.success?.(payload);
-        option?.complete?.(payload);
-        console.log('runWithController', payload);
+        emitSuccess(option, payload);
         return payload;
     }
     catch (error) {
-        console.log('runWithController', error);
-        return rejectMethod(method, option, normalizeError(error));
+        return rejectMethod(method, option, normalizeErrorMessage(error, 'unknown error'));
     }
 }
 function rejectMethod(method, option, message) {
-    const payload = { errMsg: `${method}:fail ${message}` };
-    option?.fail?.(payload);
-    option?.complete?.(payload);
+    const payload = buildFailCallbackResult(method, message);
+    emitFailure(option, payload);
     return Promise.reject(payload);
 }
-function normalizePadding(padding) {
-    if (!Array.isArray(padding) || padding.length === 0) {
-        return undefined;
-    }
-    return typeof padding[0] === 'number' ? padding[0] : undefined;
-}
-function normalizeError(error) {
-    if (typeof error === 'string') {
-        return error;
-    }
-    if (error && typeof error === 'object' && 'errMsg' in error && typeof error.errMsg === 'string') {
-        return error.errMsg;
-    }
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return 'unknown error';
-}
 //# sourceMappingURL=index.js.map

package/dist/api/request/index.js

@@ -1,4 +1,5 @@
 import { request as appletRequest } from '@byted-doubao-apps/framework/api';
+import { buildFailCallbackResult, buildOkCallbackResult, emitFailure, emitSuccess } from '../utils.js';
 import { createRequestTask } from './request-task.js';
 const DEFAULT_METHOD = 'GET';
 const DEFAULT_TIMEOUT = 60000;
@@ -7,16 +8,11 @@ function buildSuccessResult(response, header, statusCode) {
         data: response,
         header: header ?? {},
         statusCode: statusCode ?? 0,
-        errMsg: 'request:ok'
+        ...buildOkCallbackResult('request')
     };
 }
 function buildFailResult(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { errMsg: `request:fail ${message}` };
-}
-function runComplete(complete, result) {
-    if (complete)
-        complete(result);
+    return buildFailCallbackResult('request', error);
 }
 export function request(option) {
     const { url, data, header, method = DEFAULT_METHOD, timeout = DEFAULT_TIMEOUT, success, fail, complete } = option;
@@ -26,8 +22,8 @@ export function request(option) {
     const promise = appletRequest({
         url,
         method: upperMethod,
-        data: data,
-        header: { 'Content-Type': 'application/json', ...header }
+        data,
+        header
     })
         .then((res) => {
         if (settled)
@@ -36,9 +32,7 @@ export function request(option) {
         if (timeoutId)
             clearTimeout(timeoutId);
         const result = buildSuccessResult(res.data, res.header, res.statusCode);
-        if (success)
-            success(result);
-        runComplete(complete, result);
+        emitSuccess({ success, complete }, result, result);
         return result;
     })
         .catch((error) => {
@@ -48,9 +42,7 @@ export function request(option) {
         if (timeoutId)
             clearTimeout(timeoutId);
         const result = buildFailResult(error);
-        if (fail)
-            fail(result);
-        runComplete(complete, result);
+        emitFailure({ fail, complete }, result);
         return Promise.reject(result);
     });
     if (Number.isFinite(timeout) && timeout > 0) {
@@ -59,9 +51,7 @@ export function request(option) {
                 return;
             settled = true;
             const result = buildFailResult('timeout');
-            if (fail)
-                fail(result);
-            runComplete(complete, result);
+            emitFailure({ fail, complete }, result);
         }, timeout);
     }
     return createRequestTask(promise);

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

@@ -0,0 +1,4 @@
+export { navigateBack } from './navigate-back.js';
+export { navigateTo } from './navigate-to.js';
+export { redirectTo } from './redirect-to.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/router/index.js

@@ -0,0 +1,4 @@
+export { navigateBack } from './navigate-back.js';
+export { navigateTo } from './navigate-to.js';
+export { redirectTo } from './redirect-to.js';
+//# sourceMappingURL=index.js.map

package/dist/api/router/navigate-back.d.ts

@@ -0,0 +1,5 @@
+import type { navigateBack as taroNavigateBack } from '@tarojs/taro';
+export declare function navigateBack(params?: Parameters<typeof taroNavigateBack>[0]): Promise<{
+    errMsg: string;
+}>;
+//# sourceMappingURL=navigate-back.d.ts.map

package/dist/api/router/navigate-back.js

@@ -0,0 +1,20 @@
+import { navigateBack as appNavigateBack } from '@byted-doubao-apps/framework/api';
+export async function navigateBack(params) {
+    try {
+        await appNavigateBack(params);
+        return {
+            errMsg: ''
+        };
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            return {
+                errMsg: err.message
+            };
+        }
+        return {
+            errMsg: String(err)
+        };
+    }
+}
+//# sourceMappingURL=navigate-back.js.map

package/dist/api/{navigate/index.d.ts → router/navigate-to.d.ts}

@@ -1,5 +1,5 @@
 import type { navigateTo as taroNavigateTo } from '@tarojs/taro';
 export declare function navigateTo(params: Parameters<typeof taroNavigateTo>[0]): Promise<{
     errMsg: string;
-} | undefined>;
-//# sourceMappingURL=index.d.ts.map
+}>;
+//# sourceMappingURL=navigate-to.d.ts.map

package/dist/api/{navigate/index.js → router/navigate-to.js}

@@ -1,11 +1,8 @@
-import { openPage } from '@byted-doubao-apps/framework/api';
-// TODO only impl major params
+import { navigateTo as appNavigateTo } from '@byted-doubao-apps/framework/api';
 export async function navigateTo(params) {
     try {
-        const pageId = params.url.split('/')[1];
-        await openPage({
-            pageId,
-            context: {}
+        await appNavigateTo({
+            url: params.url
         });
         return {
             errMsg: ''
@@ -17,6 +14,9 @@ export async function navigateTo(params) {
                 errMsg: err.message
             };
         }
+        return {
+            errMsg: String(err)
+        };
     }
 }
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=navigate-to.js.map

package/dist/api/router/redirect-to.d.ts

@@ -0,0 +1,5 @@
+import type { redirectTo as taroRedirectTo } from '@tarojs/taro';
+export declare function redirectTo(params: Parameters<typeof taroRedirectTo>[0]): Promise<{
+    errMsg: string;
+}>;
+//# sourceMappingURL=redirect-to.d.ts.map

package/dist/api/router/redirect-to.js

@@ -0,0 +1,22 @@
+import { redirectTo as appRedirectTo } from '@byted-doubao-apps/framework/api';
+export async function redirectTo(params) {
+    try {
+        await appRedirectTo({
+            url: params.url
+        });
+        return {
+            errMsg: ''
+        };
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            return {
+                errMsg: err.message
+            };
+        }
+        return {
+            errMsg: String(err)
+        };
+    }
+}
+//# sourceMappingURL=redirect-to.js.map

package/dist/api/show-toast/index.d.ts

@@ -0,0 +1,6 @@
+import type { showToast as taroShowToast } from '@tarojs/taro';
+type TaroShowToastOption = NonNullable<Parameters<typeof taroShowToast>[0]>;
+type TaroShowToastResult = Awaited<ReturnType<typeof taroShowToast>>;
+export declare function showToast(option?: TaroShowToastOption): Promise<TaroShowToastResult>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/api/show-toast/index.js

@@ -0,0 +1,39 @@
+import { showToast as appShowToast } from '@byted-doubao-apps/framework/api';
+import { runCallbackApi } from '../utils.js';
+function resolveType(icon) {
+    if (icon === 'success' || icon === 'error') {
+        return icon;
+    }
+    return undefined;
+}
+function resolveIcon(icon) {
+    if (icon === 'success' || icon === 'error') {
+        return icon;
+    }
+    return undefined;
+}
+function buildFrameworkParams(option) {
+    const { title, duration, icon, image } = option ?? {};
+    const params = {
+        message: typeof title === 'string' ? title : ''
+    };
+    if (typeof duration === 'number') {
+        params.duration = duration;
+    }
+    if (typeof image === 'string') {
+        params.customIcon = image;
+    }
+    const mappedType = resolveType(icon);
+    const mappedIcon = resolveIcon(icon);
+    if (mappedType) {
+        params.type = mappedType;
+    }
+    if (mappedIcon && !params.customIcon) {
+        params.icon = mappedIcon;
+    }
+    return params;
+}
+export async function showToast(option) {
+    return runCallbackApi('showToast', option, () => appShowToast(buildFrameworkParams(option)));
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,16 @@
+import { getStorageInfoSync as appGetStorageInfoSync } from '@byted-doubao-apps/framework/api';
+import type { clearStorage as taroClearStorage, getStorageInfo as taroGetStorageInfo, removeStorage as taroRemoveStorage, setStorage as taroSetStorage } from '@tarojs/taro';
+type GetStorageInfoResult = ReturnType<typeof appGetStorageInfoSync>;
+type GetStorageResult<T = any> = Taro.getStorage.SuccessCallbackResult<T>;
+export declare function setStorage(option: Parameters<typeof taroSetStorage>[0]): Promise<TaroGeneral.CallbackResult>;
+export declare function setStorageSync(key: string, data: any): void;
+export declare function getStorage<T = any>(option: Taro.getStorage.Option<T>): Promise<GetStorageResult<T>>;
+export declare function getStorageSync<T = any>(key: string): T;
+export declare function removeStorage(option: Parameters<typeof taroRemoveStorage>[0]): Promise<TaroGeneral.CallbackResult>;
+export declare function removeStorageSync(key: string): void;
+export declare function clearStorage(option?: Parameters<typeof taroClearStorage>[0]): Promise<TaroGeneral.CallbackResult>;
+export declare function clearStorageSync(): void;
+export declare function getStorageInfo(option?: Parameters<typeof taroGetStorageInfo>[0]): Promise<GetStorageInfoResult>;
+export declare function getStorageInfoSync(): GetStorageInfoResult;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/api/storage/index.js

@@ -0,0 +1,55 @@
+import { clearStorage as appClearStorage, clearStorageSync as appClearStorageSync, getStorage as appGetStorage, getStorageInfo as appGetStorageInfo, getStorageInfoSync as appGetStorageInfoSync, getStorageSync as appGetStorageSync, removeStorage as appRemoveStorage, removeStorageSync as appRemoveStorageSync, setStorage as appSetStorage, setStorageSync as appSetStorageSync } from '@byted-doubao-apps/framework/api';
+import { buildOkCallbackResult, runCallbackApi, runTaroApi } from '../utils.js';
+export async function setStorage(option) {
+    const { key, data } = option;
+    return runCallbackApi('setStorage', option, () => appSetStorage({
+        key,
+        data
+    }));
+}
+export function setStorageSync(key, data) {
+    appSetStorageSync({
+        key,
+        data
+    });
+}
+export async function getStorage(option) {
+    const { key } = option;
+    return runTaroApi('getStorage', option, async () => {
+        const storage = await appGetStorage({
+            key
+        });
+        return {
+            data: storage.data,
+            ...buildOkCallbackResult('getStorage')
+        };
+    });
+}
+export function getStorageSync(key) {
+    return appGetStorageSync({
+        key
+    }).data;
+}
+export async function removeStorage(option) {
+    return runCallbackApi('removeStorage', option, () => appRemoveStorage({
+        key: option.key
+    }));
+}
+export function removeStorageSync(key) {
+    appRemoveStorageSync({
+        key
+    });
+}
+export async function clearStorage(option) {
+    return runCallbackApi('clearStorage', option, () => appClearStorage());
+}
+export function clearStorageSync() {
+    appClearStorageSync();
+}
+export async function getStorageInfo(option) {
+    return runTaroApi('getStorageInfo', option, () => appGetStorageInfo(), () => buildOkCallbackResult('getStorageInfo'));
+}
+export function getStorageInfoSync() {
+    return appGetStorageInfoSync();
+}
+//# sourceMappingURL=index.js.map

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

@@ -1,7 +1,19 @@
 import type Taro from '@tarojs/taro';
+import type { getNetworkType as taroGetNetworkType } from '@tarojs/taro';
+import type { getScreenBrightness as taroGetScreenBrightness } from '@tarojs/taro';
+type TaroMakePhoneCallOption = Parameters<typeof Taro.makePhoneCall>[0];
+type TaroMakePhoneCallResult = Awaited<ReturnType<typeof Taro.makePhoneCall>>;
+type TaroGetNetworkTypeOption = Parameters<typeof taroGetNetworkType>[0];
+type TaroGetNetworkTypeResult = Awaited<ReturnType<typeof taroGetNetworkType>>;
+type TaroGetScreenBrightnessOption = Parameters<typeof taroGetScreenBrightness>[0];
+type TaroGetScreenBrightnessResult = Awaited<ReturnType<typeof taroGetScreenBrightness>>;
 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 makePhoneCall(option: TaroMakePhoneCallOption): Promise<TaroMakePhoneCallResult>;
+export declare function getNetworkType(option?: TaroGetNetworkTypeOption): Promise<TaroGetNetworkTypeResult>;
+export declare function getScreenBrightness(option?: TaroGetScreenBrightnessOption): Promise<TaroGetScreenBrightnessResult>;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/api/system/index.js

@@ -1,3 +1,5 @@
+import { getAppBaseInfoSync, getWindowInfoSync, makePhoneCall as appMakePhoneCall, getNetworkType as appGetNetworkType, getScreenBrightness as appGetScreenBrightness } from '@byted-doubao-apps/framework/api';
+import { buildFailCallbackResult, emitFailure, runCallbackApi, runTaroApi } from '../utils.js';
 export function getSystemSetting() {
     return {};
 }
@@ -28,17 +30,45 @@ export function getDeviceInfo() {
     };
 }
 export function getAppBaseInfo() {
-    return {
-        language: 'zh_CN'
-    };
+    return getAppBaseInfoSync();
 }
 export function getWindowInfo() {
-    return {
-        pixelRatio: 1,
-        screenWidth: 0,
-        screenHeight: 0,
-        windowWidth: 0,
-        windowHeight: 0
-    };
+    return getWindowInfoSync();
+}
+export async function makePhoneCall(option) {
+    const { phoneNumber } = option;
+    if (typeof phoneNumber !== 'string' || phoneNumber.length === 0) {
+        const result = buildFailCallbackResult('makePhoneCall', 'phoneNumber is required');
+        emitFailure(option, result);
+        return Promise.reject(result);
+    }
+    const params = { phoneNumber };
+    return runCallbackApi('makePhoneCall', option, () => appMakePhoneCall(params));
+}
+export async function getNetworkType(option = {}) {
+    return runTaroApi('getNetworkType', option, async () => {
+        const response = await appGetNetworkType({});
+        return {
+            networkType: response.networkType,
+            signalStrength: typeof response.signalStrength === 'number' ? response.signalStrength : undefined,
+            hasSystemProxy: typeof response.hasSystemProxy === 'boolean' ? response.hasSystemProxy : undefined,
+            weakNet: typeof response.weakNet === 'boolean' ? response.weakNet : undefined,
+            errMsg: 'getNetworkType:ok'
+        };
+    });
+}
+export async function getScreenBrightness(option = {}) {
+    return runTaroApi('getScreenBrightness', option, async () => {
+        const response = await appGetScreenBrightness();
+        const value = typeof response?.value === 'number' ? response.value : 0;
+        const errMsg = response?.errMsg;
+        if (typeof errMsg === 'string' && errMsg.startsWith('getScreenBrightness:')) {
+            return { value, errMsg };
+        }
+        return {
+            value,
+            errMsg: 'getScreenBrightness:ok'
+        };
+    });
 }
 //# sourceMappingURL=index.js.map

package/dist/api/utils.d.ts

@@ -0,0 +1,21 @@
+export interface CallbackHooks<TSuccess, TFail = TaroGeneral.CallbackResult, TComplete = TSuccess | TFail> {
+    success?: (result: TSuccess) => void;
+    fail?: (result: TFail) => void;
+    complete?: (result: TComplete) => void;
+}
+type MaybePromise<T> = T | Promise<T>;
+export declare function emitSuccess<TSuccess, TComplete = TSuccess>(callbacks: Partial<CallbackHooks<TSuccess, never, TComplete>> | undefined, successResult: TSuccess, completeResult?: TComplete): void;
+export declare function emitFailure<TFail, TComplete = TFail>(callbacks: Partial<CallbackHooks<never, TFail, TComplete>> | undefined, result: TFail): void;
+export declare function runAsyncApi<TSuccess, TFail, TComplete = TSuccess | TFail>({ callbacks, run, buildFailResult, buildCompleteResult }: {
+    callbacks: Partial<CallbackHooks<TSuccess, TFail, TComplete>> | undefined;
+    run: () => MaybePromise<TSuccess>;
+    buildFailResult: (error: unknown) => TFail;
+    buildCompleteResult?: (result: TSuccess) => TComplete;
+}): Promise<TSuccess>;
+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 {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/api/utils.js

@@ -0,0 +1,65 @@
+export function emitSuccess(callbacks, successResult, completeResult) {
+    callbacks?.success?.(successResult);
+    callbacks?.complete?.(completeResult ?? successResult);
+}
+export function emitFailure(callbacks, result) {
+    callbacks?.fail?.(result);
+    callbacks?.complete?.(result);
+}
+export async function runAsyncApi({ callbacks, run, buildFailResult, buildCompleteResult }) {
+    try {
+        const result = await run();
+        emitSuccess(callbacks, result, buildCompleteResult?.(result));
+        return result;
+    }
+    catch (error) {
+        const result = buildFailResult(error);
+        emitFailure(callbacks, result);
+        return Promise.reject(result);
+    }
+}
+export function normalizeErrorMessage(error, fallbackMessage) {
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error && typeof error === 'object' && 'errMsg' in error && typeof error.errMsg === 'string') {
+        return error.errMsg;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof fallbackMessage === 'string') {
+        return fallbackMessage;
+    }
+    return String(error);
+}
+function buildCallbackResult(apiName, status, detail) {
+    return {
+        errMsg: detail ? `${apiName}:${status} ${detail}` : `${apiName}:${status}`
+    };
+}
+export function buildOkCallbackResult(apiName) {
+    return buildCallbackResult(apiName, 'ok');
+}
+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)
+    });
+}
+export function runTaroApi(apiName, callbacks, run, buildCompleteResult) {
+    return runAsyncApi({
+        callbacks,
+        run,
+        buildFailResult: (error) => buildFailCallbackResult(apiName, error),
+        buildCompleteResult
+    });
+}
+//# sourceMappingURL=utils.js.map

package/dist/components/Image/index.d.ts

@@ -1,6 +1,7 @@
 type ImageProps = {
     src?: string;
+    mode?: string;
 } & Record<string, unknown>;
-export declare function Image({ src, ...rest }: ImageProps): any;
+export declare function Image({ src, mode, ...rest }: ImageProps): any;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/components/Image/index.jsx

@@ -1,7 +1,8 @@
-export function Image({ src, ...rest }) {
+export function Image({ src, mode, ...rest }) {
     if (src?.endsWith('.svg') || src?.startsWith('data:image/svg')) {
         return <svg src={src} {...rest}/>;
     }
-    return <image src={src} {...rest}/>;
+    // @ts-expect-error
+    return <image {...rest} src={src ?? ''} mode={mode === 'widthFix' ? 'aspectFit' : mode}/>;
 }
 //# sourceMappingURL=index.jsx.map