@namiml/expo-sdk 3.4.0-dev.202605060437

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@namiml/expo-sdk",
+  "version": "3.4.0-dev.202605060437",
+  "type": "module",
+  "description": "Nami Expo SDK — paywall and subscription management for Expo apps",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "react-native": "./src/index.ts",
+  "source": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "nami-sdk-core.tgz",
+    "nami-expo-nami-iap.tgz"
+  ],
+  "scripts": {
+    "build": "NAMI_SDK_ENV=development rollup -c",
+    "build:prod": "NAMI_SDK_ENV=production rollup -c",
+    "test": "jest --coverage",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist",
+    "dev": "rollup -c -w",
+    "prepublishOnly": "yarn clean && yarn build:prod"
+  },
+  "dependencies": {
+    "@namiml/expo-nami-iap": "3.4.0-dev.202605060437",
+    "@namiml/sdk-core": "3.4.0-dev.202605060437",
+    "@amazon-devices/expo-asset": "~2.0.0",
+    "@amazon-devices/react-native-kepler": "^2.0.1758683737",
+    "react-native-qrcode-svg": "^6.3.21",
+    "react-native-svg": "^15.15.4"
+  },
+  "peerDependencies": {
+    "expo-constants": "*",
+    "expo-device": "*",
+    "expo-font": "*",
+    "expo-image": "*",
+    "expo-linking": "*",
+    "expo-localization": "*",
+    "expo-sqlite": "*",
+    "expo-video": "*",
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0"
+  },
+  "peerDependenciesMeta": {
+    "expo-font": {
+      "optional": true
+    },
+    "expo-image": {
+      "optional": true
+    },
+    "expo-video": {
+      "optional": true
+    },
+    "react-native-iap": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-replace": "^6.0.0",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^18.3.12",
+    "eslint": "^10.2.0",
+    "jest": "^29.7.0",
+    "jest-util": "^30.3.0",
+    "react": "^18.3.1",
+    "react-native": "^0.75.0",
+    "rollup": "^4.18.0",
+    "rollup-plugin-dts": "^6.1.0",
+    "ts-jest": "^29.2.0",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^8.58.0"
+  },
+  "packageManager": "yarn@4.4.0",
+  "sideEffects": [
+    "./src/index.*",
+    "./src/adapters/*"
+  ]
+}

package/src/adapters/expo-device.adapter.ts

@@ -0,0 +1,106 @@
+import type { IDeviceAdapter, ScreenInfo } from '@namiml/sdk-core';
+import type { DevicePayload, TDevice } from '@namiml/sdk-core';
+import { NAMI_SDK_PACKAGE_VERSION } from '@namiml/sdk-core';
+import { Dimensions, Platform } from 'react-native';
+
+function getExpoDevice() { return require('expo-device'); }
+function getExpoConstants() { return require('expo-constants').default; }
+function getExpoLocalization() { return require('expo-localization'); }
+
+const SDK_CLIENT = 'expo';
+
+const TV_SCALE_FACTORS: Record<number, number> = {
+  720: 0.67,
+  1080: 1,
+  1440: 1.5,
+  2160: 2,
+};
+
+export class ExpoDeviceAdapter implements IDeviceAdapter {
+  getDeviceData(): DevicePayload {
+    let osName = Platform.OS;
+    let osVersion = String(Platform.Version);
+    let deviceModel: string | undefined;
+
+    try {
+      const device = getExpoDevice();
+      if (device) {
+        osName = device.osName ?? osName;
+        osVersion = device.osVersion ?? osVersion;
+        deviceModel = device.modelName ?? device.modelId;
+      }
+    } catch { /* expo-device unavailable */ }
+
+    return {
+      os_name: osName,
+      os_version: osVersion,
+      browser_name: '',
+      browser_version: '',
+      sdk_client: SDK_CLIENT,
+      sdk_version: NAMI_SDK_PACKAGE_VERSION,
+      language: this.getLanguage(),
+      ...(deviceModel ? { device_model: deviceModel } : {}),
+      extended_platform: 'expo',
+      extended_platform_version: this.getExpoVersion(),
+    };
+  }
+
+  private getExpoVersion(): string {
+    try {
+      const constants = getExpoConstants();
+      return constants?.expoConfig?.sdkVersion ?? '';
+    } catch {
+      return '';
+    }
+  }
+
+  getDeviceFormFactor(): TDevice {
+    try {
+      const device = getExpoDevice();
+      const deviceType = device?.deviceType;
+      const DeviceType = device?.DeviceType;
+
+      if (DeviceType && deviceType === DeviceType.TV) return 'television';
+      if (DeviceType && deviceType === DeviceType.TABLET) return 'tablet';
+    } catch {
+      // expo-device may not be available (e.g., Expo Go without native modules)
+    }
+    return 'phone';
+  }
+
+  getDeviceScaleFactor(formFactor?: string): number {
+    const ff = formFactor ?? this.getDeviceFormFactor();
+    if (ff !== 'television') return 1;
+
+    const { height } = Dimensions.get('window');
+    const closest = Object.keys(TV_SCALE_FACTORS)
+      .map(Number)
+      .reduce((prev, curr) =>
+        Math.abs(curr - height) < Math.abs(prev - height) ? curr : prev
+      );
+    return TV_SCALE_FACTORS[closest] ?? 1;
+  }
+
+  generateUUID(): string {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+      const r = (Math.random() * 16) | 0;
+      const v = c === 'x' ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  }
+
+  getScreenInfo(): ScreenInfo {
+    const { width, height, scale } = Dimensions.get('window');
+    return { width, height, scale };
+  }
+
+  getLanguage(): string {
+    try {
+      const { getLocales } = getExpoLocalization();
+      const locales = getLocales();
+      return locales?.[0]?.languageCode ?? 'en';
+    } catch {
+      return 'en';
+    }
+  }
+}

