expo-iap 3.1.0 → 3.1.1-rc.2

package/plugin/build/withIAP.js

@@ -36,6 +36,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.modifyAppBuildGradle = void 0;
+exports.computeAutolinkModules = computeAutolinkModules;
+exports.resolveModuleSelection = resolveModuleSelection;
 const config_plugins_1 = require("expo/config-plugins");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -43,6 +46,7 @@ const withLocalOpenIAP_1 = __importDefault(require("./withLocalOpenIAP"));
 const pkg = require('../../package.json');
 const openiapVersions = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../openiap-versions.json'), 'utf8'));
 const OPENIAP_ANDROID_VERSION = openiapVersions.google;
+const AUTOLINKING_CONFIG_PATH = path.resolve(__dirname, '../../expo-module.config.json');
 // Log a message only once per Node process
 const logOnce = (() => {
     const printed = new Set();
@@ -88,13 +92,14 @@ const modifyAppBuildGradle = (gradle, language) => {
     }
     return modified;
 };
+exports.modifyAppBuildGradle = modifyAppBuildGradle;
 const withIapAndroid = (config, props) => {
     const addDeps = props?.addDeps ?? true;
     if (addDeps) {
         config = (0, config_plugins_1.withAppBuildGradle)(config, (config) => {
             // language provided by config-plugins: 'groovy' | 'kotlin'
             const language = config.modResults.language || 'groovy';
-            config.modResults.contents = modifyAppBuildGradle(config.modResults.contents, language);
+            config.modResults.contents = (0, exports.modifyAppBuildGradle)(config.modResults.contents, language);
             return config;
         });
     }
@@ -117,8 +122,88 @@ const withIapAndroid = (config, props) => {
     });
     return config;
 };
