@nebula-rn/client 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export * from './chooseMedia';
+export * from './compressImage';
+export * from './descriptions';
+export * from './file';
+export * from './getAppBaseInfo';
+export * from './getClipboardData';
+export * from './getFileInfo';
+export * from './getFileSystemManager';
+export * from './getImageInfo';
+export * from './getLocation';
+export * from './getScreenBrightness';
+export * from './getStorage';
+export * from './getStorageInfo';
+export * from './getSystemInfo';
+export * from './location';
+export * from './makePhoneCall';
+export * from './media';
+export * from './miniAppUpdate';
+export * from './network';
+export * from './onUserCaptureScreen';
+export * from './previewImage';
+export * from './scanCode';
+export * from './sensors';
+export * from './setClipboardData';
+export * from './setStorage';
+export * from './storage';

package/dist/index.js

@@ -0,0 +1,26 @@
+export * from './chooseMedia';
+export * from './compressImage';
+export * from './descriptions';
+export * from './file';
+export * from './getAppBaseInfo';
+export * from './getClipboardData';
+export * from './getFileInfo';
+export * from './getFileSystemManager';
+export * from './getImageInfo';
+export * from './getLocation';
+export * from './getScreenBrightness';
+export * from './getStorage';
+export * from './getStorageInfo';
+export * from './getSystemInfo';
+export * from './location';
+export * from './makePhoneCall';
+export * from './media';
+export * from './miniAppUpdate';
+export * from './network';
+export * from './onUserCaptureScreen';
+export * from './previewImage';
+export * from './scanCode';
+export * from './sensors';
+export * from './setClipboardData';
+export * from './setStorage';
+export * from './storage';

package/dist/location.d.ts

@@ -0,0 +1,10 @@
+export interface LocationData {
+    accuracy: number;
+    altitude: number | null;
+    latitude: number;
+    longitude: number;
+    speed: number | null;
+    timestamp: number;
+}
+export type UnsubscribeFn = () => void | Promise<void>;
+export declare const onLocationChange: (enableHighAccuracy: boolean | undefined, onSuccess: (data: LocationData) => void, onError?: (error: unknown) => void) => UnsubscribeFn;

package/dist/location.js

@@ -0,0 +1,18 @@
+import { subscribeToHostEvent } from './runtime/host';
+export const onLocationChange = (enableHighAccuracy = true, onSuccess, onError) => {
+    let unsubscribePromise = null;
+    const handle = subscribeToHostEvent('locationChange', {
+        enableHighAccuracy,
+    }, onSuccess).catch(error => {
+        onError?.(error);
+        throw error;
+    });
+    return () => {
+        if (!unsubscribePromise) {
+            unsubscribePromise = handle
+                .then(subscription => subscription.unsubscribe())
+                .catch(() => { });
+        }
+        return unsubscribePromise;
+    };
+};

package/dist/makePhoneCall/index.d.ts

@@ -0,0 +1 @@
+export declare function makePhoneCall(phoneNumber: string): Promise<boolean>;

package/dist/makePhoneCall/index.js

@@ -0,0 +1,4 @@
+import { invokeHostApi } from '../runtime/host';
+export async function makePhoneCall(phoneNumber) {
+    return invokeHostApi('makePhoneCall', { phoneNumber });
+}

package/dist/media.d.ts

@@ -0,0 +1,5 @@
+export type MediaType = 'photo' | 'video';
+export interface SaveMediaOptions {
+    album?: string;
+}
+export declare const saveMedia: (url: string, type: MediaType, options?: SaveMediaOptions) => Promise<string>;

package/dist/media.js

@@ -0,0 +1,8 @@
+import { invokeHostApi } from './runtime/host';
+export const saveMedia = (url, type, options) => {
+    return invokeHostApi('saveMedia', {
+        url,
+        type,
+        album: options?.album,
+    });
+};

package/dist/miniAppUpdate/index.d.ts

@@ -0,0 +1,3 @@
+import type { MiniAppUpdateInfo } from '@nebula-rn/sdk';
+export declare function getMiniAppUpdateInfo(): Promise<MiniAppUpdateInfo>;
+export declare function applyMiniAppUpdate(): Promise<MiniAppUpdateInfo>;

package/dist/miniAppUpdate/index.js

@@ -0,0 +1,7 @@
+import { invokeHostApi } from '../runtime/host';
+export function getMiniAppUpdateInfo() {
+    return invokeHostApi('getMiniAppUpdateInfo', {}, '1.0', 15000);
+}
+export function applyMiniAppUpdate() {
+    return invokeHostApi('applyMiniAppUpdate', {}, '1.0', 120000);
+}