package/src/adapters/expo-purchase.adapter.ts

@@ -0,0 +1,79 @@
+import type { IPurchaseAdapter, PurchaseContext, PurchaseResult } from '@namiml/sdk-core';
+import type { NamiProductDetails } from '@namiml/sdk-core';
+
+type ExpoNamiIapModule = {
+  initConnection: () => Promise<void>;
+  getProducts: (skuIds: string[]) => Promise<NamiProductDetails[]>;
+  purchase: (params: {
+    skuId: string;
+    offerId?: string;
+    appAccountToken?: string;
+  }) => Promise<{
+    transactionId: string;
+    receipt?: string;
+    skuId: string;
+  }>;
+  restorePurchases: () => Promise<Array<{
+    transactionId: string;
+    receipt?: string;
+    skuId: string;
+  }>>;
+};
+
+function getExpoNamiIap(): ExpoNamiIapModule {
+  return require('@namiml/expo-nami-iap') as ExpoNamiIapModule;
+}
+
+type PurchaseContextWithAppAccountToken = PurchaseContext & {
+  appAccountToken?: string;
+};
+
+function getPurchaseErrorMessage(error: unknown): string {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+
+  if (typeof error === 'object' && error && 'message' in error) {
+    const message = (error as { message?: unknown }).message;
+    if (typeof message === 'string' && message.length > 0) {
+      return message;
+    }
+  }
+
+  return 'Purchase failed';
+}
+
+export class ExpoPurchaseAdapter implements IPurchaseAdapter {
+  async getProducts(skuIds: string[]): Promise<NamiProductDetails[]> {
+    const { initConnection, getProducts } = getExpoNamiIap();
+    await initConnection();
+    return getProducts(skuIds);
+  }
+
+  async purchase(skuId: string, context?: PurchaseContext): Promise<PurchaseResult> {
+    const { initConnection, purchase } = getExpoNamiIap();
+    await initConnection();
+    try {
+      const tx = await purchase({
+        skuId,
+        offerId: context?.offerId,
+        appAccountToken: (context as PurchaseContextWithAppAccountToken | undefined)?.appAccountToken,
+      });
+      return {
+        success: true,
+        transactionId: tx.transactionId,
+        receipt: tx.receipt,
+        skuId: tx.skuId,
+      };
+    } catch (error) {
+      return { success: false, skuId, message: getPurchaseErrorMessage(error) };
+    }
+  }
+
+  async restorePurchases(): Promise<PurchaseResult[]> {
+    const { initConnection, restorePurchases } = getExpoNamiIap();
+    await initConnection();
+    const txs = await restorePurchases();
+    return txs.map((t) => ({ success: true, transactionId: t.transactionId, receipt: t.receipt, skuId: t.skuId }));
+  }
+}

package/src/adapters/expo-storage.adapter.ts

