react-native-mparticle 2.8.1 → 2.9.0

package/plugin/build/withMParticle.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const withMParticleIOS_1 = require("./withMParticleIOS");
+const withMParticleAndroid_1 = require("./withMParticleAndroid");
+const pkg = require('../../package.json');
+/**
+ * Expo Config Plugin for mParticle React Native SDK
+ *
+ * This plugin configures your Expo project to use the mParticle SDK by:
+ * - Adding mParticle SDK initialization to iOS AppDelegate
+ * - Adding mParticle SDK initialization to Android MainApplication
+ * - Adding kit dependencies to iOS Podfile
+ * - Adding kit dependencies to Android build.gradle
+ */
+const withMParticle = (config, props) => {
+    // Validate required props
+    if (!props.iosApiKey || !props.iosApiSecret) {
+        throw new Error('react-native-mparticle plugin requires iosApiKey and iosApiSecret');
+    }
+    if (!props.androidApiKey || !props.androidApiSecret) {
+        throw new Error('react-native-mparticle plugin requires androidApiKey and androidApiSecret');
+    }
+    // Apply iOS modifications
+    config = (0, withMParticleIOS_1.withMParticleIOS)(config, props);
+    // Apply Android modifications
+    config = (0, withMParticleAndroid_1.withMParticleAndroid)(config, props);
+    return config;
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withMParticle, pkg.name, pkg.version);

package/plugin/build/withMParticleAndroid.d.ts

@@ -0,0 +1,6 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { MParticlePluginProps } from './withMParticle';
+/**
+ * Apply all Android-specific mParticle configurations
+ */
+export declare const withMParticleAndroid: ConfigPlugin<MParticlePluginProps>;