package/dist/network.d.ts

@@ -0,0 +1,9 @@
+export interface GetNetworkTypeResult {
+    networkType: string;
+}
+export interface NetworkStatusChangeResult {
+    isConnected: boolean;
+    networkType: string;
+}
+export declare const getNetworkType: () => Promise<string>;
+export declare const onNetworkStatusChange: (callback: (res: NetworkStatusChangeResult) => void) => () => Promise<void>;

package/dist/network.js

@@ -0,0 +1,15 @@
+import { invokeHostApi, subscribeToHostEvent } from './runtime/host';
+export const getNetworkType = async () => {
+    const result = await invokeHostApi('getNetworkType');
+    return result.networkType;
+};
+export const onNetworkStatusChange = (callback) => {
+    let unsubscribePromise = null;
+    const handle = subscribeToHostEvent('networkStatusChange', {}, callback);
+    return () => {
+        if (!unsubscribePromise) {
+            unsubscribePromise = handle.then(subscription => subscription.unsubscribe());
+        }
+        return unsubscribePromise;
+    };
+};

package/dist/onUserCaptureScreen/index.d.ts

@@ -0,0 +1 @@
+export declare const onUserCaptureScreen: (callback: () => void) => () => Promise<void>;

package/dist/onUserCaptureScreen/index.js

@@ -0,0 +1,11 @@
+import { subscribeToHostEvent } from '../runtime/host';
+export const onUserCaptureScreen = (callback) => {
+    let unsubscribePromise = null;
+    const handle = subscribeToHostEvent('userCaptureScreen', {}, () => callback());
+    return () => {
+        if (!unsubscribePromise) {
+            unsubscribePromise = handle.then(subscription => subscription.unsubscribe());
+        }
+        return unsubscribePromise;
+    };
+};

package/dist/previewImage/index.d.ts

@@ -0,0 +1,8 @@
+export interface PreviewImageOptions {
+    urls: string[];
+    current?: string;
+    showMenu?: boolean;
+    saveMediaText?: string;
+    cancelText?: string;
+}
+export declare function previewImages(options: PreviewImageOptions): Promise<void>;

package/dist/previewImage/index.js

@@ -0,0 +1,4 @@
+import { invokeHostApi } from '../runtime/host';
+export function previewImages(options) {
+    return invokeHostApi('previewImage', options, '1.0', 120000);
+}

package/dist/runtime/host.d.ts

