@nebula-rn/client 0.0.1

package/dist/chooseMedia/index.d.ts

@@ -0,0 +1,22 @@
+export interface ChooseMediaFile {
+    tempFilePath: string;
+    size: number;
+    duration?: number;
+    height?: number;
+    width?: number;
+    thumbTempFilePath?: string;
+    fileType: 'image' | 'video';
+}
+export interface ChooseMediaResult {
+    tempFiles: ChooseMediaFile[];
+    type: 'image' | 'video' | 'mix';
+}
+export interface ChooseMediaOption {
+    count?: number;
+    mediaType?: ('image' | 'video' | 'mix')[];
+    sourceType?: ('album' | 'camera')[];
+    maxDuration?: number;
+    sizeType?: ('original' | 'compressed')[];
+    camera?: 'back' | 'front';
+}
+export declare const chooseMedia: (options?: ChooseMediaOption) => Promise<ChooseMediaResult>;

package/dist/chooseMedia/index.js

@@ -0,0 +1,4 @@
+import { invokeHostApi } from '../runtime/host';
+export const chooseMedia = (options = {}) => {
+    return invokeHostApi('chooseMedia', options, '1.0', 120000);
+};

package/dist/compressImage/index.d.ts

@@ -0,0 +1,7 @@
+export interface CompressImageOption {
+    src: string;
+    quality?: number;
+    compressedWidth?: number;
+    compressedHeight?: number;
+}
+export declare const compressImage: (options: CompressImageOption) => Promise<string>;

package/dist/compressImage/index.js

@@ -0,0 +1,4 @@
+import { invokeHostApi } from '../runtime/host';
+export const compressImage = (options) => {
+    return invokeHostApi('compressImage', options);
+};

package/dist/descriptions.d.ts

@@ -0,0 +1,9 @@
+import type { NebulaHostApiDescription, NebulaHostApiDescriptionMap } from '@nebula-rn/sdk';
+export type NebulaPublicApiDescription = NebulaHostApiDescription & {
+    kind?: 'api' | 'manager' | 'subscription' | 'task' | 'utility';
+    methods?: Record<string, NebulaHostApiDescription>;
+};
+export type NebulaPublicApiDescriptionMap = Record<string, NebulaPublicApiDescription>;
+export declare const nebulaApiDescriptions: NebulaPublicApiDescriptionMap;
+export declare function getNebulaApiDescriptions(): NebulaPublicApiDescriptionMap;
+export declare function getHostApiDescriptions(timeoutMs?: number): Promise<NebulaHostApiDescriptionMap>;

package/dist/descriptions.js

