@nebula-rn/client 0.0.1

package/src/scanCode/index.tsx

@@ -0,0 +1,127 @@
+import { Miniapp } from '@nebula-rn/sdk';
+import {
+  createScanCodeError,
+  SCAN_CODE_CAPABILITY_NAME,
+  SCAN_CODE_CAPABILITY_VERSION,
+} from './contract';
+import type {
+  ScanCodeData,
+  ScanCodeErrorCode,
+  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';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function toScanCodeErrorCode(code: unknown): ScanCodeErrorCode {
+  switch (code) {
+    case 'PERMISSION_DENIED':
+    case 'USER_CANCELLED':
+    case 'UNSUPPORTED_SOURCE':
+    case 'SCAN_FAILED':
+      return code;
+    default:
+      return 'SCAN_FAILED';
+  }
+}
+
+function toScanCodeFailureResult(
+  error: unknown,
+): Extract<ScanCodeResult, { ok: false }> {
+  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: unknown): ScanCodeResult {
+  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: ScanCodeOptions = {},
+): Promise<ScanCodeData> {
+  const result = await scanCodeSafe(options);
+  if (!result.ok) {
+    throw result.error;
+  }
+  return result.data;
+}
+
+export async function scanCodeSafe(
+  options: ScanCodeOptions = {},
+): Promise<ScanCodeResult> {
+  try {
+    const result = await Miniapp.invokeHostApi<ScanCodeData>(
+      SCAN_CODE_CAPABILITY_NAME,
+      options as Record<string, unknown>,
+      SCAN_CODE_CAPABILITY_VERSION,
+      120000,
+    );
+
+    return result.ok
+      ? toScanCodeSuccessResult(result.data)
+      : toScanCodeFailureResult(result.error);
+  } catch (error) {
+    return toScanCodeFailureResult(error);
+  }
+}

package/src/scanCode/types.ts

@@ -0,0 +1,38 @@
+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 class ScanCodeError extends Error {
+  readonly code: ScanCodeErrorCode;
+
+  constructor(code: ScanCodeErrorCode, message: string) {
+    super(message);
+    this.name = 'ScanCodeError';
+    this.code = code;
+  }
+}

package/src/sensors.ts

@@ -0,0 +1,48 @@
+import { subscribeToHostEvent } from './runtime/host';
+
+export interface SensorData {
+  x: number;
+  y: number;
+  z: number;
+  timestamp?: number;
+}
+
+export interface BarometerData {
+  pressure: number;
+}
+
+function createSensorSubscription<TPayload>(
+  apiName: string,
+  callback: (data: TPayload) => void,
+  payload: Record<string, unknown>,
+) {
+  let unsubscribePromise: Promise<void> | null = null;
+  const handle = subscribeToHostEvent<TPayload>(apiName, payload, callback);
+
+  return () => {
+    if (!unsubscribePromise) {
+      unsubscribePromise = handle.then(subscription =>
+        subscription.unsubscribe(),
+      );
+    }
+    return unsubscribePromise;
+  };
+}
+
+export const onAccelerometerChange = (
+  callback: (data: SensorData) => void,
+  interval: number = 100,
+) => createSensorSubscription('accelerometerChange', callback, { interval });
+
+export const onGyroscopeChange = (
+  callback: (data: SensorData) => void,
+  interval: number = 100,
+) => createSensorSubscription('gyroscopeChange', callback, { interval });
+
+export const onMagnetometerChange = (
+  callback: (data: SensorData) => void,
+  interval: number = 100,
+) => createSensorSubscription('magnetometerChange', callback, { interval });
+
+export const onBarometerChange = (callback: (data: BarometerData) => void) =>
+  createSensorSubscription('barometerChange', callback, {});

package/src/setClipboardData/index.ts

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

package/src/setStorage/index.ts

@@ -0,0 +1,11 @@
+import { setStorageItem } from '../storage';
+
+export interface SetStorageOption {
+  key: string;
+  data: unknown;
+}
+
+export const setStorage = (options: SetStorageOption) => {
+  const { key, data } = options;
+  return setStorageItem(key, data);
+};

package/src/storage.ts

@@ -0,0 +1,51 @@
+import { invokeHostApi } from './runtime/host';
+
+export const storage = null;
+
+export function serializeStorageValue(data: unknown): string {
+  return JSON.stringify(data);
+}
+
+export function deserializeStorageValue<T = unknown>(data: string): T {
+  return JSON.parse(data) as T;
+}
+
+export function setStorageItem(key: string, data: unknown): Promise<void> {
+  return invokeHostApi<void>('storage.setItem', {
+    key,
+    data: serializeStorageValue(data),
+  });
+}
+
+export async function getStorageItem(key: string): Promise<string | undefined> {
+  const result = await invokeHostApi<{ value?: string | null }>(
+    'storage.getItem',
+    {
+      key,
+    },
+  );
+
+  return result.value ?? undefined;
+}
+
+export function removeStorageItem(key: string): Promise<void> {
+  return invokeHostApi<void>('storage.removeItem', {
+    key,
+  });
+}
+
+export function clearStorageItems(): Promise<void> {
+  return invokeHostApi<void>('storage.clearItems');
+}
+
+export async function getStorageKeys(): Promise<string[]> {
+  const result = await invokeHostApi<{ keys: string[] }>('storage.getKeys');
+  return result.keys;
+}
+
+export async function getStorageCurrentSize(): Promise<number> {
+  const result = await invokeHostApi<{ size: number }>(
+    'storage.getCurrentSize',
+  );
+  return result.size;
+}

package/src/uploadFile/index.ts

@@ -0,0 +1,57 @@
+import { createHostTask } from '../runtime/host';
+
+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 const uploadFile = (options: UploadFileOption): UploadTask => {
+  return createHostTask<
+    UploadFileResult,
+    UploadProgressUpdateRes,
+    UploadHeadersReceivedRes
+  >('uploadFile', options, {
+    timeoutMs: options.timeout ?? 60000,
+  });
+};