@@ -0,0 +1,41 @@
+import type { NebulaApiInvokeResult } from '@nebula-rn/sdk';
+export type HostApiEventMessage<TPayload = unknown> = {
+    __nebulaApiEvent: 'v1';
+    apiName: string;
+    channel: string;
+    subscriptionId?: string;
+    taskId?: string;
+    payload?: TPayload;
+};
+type HostEventListener<TPayload> = (payload: TPayload) => void;
+type HostTaskProgressListener<TProgress> = (payload: TProgress) => void;
+type HostTaskHeadersListener<THeaders> = (payload: THeaders) => void;
+export type HostTask<TData, TProgress, THeaders> = {
+    abort(): Promise<void>;
+    onProgressUpdate(listener: HostTaskProgressListener<TProgress>): void;
+    offProgressUpdate(listener: HostTaskProgressListener<TProgress>): void;
+    onHeadersReceived(listener: HostTaskHeadersListener<THeaders>): void;
+    offHeadersReceived(listener: HostTaskHeadersListener<THeaders>): void;
+    then<TResult1 = TData, TResult2 = never>(onfulfilled?: ((value: TData) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TData | TResult>;
+};
+export type HostSubscriptionHandle = {
+    subscriptionId: string;
+    unsubscribe: () => Promise<void>;
+};
+export declare function createHostApiError(apiName: string, error: unknown, fallbackCode?: string): Error & {
+    code: string;
+};
+export declare function invokeHostApi<TData = unknown>(apiName: string, payload?: object, version?: string, timeoutMs?: number): Promise<TData>;
+export declare function invokeHostApiResult<TData = unknown>(apiName: string, payload?: object, version?: string, timeoutMs?: number): Promise<NebulaApiInvokeResult<TData>>;
+export declare function addHostApiEventListener<TPayload = unknown>(apiName: string, channel: string, listener: HostEventListener<TPayload>, matcher?: (message: HostApiEventMessage<TPayload>) => boolean): () => void;
+export declare function subscribeToHostEvent<TPayload = unknown>(apiName: string, payload: object, onEvent: HostEventListener<TPayload>, options?: {
+    version?: string;
+    timeoutMs?: number;
+    unsubscribePayload?: object;
+}): Promise<HostSubscriptionHandle>;
+export declare function createHostTask<TData, TProgress, THeaders>(apiName: string, payload: object, options?: {
+    version?: string;
+    timeoutMs?: number;
+}): HostTask<TData, TProgress, THeaders>;
+export {};

package/dist/runtime/host.js

@@ -0,0 +1,152 @@
+import { Miniapp } from '@nebula-rn/sdk';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function isHostApiEventMessage(value) {
+    return (value.__nebulaApiEvent === 'v1' &&
+        typeof value.apiName === 'string' &&
+        typeof value.channel === 'string');
+}
+export function createHostApiError(apiName, error, fallbackCode = 'HOST_API_FAILED') {
+    const details = isRecord(error) ? error : undefined;
+    const code = typeof details?.code === 'string' ? details.code : fallbackCode;
+    const message = typeof details?.message === 'string'
+        ? details.message
+        : error instanceof Error
+            ? error.message
+            : `${apiName}:fail host request failed`;
+    const hostError = new Error(message);
+    hostError.code = code;
+    return hostError;
+}
+export async function invokeHostApi(apiName, payload = {}, version = '1.0', timeoutMs = 15000) {
+    const result = await Miniapp.invokeHostApi(apiName, payload, version, timeoutMs);
+    if (!result.ok) {
+        throw createHostApiError(apiName, result.error);
+    }
+    return result.data;
+}
+export async function invokeHostApiResult(apiName, payload = {}, version = '1.0', timeoutMs = 15000) {
+    return Miniapp.invokeHostApi(apiName, payload, version, timeoutMs);
+}
+export function addHostApiEventListener(apiName, channel, listener, matcher) {
+    return Miniapp.onHostMessage(event => {
+        const { message } = event;
+        if (!isRecord(message) || !isHostApiEventMessage(message)) {
+            return;
+        }
+        if (message.apiName !== apiName || message.channel !== channel) {
+            return;
+        }
+        const typedMessage = message;
+        if (matcher && !matcher(typedMessage)) {
+            return;
+        }
+        listener((typedMessage.payload ?? null));
+    });
+}
+export async function subscribeToHostEvent(apiName, payload, onEvent, options) {
+    const version = options?.version ?? '1.0';
+    const timeoutMs = options?.timeoutMs ?? 15000;
+    const result = await invokeHostApi(`${apiName}.subscribe`, payload, version, timeoutMs);
+    const stopListening = addHostApiEventListener(apiName, 'subscription', onEvent, message => message.subscriptionId === result.subscriptionId);
+    return {
+        subscriptionId: result.subscriptionId,
+        unsubscribe: async () => {
+            stopListening();
+            await invokeHostApi(`${apiName}.unsubscribe`, {
+                subscriptionId: result.subscriptionId,
+                ...(options?.unsubscribePayload ?? {}),
+            }, version, timeoutMs);
+        },
+    };
+}
+class HostTaskImpl {
+    promise;
+    aborter;
+    progressListeners = new Set();
+    headersListeners = new Set();
+    cleanup;
+    constructor(promise, aborter, cleanup) {
+        this.promise = promise;
+        this.aborter = aborter;
+        this.cleanup = cleanup;
+    }
+    abort() {
+        this.cleanup();
+        return this.aborter();
+    }
+    onProgressUpdate(listener) {
+        this.progressListeners.add(listener);
+    }
+    offProgressUpdate(listener) {
+        this.progressListeners.delete(listener);
+    }
+    onHeadersReceived(listener) {
+        this.headersListeners.add(listener);
+    }
+    offHeadersReceived(listener) {
+        this.headersListeners.delete(listener);
+    }
+    emitProgress(payload) {
+        this.progressListeners.forEach(listener => listener(payload));
+    }
+    emitHeaders(payload) {
+        this.headersListeners.forEach(listener => listener(payload));
+    }
+    then(onfulfilled, onrejected) {
+        return this.promise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.promise.catch(onrejected);
+    }
+}
+export function createHostTask(apiName, payload, options) {
+    const version = options?.version ?? '1.0';
+    const timeoutMs = options?.timeoutMs ?? 15000;
+    let stopResultListener = () => { };
+    let stopProgressListener = () => { };
+    let stopHeadersListener = () => { };
+    let startedTaskId = null;
+    function cleanup() {
+        stopResultListener();
+        stopProgressListener();
+        stopHeadersListener();
+    }
+    const startTask = invokeHostApi(`${apiName}.start`, payload, version, timeoutMs);
+    const promise = startTask.then(({ taskId }) => new Promise((resolve, reject) => {
+        startedTaskId = taskId;
+        stopResultListener = addHostApiEventListener(apiName, 'task.result', resultPayload => {
+            cleanup();
+            if (isRecord(resultPayload) &&
+                typeof resultPayload.ok === 'boolean') {
+                const result = resultPayload;
+                if (result.ok) {
+                    resolve(result.data);
+                    return;
+                }
+                reject(createHostApiError(apiName, result.error));
+                return;
+            }
+            resolve(resultPayload);
+        }, message => message.taskId === taskId);
+        stopProgressListener = addHostApiEventListener(apiName, 'task.progress', progressPayload => {
+            task.emitProgress(progressPayload);
+        }, message => message.taskId === taskId);
+        stopHeadersListener = addHostApiEventListener(apiName, 'task.headers', headersPayload => {
+            task.emitHeaders(headersPayload);
+        }, message => message.taskId === taskId);
+    }));
+    const task = new HostTaskImpl(promise, async () => {
+        cleanup();
+        const taskId = startedTaskId ??
+            (await startTask.then(result => result.taskId, () => null));
+        if (!taskId) {
+            return;
+        }
+        await invokeHostApi(`${apiName}.abort`, {
+            taskId,
+        }, version, timeoutMs);
+    }, cleanup);
+    return task;
+}

package/dist/scanCode/contract.d.ts

@@ -0,0 +1,7 @@
+import { ScanCodeError } from './types';
+import type { ScanCodeCapabilityName, ScanCodeCapabilityVersion, ScanCodeErrorCode } from './types';
+export declare const SCAN_CODE_CAPABILITY_NAME: ScanCodeCapabilityName;
+export declare const SCAN_CODE_CAPABILITY_VERSION: ScanCodeCapabilityVersion;
+export declare const SCAN_CODE_DEFAULT_TYPES: readonly ["qr", "ean-13", "code-128"];
+export declare const SCAN_CODE_MINIMUM_HOST_BRIDGE_VERSION = "1.0";
+export declare function createScanCodeError(code: ScanCodeErrorCode, message: string): ScanCodeError;

package/dist/scanCode/contract.js

@@ -0,0 +1,8 @@
+import { ScanCodeError } from './types';
+export const SCAN_CODE_CAPABILITY_NAME = 'scanCode';
+export const SCAN_CODE_CAPABILITY_VERSION = '1.0';
+export const SCAN_CODE_DEFAULT_TYPES = ['qr', 'ean-13', 'code-128'];
+export const SCAN_CODE_MINIMUM_HOST_BRIDGE_VERSION = '1.0';
+export function createScanCodeError(code, message) {
+    return new ScanCodeError(code, message);
+}

package/dist/scanCode/index.d.ts

@@ -0,0 +1,6 @@
+import type { ScanCodeData, ScanCodeOptions, ScanCodeResult } from './types';
+export type { ScanCodeCapabilityName, ScanCodeCapabilityVersion, ScanCodeData, ScanCodeErrorCode, ScanCodeFailureResult, ScanCodeOptions, ScanCodeResult, ScanCodeSuccessResult, } from './types';
+export { ScanCodeError } from './types';
+export { SCAN_CODE_CAPABILITY_NAME, SCAN_CODE_CAPABILITY_VERSION, SCAN_CODE_DEFAULT_TYPES, SCAN_CODE_MINIMUM_HOST_BRIDGE_VERSION, } from './contract';
+export declare function scanCode(options?: ScanCodeOptions): Promise<ScanCodeData>;
+export declare function scanCodeSafe(options?: ScanCodeOptions): Promise<ScanCodeResult>;

package/dist/scanCode/index.js

@@ -0,0 +1,72 @@
+import { Miniapp } from '@nebula-rn/sdk';
+import { createScanCodeError, SCAN_CODE_CAPABILITY_NAME, SCAN_CODE_CAPABILITY_VERSION, } from './contract';
+export { ScanCodeError } from './types';
+export { SCAN_CODE_CAPABILITY_NAME, SCAN_CODE_CAPABILITY_VERSION, SCAN_CODE_DEFAULT_TYPES, SCAN_CODE_MINIMUM_HOST_BRIDGE_VERSION, } from './contract';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function toScanCodeErrorCode(code) {
+    switch (code) {
+        case 'PERMISSION_DENIED':
+        case 'USER_CANCELLED':
+        case 'UNSUPPORTED_SOURCE':
+        case 'SCAN_FAILED':
+            return code;
+        default:
+            return 'SCAN_FAILED';
+    }
+}
+function toScanCodeFailureResult(error) {
+    if (isRecord(error)) {
+        return {
+            ok: false,
+            error: createScanCodeError(toScanCodeErrorCode(error.code), typeof error.message === 'string'
+                ? error.message
+                : 'scanCode:fail host request failed'),
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            ok: false,
+            error: createScanCodeError('SCAN_FAILED', error.message),
+        };
+    }
+    return {
+        ok: false,
+        error: createScanCodeError('SCAN_FAILED', 'scanCode:fail unknown host error'),
+    };
+}
+function toScanCodeSuccessResult(data) {
+    if (!isRecord(data)) {
+        return {
+            ok: false,
+            error: createScanCodeError('SCAN_FAILED', 'scanCode:fail invalid host response'),
+        };
+    }
+    return {
+        ok: true,
+        data: {
+            result: typeof data.result === 'string' ? data.result : undefined,
+            scanType: typeof data.scanType === 'string' ? data.scanType : 'unknown',
+            rawData: data.rawData,
+        },
+    };
+}
+export async function scanCode(options = {}) {
+    const result = await scanCodeSafe(options);
+    if (!result.ok) {
+        throw result.error;
+    }
+    return result.data;
+}
+export async function scanCodeSafe(options = {}) {
+    try {
+        const result = await Miniapp.invokeHostApi(SCAN_CODE_CAPABILITY_NAME, options, SCAN_CODE_CAPABILITY_VERSION, 120000);
+        return result.ok
+            ? toScanCodeSuccessResult(result.data)
+            : toScanCodeFailureResult(result.error);
+    }
+    catch (error) {
+        return toScanCodeFailureResult(error);
+    }
+}

package/dist/scanCode/types.d.ts

@@ -0,0 +1,25 @@
+export type ScanCodeCapabilityName = 'scanCode';
+export type ScanCodeCapabilityVersion = '1.0';
+export type ScanCodeErrorCode = 'PERMISSION_DENIED' | 'USER_CANCELLED' | 'UNSUPPORTED_SOURCE' | 'SCAN_FAILED';
+export interface ScanCodeOptions {
+    scanType?: string[];
+    onlyFromCamera?: boolean;
+}
+export interface ScanCodeData {
+    result: string | undefined;
+    scanType: string | 'unknown';
+    rawData?: unknown;
+}
+export interface ScanCodeSuccessResult {
+    ok: true;
+    data: ScanCodeData;
+}
+export interface ScanCodeFailureResult {
+    ok: false;
+    error: ScanCodeError;
+}
+export type ScanCodeResult = ScanCodeSuccessResult | ScanCodeFailureResult;
+export declare class ScanCodeError extends Error {
+    readonly code: ScanCodeErrorCode;
+    constructor(code: ScanCodeErrorCode, message: string);
+}

package/dist/scanCode/types.js

@@ -0,0 +1,8 @@
+export class ScanCodeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ScanCodeError';
+        this.code = code;
+    }
+}