@@ -0,0 +1,259 @@
+import { Miniapp } from '@nebula-rn/sdk';
+export const nebulaApiDescriptions = {
+    chooseMedia: {
+        summary: 'Open the host media picker and return selected image or video assets.',
+        kind: 'api',
+        tags: ['media', 'picker'],
+    },
+    compressImage: {
+        summary: 'Resize and compress an image through the host runtime.',
+        kind: 'api',
+        tags: ['media', 'image'],
+    },
+    downloadFile: {
+        summary: 'Start a host-managed download task with progress and abort support.',
+        kind: 'task',
+        tags: ['file', 'network'],
+    },
+    uploadFile: {
+        summary: 'Start a host-managed upload task with progress and abort support.',
+        kind: 'task',
+        tags: ['file', 'network'],
+    },
+    getAppBaseInfo: {
+        summary: 'Return basic host app information for the current miniapp runtime.',
+        kind: 'api',
+        tags: ['device', 'app'],
+    },
+    getClipboardData: {
+        summary: 'Read plain text from the system clipboard.',
+        kind: 'api',
+        tags: ['clipboard'],
+    },
+    getFileInfo: {
+        summary: 'Read size and digest information for a file path.',
+        kind: 'api',
+        tags: ['file'],
+    },
+    getFileSystemManager: {
+        summary: 'Return a file system manager bound to host-backed file APIs.',
+        kind: 'manager',
+        tags: ['file'],
+        methods: {
+            access: {
+                summary: 'Check whether a path exists and is accessible.',
+                tags: ['file'],
+            },
+            appendFile: {
+                summary: 'Append text data to a file path.',
+                tags: ['file'],
+            },
+            saveFile: {
+                summary: 'Persist a temp file into the miniapp sandbox.',
+                tags: ['file'],
+            },
+            copyFile: {
+                summary: 'Copy a file from one path to another.',
+                tags: ['file'],
+            },
+            mkdir: {
+                summary: 'Create a directory path recursively.',
+                tags: ['file'],
+            },
+            readFile: {
+                summary: 'Read a file as text with optional encoding.',
+                tags: ['file'],
+            },
+            readdir: {
+                summary: 'List child entries in a directory.',
+                tags: ['file'],
+            },
+            rename: {
+                summary: 'Rename or move a file or directory.',
+                tags: ['file'],
+            },
+            rmdir: {
+                summary: 'Remove a directory path recursively.',
+                tags: ['file'],
+            },
+            unlink: {
+                summary: 'Delete a file path.',
+                tags: ['file'],
+            },
+            writeFile: {
+                summary: 'Write text data to a file path.',
+                tags: ['file'],
+            },
+            getFileInfo: {
+                summary: 'Read file stat information for a sandbox path.',
+                tags: ['file'],
+            },
+        },
+    },
+    getImageInfo: {
+        summary: 'Read width, height, and metadata information for an image source.',
+        kind: 'api',
+        tags: ['media', 'image'],
+    },
+    getLocation: {
+        summary: 'Get the current device location once.',
+        description: 'The host may request runtime location permission before resolving.',
+        kind: 'api',
+        tags: ['location'],
+    },
+    getScreenBrightness: {
+        summary: 'Read the current screen brightness reported by the device.',
+        kind: 'api',
+        tags: ['device'],
+    },
+    getStorage: {
+        summary: 'Read a JSON-serializable value from host-backed key-value storage.',
+        kind: 'api',
+        tags: ['storage'],
+    },
+    getStorageInfo: {
+        summary: 'Read host-backed storage usage and key information.',
+        kind: 'api',
+        tags: ['storage'],
+    },
+    getSystemInfo: {
+        summary: 'Return device, screen, and safe-area information for layout and diagnostics.',
+        kind: 'api',
+        tags: ['device', 'layout'],
+    },
+    onLocationChange: {
+        summary: 'Subscribe to host location change events.',
+        kind: 'subscription',
+        tags: ['location', 'subscription'],
+    },
+    makePhoneCall: {
+        summary: 'Open the system dialer for a phone number.',
+        kind: 'api',
+        tags: ['device', 'communication'],
+    },
+    getMiniAppUpdateInfo: {
+        summary: 'Read the installed miniapp version, update strategy, and whether a newer remote version exists.',
+        kind: 'api',
+        tags: ['miniapp', 'update'],
+    },
+    applyMiniAppUpdate: {
+        summary: 'Install the newest available bundle for the current miniapp and return the updated version state.',
+        kind: 'api',
+        tags: ['miniapp', 'update'],
+    },
+    saveMedia: {
+        summary: 'Save a photo or video into the system media library.',
+        kind: 'api',
+        tags: ['media'],
+    },
+    getNetworkType: {
+        summary: 'Read the current network connection type and connectivity state.',
+        kind: 'api',
+        tags: ['network'],
+    },
+    onNetworkStatusChange: {
+        summary: 'Subscribe to host network status change events.',
+        kind: 'subscription',
+        tags: ['network', 'subscription'],
+    },
+    onUserCaptureScreen: {
+        summary: 'Subscribe to host screenshot capture events.',
+        kind: 'subscription',
+        tags: ['device', 'subscription'],
+    },
+    previewImage: {
+        summary: 'Open a host-managed fullscreen image preview modal for one or more image URLs.',
+        kind: 'api',
+        tags: ['media', 'image', 'modal'],
+    },
+    scanCode: {
+        summary: 'Open a host-managed scanner modal and return the first detected barcode or QR code.',
+        kind: 'api',
+        tags: ['camera', 'scanner', 'modal'],
+    },
+    scanCodeSafe: {
+        summary: 'Open the host scanner modal and always resolve with an ok/error result object.',
+        kind: 'api',
+        tags: ['camera', 'scanner', 'modal'],
+    },
+    onAccelerometerChange: {
+        summary: 'Subscribe to host accelerometer events.',
+        kind: 'subscription',
+        tags: ['sensor', 'subscription'],
+    },
+    onGyroscopeChange: {
+        summary: 'Subscribe to host gyroscope events.',
+        kind: 'subscription',
+        tags: ['sensor', 'subscription'],
+    },
+    onMagnetometerChange: {
+        summary: 'Subscribe to host magnetometer events.',
+        kind: 'subscription',
+        tags: ['sensor', 'subscription'],
+    },
+    onBarometerChange: {
+        summary: 'Subscribe to host barometer events.',
+        kind: 'subscription',
+        tags: ['sensor', 'subscription'],
+    },
+    setClipboardData: {
+        summary: 'Write plain text to the system clipboard.',
+        kind: 'api',
+        tags: ['clipboard'],
+    },
+    setStorage: {
+        summary: 'Persist a JSON-serializable value in host-backed key-value storage.',
+        kind: 'api',
+        tags: ['storage'],
+    },
+    storage: {
+        summary: 'Low-level storage helpers for host-backed key-value access and serialization.',
+        kind: 'utility',
+        tags: ['storage'],
+        methods: {
+            serializeStorageValue: {
+                summary: 'Serialize a JSON-serializable value before writing to storage.',
+                tags: ['storage'],
+            },
+            deserializeStorageValue: {
+                summary: 'Deserialize a stored JSON string into a typed value.',
+                tags: ['storage'],
+            },
+            setStorageItem: {
+                summary: 'Persist a raw storage item by key.',
+                tags: ['storage'],
+            },
+            getStorageItem: {
+                summary: 'Read a raw storage item by key.',
+                tags: ['storage'],
+            },
+            removeStorageItem: {
+                summary: 'Remove a raw storage item by key.',
+                tags: ['storage'],
+            },
+            clearStorageItems: {
+                summary: 'Clear all host-backed storage entries.',
+                tags: ['storage'],
+            },
+            getStorageKeys: {
+                summary: 'List all keys in host-backed storage.',
+                tags: ['storage'],
+            },
+            getStorageCurrentSize: {
+                summary: 'Return the approximate storage size in KB.',
+                tags: ['storage'],
+            },
+        },
+    },
+    removeFile: {
+        summary: 'Remove a file from the miniapp sandbox.',
+        kind: 'api',
+        tags: ['file'],
+    },
+};
+export function getNebulaApiDescriptions() {
+    return nebulaApiDescriptions;
+}
+export function getHostApiDescriptions(timeoutMs = 15000) {
+    return Miniapp.getHostApiDescriptions(timeoutMs);
+}

