react-native-tvos 0.87.1-0 → 0.88.0-0rc2

package/scripts/spm/generate-spm-xcodeproj.js

@@ -56,8 +56,8 @@ const {
   makeLogger,
   remotePackageConfig,
 } = require('./spm-utils');
-const fs = require('fs');
-const path = require('path');
+const fs = require('node:fs');
+const path = require('node:path');
 
 /*:: import type {
   FlavoredFrameworkManifestEntry,
@@ -319,7 +319,11 @@ function shellScriptPhase(
       outputFileListPaths: empty,
       outputPaths: pathList(options.outputPaths),
       runOnlyForDeploymentPostprocessing: '0',
-      shellPath: '/bin/sh',
+      // React Native's own bodies here start with `set -euo pipefail`, which
+      // /bin/sh rejects on a host where it isn't bash (e.g. dash's `set -o
+      // pipefail: Illegal option`). Run every phase under bash, including
+      // plugin-contributed ones, so a plugin's body can rely on it too.
+      shellPath: '/bin/bash',
       shellScript: quoteIfNeeded(script),
     },
   };
@@ -763,7 +767,9 @@ if [ "$STALE" -eq 0 ] && [ -f "$WATCH_FILE" ]; then
   while IFS= read -r P; do
     [ -z "$P" ] && continue
     if [ -d "$P" ]; then
-      if [ -n "$(find "$P" -newer "$STAMP" -print -quit 2>/dev/null)" ]; then
+      # .swiftpm holds Xcode's own per-user scheme state, which it rewrites
+      # during a build — reading it as a change makes every IDE build re-sync.
+      if [ -n "$(find "$P" -name .swiftpm -prune -o -newer "$STAMP" -print -quit 2>/dev/null)" ]; then
         STALE=1
         break
       fi
@@ -899,7 +905,8 @@ function generateXcscheme(
             ActionType = "Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction">
             <ActionContent
                title = "Sync SPM Autolinking"
-               scriptText = "${escapedSync}">
+               scriptText = "${escapedSync}"
+               shellToInvoke = "/bin/bash">
                <EnvironmentBuildable>
                   <BuildableReference
                      BuildableIdentifier = "primary"
@@ -1250,7 +1257,6 @@ function injectSpmIntoPbxproj(
   plan /*: {rootUuid: string, targetUuid: string, configUuids: Array<string>, frameworksPhaseUuid: string, sourcesPhaseUuid?: ?string} */,
   reactNativePath /*: string */,
   remote /*: ?RemoteCfg */,
-  hermesCliPath /*: ?string */ = null,
   generatedSources /*: ReadonlyArray<GeneratedSource> */ = [],
   flavoredFrameworks /*: ReadonlyArray<FlavoredFrameworkManifestEntry> */ = [],
   scriptPhases /*: ReadonlyArray<PluginScriptPhase> */ = [],
@@ -1350,7 +1356,6 @@ function injectSpmIntoPbxproj(
       configUuid,
       buildConfigurationName(text, configUuid),
       reactNativePath,
-      hermesCliPath,
       flavoredFrameworks,
     );
     text = merged.text;