package/dist/sensors.d.ts

@@ -0,0 +1,13 @@
+export interface SensorData {
+    x: number;
+    y: number;
+    z: number;
+    timestamp?: number;
+}
+export interface BarometerData {
+    pressure: number;
+}
+export declare const onAccelerometerChange: (callback: (data: SensorData) => void, interval?: number) => () => Promise<void>;
+export declare const onGyroscopeChange: (callback: (data: SensorData) => void, interval?: number) => () => Promise<void>;
+export declare const onMagnetometerChange: (callback: (data: SensorData) => void, interval?: number) => () => Promise<void>;
+export declare const onBarometerChange: (callback: (data: BarometerData) => void) => () => Promise<void>;

package/dist/sensors.js

@@ -0,0 +1,15 @@
+import { subscribeToHostEvent } from './runtime/host';
+function createSensorSubscription(apiName, callback, payload) {
+    let unsubscribePromise = null;
+    const handle = subscribeToHostEvent(apiName, payload, callback);
+    return () => {
+        if (!unsubscribePromise) {
+            unsubscribePromise = handle.then(subscription => subscription.unsubscribe());
+        }
+        return unsubscribePromise;
+    };
+}
+export const onAccelerometerChange = (callback, interval = 100) => createSensorSubscription('accelerometerChange', callback, { interval });
+export const onGyroscopeChange = (callback, interval = 100) => createSensorSubscription('gyroscopeChange', callback, { interval });
+export const onMagnetometerChange = (callback, interval = 100) => createSensorSubscription('magnetometerChange', callback, { interval });
+export const onBarometerChange = (callback) => createSensorSubscription('barometerChange', callback, {});

