expo-iap 2.9.7 → 3.0.1

package/codecov.yml

@@ -6,8 +6,8 @@ codecov:
 coverage:
   precision: 2
   round: down
-  range: "50...100"
-  
+  range: '50...100'
+
   status:
     project:
       default:
@@ -18,7 +18,7 @@ coverage:
           - unittests
         paths:
           - src
-      
+
       example:
         target: 40%
         threshold: 10%
@@ -27,7 +27,7 @@ coverage:
           - example
         paths:
           - example
-    
+
     patch:
       default:
         target: 60%
@@ -43,7 +43,7 @@ parsers:
       macro: no
 
 comment:
-  layout: "reach,diff,flags,files,footer"
+  layout: 'reach,diff,flags,files,footer'
   behavior: default
   require_changes: false
   require_base: false
@@ -54,21 +54,17 @@ flags:
     paths:
       - src/
     carryforward: false
-  
-  example:
-    paths:
-      - example/
-    carryforward: false
 
 ignore:
-  - "**/__tests__/**"
-  - "**/*.test.ts"
-  - "**/*.test.tsx"
-  - "**/node_modules/**"
-  - "build/**"
-  - "android/**"
-  - "ios/**"
-  - "docs/**"
-  - "plugin/**"
-  - "*.config.js"
-  - "*.setup.js"
+  - '**/__tests__/**'
+  - '**/*.test.ts'
+  - '**/*.test.tsx'
+  - '**/node_modules/**'
+  - 'build/**'
+  - 'android/**'
+  - 'ios/**'
+  - 'docs/**'
+  - 'plugin/**'
+  - '*.config.js'
+  - '*.setup.js'
+  - 'example/**'

package/ios/ExpoIapModule.swift

@@ -271,6 +271,13 @@ public class ExpoIapModule: Module {
             return try await OpenIapModule.shared.getReceiptDataIOS() ?? ""
         }
         