package/plugin/build/withMParticleAndroid.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMParticleAndroid = void 0;
+const config_plugins_1 = require("@expo/config-plugins");
+const generateCode_1 = require("@expo/config-plugins/build/utils/generateCode");
+// Tag used for mergeContents to identify code blocks added by this plugin
+const MPARTICLE_TAG = 'react-native-mparticle';
+/**
+ * Get the mParticle log level string for Android
+ */
+function getAndroidLogLevel(logLevel) {
+    switch (logLevel) {
+        case 'none':
+            return 'MParticle.LogLevel.NONE';
+        case 'error':
+            return 'MParticle.LogLevel.ERROR';
+        case 'warning':
+            return 'MParticle.LogLevel.WARNING';
+        case 'debug':
+            return 'MParticle.LogLevel.DEBUG';
+        case 'verbose':
+            return 'MParticle.LogLevel.VERBOSE';
+        default:
+            return null;
+    }
+}
+/**
+ * Get the mParticle environment string for Android
+ */
+function getAndroidEnvironment(environment) {
+    switch (environment) {
+        case 'development':
+            return 'MParticle.Environment.Development';
+        case 'production':
+            return 'MParticle.Environment.Production';
+        case 'autoDetect':
+            return 'MParticle.Environment.AutoDetect';
+        default:
+            return null;
+    }
+}
+/**
+ * Generate mParticle initialization code for Kotlin MainApplication
+ */
+function generateKotlinInitCode(props) {
+    const { androidApiKey, androidApiSecret, logLevel, environment, useEmptyIdentifyRequest = true, dataPlanId, dataPlanVersion, } = props;
+    const lines = [
+        '// mParticle SDK initialization',
+        'val mParticleOptions = MParticleOptions.builder(this)',
+        `    .credentials("${androidApiKey}", "${androidApiSecret}")`,
+    ];
+    const androidLogLevel = getAndroidLogLevel(logLevel);
+    if (androidLogLevel) {
+        lines.push(`    .logLevel(${androidLogLevel})`);
+    }
+    const androidEnvironment = getAndroidEnvironment(environment);
+    if (androidEnvironment) {
+        lines.push(`    .environment(${androidEnvironment})`);
+    }
+    if (dataPlanId) {
+        const versionParam = dataPlanVersion ? `, ${dataPlanVersion}` : '';
+        lines.push(`    .dataplan("${dataPlanId}"${versionParam})`);
+    }
+    if (useEmptyIdentifyRequest) {
+        lines.push('    .identify(IdentityApiRequest.withEmptyUser().build())');
+    }
+    lines.push('    .build()');
+    lines.push('MParticle.start(mParticleOptions)');
+    return lines.join('\n    ');
+}
+/**
+ * Generate mParticle initialization code for Java MainApplication
+ */
+function generateJavaInitCode(props) {
+    const { androidApiKey, androidApiSecret, logLevel, environment, useEmptyIdentifyRequest = true, dataPlanId, dataPlanVersion, } = props;
+    const lines = [
+        '// mParticle SDK initialization',
+        'MParticleOptions.Builder optionsBuilder = MParticleOptions.builder(this)',
+        `    .credentials("${androidApiKey}", "${androidApiSecret}")`,
+    ];
+    const androidLogLevel = getAndroidLogLevel(logLevel);
+    if (androidLogLevel) {
+        lines.push(`    .logLevel(${androidLogLevel})`);
+    }
+    const androidEnvironment = getAndroidEnvironment(environment);
+    if (androidEnvironment) {
+        lines.push(`    .environment(${androidEnvironment})`);
+    }
+    if (dataPlanId) {
+        const versionParam = dataPlanVersion ? `, ${dataPlanVersion}` : '';
+        lines.push(`    .dataplan("${dataPlanId}"${versionParam})`);
+    }
+    if (useEmptyIdentifyRequest) {
+        lines.push('    .identify(IdentityApiRequest.withEmptyUser().build())');
+    }
+    // Java needs semicolons
+    lines.push(';');
+    lines.push('MParticle.start(optionsBuilder.build());');
+    return lines.join('\n    ');
+}
+/**
+ * Generate mParticle import statements for Kotlin
+ */
+function getKotlinImports() {
+    return `import com.mparticle.MParticle
+import com.mparticle.MParticleOptions
+import com.mparticle.identity.IdentityApiRequest`;
+}
+/**
+ * Generate mParticle import statements for Java
+ */
+function getJavaImports() {
+    return `import com.mparticle.MParticle;
+import com.mparticle.MParticleOptions;
+import com.mparticle.identity.IdentityApiRequest;`;
+}
+/**
+ * Add mParticle configuration to MainApplication
+ * Handles both Kotlin and Java
+ */
+const withMParticleMainApplication = (config, props) => {
+    return (0, config_plugins_1.withMainApplication)(config, config => {
+        const { contents, language } = config.modResults;
+        // Check if mParticle is already initialized
+        if (contents.includes('MParticleOptions') ||
+            contents.includes('mParticleOptions')) {
+            return config;
+        }
+        const isKotlin = language === 'kt';
+        if (isKotlin) {
+            config.modResults.contents = addMParticleToKotlinMainApplication(contents, props);
+        }
+        else if (language === 'java') {
+            config.modResults.contents = addMParticleToJavaMainApplication(contents, props);
+        }
+        else {
+            console.warn(`[react-native-mparticle] Unsupported MainApplication language: ${language}. ` +
+                'mParticle initialization must be added manually.');
+        }
+        return config;
+    });
+};
+/**
+ * Add mParticle import and initialization to Kotlin MainApplication
+ */
+function addMParticleToKotlinMainApplication(contents, props) {
+    // Add import statements using mergeContents
+    const withImports = (0, generateCode_1.mergeContents)({
+        src: contents,
+        newSrc: getKotlinImports(),
+        anchor: /^package .+$/m,
+        offset: 1,
+        tag: `${MPARTICLE_TAG}-import`,
+        comment: '//',
+    });
+    // Generate initialization code
+    const initCode = generateKotlinInitCode(props);
+    // Find the right place to add initialization code
+    // Try ApplicationLifecycleDispatcher first (Expo pattern), then super.onCreate()
+    let result = withImports.contents;
+    if (result.includes('ApplicationLifecycleDispatcher.onApplicationCreate(this)')) {
+        const withInit = (0, generateCode_1.mergeContents)({
+            src: result,
+            newSrc: `\n    ${initCode}\n`,
+            anchor: /ApplicationLifecycleDispatcher\.onApplicationCreate\(this\)/,
+            offset: 1,
+            tag: `${MPARTICLE_TAG}-init`,
+            comment: '//',
+        });
+        result = withInit.contents;
+    }
+    else if (result.includes('super.onCreate()')) {
+        const withInit = (0, generateCode_1.mergeContents)({
+            src: result,
+            newSrc: `\n    ${initCode}\n`,
+            anchor: /super\.onCreate\(\)/,
+            offset: 1,
+            tag: `${MPARTICLE_TAG}-init`,
+            comment: '//',
+        });
+        result = withInit.contents;
+    }
+    return result;
+}
+/**
+ * Add mParticle import and initialization to Java MainApplication
+ */
+function addMParticleToJavaMainApplication(contents, props) {
+    // Add import statements using mergeContents
+    const withImports = (0, generateCode_1.mergeContents)({
+        src: contents,
+        newSrc: getJavaImports(),
+        anchor: /^package .+;$/m,
+        offset: 1,
+        tag: `${MPARTICLE_TAG}-import`,
+        comment: '//',
+    });
+    // Generate initialization code
+    const initCode = generateJavaInitCode(props);
+    // Find the right place to add initialization code
+    let result = withImports.contents;
+    if (result.includes('ApplicationLifecycleDispatcher.onApplicationCreate(this);')) {
+        const withInit = (0, generateCode_1.mergeContents)({
+            src: result,
+            newSrc: `\n    ${initCode}\n`,
+            anchor: /ApplicationLifecycleDispatcher\.onApplicationCreate\(this\);/,
+            offset: 1,
+            tag: `${MPARTICLE_TAG}-init`,
+            comment: '//',
+        });
+        result = withInit.contents;
+    }
+    else if (result.includes('super.onCreate();')) {
+        const withInit = (0, generateCode_1.mergeContents)({
+            src: result,
+            newSrc: `\n    ${initCode}\n`,
+            anchor: /super\.onCreate\(\);/,
+            offset: 1,
+            tag: `${MPARTICLE_TAG}-init`,
+            comment: '//',
+        });
+        result = withInit.contents;
+    }
+    return result;
+}
+/**
+ * Add kit dependencies to app/build.gradle
+ */
+const withMParticleAppBuildGradle = (config, props) => {
+    return (0, config_plugins_1.withAppBuildGradle)(config, config => {
+        const { contents } = config.modResults;
+        if (!props.androidKits || props.androidKits.length === 0) {
+            return config;
+        }
+        // Check if kits are already added
+        const kitsAlreadyAdded = props.androidKits.every(kit => contents.includes(`com.mparticle:${kit}`));
+        if (kitsAlreadyAdded) {
+            return config;
+        }
+        // Generate kit dependency lines
+        // Use + for version to auto-match core SDK version
+        const kitDependencies = props.androidKits
+            .map(kit => `    implementation "com.mparticle:${kit}:+"`)
+            .join('\n');
+        // Use mergeContents for idempotent injection
+        const withKits = (0, generateCode_1.mergeContents)({
+            src: contents,
+            newSrc: `\n    // mParticle kits\n${kitDependencies}`,
+            anchor: /dependencies\s*\{/,
+            offset: 1,
+            tag: `${MPARTICLE_TAG}-kits`,
+            comment: '//',
+        });
+        config.modResults.contents = withKits.contents;
+        return config;
+    });
+};
+/**
+ * Apply all Android-specific mParticle configurations
+ */
+const withMParticleAndroid = (config, props) => {
+    config = withMParticleMainApplication(config, props);
+    config = withMParticleAppBuildGradle(config, props);
+    return config;
+};
+exports.withMParticleAndroid = withMParticleAndroid;

package/plugin/build/withMParticleIOS.d.ts

@@ -0,0 +1,6 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { MParticlePluginProps } from './withMParticle';
+/**
+ * Apply all iOS-specific mParticle configurations
+ */
+export declare const withMParticleIOS: ConfigPlugin<MParticlePluginProps>;

package/plugin/build/withMParticleIOS.js

@@ -0,0 +1,362 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMParticleIOS = void 0;
+const config_plugins_1 = require("@expo/config-plugins");
+const generateCode_1 = require("@expo/config-plugins/build/utils/generateCode");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Tag used for mergeContents to identify code blocks added by this plugin
+const MPARTICLE_TAG = 'react-native-mparticle';
+/**
+ * Get the mParticle log level for iOS (Swift syntax)
+ */
+function getSwiftLogLevel(logLevel) {
+    switch (logLevel) {
+        case 'none':
+            return '.none';
+        case 'error':
+            return '.error';
+        case 'warning':
+            return '.warning';
+        case 'debug':
+            return '.debug';
+        case 'verbose':
+            return '.verbose';
+        default:
+            return null;
+    }
+}
+/**
+ * Get the mParticle environment for iOS (Swift syntax)
+ */
+function getSwiftEnvironment(environment) {
+    switch (environment) {
+        case 'development':
+            return '.development';
+        case 'production':
+            return '.production';
+        case 'autoDetect':
+            return '.autoDetect';
+        default:
+            return null;
+    }
+}
+/**
+ * Get the mParticle log level for iOS (Objective-C syntax)
+ */
+function getObjcLogLevel(logLevel) {
+    switch (logLevel) {
+        case 'none':
+            return 'MPILogLevelNone';
+        case 'error':
+            return 'MPILogLevelError';
+        case 'warning':
+            return 'MPILogLevelWarning';
+        case 'debug':
+            return 'MPILogLevelDebug';
+        case 'verbose':
+            return 'MPILogLevelVerbose';
+        default:
+            return null;
+    }
+}
+/**
+ * Get the mParticle environment for iOS (Objective-C syntax)
+ */
+function getObjcEnvironment(environment) {
+    switch (environment) {
+        case 'development':
+            return 'MPEnvironmentDevelopment';
+        case 'production':
+            return 'MPEnvironmentProduction';
+        case 'autoDetect':
+            return 'MPEnvironmentAutoDetect';
+        default:
+            return null;
+    }
+}
+/**
+ * Generate mParticle initialization code for Swift AppDelegate
+ */
+function generateSwiftInitCode(props) {
+    const { iosApiKey, iosApiSecret, logLevel, environment, useEmptyIdentifyRequest = true, dataPlanId, dataPlanVersion, } = props;
+    const lines = [
+        '// mParticle SDK initialization',
+        `let mParticleOptions = MParticleOptions(key: "${iosApiKey}", secret: "${iosApiSecret}")`,
+    ];
+    const swiftLogLevel = getSwiftLogLevel(logLevel);
+    if (swiftLogLevel) {
+        lines.push(`mParticleOptions.logLevel = ${swiftLogLevel}`);
+    }
+    const swiftEnvironment = getSwiftEnvironment(environment);
+    if (swiftEnvironment) {
+        lines.push(`mParticleOptions.environment = ${swiftEnvironment}`);
+    }
+    if (dataPlanId) {
+        lines.push(`mParticleOptions.dataPlanId = "${dataPlanId}"`);
+        if (dataPlanVersion) {
+            lines.push(`mParticleOptions.dataPlanVersion = ${dataPlanVersion} as NSNumber`);
+        }
+    }
+    if (useEmptyIdentifyRequest) {
+        lines.push('let identifyRequest = MPIdentityApiRequest.withEmptyUser()');
+        lines.push('mParticleOptions.identifyRequest = identifyRequest');
+    }
+    lines.push('MParticle.sharedInstance().start(with: mParticleOptions)');
+    return lines.join('\n    ');
+}
+/**
+ * Generate mParticle initialization code for Objective-C AppDelegate
+ */
+function generateObjcInitCode(props) {
+    const { iosApiKey, iosApiSecret, logLevel, environment, useEmptyIdentifyRequest = true, dataPlanId, dataPlanVersion, } = props;
+    const lines = [
+        '// mParticle SDK initialization',
+        `MParticleOptions *mParticleOptions = [MParticleOptions optionsWithKey:@"${iosApiKey}"`,
+        `                                                               secret:@"${iosApiSecret}"];`,
+    ];
+    const objcLogLevel = getObjcLogLevel(logLevel);
+    if (objcLogLevel) {
+        lines.push(`mParticleOptions.logLevel = ${objcLogLevel};`);
+    }
+    const objcEnvironment = getObjcEnvironment(environment);
+    if (objcEnvironment) {
+        lines.push(`mParticleOptions.environment = ${objcEnvironment};`);
+    }
+    if (dataPlanId) {
+        lines.push(`mParticleOptions.dataPlanId = @"${dataPlanId}";`);
+        if (dataPlanVersion) {
+            lines.push(`mParticleOptions.dataPlanVersion = @(${dataPlanVersion});`);
+        }
+    }
+    if (useEmptyIdentifyRequest) {
+        lines.push('MPIdentityApiRequest *identifyRequest = [MPIdentityApiRequest requestWithEmptyUser];');
+        lines.push('mParticleOptions.identifyRequest = identifyRequest;');
+    }
+    lines.push('[[MParticle sharedInstance] startWithOptions:mParticleOptions];');
+    return lines.join('\n  ');
+}
+/**
+ * Add mParticle configuration to AppDelegate
+ * Handles both Swift and Objective-C/Objective-C++
+ */
+const withMParticleAppDelegate = (config, props) => {
+    return (0, config_plugins_1.withAppDelegate)(config, config => {
+        const { contents, language } = config.modResults;
+        // Check if mParticle is already initialized
+        if (contents.includes('MParticleOptions') ||
+            contents.includes('mParticleOptions')) {
+            return config;
+        }
+        if (language === 'swift') {
+            config.modResults.contents = addMParticleToSwiftAppDelegate(contents, props);
+        }
+        else if (language === 'objc' || language === 'objcpp') {
+            config.modResults.contents = addMParticleToObjcAppDelegate(contents, props);
+        }
+        else {
+            console.warn(`[react-native-mparticle] Unsupported AppDelegate language: ${language}. ` +
+                'mParticle initialization must be added manually.');
+        }
+        return config;
+    });
+};
+/**
+ * Add mParticle import and initialization to Swift AppDelegate
+ */
+function addMParticleToSwiftAppDelegate(contents, props) {
+    // Add import statement
+    // Use mergeContents for safe, idempotent code injection
+    const withImport = (0, generateCode_1.mergeContents)({
+        src: contents,
+        newSrc: 'import mParticle_Apple_SDK',
+        anchor: /import Expo/,
+        offset: 1,
+        tag: `${MPARTICLE_TAG}-import`,
+        comment: '//',
+    });
+    // Generate initialization code
+    const initCode = generateSwiftInitCode(props);
+    // Find the right place to add initialization code
+    // For Expo SDK 53+, it should be in didFinishLaunchingWithOptions before the return
+    // Look for the return super.application pattern
+    const withInit = (0, generateCode_1.mergeContents)({
+        src: withImport.contents,
+        newSrc: `\n    ${initCode}\n`,
+        anchor: /return super\.application\(application, didFinishLaunchingWithOptions: launchOptions\)/,
+        offset: 0,
+        tag: `${MPARTICLE_TAG}-init`,
+        comment: '//',
+    });
+    return withInit.contents;
+}
+/**
+ * Add mParticle import and initialization to Objective-C AppDelegate
+ */
+function addMParticleToObjcAppDelegate(contents, props) {
+    // Add import statement after React import or first import
+    const withImport = (0, generateCode_1.mergeContents)({
+        src: contents,
+        newSrc: '#import "mParticle.h"',
+        anchor: /#import <React\/RCTBundleURLProvider\.h>|#import "AppDelegate\.h"/,
+        offset: 1,
+        tag: `${MPARTICLE_TAG}-import`,
+        comment: '//',
+    });
+    // Generate initialization code
+    const initCode = generateObjcInitCode(props);
+    // Try different patterns for where to insert the init code
+    let result = withImport.contents;
+    // Pattern 1: Expo's return [super application...
+    if (result.includes('return [super application:application didFinishLaunchingWithOptions:launchOptions];')) {
+        const withInit = (0, generateCode_1.mergeContents)({
+            src: result,
+            newSrc: `\n  ${initCode}\n`,
+            anchor: /return \[super application:application didFinishLaunchingWithOptions:launchOptions\];/,
+            offset: 0,
+            tag: `${MPARTICLE_TAG}-init`,
+            comment: '//',
+        });
+        result = withInit.contents;
+    }
+    // Pattern 2: self.initialProps = @{};
+    else if (result.includes('self.initialProps = @{};')) {
+        const withInit = (0, generateCode_1.mergeContents)({
+            src: result,
+            newSrc: `\n  ${initCode}\n`,
+            anchor: /self\.initialProps = @\{\};/,
+            offset: 1,
+            tag: `${MPARTICLE_TAG}-init`,
+            comment: '//',
+        });
+        result = withInit.contents;
+    }
+    // Pattern 3: return YES;
+    else if (result.includes('return YES;')) {
+        const withInit = (0, generateCode_1.mergeContents)({
+            src: result,
+            newSrc: `\n  ${initCode}\n`,
+            anchor: /return YES;/,
+            offset: 0,
+            tag: `${MPARTICLE_TAG}-init`,
+            comment: '//',
+        });
+        result = withInit.contents;
+    }
+    return result;
+}
+/**
+ * Known transitive dependencies that need dynamic linking for each kit
+ * These are dependencies of mParticle kits that must also be dynamic frameworks
+ */
+const KIT_TRANSITIVE_DEPENDENCIES = {
+    'mParticle-Rokt': ['Rokt-Widget'],
+    // Add other kit dependencies here as needed
+    // "mParticle-Amplitude": [],
+    // "mParticle-Braze": [],
+};
+/**
+ * Get all pods that need dynamic framework linking
+ */
+function getDynamicFrameworkPods(iosKits) {
+    const pods = ['mParticle-Apple-SDK'];
+    if (iosKits) {
+        for (const kit of iosKits) {
+            pods.push(kit);
+            // Add transitive dependencies for this kit
+            const transitiveDeps = KIT_TRANSITIVE_DEPENDENCIES[kit];
+            if (transitiveDeps) {
+                pods.push(...transitiveDeps);
+            }
+        }
+    }
+    return [...new Set(pods)]; // Remove duplicates
+}
+/**
+ * Add kit pods and pre_install hook to Podfile
+ */
+const withMParticlePodfile = (config, props) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        'ios',
+        async (config) => {
+            const podfilePath = path.join(config.modRequest.platformProjectRoot, 'Podfile');
+            if (!fs.existsSync(podfilePath)) {
+                return config;
+            }
+            let podfileContent = fs.readFileSync(podfilePath, 'utf-8');
+            // Add pre_install hook for dynamic framework linking if not already present
+            if (!podfileContent.includes('mParticle-Apple-SDK')) {
+                // Get all pods that need dynamic linking (including transitive dependencies)
+                const dynamicPods = getDynamicFrameworkPods(props.iosKits);
+                const podConditions = dynamicPods
+                    .map(pod => `pod.name == '${pod}'`)
+                    .join(' || ');
+                const preInstallHook = `
+# mParticle dynamic framework linking (added by react-native-mparticle expo plugin)
+pre_install do |installer|
+  installer.pod_targets.each do |pod|
+    if ${podConditions}
+      def pod.build_type;
+        Pod::BuildType.new(:linkage => :dynamic, :packaging => :framework)
+      end
+    end
+  end
+end
+`;
+                // Add pre_install hook after platform declaration
+                const platformRegex = /platform :ios.*\n/;
+                if (platformRegex.test(podfileContent)) {
+                    podfileContent = podfileContent.replace(platformRegex, `$&${preInstallHook}`);
+                }
+            }
+            // Add kit pods if specified
+            if (props.iosKits && props.iosKits.length > 0) {
+                const kitPods = props.iosKits.map(kit => `  pod '${kit}'`).join('\n');
+                // Check if kits are already added
+                const kitsAlreadyAdded = props.iosKits.every(kit => podfileContent.includes(`pod '${kit}'`));
+                if (!kitsAlreadyAdded) {
+                    // Add kit pods inside the main target block
+                    // Look for use_react_native! and add after it
+                    const useReactNativeRegex = /(use_react_native!\([^)]*\))/s;
+                    if (useReactNativeRegex.test(podfileContent)) {
+                        podfileContent = podfileContent.replace(useReactNativeRegex, `$1\n\n  # mParticle kits (added by react-native-mparticle expo plugin)\n${kitPods}`);
+                    }
+                }
+            }
+            fs.writeFileSync(podfilePath, podfileContent);
+            return config;
+        },
+    ]);
+};
+/**
+ * Apply all iOS-specific mParticle configurations
+ */
+const withMParticleIOS = (config, props) => {
+    config = withMParticleAppDelegate(config, props);
+    config = withMParticlePodfile(config, props);
+    return config;
+};
+exports.withMParticleIOS = withMParticleIOS;