package/dist/setClipboardData/index.d.ts

@@ -0,0 +1 @@
+export declare const setClipboardData: (data: string) => Promise<void>;

package/dist/setClipboardData/index.js

@@ -0,0 +1,2 @@
+import { invokeHostApi } from '../runtime/host';
+export const setClipboardData = (data) => invokeHostApi('setClipboardData', { data });

package/dist/setStorage/index.d.ts

@@ -0,0 +1,5 @@
+export interface SetStorageOption {
+    key: string;
+    data: unknown;
+}
+export declare const setStorage: (options: SetStorageOption) => Promise<void>;

package/dist/setStorage/index.js

@@ -0,0 +1,5 @@
+import { setStorageItem } from '../storage';
+export const setStorage = (options) => {
+    const { key, data } = options;
+    return setStorageItem(key, data);
+};

package/dist/storage.d.ts

@@ -0,0 +1,9 @@
+export declare const storage: null;
+export declare function serializeStorageValue(data: unknown): string;
+export declare function deserializeStorageValue<T = unknown>(data: string): T;
+export declare function setStorageItem(key: string, data: unknown): Promise<void>;
+export declare function getStorageItem(key: string): Promise<string | undefined>;
+export declare function removeStorageItem(key: string): Promise<void>;
+export declare function clearStorageItems(): Promise<void>;
+export declare function getStorageKeys(): Promise<string[]>;
+export declare function getStorageCurrentSize(): Promise<number>;