+        // Backward-compatible alias expected by JS layer/tests
+        AsyncFunction("getReceiptDataIOS") { () async throws -> String in
+            try await ensureConnection()
+            logDebug("getReceiptDataIOS called (alias of getReceiptIOS)")
+            return try await OpenIapModule.shared.getReceiptDataIOS() ?? ""
+        }
+        
         AsyncFunction("requestReceiptRefreshIOS") { () async throws -> String in
             try await ensureConnection()
             logDebug("requestReceiptRefreshIOS called")
@@ -307,11 +314,11 @@ public class ExpoIapModule: Module {
             return true
         }
         
-        AsyncFunction("showManageSubscriptionsIOS") { () async throws -> Bool in
+        AsyncFunction("showManageSubscriptionsIOS") { () async throws -> [[String: Any?]] in
             try await ensureConnection()
             logDebug("showManageSubscriptionsIOS called")
-            let _ = try await OpenIapModule.shared.showManageSubscriptionsIOS()
-            return true
+            let purchases = try await OpenIapModule.shared.showManageSubscriptionsIOS()
+            return OpenIapSerialization.purchases(purchases)
         }
         
         AsyncFunction("deepLinkToSubscriptionsIOS") { () async throws in

package/jest.config.js

@@ -1,7 +1,6 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
-  // Disable watchman to avoid sandbox/permission issues in CI and sandboxes
   watchman: false,
   roots: ['<rootDir>/src'],
   testMatch: [
@@ -34,12 +33,9 @@ module.exports = {
     '!src/ExpoIapModule.ts',
     '!src/ExpoIapModule.web.ts',
   ],
-  coverageThreshold: {
-    global: {
-      branches: 15,
-      functions: 15,
-      lines: 15,
-      statements: 15,
-    },
-  },
+  coveragePathIgnorePatterns: [
+    '<rootDir>/src/useIAP.ts',
+    '<rootDir>/src/ExpoIap.types.ts',
+    '<rootDir>/src/utils/constants.ts',
+  ],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-iap",
-  "version": "2.9.7",
+  "version": "3.0.1",
   "description": "In App Purchase module in Expo",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -11,10 +11,11 @@
     "lint:eslint": "eslint --fix 'src/**/*.{ts,tsx}' 'plugin/src/**/*.{ts,tsx}'",
     "lint:prettier": "prettier --write \"**/*.{md,js,jsx,ts,tsx}\"",
     "lint:tsc": "tsc -p tsconfig.json --noEmit --skipLibCheck",
-    "lint:ci": "bun run lint:tsc && bun run lint:eslint && bun run lint:prettier",
+    "lint:kt": "sh -c 'command -v ktlint >/dev/null 2>&1 && ktlint --format ./android || { echo \"ktlint not installed; skipping\"; exit 0; }'",
+    "lint:ci": "bun run lint:tsc && bun run lint:eslint && bun run lint:prettier && bun run lint:kt",
     "test": "jest",
     "test:coverage": "jest --coverage",
-    "prepare": "expo-module prepare",
+    "prepare": "expo-module prepare && husky install",
     "expo-module": "expo-module",
     "open:ios": "xed example/ios",
     "open:android": "open -a \"Android Studio\" example/android",
@@ -42,6 +43,7 @@
   "license": "MIT",
   "homepage": "https://github.com/hyochan/expo-iap#readme",
   "devDependencies": {
+    "husky": "^9.0.11",
     "@jest/globals": "^30.0.5",
     "@types/jest": "^30.0.0",
     "@types/react": "~19.1.7",

package/plugin/build/withIAP.d.ts

@@ -1,7 +1,10 @@
 import { ConfigPlugin } from 'expo/config-plugins';
 export interface ExpoIapPluginOptions {
     /** Local development path for OpenIAP library */
-    localPath?: string;
+    localPath?: string | {
+        ios?: string;
+        android?: string;
+    };
     /** Enable local development mode */
     enableLocalDev?: boolean;
 }

package/plugin/build/withIAP.js

@@ -55,39 +55,48 @@ const addLineToGradle = (content, anchor, lineToAdd, offset = 1) => {
     const lines = content.split('\n');
     const index = lines.findIndex((line) => line.match(anchor));
     if (index === -1) {
-        console.warn(`Anchor "${anchor}" not found in build.gradle. Appending to end.`);
-        lines.push(lineToAdd);
+        config_plugins_1.WarningAggregator.addWarningAndroid('expo-iap', `dependencies { ... } block not found; skipping injection: ${lineToAdd.trim()}`);
+        return content;
     }
     else {
         lines.splice(index + offset, 0, lineToAdd);
     }
     return lines.join('\n');
 };
-const modifyAppBuildGradle = (gradle) => {
+const modifyAppBuildGradle = (gradle, language) => {
     let modified = gradle;
-    // Add billing library dependencies to app-level build.gradle
-    const billingDep = `    implementation "com.android.billingclient:billing-ktx:8.0.0"`;
-    const gmsDep = `    implementation "com.google.android.gms:play-services-base:18.1.0"`;
-    let hasAddedDependency = false;
-    if (!modified.includes(billingDep)) {
-        modified = addLineToGradle(modified, /dependencies\s*{/, billingDep);
-        hasAddedDependency = true;
+    // Ensure OpenIAP dependency exists at desired version in app-level build.gradle(.kts)
+    const impl = (ga, v) => language === 'kotlin'
+        ? `    implementation("${ga}:${v}")`
+        : `    implementation "${ga}:${v}"`;
+    // Pin OpenIAP Google library to 1.1.0
+    const openiapDep = impl('io.github.hyochan.openiap:openiap-google', '1.1.0');
+    // Remove any existing openiap-google lines (any version, groovy/kotlin, implementation/api)
+    const openiapAnyLine = /^\s*(?:implementation|api)\s*\(?\s*["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*\)?\s*$/gm;
+    const hadExisting = openiapAnyLine.test(modified);
+    if (hadExisting) {
+        modified = modified.replace(openiapAnyLine, '').replace(/\n{3,}/g, '\n\n');
     }
-    if (!modified.includes(gmsDep)) {
-        modified = addLineToGradle(modified, /dependencies\s*{/, gmsDep, 1);
-        hasAddedDependency = true;
+    // Ensure the desired dependency line is present
+    if (!new RegExp(String.raw `io\.github\.hyochan\.openiap:openiap-google:1\.1\.0`).test(modified)) {
+        // Insert just after the opening `dependencies {` line
+        modified = addLineToGradle(modified, /dependencies\s*{/, openiapDep, 1);
+        logOnce(hadExisting
+            ? '🛠️ expo-iap: Replaced OpenIAP dependency with 1.1.0'
+            : '🛠️ expo-iap: Added OpenIAP dependency (1.1.0) to build.gradle');
     }
-    // Log only once and only if we actually added dependencies
-    if (hasAddedDependency)
-        logOnce('🛠️ expo-iap: Added billing dependencies to build.gradle');
     return modified;
 };
-const withIapAndroid = (config) => {
-    // Add IAP dependencies to app build.gradle
-    config = (0, config_plugins_1.withAppBuildGradle)(config, (config) => {
-        config.modResults.contents = modifyAppBuildGradle(config.modResults.contents);
-        return config;
-    });
+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);
+            return config;
+        });
+    }
     config = (0, config_plugins_1.withAndroidManifest)(config, (config) => {
         const manifest = config.modResults;
         if (!manifest.manifest['uses-permission']) {
@@ -137,17 +146,28 @@ const withIapIOS = (config) => {
 };
 const withIap = (config, options) => {
     try {
-        // Apply Android modifications
-        let result = withIapAndroid(config);
+        // 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 });
         // iOS: choose one path to avoid overlap
-        if (options?.enableLocalDev || options?.localPath) {
+        if (isLocalDev) {
             if (!options?.localPath) {
                 config_plugins_1.WarningAggregator.addWarningIOS('expo-iap', 'enableLocalDev is true but no localPath provided. Skipping local OpenIAP integration.');
             }
             else {
-                const localPath = path.resolve(options.localPath);
-                logOnce(`🔧 [expo-iap] Enabling local OpenIAP development at: ${localPath}`);
-                result = (0, withLocalOpenIAP_1.default)(result, { localPath });
+                const raw = options.localPath;
+                const resolved = typeof raw === 'string'
+                    ? path.resolve(raw)
+                    : {
+                        ios: raw.ios ? path.resolve(raw.ios) : undefined,
+                        android: raw.android ? path.resolve(raw.android) : undefined,
+                    };
+                const preview = typeof resolved === 'string'
+                    ? resolved
+                    : `ios=${resolved.ios ?? 'auto'}, android=${resolved.android ?? 'auto'}`;
+                logOnce(`🔧 [expo-iap] Enabling local OpenIAP: ${preview}`);
+                result = (0, withLocalOpenIAP_1.default)(result, { localPath: resolved });
             }
         }
         else {

package/plugin/build/withLocalOpenIAP.d.ts

@@ -1,9 +1,13 @@
-import { ConfigPlugin } from '@expo/config-plugins';
+import { ConfigPlugin } from 'expo/config-plugins';
 /**
  * Plugin to add local OpenIAP pod dependency for development
  * This is only for local development with openiap-apple library
  */
+type LocalPathOption = string | {
+    ios?: string;
+    android?: string;
+};
 declare const withLocalOpenIAP: ConfigPlugin<{
-    localPath?: string;
+    localPath?: LocalPathOption;
 } | void>;
 export default withLocalOpenIAP;

package/plugin/build/withLocalOpenIAP.js

@@ -33,51 +33,61 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const config_plugins_1 = require("@expo/config-plugins");
+const config_plugins_1 = require("expo/config-plugins");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-/**
- * Plugin to add local OpenIAP pod dependency for development
- * This is only for local development with openiap-apple library
- */
 const withLocalOpenIAP = (config, props) => {
-    return (0, config_plugins_1.withDangerousMod)(config, [
+    // Helper to resolve Android module path
+    const resolveAndroidModulePath = (p) => {
+        if (!p)
+            return null;
+        // Prefer the module directory if it exists
+        const candidates = [
+            path.join(p, 'openiap-google'),
+            path.join(p, 'openiap'),
+            p,
+        ];
+        for (const c of candidates) {
+            if (fs.existsSync(path.join(c, 'build.gradle')) ||
+                fs.existsSync(path.join(c, 'build.gradle.kts'))) {
+                return c;
+            }
+        }
+        return null;
+    };
+    // iOS: inject local pod path
+    config = (0, config_plugins_1.withDangerousMod)(config, [
         'ios',
         async (config) => {
-            const { platformProjectRoot } = config.modRequest;
+            const { platformProjectRoot, projectRoot } = config.modRequest;
+            const raw = props?.localPath;
+            const iosPath = (typeof raw === 'string' ? raw : raw?.ios) ||
+                path.resolve(projectRoot, 'openiap-apple');
             const podfilePath = path.join(platformProjectRoot, 'Podfile');
-            // Default local path or use provided one
-            const localOpenIapPath = props?.localPath ||
-                path.resolve(config.modRequest.projectRoot, 'openiap-apple');
-            // Check if local path exists
-            if (!fs.existsSync(localOpenIapPath)) {
-                console.warn(`⚠️  Local openiap-apple path not found: ${localOpenIapPath}`);
-                console.warn('   Skipping local pod injection. Using default pod resolution.');
+            if (!fs.existsSync(iosPath)) {
+                console.warn(`⚠️  Local openiap-apple path not found: ${iosPath}`);
+                console.warn('   Skipping local pod injection.');
                 return config;
             }
-            // Read Podfile
             if (!fs.existsSync(podfilePath)) {
                 console.warn(`⚠️  Podfile not found at ${podfilePath}. Skipping.`);
                 return config;
             }
             let podfileContent = fs.readFileSync(podfilePath, 'utf8');
-            // Check if already has the local pod reference
             if (podfileContent.includes("pod 'openiap',")) {
                 console.log('✅ Local OpenIAP pod already configured');
                 return config;
             }
-            // Find the target block and inject the local pod
             const targetRegex = /target\s+['"][\w]+['"]\s+do\s*\n\s*use_expo_modules!/;
             if (targetRegex.test(podfileContent)) {
                 podfileContent = podfileContent.replace(targetRegex, (match) => {
                     return `${match}
   
   # Local OpenIAP pod for development (added by expo-iap plugin)
-  pod 'openiap', :path => '${localOpenIapPath}'`;
+  pod 'openiap', :path => '${iosPath}'`;
                 });
-                // Write back to Podfile
                 fs.writeFileSync(podfilePath, podfileContent);
-                console.log(`✅ Added local OpenIAP pod at: ${localOpenIapPath}`);
+                console.log(`✅ Added local OpenIAP pod at: ${iosPath}`);
             }
             else {
                 console.warn('⚠️  Could not find target block in Podfile');
@@ -85,5 +95,154 @@ const withLocalOpenIAP = (config, props) => {
             return config;
         },
     ]);
+    // Android: include local module and add dependency if available
+    config = (0, config_plugins_1.withSettingsGradle)(config, (config) => {
+        const raw = props?.localPath;
+        const projectRoot = config.modRequest.projectRoot;
+        const androidInput = typeof raw === 'string' ? undefined : raw?.android;
+        const androidModulePath = resolveAndroidModulePath(androidInput) ||
+            resolveAndroidModulePath(path.resolve(projectRoot, 'openiap-google')) ||
+            null;
+        if (!androidModulePath || !fs.existsSync(androidModulePath)) {
+            if (androidInput) {
+                console.warn(`⚠️  Could not resolve Android OpenIAP module at: ${androidInput}. Skipping local Android linkage.`);
+            }
+            return config;
+        }
+        // 1) settings.gradle: include and map projectDir
+        const settings = config.modResults;
+        const includeLine = "include ':openiap-google'";
+        const projectDirLine = `project(':openiap-google').projectDir = new File('${androidModulePath.replace(/\\/g, '/')}')`;
+        let contents = settings.contents ?? '';
+        // Ensure pluginManagement has plugin mappings required by the included module
+        const injectPluginManagement = () => {
+            const header = 'pluginManagement {';
+            const needsVannik = !/id\s*\(\s*["']com\.vanniktech\.maven\.publish["']/.test(contents);
+            const needsKotlinAndroid = !/id\s*\(\s*["']org\.jetbrains\.kotlin\.android["']/.test(contents);
+            const needsCompose = !/id\s*\(\s*["']org\.jetbrains\.kotlin\.plugin\.compose["']/.test(contents);
+            const needsRepos = !/pluginManagement[\s\S]*?repositories\s*\{/.test(contents);
+            const pluginLines = [];
+            if (needsVannik)
+                pluginLines.push(`  id("com.vanniktech.maven.publish") version "0.29.0"`);
+            if (needsKotlinAndroid)
+                pluginLines.push(`  id("org.jetbrains.kotlin.android") version "2.0.21"`);
+            if (needsCompose)
+                pluginLines.push(`  id("org.jetbrains.kotlin.plugin.compose") version "2.0.21"`);
+            // If everything already present, skip
+            if (pluginLines.length === 0 && !needsRepos)
+                return;
+            const pluginsBlock = pluginLines.length
+                ? `plugins {\n${pluginLines.join('\n')}\n}`
+                : '';
+            const reposBlock = `repositories { gradlePluginPortal(); google(); mavenCentral() }`;
+            if (contents.includes(header)) {
+                contents = contents.replace(/pluginManagement\s*\{/, (m) => {
+                    let injection = m + `\n  // Added by expo-iap (local openiap-google)\n`;
+                    if (pluginsBlock)
+                        injection += `  ${pluginsBlock}\n`;
+                    if (needsRepos)
+                        injection += `  ${reposBlock}\n`;
+                    return injection;
+                });
+            }
+            else {
+                contents =
+                    `pluginManagement {\n  // Added by expo-iap (local openiap-google)\n` +
+                        (pluginsBlock ? `  ${pluginsBlock}\n` : '') +
+                        `  ${reposBlock}\n}\n\n${contents}`;
+            }
+        };
+        if (!/com\.vanniktech\.maven\.publish/.test(contents) ||
+            !/org\.jetbrains\.kotlin\.android/.test(contents)) {
+            injectPluginManagement();
+        }
+        if (!contents.includes(includeLine))
+            contents += `\n${includeLine}\n`;
+        if (!contents.includes(projectDirLine))
+            contents += `${projectDirLine}\n`;
+        settings.contents = contents;
+        console.log(`✅ Linked local Android module at: ${androidModulePath}`);
+        return config;
+    });
+    // 2) app/build.gradle: add implementation project(':openiap-google')
+    config = (0, config_plugins_1.withAppBuildGradle)(config, (config) => {
+        const raw = props?.localPath;
+        const projectRoot = config.modRequest.projectRoot;
+        const androidInput = typeof raw === 'string' ? undefined : raw?.android;
+        const androidModulePath = resolveAndroidModulePath(androidInput) ||
+            resolveAndroidModulePath(path.resolve(projectRoot, 'openiap-google')) ||
+            null;
+        if (!androidModulePath || !fs.existsSync(androidModulePath)) {
+            return config;
+        }
+        const gradle = config.modResults;
+        const dependencyLine = `    implementation project(':openiap-google')`;
+        // Remove any previously added Maven deps for openiap-google to avoid duplicate classes
+        const removalPatterns = [
+            // Groovy DSL: implementation "io.github.hyochan.openiap:openiap-google:x.y.z" or api "..."
+            /^\s*(?:implementation|api)\s+["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*$/gm,
+            // Kotlin DSL: implementation("io.github.hyochan.openiap:openiap-google:x.y.z") or api("...")
+            /^\s*(?:implementation|api)\s*\(\s*["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*\)\s*$/gm,
+        ];
+        let contents = gradle.contents;
+        let removedAny = false;
+        for (const pattern of removalPatterns) {
+            if (pattern.test(contents)) {
+                contents = contents.replace(pattern, '\n');
+                removedAny = true;
+            }
+        }
+        if (removedAny) {
+            gradle.contents = contents;
+            console.log('🧹 Removed Maven openiap-google to use local :openiap-google');
+        }
+        if (!gradle.contents.includes(dependencyLine)) {
+            const anchor = /dependencies\s*\{/m;
+            if (anchor.test(gradle.contents)) {
+                gradle.contents = gradle.contents.replace(anchor, (m) => `${m}\n${dependencyLine}`);
+            }
+            else {
+                gradle.contents += `\n\ndependencies {\n${dependencyLine}\n}\n`;
+            }
+            console.log('🛠️ Added dependency on local :openiap-google project');
+        }
+        return config;
+    });
+    // 3) Ensure final cleanup in app/build.gradle after all mods are applied
+    config = (0, config_plugins_1.withDangerousMod)(config, [
+        'android',
+        async (config) => {
+            try {
+                const { platformProjectRoot } = config.modRequest;
+                const appBuildGradle = path.join(platformProjectRoot, 'app', 'build.gradle');
+                if (fs.existsSync(appBuildGradle)) {
+                    let contents = fs.readFileSync(appBuildGradle, 'utf8');
+                    const patterns = [
+                        // Groovy DSL
+                        /^\s*(?:implementation|api)\s+["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*$/gm,
+                        // Kotlin DSL
+                        /^\s*(?:implementation|api)\s*\(\s*["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*\)\s*$/gm,
+                    ];
+                    let changed = false;
+                    for (const p of patterns) {
+                        if (p.test(contents)) {
+                            contents = contents.replace(p, '\n');
+                            changed = true;
+                        }
+                    }
+                    if (changed) {
+                        fs.writeFileSync(appBuildGradle, contents);
+                        console.log('🧹 expo-iap: Cleaned Maven openiap-google for local :openiap-google');
+                    }
+                }
+            }
+            catch (e) {
+                console.warn('expo-iap: cleanup step failed:', e);
+            }
+            return config;
+        },
+    ]);
+    // (removed) Avoid global root build.gradle mutations; included module should manage its plugins
+    return config;
 };
 exports.default = withLocalOpenIAP;