react-native-mparticle 2.8.0 → 2.9.0

package/package.json

@@ -4,31 +4,55 @@
   "homepage": "https://www.mparticle.com",
   "license": "Apache-2.0",
   "repository": "mParticle/react-native-mparticle",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "react-native": "js/index",
   "scripts": {
     "build": "tsc",
+    "build:plugin": "tsc --build plugin",
     "clean": "rm -rf lib",
-    "prepare": "yarn clean && yarn build",
-    "dev:pack": "yarn build && yarn pack --filename react-native-mparticle-latest.tgz",
+    "clean:plugin": "rm -rf plugin/build",
+    "prepare": "yarn clean && yarn build && yarn build:plugin",
+    "dev:pack": "yarn build && yarn build:plugin && yarn pack --filename react-native-mparticle-latest.tgz",
     "dev:link": "./dev-link.sh",
     "lint": "eslint '{js,lib}/**/*.{ts,tsx}' --fix",
     "format": "prettier --write '{js,lib}/**/*.{ts,tsx}'",
     "test": "npm run lint"
   },
+  "files": [
+    "android",
+    "ios",
+    "js",
+    "lib",
+    "react-native-mparticle.podspec",
+    "app.plugin.js",
+    "plugin"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
   "dependencies": {},
   "peerDependencies": {
     "react": ">= 16.0.0-alpha.12",
-    "react-native": ">= 0.45.0"
+    "react-native": ">= 0.45.0",
+    "@expo/config-plugins": ">=7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@expo/config-plugins": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@expo/config-plugins": "^7.2.5",
     "@typescript-eslint/eslint-plugin": "^5.62.0",
     "@typescript-eslint/parser": "^5.62.0",
     "eslint": "^8.45.0",
     "eslint-config-prettier": "^8.10.0",
     "eslint-plugin-prettier": "^4.2.1",
+    "expo-module-scripts": "^3.0.0",
     "prettier": "^2.8.8",
     "@types/react": "^18.0.0",
     "@types/react-native": "^0.70.0",

package/plugin/build/withMParticle.d.ts

@@ -0,0 +1,60 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+/**
+ * mParticle plugin configuration options
+ */
+export interface MParticlePluginProps {
+    /**
+     * iOS API key from mParticle dashboard
+     */
+    iosApiKey: string;
+    /**
+     * iOS API secret from mParticle dashboard
+     */
+    iosApiSecret: string;
+    /**
+     * Android API key from mParticle dashboard
+     */
+    androidApiKey: string;
+    /**
+     * Android API secret from mParticle dashboard
+     */
+    androidApiSecret: string;
+    /**
+     * Log level for debugging
+     * @default 'none'
+     */
+    logLevel?: 'none' | 'error' | 'warning' | 'debug' | 'verbose';
+    /**
+     * mParticle environment
+     * @default 'autoDetect'
+     */
+    environment?: 'development' | 'production' | 'autoDetect';
+    /**
+     * Data plan ID for validation
+     */
+    dataPlanId?: string;
+    /**
+     * Data plan version for validation
+     */
+    dataPlanVersion?: number;
+    /**
+     * iOS kit pod names to include
+     * @example ['mParticle-Rokt', 'mParticle-Amplitude']
+     */
+    iosKits?: string[];
+    /**
+     * Android kit artifact names to include (version auto-detected from core SDK)
+     * @example ['android-rokt-kit', 'android-amplitude-kit']
+     */
+    androidKits?: string[];
+    /**
+     * Whether to use an empty identify request at initialization
+     * If true or omitted, uses requestWithEmptyUser/withEmptyUser()
+     * If false, no identify request is made at initialization
+     * Identity should be updated from React Native code after initialization
+     * @default true
+     */
+    useEmptyIdentifyRequest?: boolean;
+}
+declare const _default: ConfigPlugin<MParticlePluginProps>;
+export default _default;

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>;