@use-voltra/ios-client 2.1.1 → 2.3.0

package/expo-plugin/src/ios-widget/xcode/configurationList.ts

@@ -1,34 +1,52 @@
 import { XcodeProject } from '@expo/config-plugins'
 
 import { IOS } from '../../constants'
+import type { MainAppSigningSettings, MainAppTargetSettings } from './mainAppSettings'
 
-export interface AddConfigurationListOptions {
+export interface EnsureConfigurationListOptions {
   targetName: string
   bundleIdentifier: string
   deploymentTarget: string
-  codeSignStyle?: string
-  developmentTeam?: string
-  provisioningProfileSpecifier?: string
+  /**
+   * App marketing version (CFBundleShortVersionString). App Store Connect expects the appex
+   * version to match the app's, so this becomes the widget's MARKETING_VERSION.
+   */
+  version?: string
+  /** App build number; becomes the widget's CURRENT_PROJECT_VERSION. */
+  buildNumber?: string
+  /** Main app signing settings, applied per configuration name (Debug→Debug, Release→Release). */
+  mainAppSettings?: MainAppTargetSettings | null
 }
 
-function createCommonBuildSettings(options: AddConfigurationListOptions) {
-  const {
-    targetName,
-    bundleIdentifier,
-    deploymentTarget,
-    codeSignStyle,
-    developmentTeam,
-    provisioningProfileSpecifier,
-  } = options
-
-  const commonBuildSettings: Record<string, string> = {
+/**
+ * Resolves the main app signing settings for a widget configuration name: an exact name match
+ * wins, otherwise the first available configuration's settings are used as fallback.
+ */
+function signingForConfiguration(
+  mainAppSettings: MainAppTargetSettings | null | undefined,
+  configurationName: string
+): MainAppSigningSettings {
+  if (!mainAppSettings) {
+    return {}
+  }
+  return mainAppSettings.byConfigurationName[configurationName] ?? mainAppSettings.fallback
+}
+
+function createBuildSettings(options: EnsureConfigurationListOptions, configurationName: string) {
+  const { targetName, bundleIdentifier, deploymentTarget, version, buildNumber, mainAppSettings } = options
+  const { codeSignStyle, developmentTeam, provisioningProfileSpecifier } = signingForConfiguration(
+    mainAppSettings,
+    configurationName
+  )
+
+  const buildSettings: Record<string, string> = {
     PRODUCT_NAME: `"$(TARGET_NAME)"`,
     SWIFT_VERSION: IOS.SWIFT_VERSION,
     TARGETED_DEVICE_FAMILY: `"${IOS.DEVICE_FAMILY}"`,
     INFOPLIST_FILE: `${targetName}/Info.plist`,
     INFOPLIST_OUTPUT_FORMAT: `"xml"`,
-    CURRENT_PROJECT_VERSION: `"1"`,
-    MARKETING_VERSION: `"1.0"`,
+    CURRENT_PROJECT_VERSION: `"${buildNumber ?? '1'}"`,
+    MARKETING_VERSION: `"${version ?? '1.0'}"`,
     IPHONEOS_DEPLOYMENT_TARGET: `"${deploymentTarget}"`,
     PRODUCT_BUNDLE_IDENTIFIER: `"${bundleIdentifier}"`,
     SWIFT_OPTIMIZATION_LEVEL: `"-Onone"`,
@@ -37,41 +55,37 @@ function createCommonBuildSettings(options: AddConfigurationListOptions) {
     ASSETCATALOG_COMPILER_APPICON_NAME: '""',
   }
 
-  // Synchronize code signing settings from main app target
+  // Synchronize code signing settings from the main app target's matching configuration
   if (codeSignStyle) {
-    commonBuildSettings.CODE_SIGN_STYLE = `"${codeSignStyle}"`
+    buildSettings.CODE_SIGN_STYLE = `"${codeSignStyle}"`
   }
   if (developmentTeam) {
-    commonBuildSettings.DEVELOPMENT_TEAM = `"${developmentTeam}"`
+    buildSettings.DEVELOPMENT_TEAM = `"${developmentTeam}"`
   }
   if (provisioningProfileSpecifier) {
-    commonBuildSettings.PROVISIONING_PROFILE_SPECIFIER = `"${provisioningProfileSpecifier}"`
+    buildSettings.PROVISIONING_PROFILE_SPECIFIER = `"${provisioningProfileSpecifier}"`
   }
 
-  return commonBuildSettings
+  return buildSettings
 }
 
 /**
- * Adds the XCConfigurationList for the widget extension target.
+ * Adds a fresh XCConfigurationList for the widget extension target. Internal create-only fallback
+ * for {@link ensureXCConfigurationList}; not part of the public pipeline.
  */
-export function addXCConfigurationList(xcodeProject: XcodeProject, options: AddConfigurationListOptions) {
+function addXCConfigurationList(xcodeProject: XcodeProject, options: EnsureConfigurationListOptions) {
   const { targetName } = options
-  const commonBuildSettings = createCommonBuildSettings(options)
 
   const buildConfigurationsList = [
     {
       name: 'Debug',
       isa: 'XCBuildConfiguration',
-      buildSettings: {
-        ...commonBuildSettings,
-      },
+      buildSettings: createBuildSettings(options, 'Debug'),
     },
     {
       name: 'Release',
       isa: 'XCBuildConfiguration',
-      buildSettings: {
-        ...commonBuildSettings,
-      },
+      buildSettings: createBuildSettings(options, 'Release'),
     },
   ]
 
@@ -85,11 +99,13 @@ export function addXCConfigurationList(xcodeProject: XcodeProject, options: AddC
 }
 
 /**
- * Ensures an existing XCConfigurationList is updated, or adds a new one if missing.
+ * Ensures an existing XCConfigurationList is updated, or adds a new one if missing. Each widget
+ * configuration receives the build settings derived for its own name, so Debug and Release signing
+ * stay in sync with the main app's respective configurations.
  */
 export function ensureXCConfigurationList(
   xcodeProject: XcodeProject,
-  options: AddConfigurationListOptions,
+  options: EnsureConfigurationListOptions,
   existingConfigurationListId?: string | { value?: string }
 ) {
   const configurationListId =
@@ -103,7 +119,6 @@ export function ensureXCConfigurationList(
     return addXCConfigurationList(xcodeProject, options)
   }
 
-  const commonBuildSettings = createCommonBuildSettings(options)
   const buildConfigurations = configurationList.buildConfigurations
   const buildConfigurationSection = xcodeProject.pbxXCBuildConfigurationSection()
 
@@ -117,9 +132,11 @@ export function ensureXCConfigurationList(
       continue
     }
 
+    const configurationName =
+      typeof buildConfiguration.name === 'string' ? buildConfiguration.name.replace(/^"|"$/g, '') : ''
     buildConfiguration.buildSettings = {
       ...(buildConfiguration.buildSettings ?? {}),
-      ...commonBuildSettings,
+      ...createBuildSettings(options, configurationName),
     }
   }
 

package/expo-plugin/src/ios-widget/xcode/fileReferences.ts

@@ -0,0 +1,51 @@
+import { XcodeProject } from '@expo/config-plugins'
+
+const pbxFile = require('xcode/lib/pbxFile')
+
+/** Strips surrounding quotes from a pbx path/name value. */
+export function normalizePath(value: string | undefined): string {
+  if (!value) {
+    return ''
+  }
+  return value.replace(/^"|"$/g, '')
+}
+
+/** Strips a trailing `/* comment *\/` and whitespace, yielding the bare UUID of a pbx reference. */
+export function normalizeRef(value: unknown): string {
+  return String(value)
+    .replace(/\/\*.*?\*\//g, '')
+    .trim()
+}
+
+/**
+ * Resolves the PBXFileReference UUID for a widget file, scoped to the widget's own PBXGroup.
+ *
+ * pbxproj paths are group-relative, so a bare path like `Assets.xcassets` collides with any other
+ * extension's identically named file. Scoping the lookup to the children of the widget group
+ * (identified by `targetName`) keeps the widget's references distinct from those, which is what
+ * prevents the shared-fileRef corruption behind issues #87/#32. When the widget group does not
+ * exist yet, a fresh reference is created.
+ */
+export function ensureWidgetFileReference(xcodeProject: XcodeProject, filePath: string, targetName: string): string {
+  const file = new pbxFile(filePath)
+  const fileReferenceSection = xcodeProject.pbxFileReferenceSection()
+  const group = xcodeProject.pbxGroupByName(targetName)
+
+  if (group?.children) {
+    for (const child of group.children) {
+      const refKey = normalizeRef(child.value)
+      const entry = fileReferenceSection[refKey]
+      if (!entry) {
+        continue
+      }
+      const entryPath = normalizePath(entry.path)
+      if (entryPath === file.path || entryPath === normalizePath(filePath)) {
+        return refKey
+      }
+    }
+  }
+
+  file.fileRef = xcodeProject.generateUuid()
+  xcodeProject.addToPbxFileReferenceSection(file)
+  return file.fileRef
+}

package/expo-plugin/src/ios-widget/xcode/groups.ts

@@ -1,6 +1,7 @@
 import { XcodeProject } from '@expo/config-plugins'
 
 import type { IOSWidgetExtensionFiles } from '../../types'
+import { ensureWidgetFileReference } from './fileReferences'
 
 const pbxFile = require('xcode/lib/pbxFile')
 
@@ -9,37 +10,63 @@ export interface AddPbxGroupOptions {
   widgetFiles: IOSWidgetExtensionFiles
 }
 
+function collectGroupFiles(widgetFiles: IOSWidgetExtensionFiles): string[] {
+  const { swiftFiles, intentFiles, assetDirectories, entitlementFiles, plistFiles, localizedStringResources } =
+    widgetFiles
+  return [
+    ...swiftFiles,
+    ...intentFiles,
+    ...entitlementFiles,
+    ...plistFiles,
+    ...assetDirectories,
+    ...localizedStringResources,
+  ]
+}
+
 /**
  * Adds a PBXGroup for the widget extension files.
+ *
+ * Constructs the PBXGroup and its PBXFileReference children by hand rather than delegating to
+ * `xcodeProject.addPbxGroup`, because that helper also creates a PBXBuildFile per file as a side
+ * effect. Those extra build files collide with the ones managed by the build-phase functions and
+ * produce the "no parent for object" consistency errors from issues #87/#32. File references are
+ * resolved through the widget-scoped {@link ensureWidgetFileReference} so they are shared with the
+ * build phases instead of duplicated.
+ *
+ * Internal create-only fallback for {@link ensurePbxGroup}; not part of the public pipeline.
  */
-export function addPbxGroup(xcodeProject: XcodeProject, options: AddPbxGroupOptions): void {
+function addPbxGroup(xcodeProject: XcodeProject, options: AddPbxGroupOptions): void {
   const { targetName, widgetFiles } = options
-  const { swiftFiles, intentFiles, assetDirectories, entitlementFiles, plistFiles, localizedStringResources } =
-    widgetFiles
+  const allFiles = collectGroupFiles(widgetFiles)
 
-  // Add PBX group with all widget files
-  const { uuid: pbxGroupUuid } = xcodeProject.addPbxGroup(
-    [
-      ...swiftFiles,
-      ...intentFiles,
-      ...entitlementFiles,
-      ...plistFiles,
-      ...assetDirectories,
-      ...localizedStringResources,
-    ],
-    targetName,
-    targetName
-  )
+  const pbxGroupUuid = xcodeProject.generateUuid()
+  const pbxGroup = {
+    isa: 'PBXGroup',
+    children: [] as { value: string; comment: string }[],
+    name: targetName,
+    path: targetName,
+    sourceTree: '"<group>"',
+  }
 
-  // Add PBXGroup to top level group
   const groups = xcodeProject.hash.project.objects['PBXGroup']
-  if (pbxGroupUuid) {
-    Object.keys(groups).forEach(function (key) {
-      if (groups[key].name === undefined && groups[key].path === undefined) {
-        xcodeProject.addToPbxGroup(pbxGroupUuid, key)
-      }
-    })
+  groups[pbxGroupUuid] = pbxGroup
+  groups[`${pbxGroupUuid}_comment`] = targetName
+
+  for (const filePath of allFiles) {
+    const file = new pbxFile(filePath)
+    const fileRef = ensureWidgetFileReference(xcodeProject, filePath, targetName)
+    pbxGroup.children.push({ value: fileRef, comment: file.basename })
   }
+
+  // Attach the new group to the top-level (unnamed, path-less) group.
+  Object.keys(groups).forEach(function (key) {
+    if (/_comment$/.test(key)) {
+      return
+    }
+    if (groups[key].name === undefined && groups[key].path === undefined) {
+      xcodeProject.addToPbxGroup(pbxGroupUuid, key)
+    }
+  })
 }
 
 /**
@@ -47,16 +74,7 @@ export function addPbxGroup(xcodeProject: XcodeProject, options: AddPbxGroupOpti
  */
 export function ensurePbxGroup(xcodeProject: XcodeProject, options: AddPbxGroupOptions): void {
   const { targetName, widgetFiles } = options
-  const { swiftFiles, intentFiles, assetDirectories, entitlementFiles, plistFiles, localizedStringResources } =
-    widgetFiles
-  const allFiles = [
-    ...swiftFiles,
-    ...intentFiles,
-    ...entitlementFiles,
-    ...plistFiles,
-    ...assetDirectories,
-    ...localizedStringResources,
-  ]
+  const allFiles = collectGroupFiles(widgetFiles)
 
   const existingGroup = xcodeProject.pbxGroupByName(targetName)
   if (!existingGroup) {
@@ -70,7 +88,7 @@ export function ensurePbxGroup(xcodeProject: XcodeProject, options: AddPbxGroupO
 
   for (const filePath of allFiles) {
     const file = new pbxFile(filePath)
-    const fileRef = ensureFileReference(xcodeProject, filePath)
+    const fileRef = ensureWidgetFileReference(xcodeProject, filePath, targetName)
     const alreadyInGroup = existingGroup.children.some(
       (child: any) => child.value === fileRef || child.comment === file.basename
     )
@@ -79,23 +97,3 @@ export function ensurePbxGroup(xcodeProject: XcodeProject, options: AddPbxGroupO
     }
   }
 }
-
-function ensureFileReference(xcodeProject: XcodeProject, filePath: string): string {
-  const fileReferenceSection = xcodeProject.pbxFileReferenceSection()
-  const file = new pbxFile(filePath)
-
-  for (const key of Object.keys(fileReferenceSection)) {
-    if (/_comment$/.test(key)) {
-      continue
-    }
-    const entry = fileReferenceSection[key]
-    const entryPath = typeof entry?.path === 'string' ? entry.path.replace(/^"|"$/g, '') : ''
-    if (entryPath === file.path || entryPath === filePath) {
-      return key
-    }
-  }
-
-  file.fileRef = xcodeProject.generateUuid()
-  xcodeProject.addToPbxFileReferenceSection(file)
-  return file.fileRef
-}

package/expo-plugin/src/ios-widget/xcode/index.ts

@@ -1,21 +1,133 @@
-import { ConfigPlugin, withXcodeProject } from '@expo/config-plugins'
+import { ConfigPlugin, withXcodeProject, XcodeProject } from '@expo/config-plugins'
 import * as path from 'path'
 
-import type { IOSWidgetConfig } from '../../types'
+import type { IOSDynamicLiveActivityConfig, IOSWidgetConfig, IOSWidgetExtensionFiles } from '../../types'
 import { getIOSWidgetExtensionFiles } from '../../utils/fileDiscovery'
 import { detectClientRenderedWidgets } from '../clientRendered'
-import { addBuildPhases, ensureBuildPhases, ensureWidgetBundleScriptPhase } from './buildPhases'
-import { addXCConfigurationList, ensureXCConfigurationList } from './configurationList'
-import { addPbxGroup, ensurePbxGroup } from './groups'
+import { ensureBuildPhases, ensureWidgetBundleScriptPhase } from './buildPhases'
+import { ensureXCConfigurationList } from './configurationList'
+import { ensurePbxGroup } from './groups'
 import { getMainAppTargetSettings } from './mainAppSettings'
-import { addProductFile, ensureProductFile } from './productFile'
-import { configureTarget, ensureTargetAttributes, ensureTargetDependency } from './target'
+import { ensureProductFile } from './productFile'
+import { createTargetSkeleton, ensureTargetAttributes, ensureTargetDependency } from './target'
 
 export interface ConfigureXcodeProjectProps {
   targetName: string
   bundleIdentifier: string
   deploymentTarget: string
+  /** App marketing version; becomes the widget's MARKETING_VERSION so the appex matches the app. */
+  version?: string
+  /** App build number; becomes the widget's CURRENT_PROJECT_VERSION. */
+  buildNumber?: string
   widgets?: IOSWidgetConfig[]
+  liveActivities?: IOSDynamicLiveActivityConfig[]
+}
+
+/**
+ * Applies all widget-extension changes to an already-parsed Xcode project.
+ *
+ * This is the pure core of {@link configureXcodeProject}: it takes the parsed project, the plugin
+ * props, the discovered widget files, and whether any widget is client-rendered, then mutates the
+ * project in place. It performs no filesystem or `modRequest` access, which makes it directly
+ * testable against pbxproj fixtures.
+ *
+ * When the widget target does not exist yet, the minimal native-target skeleton is created first
+ * (targets cannot be "ensured" into existence); every other object is then reconciled by the same
+ * idempotent ensure pipeline that runs for an already-existing target.
+ */
+export function applyXcodeChanges(
+  xcodeProject: XcodeProject,
+  props: ConfigureXcodeProjectProps,
+  widgetFiles: IOSWidgetExtensionFiles,
+  hasClientRenderedWidgets = false
+): void {
+  const { targetName, bundleIdentifier, deploymentTarget, version, buildNumber } = props
+  const groupName = 'Embed Foundation Extensions'
+  const mainTargetUuid = xcodeProject.getFirstTarget().uuid
+  // The catalog is compiled into the app even for a legacy-only configuration.
+  // Keep it in the extension group too so both targets share one PBX file reference.
+  const effectiveWidgetFiles: IOSWidgetExtensionFiles = {
+    ...widgetFiles,
+    swiftFiles: Array.from(new Set([...widgetFiles.swiftFiles, 'VoltraDynamicLiveActivityTypes.swift'])),
+  }
+
+  // Read main app target settings to synchronize code signing (per configuration).
+  const mainAppSettings = getMainAppTargetSettings(xcodeProject)
+
+  // Use the deploymentTarget from plugin config (or default), ignore main app's deployment target.
+  // This allows the widget extension to have its own deployment target independent of the main app.
+
+  // Resolve (or create) the widget target. A target cannot be reconciled into existence, so the
+  // absent case creates the minimal skeleton; from here on both paths share one pipeline.
+  let targetUuid = xcodeProject.findTargetKey(targetName)
+  if (!targetUuid) {
+    targetUuid = xcodeProject.generateUuid()
+    createTargetSkeleton(xcodeProject, { targetName, targetUuid })
+  }
+  const target = xcodeProject.pbxNativeTargetSection()[targetUuid]
+
+  // Ensure the configuration list is present and its settings are in sync.
+  const xCConfigurationList = ensureXCConfigurationList(
+    xcodeProject,
+    {
+      targetName,
+      bundleIdentifier,
+      deploymentTarget,
+      version,
+      buildNumber,
+      mainAppSettings,
+    },
+    target.buildConfigurationList
+  )
+
+  // Ensure the product file (.appex) exists.
+  const productFile = ensureProductFile(xcodeProject, {
+    targetName,
+    groupName,
+  })
+
+  // Point the target at the reconciled configuration list and product file.
+  target.productReference = productFile.fileRef
+  target.buildConfigurationList = xCConfigurationList.uuid
+  target.productType = `"com.apple.product-type.app-extension"`
+  target.name = targetName
+  target.productName = targetName
+  if (!target.buildPhases) {
+    target.buildPhases = []
+  }
+
+  // Ensure the group first so the widget's file references exist before the build phases
+  // reference them (the phases resolve files through the widget-scoped group).
+  ensurePbxGroup(xcodeProject, {
+    targetName,
+    widgetFiles: effectiveWidgetFiles,
+  })
+
+  // Ensure build phases and their files.
+  ensureBuildPhases(xcodeProject, {
+    targetUuid,
+    targetName,
+    groupName,
+    productFile,
+    widgetFiles: effectiveWidgetFiles,
+    mainTargetUuid: xcodeProject.getFirstTarget().uuid,
+    // The app-side lifecycle service always compiles against the generated catalog.
+    // An empty catalog keeps legacy-only apps source-compatible.
+    mainSwiftFiles: ['VoltraDynamicLiveActivityTypes.swift'],
+  })
+
+  if (hasClientRenderedWidgets || (props.liveActivities?.length ?? 0) > 0) {
+    ensureWidgetBundleScriptPhase(xcodeProject, targetUuid)
+  }
+  if ((props.liveActivities?.length ?? 0) > 0) {
+    // Local Dynamic Live Activity starts preflight the baked definition from
+    // the app process, while WidgetKit renders from the extension process.
+    // Bake the same manifest into both products.
+    ensureWidgetBundleScriptPhase(xcodeProject, mainTargetUuid, 'live-activities')
+  }
+
+  ensureTargetAttributes(xcodeProject, targetUuid)
+  ensureTargetDependency(xcodeProject, targetUuid)
 }
 
 /**
@@ -28,10 +140,12 @@ export interface ConfigureXcodeProjectProps {
  * - Adds build phases (Sources, CopyFiles, Frameworks, Resources)
  * - Adds PBXGroup for widget files
  *
- * This should run after generateWidgetExtensionFiles so the files exist.
+ * This should run after generateWidgetExtensionFiles so the files exist. The wrapper is kept thin:
+ * it discovers widget files and detects client-rendered widgets, then delegates the actual pbxproj
+ * mutation to {@link applyXcodeChanges}.
  */
 export const configureXcodeProject: ConfigPlugin<ConfigureXcodeProjectProps> = (config, props) => {
-  const { targetName, bundleIdentifier, deploymentTarget, widgets } = props
+  const { targetName, widgets, liveActivities } = props
 
   return withXcodeProject(config, (config) => {
     if (config.modRequest.introspect) {
@@ -39,7 +153,6 @@ export const configureXcodeProject: ConfigPlugin<ConfigureXcodeProjectProps> = (
     }
 
     const xcodeProject = config.modResults
-    const groupName = 'Embed Foundation Extensions'
 
     // The release widget-bundling phase is only needed when a widget is a Dynamic Widget (server
     // widgets carry no JS bundle). Detect once so both the create and update paths agree.
@@ -47,119 +160,11 @@ export const configureXcodeProject: ConfigPlugin<ConfigureXcodeProjectProps> = (
       !!widgets &&
       detectClientRenderedWidgets(widgets, config.modRequest.projectRoot).some((widget) => widget.clientRendered)
 
-    // Check if target already exists
-    const nativeTargets = xcodeProject.pbxNativeTargetSection()
-    const existingTargetKey = xcodeProject.findTargetKey(targetName)
-    const existingTarget = existingTargetKey ? nativeTargets[existingTargetKey] : null
-
     const { platformProjectRoot } = config.modRequest
     const targetPath = path.join(platformProjectRoot, targetName)
     const widgetFiles = getIOSWidgetExtensionFiles(targetPath, targetName)
 
-    // Read main app target settings to synchronize code signing
-    const mainAppSettings = getMainAppTargetSettings(xcodeProject)
-
-    // Use the deploymentTarget from plugin config (or default), ignore main app's deployment target
-    // This allows the widget extension to have its own deployment target independent of the main app
-
-    if (existingTarget && existingTargetKey) {
-      // Ensure configuration list is up to date
-      const xCConfigurationList = ensureXCConfigurationList(
-        xcodeProject,
-        {
-          targetName,
-          bundleIdentifier,
-          deploymentTarget,
-          codeSignStyle: mainAppSettings?.codeSignStyle,
-          developmentTeam: mainAppSettings?.developmentTeam,
-          provisioningProfileSpecifier: mainAppSettings?.provisioningProfileSpecifier,
-        },
-        existingTarget.buildConfigurationList
-      )
-
-      // Ensure product file exists
-      const productFile = ensureProductFile(xcodeProject, {
-        targetName,
-        groupName,
-      })
-
-      // Update target references
-      existingTarget.productReference = productFile.fileRef
-      existingTarget.buildConfigurationList = xCConfigurationList.uuid
-      existingTarget.productType = `"com.apple.product-type.app-extension"`
-      existingTarget.name = targetName
-      existingTarget.productName = targetName
-      if (!existingTarget.buildPhases) {
-        existingTarget.buildPhases = []
-      }
-
-      // Ensure build phases and groups
-      ensureBuildPhases(xcodeProject, {
-        targetUuid: existingTargetKey,
-        groupName,
-        productFile,
-        widgetFiles,
-        mainTargetUuid: xcodeProject.getFirstTarget().uuid,
-      })
-
-      if (hasClientRenderedWidgets) {
-        ensureWidgetBundleScriptPhase(xcodeProject, existingTargetKey)
-      }
-
-      ensurePbxGroup(xcodeProject, {
-        targetName,
-        widgetFiles,
-      })
-
-      ensureTargetAttributes(xcodeProject, existingTargetKey)
-      ensureTargetDependency(xcodeProject, existingTargetKey)
-
-      return config
-    }
-
-    // Add configuration list
-    const targetUuid = xcodeProject.generateUuid()
-
-    const xCConfigurationList = addXCConfigurationList(xcodeProject, {
-      targetName,
-      bundleIdentifier,
-      deploymentTarget,
-      codeSignStyle: mainAppSettings?.codeSignStyle,
-      developmentTeam: mainAppSettings?.developmentTeam,
-      provisioningProfileSpecifier: mainAppSettings?.provisioningProfileSpecifier,
-    })
-
-    // Add product file
-    const productFile = addProductFile(xcodeProject, {
-      targetName,
-      groupName,
-    })
-
-    // Configure target (native target, project section, dependency)
-    configureTarget(xcodeProject, {
-      targetName,
-      targetUuid,
-      productFile,
-      xCConfigurationList,
-    })
-
-    // Add build phases
-    addBuildPhases(xcodeProject, {
-      targetUuid,
-      groupName,
-      productFile,
-      widgetFiles,
-    })
-
-    if (hasClientRenderedWidgets) {
-      ensureWidgetBundleScriptPhase(xcodeProject, targetUuid)
-    }
-
-    // Add PBX group
-    addPbxGroup(xcodeProject, {
-      targetName,
-      widgetFiles,
-    })
+    applyXcodeChanges(xcodeProject, props, widgetFiles, hasClientRenderedWidgets || (liveActivities?.length ?? 0) > 0)
 
     return config
   })