@use-voltra/ios-client 2.1.0 → 2.2.0

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,23 +1,118 @@
-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 { 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[]
 }
 
+/**
+ * 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'
+
+  // 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,
+  })
+
+  // Ensure build phases and their files.
+  ensureBuildPhases(xcodeProject, {
+    targetUuid,
+    targetName,
+    groupName,
+    productFile,
+    widgetFiles,
+    mainTargetUuid: xcodeProject.getFirstTarget().uuid,
+  })
+
+  if (hasClientRenderedWidgets) {
+    ensureWidgetBundleScriptPhase(xcodeProject, targetUuid)
+  }
+
+  ensureTargetAttributes(xcodeProject, targetUuid)
+  ensureTargetDependency(xcodeProject, targetUuid)
+}
+
 /**
  * Plugin step that configures the Xcode project for the widget extension.
  *
@@ -28,10 +123,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 } = props
 
   return withXcodeProject(config, (config) => {
     if (config.modRequest.introspect) {
@@ -39,7 +136,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 +143,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)
 
     return config
   })

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

@@ -1,27 +1,55 @@
 import { XcodeProject } from '@expo/config-plugins'
 
-export interface MainAppTargetSettings {
-  deploymentTarget: string
+/** Code-signing settings read from one of the main app target's build configurations. */
+export interface MainAppSigningSettings {
   codeSignStyle?: string
   developmentTeam?: string
   provisioningProfileSpecifier?: string
 }
 
