@nebula-rn/sdk 0.0.1

package/dist/miniappRuntime.js

@@ -0,0 +1,233 @@
+import { addNebulaEventListener, getNebulaNativeModule, isProtocolResponse, NEBULA_MINI_APP_MESSAGE_EVENT, NEBULA_PAGE_LIFECYCLE_EVENT, } from './nebulaNative';
+let currentMiniAppId = null;
+let miniAppProtocolListening = false;
+const pendingProtocolRequests = new Map();
+export function compareCapabilityVersions(left, right) {
+    const leftParts = left.split('.').map(part => Number(part) || 0);
+    const rightParts = right.split('.').map(part => Number(part) || 0);
+    const maxLength = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftPart = leftParts[index] ?? 0;
+        const rightPart = rightParts[index] ?? 0;
+        if (leftPart > rightPart) {
+            return 1;
+        }
+        if (leftPart < rightPart) {
+            return -1;
+        }
+    }
+    return 0;
+}
+function createProtocolRequestId() {
+    return `nebula-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function ensureMiniAppProtocolListener() {
+    if (miniAppProtocolListening) {
+        return;
+    }
+    const unsubscribe = addNebulaEventListener(NEBULA_MINI_APP_MESSAGE_EVENT, (event) => {
+        const message = event.message;
+        if (!isProtocolResponse(message)) {
+            return;
+        }
+        const pending = pendingProtocolRequests.get(message.requestId);
+        if (!pending) {
+            console.warn('[NebulaMiniAppAPI] missing pending request', {
+                kind: message.kind,
+                requestId: message.requestId,
+                pendingRequestIds: Array.from(pendingProtocolRequests.keys()),
+            });
+            return;
+        }
+        clearTimeout(pending.timeoutId);
+        pendingProtocolRequests.delete(message.requestId);
+        if (message.kind === 'capabilities') {
+            pending.resolve(message.data);
+            return;
+        }
+        if (message.kind === 'apiDescriptions') {
+            pending.resolve(message.data);
+            return;
+        }
+        if (message.kind === 'invokeResult') {
+            pending.resolve(message.result);
+        }
+    });
+    if (!unsubscribe) {
+        return;
+    }
+    miniAppProtocolListening = true;
+}
+export class Miniapp {
+    static bootstrap(appId) {
+        if (typeof appId === 'string' && appId.length > 0) {
+            currentMiniAppId = appId;
+            globalThis.__nebulaCurrentAppId = appId;
+        }
+    }
+    static async navigateTo(url) {
+        return getNebulaNativeModule().navigateTo(currentMiniAppId || '', url);
+    }
+    static async redirectTo(url) {
+        return getNebulaNativeModule().redirectTo(currentMiniAppId || '', url);
+    }
+    static async reLaunch(url) {
+        return getNebulaNativeModule().reLaunch(currentMiniAppId || '', url);
+    }
+    static async navigateBack(delta = 1) {
+        return getNebulaNativeModule().navigateBack(currentMiniAppId || '', delta);
+    }
+    static async setPageStyle(style) {
+        return getNebulaNativeModule().setPageStyle(currentMiniAppId || '', style);
+    }
+    static async setNavigationBarTitle(title) {
+        return this.setPageStyle({ navigationBarTitleText: title });
+    }
+    static async setNavigationBarColor(options) {
+        return this.setPageStyle({
+            navigationBarBackgroundColor: options.backgroundColor,
+            navigationBarTextColor: options.frontColor,
+        });
+    }
+    static getDeviceInfo() {
+        return getNebulaNativeModule().getDeviceInfo();
+    }
+    static getAppId() {
+        return currentMiniAppId;
+    }
+    static getSandboxPath() {
+        return `/Documents/MiniApps/${currentMiniAppId || ''}`;
+    }
+    static async showToast(title) {
+        return getNebulaNativeModule().showToast(title);
+    }
+    static async postMessageToHost(message) {
+        return getNebulaNativeModule().postMessageToHost(currentMiniAppId || '', message);
+    }
+    static async bringHostToFront() {
+        return getNebulaNativeModule().bringHostToFront();
+    }
+    static async restoreMiniApp(token) {
+        return getNebulaNativeModule().restoreMiniApp(token);
+    }
+    static async presentHostModal(moduleName, props = {}) {
+        return getNebulaNativeModule().presentHostModal(moduleName, props);
+    }
+    static async dismissHostModal() {
+        return getNebulaNativeModule().dismissHostModal();
+    }
+    static async invokeHostApi(apiName, payload = {}, version = '1.0.0', timeoutMs = 15000) {
+        ensureMiniAppProtocolListener();
+        return new Promise((resolve, reject) => {
+            const requestId = createProtocolRequestId();
+            const timeoutId = timeoutMs > 0
+                ? setTimeout(() => {
+                    console.warn('[NebulaMiniAppAPI] invokeHostApi timeout', {
+                        apiName,
+                        requestId,
+                        pendingRequestIds: Array.from(pendingProtocolRequests.keys()),
+                    });
+                    pendingProtocolRequests.delete(requestId);
+                    reject(new Error(`Timed out waiting for host API: ${apiName}`));
+                }, timeoutMs)
+                : setTimeout(() => { }, 2147483647);
+            pendingProtocolRequests.set(requestId, {
+                resolve,
+                reject,
+                timeoutId,
+            });
+            this.postMessageToHost({
+                __nebulaProtocol: 'api.v1',
+                kind: 'invoke',
+                requestId,
+                api: apiName,
+                version,
+                payload,
+            }).catch(error => {
+                clearTimeout(timeoutId);
+                pendingProtocolRequests.delete(requestId);
+                console.error('[NebulaMiniAppAPI] invokeHostApi postMessageToHost failed', {
+                    apiName,
+                    requestId,
+                    error,
+                });
+                reject(error);
+            });
+        });
+    }
+    static async getCapabilities() {
+        ensureMiniAppProtocolListener();
+        return new Promise((resolve, reject) => {
+            const requestId = createProtocolRequestId();
+            const timeoutId = setTimeout(() => {
+                pendingProtocolRequests.delete(requestId);
+                reject(new Error('Timed out waiting for host capabilities'));
+            }, 15000);
+            pendingProtocolRequests.set(requestId, {
+                resolve,
+                reject,
+                timeoutId,
+            });
+            this.postMessageToHost({
+                __nebulaProtocol: 'api.v1',
+                kind: 'getCapabilities',
+                requestId,
+            }).catch(error => {
+                clearTimeout(timeoutId);
+                pendingProtocolRequests.delete(requestId);
+                reject(error);
+            });
+        });
+    }
+    static async isSupported(apiName, minimumVersion) {
+        const { capabilities } = await this.getCapabilities();
+        const capability = capabilities[apiName];
+        if (!capability?.supported) {
+            return false;
+        }
+        if (!minimumVersion) {
+            return true;
+        }
+        return compareCapabilityVersions(capability.version, minimumVersion) >= 0;
+    }
+    static async getHostApiDescriptions(timeoutMs = 15000) {
+        ensureMiniAppProtocolListener();
+        return new Promise((resolve, reject) => {
+            const requestId = createProtocolRequestId();
+            const timeoutId = setTimeout(() => {
+                pendingProtocolRequests.delete(requestId);
+                reject(new Error('Timed out waiting for host API descriptions'));
+            }, timeoutMs);
+            pendingProtocolRequests.set(requestId, {
+                resolve,
+                reject,
+                timeoutId,
+            });
+            this.postMessageToHost({
+                __nebulaProtocol: 'api.v1',
+                kind: 'getApiDescriptions',
+                requestId,
+            }).catch(error => {
+                clearTimeout(timeoutId);
+                pendingProtocolRequests.delete(requestId);
+                reject(error);
+            });
+        });
+    }
+    static onHostMessage(listener) {
+        const unsubscribe = addNebulaEventListener(NEBULA_MINI_APP_MESSAGE_EVENT, listener);
+        if (!unsubscribe) {
+            console.warn('[Nebula] Native event emitter unavailable for host messages');
+            return () => { };
+        }
+        return unsubscribe;
+    }
+    static onPageLifecycle(listener) {
+        const unsubscribe = addNebulaEventListener(NEBULA_PAGE_LIFECYCLE_EVENT, listener);
+        if (!unsubscribe) {
+            console.warn('[Nebula] Native event emitter unavailable for page lifecycle events');
+            return () => { };
+        }
+        return unsubscribe;
+    }
+}

package/dist/nebulaNative.d.ts

@@ -0,0 +1,12 @@
+import { NativeEventEmitter } from 'react-native';
+import type { BridgeMessage, NebulaNativeModuleType, NebulaProtocolRequest, NebulaProtocolResponse } from './nebulaTypes';
+export declare const nebulaEventEmitter: NativeEventEmitter;
+export declare const NEBULA_HOST_MESSAGE_EVENT = "NebulaHostMessage";
+export declare const NEBULA_MINI_APP_MESSAGE_EVENT = "NebulaMiniAppMessage";
+export declare const NEBULA_PAGE_LIFECYCLE_EVENT = "NebulaPageLifecycle";
+export declare const NEBULA_INTERNAL_MINIAPP_LOADING_MODULE = "NebulaInternalMiniappLoading";
+export declare const PAGE_RESERVED_PROP_KEYS: Set<string>;
+export declare function getNebulaNativeModule(): NebulaNativeModuleType;
+export declare function addNebulaEventListener<TEvent = BridgeMessage>(eventName: string, listener: (event: TEvent) => void): (() => void) | null;
+export declare function isProtocolRequest(message: Record<string, unknown>): message is NebulaProtocolRequest;
+export declare function isProtocolResponse(message: Record<string, unknown>): message is NebulaProtocolResponse;

package/dist/nebulaNative.js

@@ -0,0 +1,49 @@
+import { NativeEventEmitter, NativeModules } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+import NebulaNativeModuleSpec from './specs/NativeNebulaModule';
+const turboNebulaNativeModule = NebulaNativeModuleSpec ??
+    TurboModuleRegistry.get('NebulaNativeModule');
+const { NebulaNativeModule: legacyNebulaNativeModule } = NativeModules;
+const NebulaNativeModule = turboNebulaNativeModule ?? legacyNebulaNativeModule;
+export const nebulaEventEmitter = legacyNebulaNativeModule
+    ? new NativeEventEmitter(legacyNebulaNativeModule)
+    : null;
+export const NEBULA_HOST_MESSAGE_EVENT = 'NebulaHostMessage';
+export const NEBULA_MINI_APP_MESSAGE_EVENT = 'NebulaMiniAppMessage';
+export const NEBULA_PAGE_LIFECYCLE_EVENT = 'NebulaPageLifecycle';
+export const NEBULA_INTERNAL_MINIAPP_LOADING_MODULE = 'NebulaInternalMiniappLoading';
+export const PAGE_RESERVED_PROP_KEYS = new Set([
+    'appId',
+    'instanceId',
+    'sandboxPath',
+    'title',
+    '__pageConfig',
+    '__routePath',
+    '__routeUrl',
+]);
+if (!NebulaNativeModule) {
+    console.warn('[Nebula] NebulaNativeModule not found. Make sure Nebula framework is integrated.');
+}
+export function getNebulaNativeModule() {
+    if (!NebulaNativeModule) {
+        throw new Error('[Nebula] NebulaNativeModule not available');
+    }
+    return NebulaNativeModule;
+}
+export function addNebulaEventListener(eventName, listener) {
+    if (!nebulaEventEmitter) {
+        return null;
+    }
+    const sub = nebulaEventEmitter.addListener(eventName, listener);
+    return () => sub.remove();
+}
+export function isProtocolRequest(message) {
+    return (message.__nebulaProtocol === 'api.v1' &&
+        typeof message.kind === 'string' &&
+        typeof message.requestId === 'string');
+}
+export function isProtocolResponse(message) {
+    return (message.__nebulaProtocol === 'api.v1' &&
+        typeof message.kind === 'string' &&
+        typeof message.requestId === 'string');
+}

package/dist/nebulaTypes.d.ts

@@ -0,0 +1,232 @@
+import type { ReactNode } from 'react';
+import type { TurboModule } from 'react-native';
+import type { NebulaPageStyle } from './specs/NativeNebulaModule';
+export type { MiniAppUpdateStrategy } from './specs/NativeNebulaModule';
+export type { NebulaPageStyle } from './specs/NativeNebulaModule';
+export type { NebulaCapabilitiesResult as NebulaNativeCapabilitiesResult, NebulaCapabilityMap as NebulaNativeCapabilityMap, } from './specs/NativeNebulaModule';
+export type MiniAppResult = {
+    success: boolean;
+    appId: string;
+    mode?: string;
+};
+export type InstalledMiniAppsResult = {
+    apps: string[];
+};
+export type InstalledMiniAppInfo = {
+    appId: string;
+    mode?: string | null;
+    bundlePath?: string | null;
+    sourceUrl?: string | null;
+    version?: string | null;
+    updateStrategy?: 'auto' | 'manual' | null;
+};
+export type InstalledMiniAppInfoResult = {
+    installed: boolean;
+    app?: InstalledMiniAppInfo | null;
+};
+export type MiniAppUpdateInfo = {
+    appId: string;
+    currentVersion?: string | null;
+    latestVersion?: string | null;
+    hasUpdate: boolean;
+    updateStrategy: 'auto' | 'manual';
+    mode?: string | null;
+    sourceUrl?: string | null;
+};
+export type MiniAppVersionType = 'release' | 'experience';
+export type MiniappLoadingStatus = 'installing' | 'loading' | 'ready' | 'error';
+export type MiniappLoadingExtraData = Record<string, unknown>;
+export type MiniappLoadingProps = {
+    appId: string;
+    mode: 'development' | 'production';
+    status: MiniappLoadingStatus;
+    title?: string | null;
+    icon?: ReactNode;
+    extraData?: MiniappLoadingExtraData | null;
+    errorMessage?: string | null;
+};
+export type MiniappLoadingResolveContext = {
+    appId: string;
+    mode: 'development' | 'production';
+    status: MiniappLoadingStatus;
+    title?: string | null;
+    icon?: ReactNode;
+    extraData?: MiniappLoadingExtraData | null;
+    errorMessage?: string | null;
+    installedInfo?: InstalledMiniAppInfo | null;
+};
+export type MiniappLoadingResolvedProps = Partial<Pick<MiniappLoadingProps, 'title' | 'icon' | 'extraData'>>;
+export type ServerBaseURLResult = {
+    serverBaseURL?: string | null;
+};
+export type MiniappLoadingDelayResult = {
+    delayMs: number;
+};
+export type NavigationResult = {
+    errMsg: string;
+};
+export type HostVisibilityResult = {
+    success: boolean;
+    token?: string | null;
+};
+export type RegisteredMiniAppManifest = {
+    entryPagePath?: string;
+    pageConfigs?: Record<string, NebulaPageStyle>;
+    pages: Record<string, string>;
+    updateStrategy?: 'auto' | 'manual';
+    version?: string;
+    window?: NebulaPageStyle;
+};
+export type BridgeMessage = {
+    appId: string;
+    message: Record<string, unknown>;
+    timestamp?: number;
+};
+export type NebulaApiError = {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+};
+export type NebulaApiInvokeResult<T = unknown> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: NebulaApiError;
+};
+export type NebulaHostCapabilityDescriptor = {
+    supported: boolean;
+    version: string;
+};
+export type NebulaHostCapabilityMap = Record<string, NebulaHostCapabilityDescriptor>;
+export type NebulaApiFieldDescriptor = {
+    name: string;
+    type: string;
+    required?: boolean;
+    description: string;
+};
+export type NebulaApiExampleDescriptor = {
+    title: string;
+    code: string;
+};
+export type NebulaHostApiDescription = {
+    summary: string;
+    description?: string;
+    params?: NebulaApiFieldDescriptor[];
+    returns?: {
+        type: string;
+        description: string;
+    };
+    tags?: string[];
+    examples?: NebulaApiExampleDescriptor[];
+};
+export type NebulaHostApiDescriptionMap = Record<string, NebulaHostApiDescription>;
+export type NebulaProtocolRequest = {
+    __nebulaProtocol: 'api.v1';
+    kind: 'getCapabilities';
+    requestId: string;
+} | {
+    __nebulaProtocol: 'api.v1';
+    kind: 'getApiDescriptions';
+    requestId: string;
+} | {
+    __nebulaProtocol: 'api.v1';
+    kind: 'invoke';
+    requestId: string;
+    api: string;
+    version?: string;
+    payload?: Record<string, unknown>;
+};
+export type NebulaProtocolResponse = {
+    __nebulaProtocol: 'api.v1';
+    kind: 'capabilities';
+    requestId: string;
+    data: {
+        bridgeVersion: string;
+        capabilities: NebulaHostCapabilityMap;
+    };
+} | {
+    __nebulaProtocol: 'api.v1';
+    kind: 'apiDescriptions';
+    requestId: string;
+    data: NebulaHostApiDescriptionMap;
+} | {
+    __nebulaProtocol: 'api.v1';
+    kind: 'invokeResult';
+    requestId: string;
+    result: NebulaApiInvokeResult;
+};
+export type NebulaHostApiContext = {
+    appId: string;
+    requestId: string;
+    version?: string;
+};
+export type NebulaHostApiHandler = {
+    version: string;
+    supported?: boolean | (() => boolean | Promise<boolean>);
+    description?: NebulaHostApiDescription;
+    handle: (payload: Record<string, unknown>, context: NebulaHostApiContext) => Promise<NebulaApiInvokeResult> | NebulaApiInvokeResult;
+};
+export type PendingProtocolRequest = {
+    reject: (reason?: unknown) => void;
+    resolve: (value: any) => void;
+    timeoutId: ReturnType<typeof setTimeout>;
+};
+export type PageLifecycleEvent = {
+    appId: string;
+    instanceId: string;
+    routePath?: string;
+    type: 'show' | 'hide' | 'unload' | 'ready';
+};
+export type MiniAppPageContextValue = {
+    appId: string | null;
+    instanceId: string | null;
+    params: Record<string, unknown>;
+    routePath: string;
+    routeUrl: string;
+    pageStyle: Record<string, unknown>;
+};
+export type NebulaNativeModuleType = TurboModule & {
+    openMiniApp: (appId: string, initialProps: Record<string, unknown>) => Promise<MiniAppResult>;
+    openMiniAppWithBundleURL: (appId: string, bundleURL: string, connectToURLMetroServer: boolean, initialProps: Record<string, unknown>) => Promise<MiniAppResult>;
+    preloadMiniApp: (appId: string) => Promise<MiniAppResult>;
+    preloadMiniAppWithBundleURL: (appId: string, bundleURL: string, connectToURLMetroServer: boolean) => Promise<MiniAppResult>;
+    installMiniApp: (appId: string, bundleURL: string) => Promise<MiniAppResult>;
+    installMiniAppWithBundleURL: (appId: string, bundleURL: string, connectToURLMetroServer: boolean) => Promise<MiniAppResult>;
+    installMiniAppFromURLs: (appId: string, bundleURL: string, manifestURL: string, assetsURL: string, connectToURLMetroServer: boolean) => Promise<MiniAppResult>;
+    closeMiniApp: (appId: string) => Promise<MiniAppResult>;
+    uninstallMiniApp: (appId: string) => Promise<MiniAppResult>;
+    getCapabilities: () => Promise<{
+        bridgeVersion: string;
+        capabilities: Record<string, string>;
+    }>;
+    getServerBaseURL: () => Promise<ServerBaseURLResult>;
+    setServerBaseURL: (serverBaseURL?: string | null) => Promise<ServerBaseURLResult>;
+    setMiniappLoadingDelay: (delayMs?: number | null) => Promise<MiniappLoadingDelayResult>;
+    setMiniappLoadingEnterContentDelay: (delayMs?: number | null) => Promise<MiniappLoadingDelayResult>;
+    registerRoutes: (appId: string, routes: Record<string, string>) => Promise<{
+        success: boolean;
+        appId: string;
+        count: number;
+    }>;
+    registerManifest: (appId: string, manifest: RegisteredMiniAppManifest) => Promise<{
+        success: boolean;
+        appId: string;
+        count: number;
+    }>;
+    postMessageToHost: (appId: string, message: Record<string, unknown>) => Promise<NavigationResult>;
+    postMessageToMiniApp: (appId: string, message: Record<string, unknown>) => Promise<NavigationResult>;
+    bringHostToFront: () => Promise<HostVisibilityResult>;
+    restoreMiniApp: (token?: string | null) => Promise<HostVisibilityResult>;
+    presentHostModal: (moduleName: string, props: Record<string, unknown>) => Promise<NavigationResult>;
+    dismissHostModal: () => Promise<NavigationResult>;
+    getInstalledMiniApps: () => Promise<InstalledMiniAppsResult>;
+    getInstalledMiniAppInfo: (appId: string) => Promise<InstalledMiniAppInfoResult>;
+    navigateTo: (appId: string, url: string) => Promise<NavigationResult>;
+    redirectTo: (appId: string, url: string) => Promise<NavigationResult>;
+    reLaunch: (appId: string, url: string) => Promise<NavigationResult>;
+    navigateBack: (appId: string, delta: number) => Promise<NavigationResult>;
+    setPageStyle: (appId: string, style: NebulaPageStyle) => Promise<NavigationResult>;
+    showToast: (title: string) => Promise<NavigationResult>;
+    getDeviceInfo: () => Record<string, unknown>;
+};

package/dist/nebulaTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/pageConfig.d.ts

@@ -0,0 +1,10 @@
+export type MiniAppPageConfig = {
+    route?: string;
+    backgroundColor?: string;
+    navigationBarBackgroundColor?: string;
+    navigationBarTextColor?: string;
+    navigationBarTitleText?: string;
+    navigationStyle?: 'default' | 'custom';
+    visualEffectInBackground?: 'blur' | 'none';
+};
+export declare function definePageConfig<T extends MiniAppPageConfig>(config: T): T;

package/dist/pageConfig.js

@@ -0,0 +1,3 @@
+export function definePageConfig(config) {
+    return config;
+}

package/dist/specs/NativeNebulaModule.d.ts

@@ -0,0 +1,86 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+export type MiniAppUpdateStrategy = 'auto' | 'manual';
+export type MiniAppResult = {
+    success: boolean;
+    appId: string;
+    mode?: string;
+};
+export type InstalledMiniAppsResult = {
+    apps: string[];
+};
+export type InstalledMiniAppInfo = {
+    appId: string;
+    mode?: string | null;
+    bundlePath?: string | null;
+    sourceUrl?: string | null;
+    version?: string | null;
+    updateStrategy?: MiniAppUpdateStrategy | null;
+};
+export type InstalledMiniAppInfoResult = {
+    installed: boolean;
+    app?: InstalledMiniAppInfo | null;
+};
+export type ServerBaseURLResult = {
+    serverBaseURL?: string | null;
+};
+export type MiniappLoadingDelayResult = {
+    delayMs: number;
+};
+export type NebulaCapabilityMap = {
+    [capabilityName: string]: string;
+};
+export type NebulaCapabilitiesResult = {
+    bridgeVersion: string;
+    capabilities: NebulaCapabilityMap;
+};
+export type NavigationResult = {
+    errMsg: string;
+};
+export type HostVisibilityResult = {
+    success: boolean;
+    token?: string | null;
+};
+export type NebulaPageStyle = {
+    backgroundColor?: string;
+    navigationBarBackgroundColor?: string;
+    navigationBarTextColor?: string;
+    navigationBarTitleText?: string;
+    navigationStyle?: 'default' | 'custom';
+    visualEffectInBackground?: 'blur' | 'none';
+};
+export interface Spec extends TurboModule {
+    openMiniApp(appId: string, initialProps: UnsafeObject): Promise<MiniAppResult>;
+    openMiniAppWithBundleURL(appId: string, bundleURL: string, connectToURLMetroServer: boolean, initialProps: UnsafeObject): Promise<MiniAppResult>;
+    preloadMiniApp(appId: string): Promise<MiniAppResult>;
+    preloadMiniAppWithBundleURL(appId: string, bundleURL: string, connectToURLMetroServer: boolean): Promise<MiniAppResult>;
+    installMiniApp(appId: string, bundleURL: string): Promise<MiniAppResult>;
+    installMiniAppWithBundleURL(appId: string, bundleURL: string, connectToURLMetroServer: boolean): Promise<MiniAppResult>;
+    installMiniAppFromURLs(appId: string, bundleURL: string, manifestURL: string, assetsURL: string, connectToURLMetroServer: boolean): Promise<MiniAppResult>;
+    closeMiniApp(appId: string): Promise<MiniAppResult>;
+    uninstallMiniApp(appId: string): Promise<MiniAppResult>;
+    getCapabilities(): Promise<NebulaCapabilitiesResult>;
+    getServerBaseURL(): Promise<ServerBaseURLResult>;
+    setServerBaseURL(serverBaseURL?: string | null): Promise<ServerBaseURLResult>;
+    setMiniappLoadingDelay(delayMs?: number | null): Promise<MiniappLoadingDelayResult>;
+    setMiniappLoadingEnterContentDelay(delayMs?: number | null): Promise<MiniappLoadingDelayResult>;
+    getInstalledMiniApps(): Promise<InstalledMiniAppsResult>;
+    getInstalledMiniAppInfo(appId: string): Promise<InstalledMiniAppInfoResult>;
+    registerRoutes(appId: string, routes: UnsafeObject): Promise<UnsafeObject>;
+    registerManifest(appId: string, manifest: UnsafeObject): Promise<UnsafeObject>;
+    postMessageToHost(appId: string, message: UnsafeObject): Promise<NavigationResult>;
+    postMessageToMiniApp(appId: string, message: UnsafeObject): Promise<NavigationResult>;
+    bringHostToFront(): Promise<HostVisibilityResult>;
+    restoreMiniApp(token?: string | null): Promise<HostVisibilityResult>;
+    presentHostModal(moduleName: string, props: UnsafeObject): Promise<NavigationResult>;
+    dismissHostModal(): Promise<NavigationResult>;
+    navigateTo(appId: string, url: string): Promise<NavigationResult>;
+    redirectTo(appId: string, url: string): Promise<NavigationResult>;
+    reLaunch(appId: string, url: string): Promise<NavigationResult>;
+    navigateBack(appId: string, delta: number): Promise<NavigationResult>;
+    setPageStyle(appId: string, style: UnsafeObject): Promise<NavigationResult>;
+    showToast(title: string): Promise<NavigationResult>;
+    getDeviceInfo(): UnsafeObject;
+}
+declare const _default: Spec;
+export default _default;

package/dist/specs/NativeNebulaModule.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('NebulaNativeModule');

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@nebula-rn/sdk",
+  "version": "0.0.1",
+  "description": "Nebula Mini-App Framework - JavaScript/TypeScript client SDK",
+  "author": "Hector Zhuang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Hector-Zhuang/nebula.git",
+    "directory": "packages/nebula-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/Hector-Zhuang/nebula/issues"
+  },
+  "homepage": "https://github.com/Hector-Zhuang/nebula/tree/main/packages/nebula-sdk#readme",
+  "keywords": ["nebula", "superapp", "miniapp", "react-native"],
+  "main": "./dist/index.js",
+  "react-native": "./src/index.ts",
+  "source": "./src/index.ts",
+  "types": "./dist/index.d.ts",
+  "files": ["dist", "src", "README.md"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint src --ext .ts,.tsx",
+    "prepack": "npm run build"
+  },
+  "codegenConfig": {
+    "name": "NebulaSpecs",
+    "type": "modules",
+    "jsSrcsDir": "src/specs",
+    "android": {
+      "javaPackageName": "com.superapp.specs"
+    }
+  },
+  "peerDependencies": {
+    "react": ">=19",
+    "react-native": ">=0.83"
+  }
+}