@@ -0,0 +1,92 @@
+import type { IStorageAdapter } from '@namiml/sdk-core';
+
+type SQLiteRow = { value?: string; key?: string };
+type SQLiteDatabase = {
+  runSync(query: string, params?: unknown[]): void;
+  getFirstSync(query: string, params?: unknown[]): SQLiteRow | null;
+  getAllSync(query: string, params?: unknown[]): SQLiteRow[];
+};
+
+export class ExpoStorageAdapter implements IStorageAdapter {
+  private db: SQLiteDatabase | null = null;
+  private memoryFallback: Map<string, string> | null = null;
+
+  constructor() {
+    try {
+      const { openDatabaseSync } = require('expo-sqlite');
+      const database = openDatabaseSync('nami-sdk-storage') as SQLiteDatabase;
+      database.runSync(
+        'CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY, value TEXT)'
+      );
+      this.db = database;
+    } catch {
+      this.memoryFallback = new Map();
+    }
+  }
+
+  getItem(key: string): string | null {
+    if (this.memoryFallback) return this.memoryFallback.get(key) ?? null;
+    const database = this.db;
+    if (!database) return null;
+    try {
+      const row = database.getFirstSync('SELECT value FROM kv WHERE key = ?', [key]);
+      return row?.value ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  setItem(key: string, value: string): void {
+    if (this.memoryFallback) {
+      this.memoryFallback.set(key, value);
+      return;
+    }
+    const database = this.db;
+    if (!database) return;
+    try {
+      database.runSync('INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)', [key, value]);
+    } catch {
+      /* silent */
+    }
+  }
+
+  removeItem(key: string): void {
+    if (this.memoryFallback) {
+      this.memoryFallback.delete(key);
+      return;
+    }
+    const database = this.db;
+    if (!database) return;
+    try {
+      database.runSync('DELETE FROM kv WHERE key = ?', [key]);
+    } catch {
+      /* silent */
+    }
+  }
+
+  clear(): void {
+    if (this.memoryFallback) {
+      this.memoryFallback.clear();
+      return;
+    }
+    const database = this.db;
+    if (!database) return;
+    try {
+      database.runSync('DELETE FROM kv');
+    } catch {
+      /* silent */
+    }
+  }
+
+  getAllKeys(): string[] {
+    if (this.memoryFallback) return [...this.memoryFallback.keys()];
+    const database = this.db;
+    if (!database) return [];
+    try {
+      const rows = database.getAllSync('SELECT key FROM kv');
+      return rows.map((row) => row.key).filter((key): key is string => typeof key === 'string');
+    } catch {
+      return [];
+    }
+  }
+}

package/src/adapters/expo-ui.adapter.ts

@@ -0,0 +1,57 @@
+import type { IUIAdapter, PaywallHandle, FlowNavigationOptions } from '@namiml/sdk-core';
+import type { IPaywall } from '@namiml/sdk-core';
+import type { NamiPaywallLaunchContext } from '@namiml/sdk-core';
+
+type PaywallListener = (paywall: IPaywall, context: NamiPaywallLaunchContext) => void;
+type ReRenderListener = () => void;
+type FlowNavListener = (paywall: IPaywall, options: FlowNavigationOptions) => void;
+
+/**
+ * Expo UI adapter.
+ * Uses a listener pattern so the Expo PaywallView component can register
+ * itself to receive create/reRender/flowNav events from the core SDK.
+ */
+export class ExpoUIAdapter implements IUIAdapter {
+  private paywallListener: PaywallListener | null = null;
+  private reRenderListener: ReRenderListener | null = null;
+  private flowNavListener: FlowNavListener | null = null;
+
+  onPaywallRequested(listener: PaywallListener): () => void {
+    this.paywallListener = listener;
+    return () => { this.paywallListener = null; };
+  }
+
+  onReRenderRequested(listener: ReRenderListener): () => void {
+    this.reRenderListener = listener;
+    return () => { this.reRenderListener = null; };
+  }
+
+  onFlowNavigationRequested(listener: FlowNavListener): () => void {
+    this.flowNavListener = listener;
+    return () => { this.flowNavListener = null; };
+  }
+
+  createPaywall(
+    type: string | undefined,
+    value: string,
+    context: NamiPaywallLaunchContext
+  ): PaywallHandle {
+    // In Expo, we don't create a DOM element. Instead, we notify the
+    // registered PaywallView component to present the paywall.
+    // The PaywallView resolves the paywall data using the same core logic.
+    if (this.paywallListener) {
+      // Build minimal paywall info for navigation
+      const paywallInfo = { type, value, context };
+      this.paywallListener(paywallInfo as any, context);
+    }
+    return { type, value, context };
+  }
+
+  reRenderPaywall(): void {
+    this.reRenderListener?.();
+  }
+
+  flowNavigateToScreen(paywall: IPaywall, options: FlowNavigationOptions): void {
+    this.flowNavListener?.(paywall, options);
+  }
+}

package/src/adapters/index.ts

@@ -0,0 +1,33 @@
+import { logger, registerPlatformAdapters, registerPurchaseAdapter } from '@namiml/sdk-core';
+import { ExpoStorageAdapter } from './expo-storage.adapter';
+import { ExpoDeviceAdapter } from './expo-device.adapter';
+import { ExpoUIAdapter } from './expo-ui.adapter';
+import { ExpoPurchaseAdapter } from './expo-purchase.adapter';
+
+export const expoUIAdapter = new ExpoUIAdapter();
+let adaptersRegistered = false;
+
+export function registerExpoAdapters(): void {
+  if (adaptersRegistered) {
+    return;
+  }
+
+  try {
+    registerPlatformAdapters({
+      storage: new ExpoStorageAdapter(),
+      device: new ExpoDeviceAdapter(),
+      ui: expoUIAdapter,
+    });
+    registerPurchaseAdapter(new ExpoPurchaseAdapter());
+    adaptersRegistered = true;
+  } catch (error) {
+    logger.warn('[NamiExpo] Failed to register Expo adapters.', error);
+  }
+}
+
+registerExpoAdapters();
+
+export { ExpoStorageAdapter } from './expo-storage.adapter';
+export { ExpoDeviceAdapter } from './expo-device.adapter';
+export { ExpoUIAdapter } from './expo-ui.adapter';
+export { ExpoPurchaseAdapter } from './expo-purchase.adapter';

package/src/amazon-kepler.d.ts

@@ -0,0 +1,7 @@
+declare module '@amazon-devices/react-native-kepler' {
+  export const TVFocusGuideView: any;
+  export function useKeplerAppStateManager(): {
+    getComponentInstance?: () => unknown;
+    isForeground?: boolean;
+  };
+}