package/dist/file.d.ts

@@ -0,0 +1,51 @@
+export interface HeadersRes {
+    header: Record<string, string>;
+}
+export interface Task<T, P> {
+    abort(): Promise<void>;
+    onProgressUpdate(listener: (res: P) => void): void;
+    offProgressUpdate(listener: (res: P) => void): void;
+    onHeadersReceived(listener: (res: HeadersRes) => void): void;
+    offHeadersReceived(listener: (res: HeadersRes) => void): void;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+}
+export interface DownloadProgressRes {
+    progress: number;
+    totalBytesWritten: number;
+    totalBytesExpectedToWrite: number;
+}
+export interface DownloadFileResult {
+    tempFilePath: string;
+    statusCode: number;
+}
+export interface DownloadFileOption {
+    url: string;
+    header?: Record<string, string>;
+    timeout?: number;
+    filePath?: string;
+}
+export type DownloadTask = Task<DownloadFileResult, DownloadProgressRes>;
+export declare const downloadFile: (options: DownloadFileOption) => DownloadTask;
+export interface UploadProgressRes {
+    progress: number;
+    totalBytesSent: number;
+    totalBytesExpectedToSend: number;
+}
+export interface UploadFileResult {
+    data: string;
+    statusCode: number;
+}
+export interface UploadFileOption {
+    url: string;
+    filePath: string;
+    name: string;
+    header?: Record<string, string>;
+    formData?: Record<string, string>;
+}
+export type UploadTask = Task<UploadFileResult, UploadProgressRes>;
+export declare const uploadFile: (options: UploadFileOption) => UploadTask;
+export interface RemoveFileOption {
+    filePath: string;
+}
+export declare const removeFile: (options: RemoveFileOption) => Promise<void>;

package/dist/file.js

@@ -0,0 +1,14 @@
+import { createHostTask, invokeHostApi } from './runtime/host';
+export const downloadFile = (options) => {
+    return createHostTask('downloadFile', options, {
+        timeoutMs: 60000,
+    });
+};
+export const uploadFile = (options) => {
+    return createHostTask('uploadFile', options, {
+        timeoutMs: 60000,
+    });
+};
+export const removeFile = (options) => {
+    return invokeHostApi('removeFile', options);
+};