+export interface MainAppTargetSettings {
+  /**
+   * Signing settings keyed by build-configuration name (e.g. `Debug`, `Release`). Release
+   * provisioning often differs from Debug, so the widget must mirror the main app per
+   * configuration rather than copying one configuration's signing into both.
+   */
+  byConfigurationName: Record<string, MainAppSigningSettings>
+  /** The first configuration's settings, used for widget configurations with no name match. */
+  fallback: MainAppSigningSettings
+}
+
+/** Strips surrounding quotes from a raw build-setting value. */
+function unquote(value: unknown): string | undefined {
+  if (typeof value !== 'string') {
+    return undefined
+  }
+  return value.replace(/^"|"$/g, '')
+}
+
+/** Reads the signing-related build settings from a single XCBuildConfiguration. */
+function readSigningSettings(buildSettings: Record<string, unknown>): MainAppSigningSettings {
+  return {
+    codeSignStyle: unquote(buildSettings.CODE_SIGN_STYLE),
+    developmentTeam: unquote(buildSettings.DEVELOPMENT_TEAM),
+    provisioningProfileSpecifier: unquote(buildSettings.PROVISIONING_PROFILE_SPECIFIER),
+  }
+}
+
 /**
- * Reads build settings from the main app target to synchronize code signing with the widget extension.
+ * Reads code-signing build settings from every build configuration of the main app target, so the
+ * widget extension can synchronize signing per configuration (Debug→Debug, Release→Release).
  *
  * @param xcodeProject The Xcode project instance
- * @returns The main app target's build settings, or null if not found
+ * @returns Signing settings keyed by configuration name plus a first-configuration fallback, or
+ * null when the main app target or its configurations cannot be resolved
  */
 export function getMainAppTargetSettings(xcodeProject: XcodeProject): MainAppTargetSettings | null {
   try {
     const mainAppTarget = xcodeProject.getFirstTarget()?.firstTarget
-
     if (!mainAppTarget) {
       return null
     }
 
-    // Get the build configuration list for the main app target
     const buildConfigurationListId = mainAppTarget.buildConfigurationList
     if (!buildConfigurationListId) {
       return null
@@ -32,62 +60,39 @@ export function getMainAppTargetSettings(xcodeProject: XcodeProject): MainAppTar
 
     const buildConfigurationList =
       xcodeProject.hash.project.objects['XCConfigurationList']?.[buildConfigurationListUuid]
-    if (!buildConfigurationList || !buildConfigurationList.buildConfigurations) {
-      return null
-    }
-
-    // Get the first build configuration (usually Debug) to read settings
-    const firstConfigRef = buildConfigurationList.buildConfigurations[0]
-    if (!firstConfigRef) {
-      return null
-    }
-
-    // Extract UUID from config reference (it might include a comment)
-    const firstConfigUuid =
-      typeof firstConfigRef === 'string' ? firstConfigRef.split(' ')[0] : firstConfigRef.value?.split(' ')[0]
-    if (!firstConfigUuid) {
+    if (!buildConfigurationList?.buildConfigurations) {
       return null
     }
 
-    const buildConfiguration = xcodeProject.hash.project.objects['XCBuildConfiguration']?.[firstConfigUuid]
-    if (!buildConfiguration || !buildConfiguration.buildSettings) {
-      return null
+    const buildConfigurationSection = xcodeProject.hash.project.objects['XCBuildConfiguration'] ?? {}
+    const byConfigurationName: Record<string, MainAppSigningSettings> = {}
+    let fallback: MainAppSigningSettings | null = null
+
+    for (const configRef of buildConfigurationList.buildConfigurations) {
+      // Extract UUID from the config reference (it might include a comment)
+      const configUuid = typeof configRef === 'string' ? configRef.split(' ')[0] : configRef.value?.split(' ')[0]
+      if (!configUuid) {
+        continue
+      }
+
+      const buildConfiguration = buildConfigurationSection[configUuid]
+      if (!buildConfiguration?.buildSettings) {
+        continue
+      }
+
+      const settings = readSigningSettings(buildConfiguration.buildSettings)
+      const configName = unquote(buildConfiguration.name)
+      if (configName && !(configName in byConfigurationName)) {
+        byConfigurationName[configName] = settings
+      }
+      fallback = fallback ?? settings
     }
 
-    const buildSettings = buildConfiguration.buildSettings
-
-    // Extract deployment target (remove quotes if present)
-    const deploymentTarget =
-      buildSettings.IPHONEOS_DEPLOYMENT_TARGET?.replace(/^"|"$/g, '') ||
-      buildSettings['IPHONEOS_DEPLOYMENT_TARGET']?.replace(/^"|"$/g, '') ||
-      null
-
-    // Extract code signing settings
-    const codeSignStyle =
-      buildSettings.CODE_SIGN_STYLE?.replace(/^"|"$/g, '') ||
-      buildSettings['CODE_SIGN_STYLE']?.replace(/^"|"$/g, '') ||
-      null
-
-    const developmentTeam =
-      buildSettings.DEVELOPMENT_TEAM?.replace(/^"|"$/g, '') ||
-      buildSettings['DEVELOPMENT_TEAM']?.replace(/^"|"$/g, '') ||
-      null
-
-    const provisioningProfileSpecifier =
-      buildSettings.PROVISIONING_PROFILE_SPECIFIER?.replace(/^"|"$/g, '') ||
-      buildSettings['PROVISIONING_PROFILE_SPECIFIER']?.replace(/^"|"$/g, '') ||
-      null
-
-    if (!deploymentTarget) {
+    if (!fallback) {
       return null
     }
 
-    return {
-      deploymentTarget,
-      codeSignStyle: codeSignStyle || undefined,
-      developmentTeam: developmentTeam || undefined,
-      provisioningProfileSpecifier: provisioningProfileSpecifier || undefined,
-    }
+    return { byConfigurationName, fallback }
   } catch {
     // If we can't read the settings, return null and use fallback values
     return null

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

@@ -42,9 +42,10 @@ function findBuildFileForFileRef(xcodeProject: XcodeProject, fileRef: string): {
 }
 
 /**
- * Adds the product file (.appex) for the widget extension.
+ * Adds the product file (.appex) for the widget extension. Internal create-only fallback for
+ * {@link ensureProductFile}; not part of the public pipeline.
  */
-export function addProductFile(xcodeProject: XcodeProject, options: AddProductFileOptions) {
+function addProductFile(xcodeProject: XcodeProject, options: AddProductFileOptions) {
   const { targetName, groupName } = options
 
   const productFileOptions = {