@nebula-rn/client 0.0.1

package/src/getImageInfo/index.ts

@@ -0,0 +1,40 @@
+import { invokeHostApi } from '../runtime/host';
+
+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 function getImageInfo(
+  option: GetImageInfoOption,
+): Promise<GetImageInfoSuccessResult> {
+  const { src, success, fail, complete } = option;
+
+  return invokeHostApi<GetImageInfoSuccessResult>('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/src/getLocation/index.ts

@@ -0,0 +1,23 @@
+import { invokeHostApi } from '../runtime/host';
+
+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 const getLocation = (
+  options: GetLocationOption = {},
+): Promise<GetLocationResult> => {
+  return invokeHostApi<GetLocationResult>('getLocation', options);
+};

package/src/getScreenBrightness/index.ts

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

package/src/getStorage/index.ts

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

package/src/getStorageInfo/index.ts

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

package/src/getSystemInfo/index.ts

@@ -0,0 +1,5 @@
+import { invokeHostApi } from '../runtime/host';
+
+export function getSystemInfo() {
+  return invokeHostApi<Record<string, unknown>>('getSystemInfo');
+}

package/src/index.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/src/location.ts

@@ -0,0 +1,40 @@
+import { subscribeToHostEvent } from './runtime/host';
+
+export interface LocationData {
+  accuracy: number;
+  altitude: number | null;
+  latitude: number;
+  longitude: number;
+  speed: number | null;
+  timestamp: number;
+}
+
+export type UnsubscribeFn = () => void | Promise<void>;
+
+export const onLocationChange = (
+  enableHighAccuracy: boolean = true,
+  onSuccess: (data: LocationData) => void,
+  onError?: (error: unknown) => void,
+): UnsubscribeFn => {
+  let unsubscribePromise: Promise<void> | null = null;
+
+  const handle = subscribeToHostEvent<LocationData>(
+    'locationChange',
+    {
+      enableHighAccuracy,
+    },
+    onSuccess,
+  ).catch(error => {
+    onError?.(error);
+    throw error;
+  });
+
+  return () => {
+    if (!unsubscribePromise) {
+      unsubscribePromise = handle
+        .then(subscription => subscription.unsubscribe())
+        .catch(() => {});
+    }
+    return unsubscribePromise;
+  };
+};

package/src/makePhoneCall/index.ts

@@ -0,0 +1,5 @@
+import { invokeHostApi } from '../runtime/host';
+
+export async function makePhoneCall(phoneNumber: string) {
+  return invokeHostApi<boolean>('makePhoneCall', { phoneNumber });
+}

package/src/media.ts

@@ -0,0 +1,19 @@
+import { invokeHostApi } from './runtime/host';
+
+export type MediaType = 'photo' | 'video';
+
+export interface SaveMediaOptions {
+  album?: string;
+}
+
+export const saveMedia = (
+  url: string,
+  type: MediaType,
+  options?: SaveMediaOptions,
+) => {
+  return invokeHostApi<string>('saveMedia', {
+    url,
+    type,
+    album: options?.album,
+  });
+};

package/src/miniAppUpdate/index.ts

@@ -0,0 +1,20 @@
+import type { MiniAppUpdateInfo } from '@nebula-rn/sdk';
+import { invokeHostApi } from '../runtime/host';
+
+export function getMiniAppUpdateInfo(): Promise<MiniAppUpdateInfo> {
+  return invokeHostApi<MiniAppUpdateInfo>(
+    'getMiniAppUpdateInfo',
+    {},
+    '1.0',
+    15000,
+  );
+}
+
+export function applyMiniAppUpdate(): Promise<MiniAppUpdateInfo> {
+  return invokeHostApi<MiniAppUpdateInfo>(
+    'applyMiniAppUpdate',
+    {},
+    '1.0',
+    120000,
+  );
+}

package/src/network.ts

@@ -0,0 +1,36 @@
+import { invokeHostApi, subscribeToHostEvent } from './runtime/host';
+
+export interface GetNetworkTypeResult {
+  networkType: string;
+}
+
+export interface NetworkStatusChangeResult {
+  isConnected: boolean;
+  networkType: string;
+}
+
+export const getNetworkType = async () => {
+  const result = await invokeHostApi<GetNetworkTypeResult>('getNetworkType');
+  return result.networkType;
+};
+
+export const onNetworkStatusChange = (
+  callback: (res: NetworkStatusChangeResult) => void,
+) => {
+  let unsubscribePromise: Promise<void> | null = null;
+
+  const handle = subscribeToHostEvent<NetworkStatusChangeResult>(
+    'networkStatusChange',
+    {},
+    callback,
+  );
+
+  return () => {
+    if (!unsubscribePromise) {
+      unsubscribePromise = handle.then(subscription =>
+        subscription.unsubscribe(),
+      );
+    }
+    return unsubscribePromise;
+  };
+};

package/src/onUserCaptureScreen/index.ts

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

package/src/previewImage/index.tsx

@@ -0,0 +1,13 @@
+import { invokeHostApi } from '../runtime/host';
+
+export interface PreviewImageOptions {
+  urls: string[];
+  current?: string;
+  showMenu?: boolean;
+  saveMediaText?: string;
+  cancelText?: string;
+}
+
+export function previewImages(options: PreviewImageOptions): Promise<void> {
+  return invokeHostApi<void>('previewImage', options, '1.0', 120000);
+}

package/src/runtime/host.ts

@@ -0,0 +1,356 @@
+import { Miniapp } from '@nebula-rn/sdk';
+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>;
+};
+
+type HostApiError = {
+  code?: unknown;
+  message?: unknown;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isHostApiEventMessage(
+  value: Record<string, unknown>,
+): value is HostApiEventMessage {
+  return (
+    value.__nebulaApiEvent === 'v1' &&
+    typeof value.apiName === 'string' &&
+    typeof value.channel === 'string'
+  );
+}
+
+export function createHostApiError(
+  apiName: string,
+  error: unknown,
+  fallbackCode = 'HOST_API_FAILED',
+): Error & { code: string } {
+  const details = isRecord(error) ? (error as HostApiError) : 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) as Error & { code: string };
+  hostError.code = code;
+  return hostError;
+}
+
+export async function invokeHostApi<TData = unknown>(
+  apiName: string,
+  payload: object = {},
+  version = '1.0',
+  timeoutMs = 15000,
+): Promise<TData> {
+  const result = await Miniapp.invokeHostApi<TData>(
+    apiName,
+    payload as Record<string, unknown>,
+    version,
+    timeoutMs,
+  );
+
+  if (!result.ok) {
+    throw createHostApiError(apiName, result.error);
+  }
+
+  return result.data;
+}
+
+export async function invokeHostApiResult<TData = unknown>(
+  apiName: string,
+  payload: object = {},
+  version = '1.0',
+  timeoutMs = 15000,
+): Promise<NebulaApiInvokeResult<TData>> {
+  return Miniapp.invokeHostApi<TData>(
+    apiName,
+    payload as Record<string, unknown>,
+    version,
+    timeoutMs,
+  );
+}
+
+export function addHostApiEventListener<TPayload = unknown>(
+  apiName: string,
+  channel: string,
+  listener: HostEventListener<TPayload>,
+  matcher?: (message: HostApiEventMessage<TPayload>) => boolean,
+): () => void {
+  return Miniapp.onHostMessage(event => {
+    const { message } = event;
+    if (!isRecord(message) || !isHostApiEventMessage(message)) {
+      return;
+    }
+
+    if (message.apiName !== apiName || message.channel !== channel) {
+      return;
+    }
+
+    const typedMessage = message as HostApiEventMessage<TPayload>;
+
+    if (matcher && !matcher(typedMessage)) {
+      return;
+    }
+
+    listener((typedMessage.payload ?? null) as TPayload);
+  });
+}
+
+export async function subscribeToHostEvent<TPayload = unknown>(
+  apiName: string,
+  payload: object,
+  onEvent: HostEventListener<TPayload>,
+  options?: {
+    version?: string;
+    timeoutMs?: number;
+    unsubscribePayload?: object;
+  },
+): Promise<HostSubscriptionHandle> {
+  const version = options?.version ?? '1.0';
+  const timeoutMs = options?.timeoutMs ?? 15000;
+  const result = await invokeHostApi<{
+    subscriptionId: string;
+  }>(`${apiName}.subscribe`, payload, version, timeoutMs);
+
+  const stopListening = addHostApiEventListener<TPayload>(
+    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<TData, TProgress, THeaders> implements HostTask<
+  TData,
+  TProgress,
+  THeaders
+> {
+  private readonly promise: Promise<TData>;
+  private readonly aborter: () => Promise<void>;
+  private readonly progressListeners = new Set<
+    HostTaskProgressListener<TProgress>
+  >();
+  private readonly headersListeners = new Set<
+    HostTaskHeadersListener<THeaders>
+  >();
+  private readonly cleanup: () => void;
+
+  constructor(
+    promise: Promise<TData>,
+    aborter: () => Promise<void>,
+    cleanup: () => void,
+  ) {
+    this.promise = promise;
+    this.aborter = aborter;
+    this.cleanup = cleanup;
+  }
+
+  abort(): Promise<void> {
+    this.cleanup();
+    return this.aborter();
+  }
+
+  onProgressUpdate(listener: HostTaskProgressListener<TProgress>): void {
+    this.progressListeners.add(listener);
+  }
+
+  offProgressUpdate(listener: HostTaskProgressListener<TProgress>): void {
+    this.progressListeners.delete(listener);
+  }
+
+  onHeadersReceived(listener: HostTaskHeadersListener<THeaders>): void {
+    this.headersListeners.add(listener);
+  }
+
+  offHeadersReceived(listener: HostTaskHeadersListener<THeaders>): void {
+    this.headersListeners.delete(listener);
+  }
+
+  emitProgress(payload: TProgress): void {
+    this.progressListeners.forEach(listener => listener(payload));
+  }
+
+  emitHeaders(payload: THeaders): void {
+    this.headersListeners.forEach(listener => listener(payload));
+  }
+
+  then<TResult1 = TData, TResult2 = never>(
+    onfulfilled?:
+      ((value: TData) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+    onrejected?:
+      | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
+      | undefined
+      | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null,
+  ): Promise<TData | TResult> {
+    return this.promise.catch(onrejected);
+  }
+}
+
+export function createHostTask<TData, TProgress, THeaders>(
+  apiName: string,
+  payload: object,
+  options?: {
+    version?: string;
+    timeoutMs?: number;
+  },
+): HostTask<TData, TProgress, THeaders> {
+  const version = options?.version ?? '1.0';
+  const timeoutMs = options?.timeoutMs ?? 15000;
+  let stopResultListener = () => {};
+  let stopProgressListener = () => {};
+  let stopHeadersListener = () => {};
+  let startedTaskId: string | null = null;
+
+  function cleanup() {
+    stopResultListener();
+    stopProgressListener();
+    stopHeadersListener();
+  }
+
+  const startTask = invokeHostApi<{ taskId: string }>(
+    `${apiName}.start`,
+    payload,
+    version,
+    timeoutMs,
+  );
+  const promise = startTask.then(
+    ({ taskId }) =>
+      new Promise<TData>((resolve, reject) => {
+        startedTaskId = taskId;
+
+        stopResultListener = addHostApiEventListener<
+          NebulaApiInvokeResult<TData> | TData
+        >(
+          apiName,
+          'task.result',
+          resultPayload => {
+            cleanup();
+            if (
+              isRecord(resultPayload) &&
+              typeof resultPayload.ok === 'boolean'
+            ) {
+              const result = resultPayload as NebulaApiInvokeResult<TData>;
+              if (result.ok) {
+                resolve(result.data);
+                return;
+              }
+              reject(createHostApiError(apiName, result.error));
+              return;
+            }
+            resolve(resultPayload as TData);
+          },
+          message => message.taskId === taskId,
+        );
+
+        stopProgressListener = addHostApiEventListener<TProgress>(
+          apiName,
+          'task.progress',
+          progressPayload => {
+            task.emitProgress(progressPayload);
+          },
+          message => message.taskId === taskId,
+        );
+
+        stopHeadersListener = addHostApiEventListener<THeaders>(
+          apiName,
+          'task.headers',
+          headersPayload => {
+            task.emitHeaders(headersPayload);
+          },
+          message => message.taskId === taskId,
+        );
+      }),
+  );
+
+  const task = new HostTaskImpl<TData, TProgress, THeaders>(
+    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/src/scanCode/contract.ts

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