package/dist/getAppBaseInfo/index.d.ts

@@ -0,0 +1,6 @@
+export declare function getAppBaseInfo(): Promise<{
+    version: string;
+    language: string;
+    enableDebug: boolean;
+    theme: string;
+}>;

package/dist/getAppBaseInfo/index.js

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

package/dist/getClipboardData/index.d.ts

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

package/dist/getClipboardData/index.js

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

package/dist/getFileInfo/index.d.ts

@@ -0,0 +1,9 @@
+export interface GetFileInfoOption {
+    filePath: string;
+    digestAlgorithm?: 'md5' | 'sha1' | 'sha256';
+}
+export interface GetFileInfoResult {
+    size: number;
+    digest: string;
+}
+export declare const getFileInfo: (options: GetFileInfoOption) => Promise<GetFileInfoResult>;

package/dist/getFileInfo/index.js

@@ -0,0 +1,4 @@
+import { invokeHostApi } from '../runtime/host';
+export const getFileInfo = (options) => {
+    return invokeHostApi('getFileInfo', options);
+};

package/dist/getFileSystemManager/index.d.ts

@@ -0,0 +1,70 @@
+import { GetFileInfoOption, GetFileInfoResult } from '../getFileInfo';
+export interface FileAccessOption {
+    path: string;
+}
+export interface FileAppendOption {
+    filePath: string;
+    data: string;
+    encoding?: 'ascii' | 'base64' | 'utf8';
+}
+export interface FileSaveOption {
+    tempFilePath: string;
+    filePath?: string;
+}
+export interface FileSaveResult {
+    savedFilePath: string;
+}
+export interface FileCopyOption {
+    srcPath: string;
+    destPath: string;
+}
+export interface FileMkdirOption {
+    dirPath: string;
+    recursive?: boolean;
+}
+export interface FileReadOption {
+    filePath: string;
+    encoding?: 'ascii' | 'base64' | 'utf8';
+    position?: number;
+    length?: number;
+}
+export interface FileReadResult {
+    data: string;
+}
+export interface FileReaddirOption {
+    dirPath: string;
+}
+export interface FileReaddirResult {
+    files: string[];
+}
+export interface FileRenameOption {
+    oldPath: string;
+    newPath: string;
+}
+export interface FileRmdirOption {
+    dirPath: string;
+    recursive?: boolean;
+}
+export interface FileUnlinkOption {
+    filePath: string;
+}
+export interface FileWriteOption {
+    filePath: string;
+    data: string;
+    encoding?: 'ascii' | 'base64' | 'utf8';
+}
+export interface FileSystemManager {
+    access(options: FileAccessOption): Promise<void>;
+    appendFile(options: FileAppendOption): Promise<void>;
+    saveFile(options: FileSaveOption): Promise<FileSaveResult>;
+    copyFile(options: FileCopyOption): Promise<void>;
+    mkdir(options: FileMkdirOption): Promise<void>;
+    readFile(options: FileReadOption): Promise<FileReadResult>;
+    readdir(options: FileReaddirOption): Promise<FileReaddirResult>;
+    rename(options: FileRenameOption): Promise<void>;
+    rmdir(options: FileRmdirOption): Promise<void>;
+    unlink(options: FileUnlinkOption): Promise<void>;
+    writeFile(options: FileWriteOption): Promise<void>;
+    getFileInfo(options: GetFileInfoOption): Promise<GetFileInfoResult>;
+}
+export declare const getFileSystemManager: () => FileSystemManager;

package/dist/getFileSystemManager/index.js

@@ -0,0 +1,43 @@
+import { invokeHostApi } from '../runtime/host';
+class FileSystemManagerImpl {
+    access(options) {
+        return invokeHostApi('fileSystem.access', options);
+    }
+    appendFile(options) {
+        return invokeHostApi('fileSystem.appendFile', options);
+    }
+    saveFile(options) {
+        return invokeHostApi('fileSystem.saveFile', options);
+    }
+    copyFile(options) {
+        return invokeHostApi('fileSystem.copyFile', options);
+    }
+    mkdir(options) {
+        return invokeHostApi('fileSystem.mkdir', options);
+    }
+    readFile(options) {
+        return invokeHostApi('fileSystem.readFile', options);
+    }
+    readdir(options) {
+        return invokeHostApi('fileSystem.readdir', options);
+    }
+    rename(options) {
+        return invokeHostApi('fileSystem.rename', options);
+    }
+    rmdir(options) {
+        return invokeHostApi('fileSystem.rmdir', options);
+    }
+    unlink(options) {
+        return invokeHostApi('fileSystem.unlink', options);
+    }
+    writeFile(options) {
+        return invokeHostApi('fileSystem.writeFile', options);
+    }
+    getFileInfo(options) {
+        return invokeHostApi('fileSystem.getFileInfo', options);
+    }
+}
+const fileSystemManager = new FileSystemManagerImpl();
+export const getFileSystemManager = () => {
+    return fileSystemManager;
+};