package/dist/storage.js

@@ -0,0 +1,36 @@
+import { invokeHostApi } from './runtime/host';
+export const storage = null;
+export function serializeStorageValue(data) {
+    return JSON.stringify(data);
+}
+export function deserializeStorageValue(data) {
+    return JSON.parse(data);
+}
+export function setStorageItem(key, data) {
+    return invokeHostApi('storage.setItem', {
+        key,
+        data: serializeStorageValue(data),
+    });
+}
+export async function getStorageItem(key) {
+    const result = await invokeHostApi('storage.getItem', {
+        key,
+    });
+    return result.value ?? undefined;
+}
+export function removeStorageItem(key) {
+    return invokeHostApi('storage.removeItem', {
+        key,
+    });
+}
+export function clearStorageItems() {
+    return invokeHostApi('storage.clearItems');
+}
+export async function getStorageKeys() {
+    const result = await invokeHostApi('storage.getKeys');
+    return result.keys;
+}
+export async function getStorageCurrentSize() {
+    const result = await invokeHostApi('storage.getCurrentSize');
+    return result.size;
+}

package/dist/uploadFile/index.d.ts

@@ -0,0 +1,30 @@
+export interface UploadFileOption {
+    url: string;
+    filePath: string;
+    name: string;
+    header?: Record<string, string>;
+    formData?: Record<string, string>;
+    timeout?: number;
+}
+export interface UploadFileResult {
+    data: string;
+    statusCode: number;
+}
+export interface UploadProgressUpdateRes {
+    progress: number;
+    totalBytesSent: number;
+    totalBytesExpectedToSend: number;
+}
+export interface UploadHeadersReceivedRes {
+    header: Record<string, string>;
+}
+export interface UploadTask {
+    abort(): Promise<void>;
+    onProgressUpdate(listener: (res: UploadProgressUpdateRes) => void): void;
+    offProgressUpdate(listener: (res: UploadProgressUpdateRes) => void): void;
+    onHeadersReceived(listener: (res: UploadHeadersReceivedRes) => void): void;
+    offHeadersReceived(listener: (res: UploadHeadersReceivedRes) => void): void;
+    then<TResult1 = UploadFileResult, TResult2 = never>(onfulfilled?: ((value: UploadFileResult) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<UploadFileResult | TResult>;
+}
+export declare const uploadFile: (options: UploadFileOption) => UploadTask;