@@ -1363,27 +1368,29 @@ function injectSpmIntoPbxproj(
   //    bundles JS via its own phase.
   const syncScript = buildSyncAutolinkingScript(reactNativePath);
   const syncPhaseUuid = mkUuid('PBXShellScriptBuildPhase', 'SyncAutolinking');
+  const syncEntry = shellScriptPhase(
+    syncPhaseUuid,
+    'Sync SPM Autolinking',
+    syncScript,
+  );
   if (!text.includes(syncPhaseUuid)) {
     text = insertObjectsIntoSection(
       text,
       'PBXShellScriptBuildPhase',
-      serializeEntry(
-        shellScriptPhase(syncPhaseUuid, 'Sync SPM Autolinking', syncScript),
-      ),
+      serializeEntry(syncEntry),
     );
   } else {
-    // Already injected on a prior run — the phase object owns its
-    // shellScript, so refresh it in place (same quoting used at creation) in
-    // case the generated script changed since. Byte-identical when it
-    // didn't; field order and every other byte of the phase are untouched.
-    const existingPhase = findObjectByUuid(text, syncPhaseUuid);
-    if (existingPhase != null) {
-      text = setScalarField(
-        text,
-        existingPhase,
-        'shellScript',
-        quoteIfNeeded(syncScript),
-      );
+    // Already injected on a prior run — the phase object owns these fields,
+    // so refresh them in place (same quoting used at creation) in case the
+    // generated script changed, or a project injected before shellPath moved
+    // to bash (see shellScriptPhase) still has the stale value. Byte-identical
+    // when neither did; field order and every other byte of the phase are
+    // untouched.
+    for (const key of ['shellScript', 'shellPath']) {
+      const current = findObjectByUuid(text, syncPhaseUuid);
+      if (current != null) {
+        text = setScalarField(text, current, key, syncEntry.fields[key]);
+      }
     }
   }
   injectedUuids.push(syncPhaseUuid);
@@ -1431,7 +1438,12 @@ function injectSpmIntoPbxproj(
   } else {
     const existingPhase = findObjectByUuid(text, embedPhaseUuid);
     if (existingPhase != null) {
-      for (const key of ['shellScript', 'inputPaths', 'outputPaths']) {
+      for (const key of [
+        'shellScript',
+        'inputPaths',
+        'outputPaths',
+        'shellPath',
+      ]) {
         const current = findObjectByUuid(text, embedPhaseUuid);
         if (current != null) {
           text = setScalarField(text, current, key, embedEntry.fields[key]);
@@ -1608,6 +1620,7 @@ function injectSpmIntoPbxproj(
           'shellScript',
           'inputPaths',
           'outputPaths',
+          'shellPath',
         ]) {
           const current = findObjectByUuid(text, uuid);
           if (current != null) {
@@ -1659,48 +1672,6 @@ function findApplicationTargetByUuid(
   return obj;
 }
 
-/**
- * Merge the React build settings into one XCBuildConfiguration's dict. Returns
- * the modified text plus a precise record of what was actually added — so
- * `deinit` (removeSpmInjection) can reverse exactly these edits, never touching
- * a value the user already had (key insight: ensureScalarField/
- * addArrayStringValues are no-ops / dedupe when a value is already present).
- */
-/**
- * Resolves the host `hermesc` from the `hermes-compiler` npm package and returns
- * its ABSOLUTE path as the HERMES_CLI_PATH value, or null when it can't be found
- * (e.g. USE_HERMES=false apps without the package). require.resolve (anchored at
- * reactNativeRoot) follows Node's lookup, so a hoisted monorepo layout — where
- * hermes-compiler sits in the workspace-root node_modules, NOT next to
- * react-native — resolves correctly.
- *
- * The value is intentionally ABSOLUTE, not `$(REACT_NATIVE_PATH)/../...`: when
- * react-native is a symlink (the monorepo default, and common in real apps), a
- * `..` after it resolves — kernel-side — to the symlink TARGET's parent, not the
- * node_modules dir, so the relative form points at a non-existent
- * `<rn-target>/../hermes-compiler`. An absolute path sidesteps that entirely
- * (and matches how the CocoaPods hermes-engine pod sets HERMES_CLI_PATH). It is
- * regenerated on every `spm add`, so machine-specificity is a non-issue.
- */
-function resolveHermesCliPathSetting(
-  reactNativeRoot /*: string */,
-) /*: ?string */ {
-  try {
-    const pkg = require.resolve('hermes-compiler/package.json', {
-      paths: [reactNativeRoot],
-    });
-    const hermesc = path.join(
-      path.dirname(pkg),
-      'hermesc',
-      'osx-bin',
-      'hermesc',
-    );
-    return fs.existsSync(hermesc) ? hermesc : null;
-  } catch {
-    return null;
-  }
-}
-
 /** Strip the surrounding plist quotes from a build-setting token, if any. */
 function unquotePlist(s /*: string */) /*: string */ {
   return s.replace(/^"/, '').replace(/"$/, '');
@@ -1723,29 +1694,24 @@ function buildSettingValueTokens(value /*: string */) /*: Set<string> */ {
   );
 }
 
+/**
+ * Merge the React build settings into one XCBuildConfiguration's dict. Returns
+ * the modified text plus a precise record of what was actually added — so
+ * `deinit` (removeSpmInjection) can reverse exactly these edits, never touching
+ * a value the user already had (key insight: ensureScalarField/
+ * addArrayStringValues are no-ops / dedupe when a value is already present).
+ */
 function mergeReactBuildSettings(
   input /*: string */,
   configUuid /*: string */,
   configurationName /*: string */,
   reactNativePath /*: string */,
-  hermesCliPath /*: ?string */ = null,
   flavoredFrameworks /*: ReadonlyArray<FlavoredFrameworkManifestEntry> */ = [],
 ) /*: {text: string, change: BuildSettingChange} */ {
   let text = input;
   const scalars = [
     {key: 'CLANG_CXX_LANGUAGE_STANDARD', value: '"c++20"'},
     {key: 'REACT_NATIVE_PATH', value: quoteIfNeeded(reactNativePath)},
-    // Under SwiftPM there is no hermes-engine pod, so react-native-xcode.sh's
-    // fallback ($PODS_ROOT/hermes-engine/destroot/bin/hermesc) resolves to a
-    // non-existent "/hermes-engine/..." and the Release JS→Hermes bundling
-    // fails. Point HERMES_CLI_PATH at the hermes-compiler npm package's host
-    // hermesc (an ABSOLUTE path resolved by the caller — see
-    // resolveHermesCliPathSetting). react-native-xcode.sh honors an already-set
-    // HERMES_CLI_PATH before its pod fallback; ensureScalarField leaves any
-    // user-provided value untouched.
-    ...(hermesCliPath != null
-      ? [{key: 'HERMES_CLI_PATH', value: quoteIfNeeded(hermesCliPath)}]
-      : []),
   ];
   // Re-locate the buildSettings dict before each edit (offsets shift).
   const dict = () => {
@@ -1925,11 +1891,40 @@ function addPreActionToScheme(
     // value itself never contains one — the next `"` is always the closing
     // delimiter.
     const valueEnd = xml.indexOf('"', valueStart);
-    return (
+    let xmlWithScript =
       xml.slice(0, valueStart) +
       escapeXmlAttribute(syncScript) +
-      xml.slice(valueEnd)
+      xml.slice(valueEnd);
+
+    // Xcode always runs a scheme pre-action's scriptText under the shell this
+    // attribute names (default /bin/sh), independent of a
+    // PBXShellScriptBuildPhase's own shellPath (see shellScriptPhase) — pin
+    // it to bash too. `>` can't appear unescaped inside either attribute
+    // value, so it reliably closes the ActionContent open tag. Search the
+    // whole open tag (not just after scriptText) and allow any spacing
+    // around `=`, since attribute order and formatting aren't guaranteed.
+    const contentOpenIdx = xmlWithScript.lastIndexOf(
+      '<ActionContent',
+      titleIdx,
     );
+    const contentCloseIdx = xmlWithScript.indexOf('>', stIdx);
+    const openTag = xmlWithScript.slice(contentOpenIdx, contentCloseIdx);
+    const stiMatch = openTag.match(/shellToInvoke\s*=\s*"/);
+    if (stiMatch != null) {
+      const stiValueStart =
+        contentOpenIdx + stiMatch.index + stiMatch[0].length;
+      const stiValueEnd = xmlWithScript.indexOf('"', stiValueStart);
+      xmlWithScript =
+        xmlWithScript.slice(0, stiValueStart) +
+        '/bin/bash' +
+        xmlWithScript.slice(stiValueEnd);
+    } else {
+      xmlWithScript =
+        xmlWithScript.slice(0, contentCloseIdx) +
+        '\n               shellToInvoke = "/bin/bash"' +
+        xmlWithScript.slice(contentCloseIdx);
+    }
+    return xmlWithScript;
   }
   const refMatch = xml.match(
     new RegExp(
@@ -1956,7 +1951,8 @@ function addPreActionToScheme(
     `            ActionType = "Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction">\n` +
     `            <ActionContent\n` +
     `               title = "Sync SPM Autolinking"\n` +
-    `               scriptText = "${escapeXmlAttribute(syncScript)}">\n` +
+    `               scriptText = "${escapeXmlAttribute(syncScript)}"\n` +
+    `               shellToInvoke = "/bin/bash">\n` +
     `               <EnvironmentBuildable>\n` +
     `                  ${cleanRef}\n` +
     `               </EnvironmentBuildable>\n` +
@@ -2230,7 +2226,7 @@ function readScriptPhasesManifest(
  */
 function readMarker(
   xcodeprojPath /*: string */,
-) /*: ?{generatedSources?: {[string]: Array<string>}, scriptPhases?: {[string]: string}, artifactsVersionOverride?: ?string, configCommand?: ?Array<string>, buildSettingChanges?: Array<BuildSettingChange>, createdArrayFields?: Array<CreatedArrayField>, scheme?: {file?: ?string, created?: ?boolean}, ...} */ {
+) /*: ?{targetUuid?: ?string, generatedSources?: {[string]: Array<string>}, scriptPhases?: {[string]: string}, artifactsVersionOverride?: ?string, configCommand?: ?Array<string>, buildSettingChanges?: Array<BuildSettingChange>, createdArrayFields?: Array<CreatedArrayField>, scheme?: {file?: ?string, created?: ?boolean}, ...} */ {
   const markerPath = path.join(xcodeprojPath, SPM_INJECTED_MARKER);
   try {
     // $FlowFixMe[incompatible-return] JSON.parse returns any
@@ -2368,7 +2364,6 @@ function injectSpmIntoExistingXcodeproj(
   }
   const reactNativePath = path.relative(appRoot, reactNativeRoot);
   const remote = remotePackageConfig(appRoot);
-  const hermesCliPath = resolveHermesCliPathSetting(reactNativeRoot);
   const generatedSources = readGeneratedSourcesManifest(appRoot);
   const scriptPhases = readScriptPhasesManifest(appRoot);
   const flavoredFrameworks = readFlavoredFrameworksManifest(appRoot).frameworks;
@@ -2441,7 +2436,6 @@ function injectSpmIntoExistingXcodeproj(
     },
     reactNativePath,
     remote,
-    hermesCliPath,
     generatedSources,
     flavoredFrameworks,
     scriptPhases,
@@ -2769,6 +2763,7 @@ module.exports = {
   buildSchemePreActionScript,
   buildEmbedFrameworksScript,
   flavorForBuildConfiguration,
+  targetBuildConfigUuids,
   frameworkConditionalSettings,
   ensureStubPackages,
   buildSpmDependencyGraph,
@@ -2783,6 +2778,7 @@ module.exports = {
   addPreActionToScheme,
   removePreActionFromScheme,
   findInjectedXcodeproj,
+  readMarker,
   readArtifactsVersionOverride,
   readPinnedConfigCommand,
   readScriptPhasesManifest,

package/scripts/spm/ios-deployment-target.js

@@ -0,0 +1,378 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+/**
+ * The iOS platform floor of the SwiftPM manifests React Native generates.
+ * SwiftPM refuses to link a product whose minimum is above the depending
+ * target's, so the floor tracks the app's own deployment target rather than a
+ * hardcoded value a dependency (every Expo package: iOS 16.4) can exceed.
+ */
+
+const {targetBuildConfigUuids} = require('./generate-spm-xcodeproj');
+const {
+  findApplicationTargets,
+  findField,
+  findObjectByUuid,
+  findProjectObject,
+  forEachObjectInSection,
+  uuidsInArray,
+} = require('./spm-pbxproj');
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Keep in sync with `min_ios_version_supported` in scripts/cocoapods/helpers.rb.
+const MIN_IOS_VERSION_SUPPORTED /*: string */ = '15.1';
+
+const IOS_VERSION_RE = /^\d+(\.\d+){0,2}$/;
+
+const DEPLOYMENT_TARGET_KEY = 'IPHONEOS_DEPLOYMENT_TARGET';
+
+// An xcconfig may `#include` another; cap the chain instead of trusting it.
+const MAX_XCCONFIG_DEPTH = 16;
+
+/*::
+// Everything the reader needs to follow a configuration's xcconfig. Without a
+// srcRoot the xcconfig step is skipped (a caller with only pbxproj text).
+type XcconfigContext = {srcRoot: ?string, readFile: (absPath: string) => ?string};
+*/
+
+function normalizeIosVersion(version /*: string */) /*: string */ {
+  return version.includes('.') ? version : `${version}.0`;
+}
+
+function segment(
+  parts /*: Array<string> */,
+  index /*: number */,
+) /*: number */ {
+  return index < parts.length ? Number(parts[index]) : 0;
+}
+
+/** Numeric, not lexicographic: `9.0` < `10.0` and `16.4` < `16.10`. */
+function compareIosVersions(a /*: string */, b /*: string */) /*: number */ {
+  const left = a.split('.');
+  const right = b.split('.');
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const delta = segment(left, i) - segment(right, i);
+    if (delta !== 0) {
+      return delta < 0 ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+function unquote(value /*: string */) /*: string */ {
+  return value.replace(/^"|"$/g, '');
+}
+
+/**
+ * A version reduced to something safe to interpolate into a manifest:
+ * normalized, and never below React Native's own minimum.
+ */
+function sanitizeIosDeploymentTarget(raw /*: ?string */) /*: string */ {
+  if (raw == null || !IOS_VERSION_RE.test(raw)) {
+    return MIN_IOS_VERSION_SUPPORTED;
+  }
+  const version = normalizeIosVersion(raw);
+  return compareIosVersions(version, MIN_IOS_VERSION_SUPPORTED) > 0
+    ? version
+    : MIN_IOS_VERSION_SUPPORTED;
+}
+
+function defaultReadFile(absPath /*: string */) /*: ?string */ {
+  try {
+    return fs.readFileSync(absPath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * `IPHONEOS_DEPLOYMENT_TARGET` as an xcconfig defines it, following `#include`
+ * lines in place so a later assignment in the includer wins. Null when the file
+ * is unreadable, sets no unconditional value, or sets one that is not a plain
+ * version (`$(inherited)`).
+ */
+function parseXcconfigSetting(
+  absPath /*: string */,
+  content /*: string */,
+  readFile /*: (absPath: string) => ?string */,
+  visited /*: Set<string> */ = new Set(),
+  depth /*: number */ = 0,
+) /*: ?string */ {
+  if (visited.has(absPath)) {
+    return null;
+  }
+  visited.add(absPath);
+  const assignment = new RegExp(`^${DEPLOYMENT_TARGET_KEY}\\s*=\\s*([^;]*);?$`);
+  let value /*: ?string */ = null;
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.replace(/\/\/.*$/, '').trim();
+    const include = line.match(/^#include\??\s+"([^"]+)"/);
+    if (include != null) {
+      const included = readXcconfigSetting(
+        path.resolve(path.dirname(absPath), include[1]),
+        readFile,
+        visited,
+        depth + 1,
+      );
+      if (included != null) {
+        value = included;
+      }
+      continue;
+    }
+    const match = line.match(assignment);
+    if (match != null) {
+      const raw = unquote(match[1].trim());
+      value = IOS_VERSION_RE.test(raw) ? raw : null;
+    }
+  }
+  return value;
+}
+
+/** parseXcconfigSetting for a path not read yet — the `#include` entry point. */
+function readXcconfigSetting(
+  absPath /*: string */,
+  readFile /*: (absPath: string) => ?string */,
+  visited /*: Set<string> */,
+  depth /*: number */,
+) /*: ?string */ {
+  if (depth > MAX_XCCONFIG_DEPTH) {
+    return null;
+  }
+  const content = readFile(absPath);
+  return content != null
+    ? parseXcconfigSetting(absPath, content, readFile, visited, depth)
+    : null;
+}
+
+/**
+ * Directory components of the PBXGroup chain holding `uuid`, outermost first —
+ * how a `"<group>"` file reference's path is anchored to the project dir.
+ */
+function groupPathPrefix(
+  text /*: string */,
+  uuid /*: string */,
+) /*: Array<string> */ {
+  const groups /*: Array<{uuid: string, path: ?string, children: Set<string>}> */ =
+    [];
+  forEachObjectInSection(text, 'PBXGroup', ({uuid: groupUuid, ...body}) => {
+    const children = findField(text, body, 'children');
+    const groupPath = findField(text, body, 'path');
+    groups.push({
+      uuid: groupUuid,
+      path: groupPath != null ? unquote(groupPath.value) : null,
+      children: children != null ? uuidsInArray(children.value) : new Set(),
+    });
+  });
+
+  const parts /*: Array<string> */ = [];
+  let current = uuid;
+  for (let i = 0; i < groups.length; i++) {
+    const parent = groups.find(group => group.children.has(current));
+    if (parent == null) {
+      break;
+    }
+    if (parent.path != null) {
+      parts.unshift(parent.path);
+    }
+    current = parent.uuid;
+  }
+  return parts;
+}
+
+/**
+ * Absolute paths to try for the xcconfig a configuration is based on, in order:
+ * the reference's own anchoring first, then plain `<srcRoot>/<path>`.
+ */
+function xcconfigCandidates(
+  text /*: string */,
+  configObj /*: {bodyOpen: number, bodyClose: number, ...} */,
+  srcRoot /*: string */,
+) /*: Array<string> */ {
+  const base = findField(text, configObj, 'baseConfigurationReference');
+  const refUuid = base?.value.match(/[0-9A-Fa-f]{24}/)?.[0];
+  if (refUuid == null) {
+    return [];
+  }
+  const ref = findObjectByUuid(text, refUuid);
+  if (ref == null) {
+    return [];
+  }
+  const pathField = findField(text, ref, 'path');
+  if (pathField == null) {
+    return [];
+  }
+  const refPath = unquote(pathField.value);
+  if (path.isAbsolute(refPath)) {
+    return [refPath];
+  }
+  const sourceTreeField = findField(text, ref, 'sourceTree');
+  const sourceTree =
+    sourceTreeField != null ? unquote(sourceTreeField.value) : '';
+  const fallback = path.join(srcRoot, refPath);
+  if (sourceTree !== '<group>') {
+    return [fallback];
+  }
+  const anchored = path.join(
+    srcRoot,
+    ...groupPathPrefix(text, refUuid),
+    refPath,
+  );
+  return anchored === fallback ? [fallback] : [anchored, fallback];
+}
+
+function configName(
+  text /*: string */,
+  configObj /*: {bodyOpen: number, bodyClose: number, ...} */,
+) /*: ?string */ {
+  const field = findField(text, configObj, 'name');
+  return field != null ? unquote(field.value) : null;
+}
+
+/** A plain-version `IPHONEOS_DEPLOYMENT_TARGET` literal in a configuration. */
+function configLiteral(
+  text /*: string */,
+  configObj /*: {bodyOpen: number, bodyClose: number, ...} */,
+) /*: ?string */ {
+  const settings = findField(text, configObj, 'buildSettings');
+  if (settings == null) {
+    return null;
+  }
+  const field = findField(
+    text,
+    {bodyOpen: settings.valueStart, bodyClose: settings.tokenEnd - 1},
+    DEPLOYMENT_TARGET_KEY,
+  );
+  if (field == null) {
+    return null;
+  }
+  const raw = unquote(field.value);
+  return IOS_VERSION_RE.test(raw) ? raw : null;
+}
+
+/**
+ * What one configuration declares: its own literal, else the xcconfig it is
+ * based on (Xcode's own precedence).
+ */
+function configDeploymentTarget(
+  text /*: string */,
+  configObj /*: {bodyOpen: number, bodyClose: number, ...} */,
+  ctx /*: XcconfigContext */,
+) /*: ?string */ {
+  const literal = configLiteral(text, configObj);
+  if (literal != null || ctx.srcRoot == null) {
+    return literal;
+  }
+  for (const candidate of xcconfigCandidates(text, configObj, ctx.srcRoot)) {
+    const content = ctx.readFile(candidate);
+    if (content != null) {
+      return parseXcconfigSetting(candidate, content, ctx.readFile);
+    }
+  }
+  return null;
+}
+
+/**
+ * The app's declared iOS deployment target, or null when nothing declares one.
+ * Target selection: the marker's `targetUuid`, else the app target named
+ * `targetName` (`--product-name`), else every app target. Each configuration
+ * falls back to the project-level one of the same name (each level accepting a
+ * literal or the xcconfig it is based on), and the lowest wins — a single
+ * manifest floor has to hold for every configuration.
+ */
+function readIosDeploymentTargetFromPbxproj(
+  text /*: string */,
+  opts /*:: ?: {
+    targetUuid?: ?string,
+    targetName?: ?string,
+    srcRoot?: ?string,
+    readFile?: (absPath: string) => ?string,
+  } */,
+) /*: ?string */ {
+  const ctx /*: XcconfigContext */ = {
+    srcRoot: opts?.srcRoot,
+    readFile: opts?.readFile ?? defaultReadFile,
+  };
+  const targetUuid = opts?.targetUuid;
+  const marked = targetUuid != null ? findObjectByUuid(text, targetUuid) : null;
+  const apps = findApplicationTargets(text);
+  const named =
+    opts?.targetName != null
+      ? apps.find(app => app.name === opts.targetName)
+      : null;
+  const targets = marked != null ? [marked] : named != null ? [named] : apps;
+
+  const projectDefaults /*: Map<string, string> */ = new Map();
+  const project = findProjectObject(text);
+  if (project != null) {
+    for (const uuid of targetBuildConfigUuids(text, project)) {
+      const config = findObjectByUuid(text, uuid);
+      const name = config != null ? configName(text, config) : null;
+      const value =
+        config != null ? configDeploymentTarget(text, config, ctx) : null;
+      if (name != null && value != null) {
+        projectDefaults.set(name, value);
+      }
+    }
+  }
+
+  let floor /*: ?string */ = null;
+  for (const target of targets) {
+    for (const uuid of targetBuildConfigUuids(text, target)) {
+      const config = findObjectByUuid(text, uuid);
+      if (config == null) {
+        continue;
+      }
+      const name = configName(text, config);
+      const value =
+        configDeploymentTarget(text, config, ctx) ??
+        (name != null ? projectDefaults.get(name) : null) ??
+        null;
+      if (
+        value != null &&
+        (floor == null || compareIosVersions(value, floor) < 0)
+      ) {
+        floor = value;
+      }
+    }
+  }
+  return floor;
+}
+
+/**
+ * The sanitized floor read from `<xcodeprojPath>/project.pbxproj`, or null when
+ * there is no project, it cannot be read, or it declares nothing usable.
+ */
+function resolveIosDeploymentTarget(
+  opts /*: {xcodeprojPath: ?string, targetUuid?: ?string, targetName?: ?string} */,
+) /*: ?string */ {
+  const {xcodeprojPath, targetUuid, targetName} = opts;
+  if (xcodeprojPath == null) {
+    return null;
+  }
+  try {
+    const found = readIosDeploymentTargetFromPbxproj(
+      fs.readFileSync(path.join(xcodeprojPath, 'project.pbxproj'), 'utf8'),
+      {targetUuid, targetName, srcRoot: path.dirname(xcodeprojPath)},
+    );
+    return found != null ? sanitizeIosDeploymentTarget(found) : null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  MIN_IOS_VERSION_SUPPORTED,
+  readIosDeploymentTargetFromPbxproj,
+  resolveIosDeploymentTarget,
+  sanitizeIosDeploymentTarget,
+};