package/dist/getImageInfo/index.d.ts

@@ -0,0 +1,16 @@
+type GetImageInfoOption = {
+    src: string;
+    success?: (res: Record<string, unknown>) => void;
+    fail?: (res: Record<string, unknown>) => void;
+    complete?: (res: Record<string, unknown>) => void;
+};
+type GetImageInfoSuccessResult = {
+    width: number;
+    height: number;
+    path: string;
+    orientation: string;
+    type: string;
+    errMsg: string;
+};
+export declare function getImageInfo(option: GetImageInfoOption): Promise<GetImageInfoSuccessResult>;
+export {};

package/dist/getImageInfo/index.js

@@ -0,0 +1,20 @@
+import { invokeHostApi } from '../runtime/host';
+export function getImageInfo(option) {
+    const { src, success, fail, complete } = option;
+    return invokeHostApi('getImageInfo', {
+        src,
+    })
+        .then(res => {
+        success?.(res);
+        complete?.(res);
+        return res;
+    })
+        .catch(error => {
+        const res = {
+            errMsg: error instanceof Error ? error.message : 'getImageInfo:fail',
+        };
+        fail?.(res);
+        complete?.(res);
+        throw res;
+    });
+}

package/dist/getLocation/index.d.ts

@@ -0,0 +1,15 @@
+export interface GetLocationOption {
+    altitude?: boolean;
+    isHighAccuracy?: boolean;
+    highAccuracyExpireTime?: number;
+}
+export interface GetLocationResult {
+    latitude: number;
+    longitude: number;
+    speed: number;
+    accuracy: number;
+    altitude: number;
+    verticalAccuracy: number;
+    horizontalAccuracy: number;
+}
+export declare const getLocation: (options?: GetLocationOption) => Promise<GetLocationResult>;

package/dist/getLocation/index.js

@@ -0,0 +1,4 @@
+import { invokeHostApi } from '../runtime/host';
+export const getLocation = (options = {}) => {
+    return invokeHostApi('getLocation', options);
+};

package/dist/getScreenBrightness/index.d.ts

@@ -0,0 +1 @@
+export declare const getScreenBrightness: () => Promise<number>;

package/dist/getScreenBrightness/index.js

@@ -0,0 +1,4 @@
+import { invokeHostApi } from '../runtime/host';
+export const getScreenBrightness = () => {
+    return invokeHostApi('getScreenBrightness');
+};

package/dist/getStorage/index.d.ts

@@ -0,0 +1 @@
+export declare const getStorage: <T>(key: string) => Promise<T>;

package/dist/getStorage/index.js

@@ -0,0 +1,8 @@
+import { deserializeStorageValue, getStorageItem } from '../storage';
+export const getStorage = async (key) => {
+    const data = await getStorageItem(key);
+    if (data !== undefined && data !== null) {
+        return deserializeStorageValue(data);
+    }
+    throw new Error('getStorage:fail data not found');
+};

package/dist/getStorageInfo/index.d.ts

@@ -0,0 +1,6 @@
+export interface GetStorageInfoResult {
+    keys: string[];
+    currentSize: number;
+    limitSize: number;
+}
+export declare const getStorageInfo: () => Promise<GetStorageInfoResult>;

package/dist/getStorageInfo/index.js

@@ -0,0 +1,12 @@
+import { getStorageCurrentSize, getStorageKeys } from '../storage';
+export const getStorageInfo = async () => {
+    const [keys, currentSize] = await Promise.all([
+        getStorageKeys(),
+        getStorageCurrentSize(),
+    ]);
+    return {
+        keys,
+        currentSize,
+        limitSize: 10240,
+    };
+};

package/dist/getSystemInfo/index.d.ts

@@ -0,0 +1 @@
+export declare function getSystemInfo(): Promise<Record<string, unknown>>;

package/dist/getSystemInfo/index.js

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