customerio-expo-plugin 3.3.0 → 3.5.0

package/plugin/src/helpers/constants/ios.ts

@@ -1,18 +1,97 @@
+import fs from 'fs';
+import * as semver from 'semver';
+
 const path = require('path');
-const resolveFrom = require('resolve-from');
+import { resolveRNSDK, tryReadRNVersion } from '../../utils/resolveRNSDK';
+
+// Threshold at which React Native pod autolinking moves from
+// @react-native-community/cli (lexical, symlink-preserving) to
+// expo-modules-autolinking (realpath). The two flavors emit different
+// :path strings on pnpm/yarn-symlink layouts, so to keep CocoaPods happy
+// we must match whichever flavor will resolve the same package later.
+const RN_REALPATH_AUTOLINKING_MIN_VERSION = '0.80.0';
+
+const PLUGIN_LOG_PREFIX = '[CustomerIO Plugin]';
+
+// Always-on so the trail shows up in customer-shared `expo prebuild`
+// output without needing a separate verbose-mode opt-in.
+function pluginLog(message: string): void {
+  // eslint-disable-next-line no-console
+  console.log(`${PLUGIN_LOG_PREFIX} ${message}`);
+}
 
+/**
+ * Returns the relative path from the iOS project dir to the installed
+ * customerio-reactnative directory, in the exact form React Native pod
+ * autolinking will emit for the same package. The two autolinking
+ * flavors disagree on path shape under pnpm/yarn symlinks:
+ *
+ *   - RN <0.80 (`@react-native-community/cli`): walks node_modules
+ *     lexically, preserves symlinks. We keep the symlink path too —
+ *     `tryResolveRNSDK` already does this without calling realpath.
+ *
+ *   - RN >=0.80 (`expo-modules-autolinking`): realpaths the package
+ *     via Node, emitting the underlying `.pnpm/...` (or yarn-classic)
+ *     path. We match by realpath'ing the resolved directory.
+ *
+ * Decision points are logged so a customer's prebuild output is enough
+ * to triage path-resolution issues without a follow-up "set
+ * CUSTOMERIO_DEBUG_MODE and rerun" round-trip.
+ */
 export function getRelativePathToRNSDK(iosPath: string) {
-  // Root path of the Expo project
   const rootAppPath = path.dirname(iosPath);
+  pluginLog(
+    `Resolving customerio-reactnative for Podfile (iosPath=${iosPath}, projectRoot=${rootAppPath})`
+  );
+
+  const { packageDir } = resolveRNSDK(rootAppPath);
+  pluginLog(`customerio-reactnative resolved to: ${packageDir}`);
 
-  // Path of the cio RN package.json file. Example: test-app/node_modules/customerio-reactnative/package.json
-  const pluginPackageJsonPath = resolveFrom.silent(
-    rootAppPath,
-    `customerio-reactnative/package.json`
+  const rnVersion = tryReadRNVersion(rootAppPath);
+  pluginLog(`Detected react-native version: ${rnVersion ?? 'unknown'}`);
+
+  const useLexical = shouldUseLexicalPath(rnVersion);
+  pluginLog(
+    useLexical
+      ? `RN <${RN_REALPATH_AUTOLINKING_MIN_VERSION} — using lexical/symlink path to match @react-native-community/cli autolinking`
+      : `RN >=${RN_REALPATH_AUTOLINKING_MIN_VERSION} or unknown — using realpath to match expo-modules-autolinking`
   );
 
-  // Example: ../node_modules/customerio-reactnative
-  return path.relative(iosPath, path.dirname(pluginPackageJsonPath));
+  let absolutePath: string;
+  if (useLexical) {
+    absolutePath = packageDir;
+  } else {
+    try {
+      absolutePath = fs.realpathSync(packageDir);
+      if (absolutePath !== packageDir) {
+        pluginLog(`Realpath differs from resolved dir: ${absolutePath}`);
+      }
+    } catch (err) {
+      pluginLog(
+        `realpathSync failed (${
+          err instanceof Error ? err.message : String(err)
+        }); falling back to symlink path`
+      );
+      absolutePath = packageDir;
+    }
+  }
+
+  const relativePath = path.relative(iosPath, absolutePath);
+  pluginLog(`Final Podfile :path => '${relativePath}'`);
+  return relativePath;
+}
+
+function shouldUseLexicalPath(rnVersion: string | null): boolean {
+  if (!rnVersion) {
+    // Modern Expo (realpath) has been the working path for the last few
+    // SDKs, so it's the safer default when RN can't be detected.
+    return false;
+  }
+  const coerced = semver.valid(rnVersion) || semver.coerce(rnVersion);
+  if (!coerced) {
+    return false;
+  }
+  return semver.lt(coerced, RN_REALPATH_AUTOLINKING_MIN_VERSION);
 }
 
 export const IOS_DEPLOYMENT_TARGET = '13.0';

package/plugin/src/helpers/utils/injectCIOPodfileCode.ts

@@ -11,92 +11,139 @@ export type InjectCIOPodfileOptions = {
   hasPush?: boolean;
 };
 
-/** Builds the host app pod line for the Podfile (single subspec or :subspecs with location). Exported for tests. */
+/** Builds the host-app pod snippet for the Podfile.
+ *
+ * The :path is resolved at prebuild time by `getRelativePathToRNSDK`,
+ * which dispatches on the installed React Native version so the path
+ * matches what RN pod autolinking will emit (lexical for RN <0.80,
+ * realpath for RN >=0.80). Baking the resolved string directly avoids
+ * any Ruby/install-time logic in the Podfile and keeps the snippet
+ * trivially diff-able.
+ *
+ * Exported for tests.
+ */
 export function buildHostAppPodSnippet(
   iosPath: string,
   isFcmPushProvider: boolean,
   options?: InjectCIOPodfileOptions
 ): string {
-  const path = getRelativePathToRNSDK(iosPath);
+  const resolvedPath = getRelativePathToRNSDK(iosPath);
   const locationEnabled = options?.locationEnabled === true;
   const hasPush = options?.hasPush !== false;
 
   if (!locationEnabled) {
     const subspec = isFcmPushProvider ? 'fcm' : 'apn';
-    return `pod 'customerio-reactnative/${subspec}', :path => '${path}'`;
+    return `pod 'customerio-reactnative/${subspec}', :path => '${resolvedPath}'`;
   }
-
   if (!hasPush) {
-    return `pod 'customerio-reactnative', :subspecs => ['location'], :path => '${path}'`;
+    return `pod 'customerio-reactnative', :subspecs => ['location'], :path => '${resolvedPath}'`;
   }
-
   const pushSubspec = isFcmPushProvider ? 'fcm' : 'apn';
-  return `pod 'customerio-reactnative', :subspecs => ['${pushSubspec}', 'location'], :path => '${path}'`;
+  return `pod 'customerio-reactnative', :subspecs => ['${pushSubspec}', 'location'], :path => '${resolvedPath}'`;
 }
 
-export async function injectCIOPodfileCode(
+const HOST_APP_BLOCK_START = '# --- CustomerIO Host App START ---';
+const HOST_APP_BLOCK_END = '# --- CustomerIO Host App END ---';
+const NOTIFICATION_BLOCK_START = '# --- CustomerIO Notification START ---';
+const NOTIFICATION_BLOCK_END = '# --- CustomerIO Notification END ---';
+
+/**
+ * Pure string transform: given the existing Podfile contents, returns the
+ * Podfile with the CustomerIO host-app block injected before the Expo
+ * `post_install do |installer|` anchor. Idempotent — returns input unchanged
+ * if the block is already present.
+ */
+export function injectHostAppPodfileCode(
+  podfileContent: string,
   iosPath: string,
   isFcmPushProvider: boolean,
   options?: InjectCIOPodfileOptions
-) {
-  const blockStart = '# --- CustomerIO Host App START ---';
-  const blockEnd = '# --- CustomerIO Host App END ---';
-
-  const filename = `${iosPath}/Podfile`;
-  const podfile = await FileManagement.read(filename);
-  const matches = podfile.match(new RegExp(blockStart));
-
-  if (!matches) {
-    // We need to decide what line of code in the Podfile to insert our native code.
-    // The "post_install" line is always present in an Expo project Podfile so it's reliable.
-    // Find that line in the Podfile and then we will insert our code above that line.
-    const lineInPodfileToInjectSnippetBefore = /post_install do \|installer\|/;
+): string {
+  if (podfileContent.match(new RegExp(HOST_APP_BLOCK_START))) {
+    return podfileContent;
+  }
 
-    const podLine = buildHostAppPodSnippet(iosPath, isFcmPushProvider, options);
+  // We need to decide what line of code in the Podfile to insert our native code.
+  // The "post_install" line is always present in an Expo project Podfile so it's reliable.
+  // Find that line in the Podfile and then we will insert our code above that line.
+  const lineInPodfileToInjectSnippetBefore = /post_install do \|installer\|/;
+  const podLine = buildHostAppPodSnippet(iosPath, isFcmPushProvider, options);
 
-    const snippetToInjectInPodfile = `
-${blockStart}
+  const snippetToInjectInPodfile = `
+${HOST_APP_BLOCK_START}
   ${podLine}
-${blockEnd}
+${HOST_APP_BLOCK_END}
 `.trim();
 
-    FileManagement.write(
-      filename,
-      injectCodeByRegex(
-        podfile,
-        lineInPodfileToInjectSnippetBefore,
-        snippetToInjectInPodfile
-      ).join('\n')
-    );
-  } else {
-    logger.info('CustomerIO Podfile snippets already exists. Skipping...');
-  }
+  return injectCodeByRegex(
+    podfileContent,
+    lineInPodfileToInjectSnippetBefore,
+    snippetToInjectInPodfile,
+  ).join('\n');
 }
 
-export async function injectCIONotificationPodfileCode(
+export async function injectCIOPodfileCode(
   iosPath: string,
-  useFrameworks: CustomerIOPluginOptionsIOS['useFrameworks'],
-  isFcmPushProvider: boolean
+  isFcmPushProvider: boolean,
+  options?: InjectCIOPodfileOptions
 ) {
   const filename = `${iosPath}/Podfile`;
   const podfile = await FileManagement.read(filename);
+  const next = injectHostAppPodfileCode(podfile, iosPath, isFcmPushProvider, options);
+  if (next !== podfile) {
+    FileManagement.write(filename, next);
+  } else {
+    logger.info('CustomerIO Podfile snippets already exists. Skipping...');
+  }
+}
 
-  const blockStart = '# --- CustomerIO Notification START ---';
-  const blockEnd = '# --- CustomerIO Notification END ---';
-
-  const matches = podfile.match(new RegExp(blockStart));
+/**
+ * Pure string transform: given the existing Podfile contents, returns the
+ * Podfile with the rich-push NotificationService target block appended at
+ * the end. Idempotent — returns input unchanged if the block is already
+ * present.
+ */
+export function appendNotificationTargetToPodfile(
+  podfileContent: string,
+  iosPath: string,
+  isFcmPushProvider: boolean,
+  useFrameworks: CustomerIOPluginOptionsIOS['useFrameworks'],
+): string {
+  if (podfileContent.match(new RegExp(NOTIFICATION_BLOCK_START))) {
+    return podfileContent;
+  }
 
-  if (!matches) {
-    const snippetToInjectInPodfile = `
-${blockStart}
+  const snippetToAppend = `
+${NOTIFICATION_BLOCK_START}
 target 'NotificationService' do
   ${useFrameworks === 'static' ? 'use_frameworks! :linkage => :static' : ''}
-  pod 'customerio-reactnative-richpush/${isFcmPushProvider ? 'fcm' : 'apn'
-      }', :path => '${getRelativePathToRNSDK(iosPath)}'
+  pod 'customerio-reactnative-richpush/${isFcmPushProvider ? 'fcm' : 'apn'}', :path => '${getRelativePathToRNSDK(iosPath)}'
 end
-${blockEnd}
+${NOTIFICATION_BLOCK_END}
 `.trim();
 
-    FileManagement.append(filename, snippetToInjectInPodfile);
+  // Mirror FileManagement.append: append directly with no separator (real
+  // Podfiles end with a trailing newline, so the appended block starts on a
+  // fresh line in practice).
+  return `${podfileContent}${snippetToAppend}`;
+}
+
+export async function injectCIONotificationPodfileCode(
+  iosPath: string,
+  useFrameworks: CustomerIOPluginOptionsIOS['useFrameworks'],
+  isFcmPushProvider: boolean
+) {
+  const filename = `${iosPath}/Podfile`;
+  const podfile = await FileManagement.read(filename);
+  const next = appendNotificationTargetToPodfile(
+    podfile,
+    iosPath,
+    isFcmPushProvider,
+    useFrameworks,
+  );
+  if (next !== podfile) {
+    // FileManagement.append matches what the previous direct-append did.
+    // Slice off the leading content (already on disk) and append only the new tail.
+    FileManagement.append(filename, next.slice(podfile.length));
   }
 }

package/plugin/src/index.ts

@@ -8,6 +8,7 @@ import type {
   LocationTrackingMode,
   NativeSDKConfig,
 } from './types/cio-types';
+import { withExpoVersion } from './utils/writeExpoVersion';
 
 export type { LocationTrackingMode, NativeSDKConfig };
 
@@ -25,6 +26,12 @@ function withCustomerIOPlugin(
     );
   }
 
+  // Belt-and-suspenders write of the plugin version into the RN SDK's
+  // package.json. The postinstall hook does the same write at install time;
+  // this covers installs where postinstall didn't run cleanly (pnpm with
+  // strict store layouts, --ignore-scripts, cached CI installs, etc).
+  config = withExpoVersion(config);
+
   // Apply platform specific modifications
   config = withCIOIos(config, props.config, props.ios, props.location);
   config = withCIOAndroid(config, props.config, props.android, props.location);

package/plugin/src/ios/withAppDelegateModifications.ts

@@ -153,9 +153,12 @@ const addFirebaseDelegateForwardDeclarationIfNeeded = (
   return stringContents;
 };
 
-const addAppdelegateHeaderModification = (stringContents: string) => {
-  // Add UNUserNotificationCenterDelegate if needed
-  stringContents = stringContents.replace(
+/**
+ * Pure string transform: ensures the AppDelegate header (Objective-C path) declares
+ * `UNUserNotificationCenterDelegate` and imports `UserNotifications`. Idempotent.
+ */
+export function modifyAppDelegateHeader(headerContent: string): string {
+  return headerContent.replace(
     CIO_APPDELEGATEHEADER_REGEX,
     (match, interfaceDeclaration, _groupedDelegates, existingDelegates) => {
       if (
@@ -179,9 +182,7 @@ ${interfaceDeclaration.trim()} <${CIO_APPDELEGATEHEADER_USER_NOTIFICATION_CENTER
       }
     }
   );
-
-  return stringContents;
-};
+}
 
 const addHandleDeeplinkInKilledState = (stringContents: string) => {
   // Find if the deep link code snippet is already present
@@ -219,59 +220,71 @@ const addHandleDeeplinkInKilledState = (stringContents: string) => {
   return stringContents;
 };
 
+/**
+ * Pure string transform: produces the modified Objective-C AppDelegate.m / AppDelegate.mm
+ * contents wired with the Customer.io push pipeline (imports, declarations, notification
+ * configuration, registration callbacks, optional killed-state deep-link, FCM forward decl,
+ * Expo notifications header). The caller is responsible for the AppDelegate header file
+ * (.h) — see `modifyAppDelegateHeader`.
+ */
+export function modifyAppDelegateContents(
+  contents: string,
+  projectName: string,
+  props: CustomerIOPluginOptionsIOS
+): string {
+  let next = addImport(contents, projectName);
+  next = addNotificationHandlerDeclaration(next);
+
+  // unless this property is explicity set to true, push notification
+  // registration will be added to the AppDelegate
+  if (props.pushNotification?.disableNotificationRegistration !== true) {
+    next = addNotificationConfiguration(next);
+  }
+
+  next = addInitializeNativeCioSdk(next);
+
+  if (props.pushNotification?.handleDeeplinkInKilledState === true) {
+    next = addHandleDeeplinkInKilledState(next);
+  }
+
+  next = addDidFailToRegisterForRemoteNotificationsWithError(next);
+  next = addDidRegisterForRemoteNotificationsWithDeviceToken(next);
+
+  if (isFcmPushProvider(props)) {
+    next = addFirebaseDelegateForwardDeclarationIfNeeded(next);
+  }
+
+  next = addExpoNotificationsHeaderModification(next);
+
+  return next;
+}
+
 export const withAppDelegateModifications: ConfigPlugin<
   CustomerIOPluginOptionsIOS
 > = (configOuter, props) => {
   return withAppDelegate(configOuter, async (config) => {
-    let stringContents = config.modResults.contents;
+    const stringContents = config.modResults.contents;
     const regex = new RegExp(
       `#import <${config.modRequest.projectName}-Swift.h>`
     );
-    const match = stringContents.match(regex);
-
-    if (!match) {
-      const headerPath = getAppDelegateHeaderFilePath(
-        config.modRequest.projectRoot
-      );
-      let headerContent = await FileManagement.read(headerPath);
-      headerContent = addAppdelegateHeaderModification(headerContent);
-      FileManagement.write(headerPath, headerContent);
-
-      stringContents = addImport(
-        stringContents,
-        config.modRequest.projectName as string
-      );
-      stringContents = addNotificationHandlerDeclaration(stringContents);
-
-      // unless this property is explicity set to true, push notification
-      // registration will be added to the AppDelegate
-      if (props.pushNotification?.disableNotificationRegistration !== true) {
-        stringContents = addNotificationConfiguration(stringContents);
-      }
-
-      stringContents = addInitializeNativeCioSdk(stringContents);
-
-      if (props.pushNotification?.handleDeeplinkInKilledState === true) {
-        stringContents = addHandleDeeplinkInKilledState(stringContents);
-      }
-
-      stringContents =
-        addDidFailToRegisterForRemoteNotificationsWithError(stringContents);
-      stringContents =
-        addDidRegisterForRemoteNotificationsWithDeviceToken(stringContents);
-
-      if (isFcmPushProvider(props)) {
-        stringContents =
-          addFirebaseDelegateForwardDeclarationIfNeeded(stringContents);
-      }
-
-      stringContents = addExpoNotificationsHeaderModification(stringContents);
 
-      config.modResults.contents = stringContents;
-    } else {
+    if (stringContents.match(regex)) {
       logger.info('Customerio AppDelegate changes already exist. Skipping...');
+      return config;
     }
 
+    const headerPath = getAppDelegateHeaderFilePath(
+      config.modRequest.projectRoot
+    );
+    const headerContent = await FileManagement.read(headerPath);
+    FileManagement.write(headerPath, modifyAppDelegateHeader(headerContent));
+
+    config.modResults.contents = modifyAppDelegateContents(
+      stringContents,
+      config.modRequest.projectName as string,
+      props
+    );
+
     return config;
   });
 };

package/plugin/src/ios/withCIOIosSwift.ts

@@ -232,12 +232,19 @@ export const withCIOIosSwift = (
   if (props?.pushNotification) {
     // With push notifications: delegate to CioSdkAppDelegateHandler for both push and auto-init
     return withAppDelegate(configOuter, async (config) => {
-      return modifyAppDelegateWithPushAppDelegateHandler(config, props);
+      config.modResults.contents = modifyAppDelegateForPushHandler(
+        config.modResults.contents,
+        props
+      );
+      return config;
     });
   } else if (sdkConfig) {
     // Without push notifications: directly inject auto initialization into AppDelegate
     return withAppDelegate(configOuter, async (config) => {
-      return modifyAppDelegateWithNativeSDKInitializer(config);
+      config.modResults.contents = modifyAppDelegateForNativeSDKInitializer(
+        config.modResults.contents
+      );
+      return config;
     });
   } else {
     return configOuter;
@@ -245,77 +252,53 @@ export const withCIOIosSwift = (
 };
 
 /**
- * Modify the AppDelegate to integrate with Customer.io SDK
+ * Pure string transform: produces the Swift AppDelegate contents wired to delegate to
+ * `CioSdkAppDelegateHandler` for both push notifications and (when configured) auto-init.
+ * Idempotent — returns `contents` unchanged when the handler is already present.
  */
-const modifyAppDelegateWithPushAppDelegateHandler = (
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  config: any,
+export function modifyAppDelegateForPushHandler(
+  contents: string,
   props: CustomerIOPluginOptionsIOS
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): any => {
-  const appDelegateContent = config.modResults.contents;
-
-  // Check if modifications have already been applied
-  if (appDelegateContent.includes(CIO_SDK_APP_DELEGATE_HANDLER_CLASS)) {
+): string {
+  if (contents.includes(CIO_SDK_APP_DELEGATE_HANDLER_CLASS)) {
     logger.info(
       'CustomerIO Swift AppDelegate changes already exist. Skipping...'
     );
-    return config;
+    return contents;
   }
 
-  // Add the handler property declaration
-  let modifiedContent = addHandlerPropertyDeclaration(appDelegateContent);
-
-  // Modify didFinishLaunchingWithOptions to initialize and call the handler
-  modifiedContent = modifyDidFinishLaunchingWithOptions(
-    modifiedContent,
+  let next = addHandlerPropertyDeclaration(contents);
+  next = modifyDidFinishLaunchingWithOptions(
+    next,
     `  cioSdkHandler.application(application, didFinishLaunchingWithOptions: launchOptions)\n\n    `
   );
+  next = addDidRegisterForRemoteNotificationsWithDeviceToken(next);
+  next = addDidFailToRegisterForRemoteNotificationsWithError(next);
 
-  // Add didRegisterForRemoteNotificationsWithDeviceToken implementation
-  modifiedContent =
-    addDidRegisterForRemoteNotificationsWithDeviceToken(modifiedContent);
-
-  // Add didFailToRegisterForRemoteNotificationsWithError implementation
-  modifiedContent =
-    addDidFailToRegisterForRemoteNotificationsWithError(modifiedContent);
-
-  // Add deep link handling for killed state if enabled
   if (props.pushNotification?.handleDeeplinkInKilledState === true) {
-    modifiedContent = addHandleDeeplinkInKilledState(modifiedContent);
+    next = addHandleDeeplinkInKilledState(next);
   }
 
-  config.modResults.contents = modifiedContent;
-  return config;
-};
+  return next;
+}
 
 /**
- * Modify the AppDelegate to integrate with Customer.io SDK
+ * Pure string transform: injects the auto-init snippet into the Swift AppDelegate's
+ * didFinishLaunchingWithOptions for the no-push path. Idempotent.
  */
-const modifyAppDelegateWithNativeSDKInitializer = (
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  config: any,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): any => {
-  const appDelegateContent = config.modResults.contents;
-
-  // Check if modifications have already been applied
-  if (appDelegateContent.includes(CIO_NATIVE_SDK_INITIALIZE_CALL)) {
+export function modifyAppDelegateForNativeSDKInitializer(contents: string): string {
+  if (contents.includes(CIO_NATIVE_SDK_INITIALIZE_CALL)) {
     logger.info(
       'CustomerIO Swift AppDelegate changes already exist. Skipping...'
     );
-    return config;
+    return contents;
   }
 
-  // Modify didFinishLaunchingWithOptions to initialize and call the handler
-  const modifiedContent = modifyDidFinishLaunchingWithOptions(
-    appDelegateContent,
+  return modifyDidFinishLaunchingWithOptions(
+    contents,
     CIO_NATIVE_SDK_INITIALIZE_SNIPPET,
   );
-
-  config.modResults.contents = modifiedContent;
-  return config;
-};
+}
 
 /**
  * Check if a method exists in the AppDelegate content
@@ -500,34 +483,47 @@ const addDidFailToRegisterForRemoteNotificationsWithError = (
 
 /**
  * Add deep link handling for killed state
- * This replaces the return statement with deep link handling code
- * and a modified return statement that uses modifiedLaunchOptions
+ *
+ * On modern Expo Swift templates, RN is bootstrapped by `factory.startReactNative(...)`
+ * inside an `#if os(iOS) || os(tvOS)` guard, *before* the trailing `return super.application(...)`.
+ * The deep-link block must run before that call so `modifiedLaunchOptions` flows into RN's
+ * initial launchOptions; otherwise the workaround is a no-op.
+ *
+ * For older templates (no `factory.startReactNative` — `super.application(...)` is what
+ * starts RN), the snippet is injected before the return statement as before.
  */
 const addHandleDeeplinkInKilledState = (content: string): string => {
-  // Check if deep link code snippet is already present
   const deepLinkMarker = 'Deep link workaround for app killed state start';
   if (content.includes(deepLinkMarker)) {
     return content;
   }
 
-  // Find the return statement with launchOptions
   const returnStatementRegex =
     /return\s+super\.application\s*\(\s*application\s*,\s*didFinishLaunchingWithOptions\s*:\s*launchOptions\s*\)/;
-  const returnStatementMatch = content.match(returnStatementRegex);
+  const modifiedReturnStatement =
+    'return super.application(application, didFinishLaunchingWithOptions: modifiedLaunchOptions)';
 
-  if (!returnStatementMatch) {
+  const factoryStartRegex =
+    /(\s*)#if\s+os\(iOS\)\s*\|\|\s*os\(tvOS\)([\s\S]*?factory\.startReactNative\s*\([\s\S]*?launchOptions:\s*)launchOptions(\s*\)[\s\S]*?#endif)/;
+
+  if (factoryStartRegex.test(content)) {
+    let result = content.replace(
+      factoryStartRegex,
+      `\n${CIO_CONFIGUREDEEPLINK_KILLEDSTATE_SWIFT_SNIPPET}\n#if os(iOS) || os(tvOS)$2modifiedLaunchOptions$3`
+    );
+    if (returnStatementRegex.test(result)) {
+      result = result.replace(returnStatementRegex, modifiedReturnStatement);
+    }
+    return result;
+  }
+
+  if (!returnStatementRegex.test(content)) {
     logger.warn('Could not find return statement with launchOptions');
     return content;
   }
-
-  // Create the replacement code with deep link handling and modified return statement
-  const modifiedReturnStatement =
-    'return super.application(application, didFinishLaunchingWithOptions: modifiedLaunchOptions)';
   const replacementCode =
     CIO_CONFIGUREDEEPLINK_KILLEDSTATE_SWIFT_SNIPPET +
     '\n\n    ' +
     modifiedReturnStatement;
-
-  // Replace the return statement with deep link handling code and modified return statement
   return content.replace(returnStatementRegex, replacementCode);
 };