-/** Ensure Podfile uses CocoaPods CDN and no stale local OpenIAP entry remains. */
-const withIapIOS = (config) => {
+const ensureOnsidePod = (content) => {
+    const podLine = "  pod 'OnsideKit', :git => 'https://github.com/onside-io/OnsideKit-iOS.git'";
+    const podRegex = /^\s*pod\s+'OnsideKit'\b.*$/m;
+    if (podRegex.test(content)) {
+        return content;
+    }
+    const targetMatch = content.match(/target\s+'[^']+'\s+do\s*\n/);
+    if (!targetMatch) {
+        config_plugins_1.WarningAggregator.addWarningIOS('expo-iap', 'Could not find a target block in Podfile when adding OnsideKit; skipping installation.');
+        return content;
+    }
+    const insertIndex = targetMatch.index + targetMatch[0].length;
+    const before = content.slice(0, insertIndex);
+    const after = content.slice(insertIndex);
+    logOnce('📦 expo-iap: Added OnsideKit pod to Podfile');
+    return `${before}${podLine}\n${after}`;
+};
+function computeAutolinkModules(existing, desired) {
+    let modules = [...existing];
+    const added = [];
+    const removed = [];
+    for (const entry of desired) {
+        const hasModule = modules.includes(entry.name);
+        if (entry.enable && !hasModule) {
+            modules = [...modules, entry.name];
+            added.push(entry.name);
+        }
+        else if (!entry.enable && hasModule) {
+            modules = modules.filter((module) => module !== entry.name);
+            removed.push(entry.name);
+        }
+    }
+    return { modules, added, removed };
+}
+const syncAutolinking = (state) => {
+    if (!fs.existsSync(AUTOLINKING_CONFIG_PATH)) {
+        return;
+    }
+    try {
+        const raw = fs.readFileSync(AUTOLINKING_CONFIG_PATH, 'utf8');
+        const config = JSON.parse(raw);
+        const iosConfig = config.ios ?? (config.ios = {});
+        const existing = Array.isArray(iosConfig.modules)
+            ? iosConfig.modules.filter((module) => module !== 'OneSideModule')
+            : [];
+        const desiredEntries = [
+            {
+                name: 'ExpoIapModule',
+                enable: state.expoIap,
+                addLog: '🔗 expo-iap: Enabled ExpoIapModule autolinking',
+                removeLog: '🧹 expo-iap: Disabled ExpoIapModule autolinking',
+            },
+            {
+                name: 'OnsideIapModule',
+                enable: state.onside,
+                addLog: '🔗 expo-iap: Enabled OnsideIapModule autolinking',
+                removeLog: '🧹 expo-iap: Disabled OnsideIapModule autolinking',
+            },
+        ];
+        const { modules: nextModules, added, removed, } = computeAutolinkModules(existing, desiredEntries.map(({ name, enable }) => ({ name, enable })));
+        for (const name of added) {
+            const entry = desiredEntries.find((candidate) => candidate.name === name);
+            if (entry) {
+                logOnce(entry.addLog);
+            }
+        }
+        for (const name of removed) {
+            const entry = desiredEntries.find((candidate) => candidate.name === name);
+            if (entry) {
+                logOnce(entry.removeLog);
+            }
+        }
+        if (added.length > 0 || removed.length > 0) {
+            iosConfig.modules = nextModules;
+            fs.writeFileSync(AUTOLINKING_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+        }
+    }
+    catch (error) {
+        config_plugins_1.WarningAggregator.addWarningIOS('expo-iap', `Failed to sync Expo IAP autolinking modules: ${String(error)}`);
+    }
+};
+const withIapIOS = (config, props) => {
     return (0, config_plugins_1.withDangerousMod)(config, [
         'ios',
         async (config) => {
@@ -140,17 +225,77 @@ const withIapIOS = (config) => {
                 content = content.replace(localPodRegex, '').replace(/\n{3,}/g, '\n\n');
                 logOnce('🧹 expo-iap: Removed local OpenIAP pod from Podfile');
             }
+            // 3) Optionally install OnsideKit when enabled in config
+            if (props?.enableOnside) {
+                content = ensureOnsidePod(content);
+            }
             fs.writeFileSync(podfilePath, content);
             return config;
         },
     ]);
 };
-const withIap = (config, options) => {
+const MODULE_RULES = {
+    expoIap: {
+        when: {
+            'expo-iap': true,
+            onside: false,
+        },
+        default: ({ options }) => options?.modules?.expoIap ?? true,
+    },
+    onside: {
+        when: {
+            'expo-iap': false,
+            onside: true,
+        },
+        default: ({ config, options }) => options?.modules?.onside ?? config.ios?.onside?.enabled ?? true,
+    },
+};
+function resolveModuleSelection(config, options) {
+    const normalizedOptions = (options ?? undefined);
+    const selection = normalizedOptions?.module ?? 'auto';
+    const includeExpoIap = pickModuleState('expoIap', selection, config, normalizedOptions);
+    const includeOnside = pickModuleState('onside', selection, config, normalizedOptions);
+    return { selection, includeExpoIap, includeOnside };
+}
+function pickModuleState(key, selection, config, options) {
+    const rules = MODULE_RULES[key];
+    const explicit = rules.when[selection];
+    if (explicit !== undefined) {
+        return explicit;
+    }
+    const override = options?.modules?.[key];
+    if (override !== undefined) {
+        return override;
+    }
+    return rules.default({ config, options });
+}
+const withIAP = (config, options) => {
     try {
+        const { includeExpoIap, includeOnside } = resolveModuleSelection(config, options);
+        const autolinkState = {
+            expoIap: includeExpoIap,
+            onside: includeOnside,
+        };
+        if (includeOnside) {
+            config.ios = {
+                ...config.ios,
+                onside: {
+                    ...(config.ios?.onside ?? {}),
+                    enabled: true,
+                },
+            };
+        }
+        else if (config.ios?.onside?.enabled) {
+            config.ios.onside.enabled = false;
+        }
         // Respect explicit flag; fall back to presence of localPath only when flag is unset
         const isLocalDev = options?.enableLocalDev ?? !!options?.localPath;
-        // Apply Android modifications (skip adding deps when linking local module)
-        let result = withIapAndroid(config, { addDeps: !isLocalDev });
+        const shouldConfigureAndroid = includeExpoIap;
+        const shouldAddAndroidDeps = includeExpoIap && !isLocalDev;
+        // Apply Android modifications (skip when Expo IAP disabled)
+        let result = shouldConfigureAndroid
+            ? withIapAndroid(config, { addDeps: shouldAddAndroidDeps })
+            : config;
         // iOS: choose one path to avoid overlap
         if (isLocalDev) {
             if (!options?.localPath) {
@@ -173,9 +318,12 @@ const withIap = (config, options) => {
         }
         else {
             // Ensure iOS Podfile is set up to resolve public CocoaPods specs
-            result = withIapIOS(result);
-            logOnce('📦 [expo-iap] Using OpenIAP from CocoaPods');
+            result = withIapIOS(result, { enableOnside: includeOnside });
+            if (includeExpoIap) {
+                logOnce('📦 [expo-iap] Using OpenIAP from CocoaPods');
+            }
         }
+        syncAutolinking(autolinkState);
         return result;
     }
     catch (error) {
@@ -184,4 +332,4 @@ const withIap = (config, options) => {
         return config;
     }
 };
-exports.default = (0, config_plugins_1.createRunOncePlugin)(withIap, pkg.name, pkg.version);
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withIAP, pkg.name, pkg.version);

package/plugin/jest.config.js

@@ -1,5 +1,15 @@
-// In documentation there is `preset: expo-module-scripts`, but it runs tests for every platform (ios, android, web, node)
-// We need only node tests right now
 module.exports = {
-  preset: 'jest-expo/node',
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.(ts|tsx)$': [
+      'ts-jest',
+      {
+        tsconfig: '<rootDir>/tsconfig.json',
+      },
+    ],
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'json'],
+  roots: ['<rootDir>/__tests__'],
+  testMatch: ['**/?(*.)+(spec|test).ts?(x)'],
 };

package/plugin/src/expoConfig.augmentation.d.ts

@@ -0,0 +1,38 @@
+import type {IOS} from '@expo/config-types';
+
+export type ExpoIapModuleOverrides = {
+  expoIap?: boolean;
+  onside?: boolean;
+};
+
+type BaseExpoIapOptions = {
+  enableLocalDev?: boolean;
+  localPath?:
+    | string
+    | {
+        ios?: string;
+        android?: string;
+      };
+};
+
+type AutoModuleOptions = BaseExpoIapOptions & {
+  module?: 'auto';
+  modules?: ExpoIapModuleOverrides;
+};
+
+type ExplicitModuleOptions = BaseExpoIapOptions & {
+  module: 'expo-iap' | 'onside';
+  modules?: never;
+};
+
+export type ExpoIapPluginCommonOptions =
+  | AutoModuleOptions
+  | ExplicitModuleOptions;
+
+declare module '@expo/config-types' {
+  interface IOS {
+    onside?: {
+      enabled?: boolean;
+    };
+  }
+}

package/plugin/src/withIAP.ts

@@ -6,9 +6,11 @@ import {
   withAppBuildGradle,
   withDangerousMod,
 } from 'expo/config-plugins';
+import type {ExpoConfig} from '@expo/config-types';
 import * as fs from 'fs';
 import * as path from 'path';
 import withLocalOpenIAP from './withLocalOpenIAP';
+import type {ExpoIapPluginCommonOptions} from './expoConfig.augmentation';
 
 const pkg = require('../../package.json');
 const openiapVersions = JSON.parse(
@@ -18,6 +20,10 @@ const openiapVersions = JSON.parse(
   ),
 );
 const OPENIAP_ANDROID_VERSION = openiapVersions.google;
+const AUTOLINKING_CONFIG_PATH = path.resolve(
+  __dirname,
+  '../../expo-module.config.json',
+);
 
 // Log a message only once per Node process
 const logOnce = (() => {
@@ -50,7 +56,7 @@ const addLineToGradle = (
   return lines.join('\n');
 };
 
-const modifyAppBuildGradle = (
+export const modifyAppBuildGradle = (
   gradle: string,
   language: 'groovy' | 'kotlin',
 ): string => {
@@ -138,7 +144,136 @@ const withIapAndroid: ConfigPlugin<{addDeps?: boolean} | void> = (
 };
 
 /** Ensure Podfile uses CocoaPods CDN and no stale local OpenIAP entry remains. */
-const withIapIOS: ConfigPlugin = (config) => {
+type WithIapIosOptions = {
+  enableOnside?: boolean;
+};
+
+const ensureOnsidePod = (content: string): string => {
+  const podLine =
+    "  pod 'OnsideKit', :git => 'https://github.com/onside-io/OnsideKit-iOS.git'";
+  const podRegex = /^\s*pod\s+'OnsideKit'\b.*$/m;
+
+  if (podRegex.test(content)) {
+    return content;
+  }
+
+  const targetMatch = content.match(/target\s+'[^']+'\s+do\s*\n/);
+  if (!targetMatch) {
+    WarningAggregator.addWarningIOS(
+      'expo-iap',
+      'Could not find a target block in Podfile when adding OnsideKit; skipping installation.',
+    );
+    return content;
+  }
+
+  const insertIndex = targetMatch.index! + targetMatch[0].length;
+  const before = content.slice(0, insertIndex);
+  const after = content.slice(insertIndex);
+
+  logOnce('📦 expo-iap: Added OnsideKit pod to Podfile');
+
+  return `${before}${podLine}\n${after}`;
+};
+
+export type AutolinkState = {expoIap: boolean; onside: boolean};
+
+type AutolinkEntry = {name: string; enable: boolean};
+
+export function computeAutolinkModules(
+  existing: string[],
+  desired: AutolinkEntry[],
+): {modules: string[]; added: string[]; removed: string[]} {
+  let modules = [...existing];
+  const added: string[] = [];
+  const removed: string[] = [];
+
+  for (const entry of desired) {
+    const hasModule = modules.includes(entry.name);
+    if (entry.enable && !hasModule) {
+      modules = [...modules, entry.name];
+      added.push(entry.name);
+    } else if (!entry.enable && hasModule) {
+      modules = modules.filter((module) => module !== entry.name);
+      removed.push(entry.name);
+    }
+  }
+
+  return {modules, added, removed};
+}
+
+const syncAutolinking = (state: AutolinkState) => {
+  if (!fs.existsSync(AUTOLINKING_CONFIG_PATH)) {
+    return;
+  }
+
+  try {
+    const raw = fs.readFileSync(AUTOLINKING_CONFIG_PATH, 'utf8');
+    const config = JSON.parse(raw);
+    const iosConfig = config.ios ?? (config.ios = {});
+    const existing: string[] = Array.isArray(iosConfig.modules)
+      ? iosConfig.modules.filter((module: string) => module !== 'OneSideModule')
+      : [];
+
+    const desiredEntries: {
+      name: string;
+      enable: boolean;
+      addLog: string;
+      removeLog: string;
+    }[] = [
+      {
+        name: 'ExpoIapModule',
+        enable: state.expoIap,
+        addLog: '🔗 expo-iap: Enabled ExpoIapModule autolinking',
+        removeLog: '🧹 expo-iap: Disabled ExpoIapModule autolinking',
+      },
+      {
+        name: 'OnsideIapModule',
+        enable: state.onside,
+        addLog: '🔗 expo-iap: Enabled OnsideIapModule autolinking',
+        removeLog: '🧹 expo-iap: Disabled OnsideIapModule autolinking',
+      },
+    ];
+
+    const {
+      modules: nextModules,
+      added,
+      removed,
+    } = computeAutolinkModules(
+      existing,
+      desiredEntries.map(({name, enable}) => ({name, enable})),
+    );
+
+    for (const name of added) {
+      const entry = desiredEntries.find((candidate) => candidate.name === name);
+      if (entry) {
+        logOnce(entry.addLog);
+      }
+    }
+
+    for (const name of removed) {
+      const entry = desiredEntries.find((candidate) => candidate.name === name);
+      if (entry) {
+        logOnce(entry.removeLog);
+      }
+    }
+
+    if (added.length > 0 || removed.length > 0) {
+      iosConfig.modules = nextModules;
+      fs.writeFileSync(
+        AUTOLINKING_CONFIG_PATH,
+        `${JSON.stringify(config, null, 2)}\n`,
+        'utf8',
+      );
+    }
+  } catch (error) {
+    WarningAggregator.addWarningIOS(
+      'expo-iap',
+      `Failed to sync Expo IAP autolinking modules: ${String(error)}`,
+    );
+  }
+};
+
+const withIapIOS: ConfigPlugin<WithIapIosOptions | void> = (config, props) => {
   return withDangerousMod(config, [
     'ios',
     async (config) => {
@@ -166,33 +301,134 @@ const withIapIOS: ConfigPlugin = (config) => {
         logOnce('🧹 expo-iap: Removed local OpenIAP pod from Podfile');
       }
 
+      // 3) Optionally install OnsideKit when enabled in config
+      if (props?.enableOnside) {
+        content = ensureOnsidePod(content);
+      }
+
       fs.writeFileSync(podfilePath, content);
       return config;
     },
   ]);
 };
 
-export interface ExpoIapPluginOptions {
-  /** Local development path for OpenIAP library */
-  localPath?:
-    | string
-    | {
-        ios?: string;
-        android?: string;
-      };
-  /** Enable local development mode */
-  enableLocalDev?: boolean;
+export interface ModuleSelectionResult {
+  selection: 'auto' | 'expo-iap' | 'onside';
+  includeExpoIap: boolean;
+  includeOnside: boolean;
+}
+
+type ModuleKey = 'expoIap' | 'onside';
+
+type ModuleRules = Record<
+  ModuleKey,
+  {
+    when: Partial<Record<ModuleSelectionResult['selection'], boolean>>;
+    default: (args: {
+      config: ExpoConfig;
+      options?: ExpoIapPluginCommonOptions;
+    }) => boolean;
+  }
+>;
+
+const MODULE_RULES: ModuleRules = {
+  expoIap: {
+    when: {
+      'expo-iap': true,
+      onside: false,
+    },
+    default: ({options}) => options?.modules?.expoIap ?? true,
+  },
+  onside: {
+    when: {
+      'expo-iap': false,
+      onside: true,
+    },
+    default: ({config, options}) =>
+      options?.modules?.onside ?? config.ios?.onside?.enabled ?? true,
+  },
+};
+
+export function resolveModuleSelection(
+  config: ExpoConfig,
+  options?: ExpoIapPluginCommonOptions | void,
+): ModuleSelectionResult {
+  const normalizedOptions = (options ?? undefined) as
+    | ExpoIapPluginCommonOptions
+    | undefined;
+
+  const selection = normalizedOptions?.module ?? 'auto';
+
+  const includeExpoIap = pickModuleState(
+    'expoIap',
+    selection,
+    config,
+    normalizedOptions,
+  );
+  const includeOnside = pickModuleState(
+    'onside',
+    selection,
+    config,
+    normalizedOptions,
+  );
+
+  return {selection, includeExpoIap, includeOnside};
+}
+
+function pickModuleState(
+  key: ModuleKey,
+  selection: ModuleSelectionResult['selection'],
+  config: ExpoConfig,
+  options?: ExpoIapPluginCommonOptions,
+): boolean {
+  const rules = MODULE_RULES[key];
+  const explicit = rules.when[selection];
+  if (explicit !== undefined) {
+    return explicit;
+  }
+  const override = options?.modules?.[key];
+  if (override !== undefined) {
+    return override;
+  }
+  return rules.default({config, options});
 }
 
-const withIap: ConfigPlugin<ExpoIapPluginOptions | void> = (
+const withIAP: ConfigPlugin<ExpoIapPluginCommonOptions | void> = (
   config,
   options,
 ) => {
   try {
+    const {includeExpoIap, includeOnside} = resolveModuleSelection(
+      config as ExpoConfig,
+      options,
+    );
+
+    const autolinkState: AutolinkState = {
+      expoIap: includeExpoIap,
+      onside: includeOnside,
+    };
+
+    if (includeOnside) {
+      config.ios = {
+        ...config.ios,
+        onside: {
+          ...(config.ios?.onside ?? {}),
+          enabled: true,
+        },
+      } as typeof config.ios;
+    } else if (config.ios?.onside?.enabled) {
+      config.ios.onside.enabled = false;
+    }
+
     // Respect explicit flag; fall back to presence of localPath only when flag is unset
     const isLocalDev = options?.enableLocalDev ?? !!options?.localPath;
-    // Apply Android modifications (skip adding deps when linking local module)
-    let result = withIapAndroid(config, {addDeps: !isLocalDev});
+    const shouldConfigureAndroid = includeExpoIap;
+    const shouldAddAndroidDeps = includeExpoIap && !isLocalDev;
+
+    // Apply Android modifications (skip when Expo IAP disabled)
+    let result = shouldConfigureAndroid
+      ? withIapAndroid(config, {addDeps: shouldAddAndroidDeps})
+      : config;
 
     // iOS: choose one path to avoid overlap
     if (isLocalDev) {
@@ -222,10 +458,14 @@ const withIap: ConfigPlugin<ExpoIapPluginOptions | void> = (
       }
     } else {
       // Ensure iOS Podfile is set up to resolve public CocoaPods specs
-      result = withIapIOS(result);
-      logOnce('📦 [expo-iap] Using OpenIAP from CocoaPods');
+      result = withIapIOS(result, {enableOnside: includeOnside});
+      if (includeExpoIap) {
+        logOnce('📦 [expo-iap] Using OpenIAP from CocoaPods');
+      }
     }
 
+    syncAutolinking(autolinkState);
+
     return result;
   } catch (error) {
     WarningAggregator.addWarningAndroid(
@@ -237,4 +477,4 @@ const withIap: ConfigPlugin<ExpoIapPluginOptions | void> = (
   }
 };
 
-export default createRunOncePlugin(withIap, pkg.name, pkg.version);
+export default createRunOncePlugin(withIAP, pkg.name, pkg.version);

package/plugin/tsconfig.json

@@ -2,7 +2,8 @@
   "extends": "expo-module-scripts/tsconfig.plugin",
   "compilerOptions": {
     "outDir": "build",
-    "rootDir": "src"
+    "rootDir": "src",
+    "isolatedModules": true
   },
   "include": ["./src"],
   "exclude": ["**/__mocks__/*", "**/__tests__/*"]

package/plugin/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/withIAP.ts","./src/withLocalOpenIAP.ts"],"version":"5.9.2"}
+{"root":["./src/expoconfig.augmentation.d.ts","./src/withiap.ts","./src/withlocalopeniap.ts"],"version":"5.9.2"}

package/src/ExpoIapModule.ts

@@ -1,10 +1,51 @@
-import {requireNativeModule} from 'expo-modules-core';
+import {requireNativeModule, UnavailabilityError} from 'expo-modules-core';
 
-// It loads the native module object from the JSI or falls back to
-// the bridge module (from NativeModulesProxy) if the remote debugger is on.
-const ExpoIapModule = requireNativeModule('ExpoIap');
+type NativeIapModuleName = 'ExpoIapOnside' | 'ExpoIap';
+
+const {module: ExpoIapModule, name: resolvedNativeModuleName} =
+  resolveNativeModule();
+
+export const USING_ONSIDE_SDK = resolvedNativeModuleName === 'ExpoIapOnside';
 
 // Platform-specific error codes from native modules
 export const NATIVE_ERROR_CODES = ExpoIapModule.ERROR_CODES || {};
 
 export default ExpoIapModule;
+
+function resolveNativeModule(): {
+  module: any;
+  name: NativeIapModuleName;
+} {
+  const candidates: NativeIapModuleName[] = ['ExpoIapOnside', 'ExpoIap'];
+
+  for (const name of candidates) {
+    try {
+      const module = requireNativeModule(name);
+      return {module, name};
+    } catch (error) {
+      if (name === 'ExpoIapOnside' && isMissingModuleError(error, name)) {
+        // Onside module is optional. If unavailable, fall back to ExpoIap.
+        continue;
+      }
+
+      throw error;
+    }
+  }
+
+  throw new UnavailabilityError(
+    'expo-iap',
+    'ExpoIap native module is unavailable',
+  );
+}
+
+function isMissingModuleError(error: unknown, moduleName: string): boolean {
+  if (error instanceof UnavailabilityError) {
+    return true;
+  }
+
+  if (error instanceof Error) {
+    return error.message.includes(`Cannot find native module '${moduleName}'`);
+  }
+
+  return false;
+}