expo-iap 2.9.6 → 3.0.0

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,150 @@ 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 injected external deps that can conflict with the local module
+        const removalPatterns = [
+            /\n\s*implementation\s+"com\.android\.billingclient:billing-ktx:[^"]+"\s*\n/g,
+            /\n\s*implementation\s+"com\.google\.android\.gms:play-services-base:[^"]+"\s*\n/g,
+        ];
+        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 external Play Billing/GMS deps 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 = [
+                        /\n\s*implementation\s+"com\.android\.billingclient:billing-ktx:[^"]+"\s*\n/g,
+                        /\n\s*implementation\s+"com\.google\.android\.gms:play-services-base:[^"]+"\s*\n/g,
+                    ];
+                    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 app/build.gradle billing/gms deps 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;

package/plugin/src/withIAP.ts

@@ -32,49 +32,67 @@ const addLineToGradle = (
   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.`,
+    WarningAggregator.addWarningAndroid(
+      'expo-iap',
+      `dependencies { ... } block not found; skipping injection: ${lineToAdd.trim()}`,
     );
-    lines.push(lineToAdd);
+    return content;
   } else {
     lines.splice(index + offset, 0, lineToAdd);
   }
   return lines.join('\n');
 };
 
-const modifyAppBuildGradle = (gradle: string): string => {
+const modifyAppBuildGradle = (
+  gradle: string,
+  language: 'groovy' | 'kotlin',
+): string => {
   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"`;
+  // Add OpenIAP dependency to app-level build.gradle(.kts)
+  const impl = (ga: string, v: string) =>
+    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');
+
+  const hasGA = (ga: string) =>
+    new RegExp(String.raw`\b(?:implementation|api)\s*\(?["']${ga}:`, 'm').test(
+      modified,
+    );
 
   let hasAddedDependency = false;
 
-  if (!modified.includes(billingDep)) {
-    modified = addLineToGradle(modified, /dependencies\s*{/, billingDep);
-    hasAddedDependency = true;
-  }
-  if (!modified.includes(gmsDep)) {
-    modified = addLineToGradle(modified, /dependencies\s*{/, gmsDep, 1);
+  if (!hasGA('io.github.hyochan.openiap:openiap-google')) {
+    modified = addLineToGradle(modified, /dependencies\s*{/, openiapDep, 0);
     hasAddedDependency = true;
   }
 
   // Log only once and only if we actually added dependencies
   if (hasAddedDependency)
-    logOnce('🛠️ expo-iap: Added billing dependencies to build.gradle');
+    logOnce('🛠️ expo-iap: Added OpenIAP dependency to build.gradle');
 
   return modified;
 };
 
-const withIapAndroid: ConfigPlugin = (config) => {
-  // Add IAP dependencies to app build.gradle
-  config = withAppBuildGradle(config, (config) => {
-    config.modResults.contents = modifyAppBuildGradle(
-      config.modResults.contents,
-    );
-    return config;
-  });
+const withIapAndroid: ConfigPlugin<{addDeps?: boolean} | void> = (
+  config,
+  props,
+) => {
+  const addDeps = props?.addDeps ?? true;
+
+  if (addDeps) {
+    config = withAppBuildGradle(config, (config) => {
+      // language provided by config-plugins: 'groovy' | 'kotlin'
+      const language = (config.modResults as any).language || 'groovy';
+      config.modResults.contents = modifyAppBuildGradle(
+        config.modResults.contents,
+        language,
+      );
+      return config;
+    });
+  }
 
   config = withAndroidManifest(config, (config) => {
     const manifest = config.modResults;
@@ -140,7 +158,12 @@ const withIapIOS: ConfigPlugin = (config) => {
 
 export interface ExpoIapPluginOptions {
   /** Local development path for OpenIAP library */
-  localPath?: string;
+  localPath?:
+    | string
+    | {
+        ios?: string;
+        android?: string;
+      };
   /** Enable local development mode */
   enableLocalDev?: boolean;
 }
@@ -150,8 +173,9 @@ const withIap: ConfigPlugin<ExpoIapPluginOptions | void> = (
   options,
 ) => {
   try {
-    // Apply Android modifications
-    let result = withIapAndroid(config);
+    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) {
@@ -161,11 +185,23 @@ const withIap: ConfigPlugin<ExpoIapPluginOptions | void> = (
           '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 = withLocalOpenIAP(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 = withLocalOpenIAP(result, {localPath: resolved});
       }
     } else {
       // Ensure iOS Podfile is set up to resolve public CocoaPods specs

package/plugin/src/withLocalOpenIAP.ts

@@ -1,4 +1,9 @@
-import {ConfigPlugin, withDangerousMod} from '@expo/config-plugins';
+import {
+  ConfigPlugin,
+  withDangerousMod,
+  withSettingsGradle,
+  withAppBuildGradle,
+} from 'expo/config-plugins';
 import * as fs from 'fs';
 import * as path from 'path';
 
@@ -6,46 +11,60 @@ import * as path from 'path';
  * Plugin to add local OpenIAP pod dependency for development
  * This is only for local development with openiap-apple library
  */
-const withLocalOpenIAP: ConfigPlugin<{localPath?: string} | void> = (
+type LocalPathOption = string | {ios?: string; android?: string};
+
+const withLocalOpenIAP: ConfigPlugin<{localPath?: LocalPathOption} | void> = (
   config,
   props,
 ) => {
-  return withDangerousMod(config, [
+  // Helper to resolve Android module path
+  const resolveAndroidModulePath = (p?: string): string | null => {
+    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 = withDangerousMod(config, [
     'ios',
     async (config) => {
-      const {platformProjectRoot} = config.modRequest;
+      const {platformProjectRoot, projectRoot} = config.modRequest as any;
+      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!/;
 
@@ -54,12 +73,10 @@ const withLocalOpenIAP: ConfigPlugin<{localPath?: string} | void> = (
           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');
       }
@@ -67,6 +84,193 @@ const withLocalOpenIAP: ConfigPlugin<{localPath?: string} | void> = (
       return config;
     },
   ]);
+
+  // Android: include local module and add dependency if available
+  config = withSettingsGradle(config, (config) => {
+    const raw = props?.localPath;
+    const projectRoot = (config.modRequest as any).projectRoot as string;
+    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: string[] = [];
+      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 = withAppBuildGradle(config, (config) => {
+    const raw = props?.localPath;
+    const projectRoot = (config.modRequest as any).projectRoot as string;
+    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 injected external deps that can conflict with the local module
+    const removalPatterns = [
+      /\n\s*implementation\s+"com\.android\.billingclient:billing-ktx:[^"]+"\s*\n/g,
+      /\n\s*implementation\s+"com\.google\.android\.gms:play-services-base:[^"]+"\s*\n/g,
+    ];
+    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 external Play Billing/GMS deps 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 = withDangerousMod(config, [
+    'android',
+    async (config) => {
+      try {
+        const {platformProjectRoot} = config.modRequest as any;
+        const appBuildGradle = path.join(
+          platformProjectRoot,
+          'app',
+          'build.gradle',
+        );
+        if (fs.existsSync(appBuildGradle)) {
+          let contents = fs.readFileSync(appBuildGradle, 'utf8');
+          const patterns = [
+            /\n\s*implementation\s+"com\.android\.billingclient:billing-ktx:[^"]+"\s*\n/g,
+            /\n\s*implementation\s+"com\.google\.android\.gms:play-services-base:[^"]+"\s*\n/g,
+          ];
+          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 app/build.gradle billing/gms deps 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;
 };
 
 export default withLocalOpenIAP;