react-native 0.88.0-rc.0 → 0.88.0-rc.1

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

@@ -10,7 +10,8 @@
 
 'use strict';
 
-/*:: import type {
+/*:: import type {SwiftpmConfig} from './swiftpm-config';
+import type {
   AggregatorInput,
   AutolinkedDep,
   AutolinkingArgs,
@@ -62,11 +63,15 @@ const {
   SpmNameCollisionError,
   assertSwiftNameNotReserved,
   defaultReadConfig,
+  defaultReadPodspec,
   defaultResolveDep,
   expandSpmDependencies,
-  isValidSwiftName,
 } = require('./expand-spm-dependencies');
-const {readPodspec} = require('./read-podspec');
+const {
+  MIN_IOS_VERSION_SUPPORTED,
+  sanitizeIosDeploymentTarget,
+} = require('./ios-deployment-target');
+const {findPodspecs, readPodspecCached} = require('./read-podspec');
 const {
   AUTOLINKED_PACKAGE_NAME,
   REACT_CODEGEN_PACKAGE_NAME,
@@ -74,10 +79,14 @@ const {
   REACT_NATIVE_PACKAGE_NAME,
   REACT_NATIVE_PRODUCTS,
   RemoteVersionError,
+  displayPath,
   findProjectRoot,
+  isValidSwiftName,
   makeLogger,
   remotePackageConfig,
+  swiftNameKey,
 } = require('./spm-utils');
+const {readSwiftpmConfig, stringList} = require('./swiftpm-config');
 const fs = require('node:fs');
 const path = require('node:path');
 const yargs = require('yargs');
@@ -205,6 +214,10 @@ function parseArgs(argv /*: Array<string> */) /*: AutolinkingArgs */ {
       describe:
         'Path to the xcframeworks sub-package (absolute or relative to appRoot)',
     })
+    .option('ios-deployment-target', {
+      type: 'string',
+      describe: `Platform floor of the generated manifests (default: ${MIN_IOS_VERSION_SUPPORTED})`,
+    })
     .usage(
       'Usage: $0 [options]\n\nGenerates autolinked/Package.swift for SPM autolinking.',
     )
@@ -217,6 +230,9 @@ function parseArgs(argv /*: Array<string> */) /*: AutolinkingArgs */ {
     autolinkingJson: parsed['autolinking-json'] ?? null,
     output: parsed.output ?? null,
     xcframeworksPath: parsed['xcframeworks-path'] ?? null,
+    iosDeploymentTarget: sanitizeIosDeploymentTarget(
+      parsed['ios-deployment-target'],
+    ),
   };
 }
 
@@ -233,92 +249,116 @@ function readAutolinkingJson(
 }
 
 /**
- * Attempts to read react-native.config.js to find spm.modules entries.
- * These are extra modules not discoverable via autolinking.json.
+ * One of the app's settings, and the root that declared it. Looked up field by
+ * field so a project-root `swiftpmConfig` cannot hide a field the Xcode dir
+ * still declares: the directory holding the app's package.json wins (where
+ * codegen reads `codegenConfig` from), and `appRoot` — the Xcode project dir,
+ * the settings' old home — fills the gaps.
+ */
+function appConfigField(
+  appRoot /*: string */,
+  field /*: 'modules' | 'denyPlugins' */,
+) /*: ?{root: string, value: unknown} */ {
+  const projectRoot = findProjectRoot(appRoot);
+  const roots = projectRoot === appRoot ? [appRoot] : [projectRoot, appRoot];
+  for (const root of roots) {
+    const value = readSwiftpmConfig(root, defaultReadConfig(root))?.[field];
+    if (value === undefined) {
+      continue;
+    }
+    if (root !== projectRoot) {
+      warn(
+        `Read '${field}' from ${displayPath(root)}. Move it to 'swiftpmConfig' in ${displayPath(path.join(projectRoot, 'package.json'))} — an app's SwiftPM settings belong with its package.json.`,
+      );
+    }
+    return {root, value};
+  }
+  return null;
+}
+
+/**
+ * The app's own native modules — the ones autolinking.json cannot discover —
+ * with the root that declared them, since each `path` is relative to the file
+ * it is written in:
  *
- * Expected structure in react-native.config.js:
- * module.exports = {
- *   ...
- *   spm: {
- *     modules: [
+ *   // <project root>/package.json
+ *   "swiftpmConfig": {
+ *     "modules": [
  *       {
- *         name: "MyNativeModule",
- *         path: "ios/MyNativeModule",            // relative to appRoot
- *         exclude: ["*.js", "*.podspec"],        // optional
+ *         "name": "MyNativeModule",
+ *         "path": "ios/MyNativeModule",
+ *         "exclude": ["*.js", "*.podspec"]
  *       }
  *     ]
  *   }
- * }
  */
 function readSpmModulesFromConfig(
   appRoot /*: string */,
-) /*: Array<SpmModuleConfig> */ {
-  const configPath = path.join(appRoot, 'react-native.config.js');
-  if (!fs.existsSync(configPath)) {
-    return [];
+) /*: {modules: Array<SpmModuleConfig>, root: string} */ {
+  const declared = appConfigField(appRoot, 'modules');
+  if (declared == null || !Array.isArray(declared.value)) {
+    return {modules: [], root: appRoot};
   }
-  try {
-    // $FlowFixMe[unsupported-syntax] dynamic require by computed path
-    const config = require(configPath);
-    return config.spm?.modules ?? [];
-  } catch (e) {
-    // Config might use Ruby interop or other patterns – skip
-    return [];
+  // Entries stay unvalidated here: assertSpmModuleName checks each name, and
+  // the emission loop reads the rest defensively.
+  // $FlowFixMe[incompatible-type] user-authored entries
+  const modules /*: ReadonlyArray<SpmModuleConfig> */ = declared.value;
+  return {modules: [...modules], root: declared.root};
+}
+
+function moduleClashDiagnosis(
+  moduleName /*: string */,
+  clash /*: string */,
+) /*: string */ {
+  if (clash === moduleName) {
+    return `is already the name of another autolinked target.`;
   }
+  if (clash.toLowerCase() === moduleName.toLowerCase()) {
+    return `differs from the existing target '${clash}' only in case, which collides on case-insensitive filesystems.`;
+  }
+  return `compiles as the same module as the existing target '${clash}'.`;
 }
 
 /**
  * Validates one app-local `spm.modules` name against the same rules a library's
  * `spm.name` gets: a usable Swift identifier, not a name React Native reserves,
  * and not one already taken by another module or an autolinked dep.
- * `taken` maps lower-cased name → the name as written.
+ * `taken` is keyed by swiftNameKey, valued with the name as written.
  */
 function assertSpmModuleName(
   name /*: unknown */,
   taken /*: Map<string, string> */,
 ) /*: void */ {
   const remedy =
-    "Rename it in this app's react-native.config.js 'spm.modules'.";
+    "Rename it in this app's package.json 'swiftpmConfig.modules'.";
   if (typeof name !== 'string' || !isValidSwiftName(name)) {
     throw new Error(
-      `react-native autolinking: invalid 'spm.modules' name ${JSON.stringify(name) ?? 'undefined'}: must start with a letter or underscore and contain only letters, digits, underscores, or hyphens.`,
+      `react-native autolinking: invalid 'swiftpmConfig.modules' name ${JSON.stringify(name) ?? 'undefined'}: must start with a letter or underscore and contain only letters, digits, underscores, or hyphens.`,
     );
   }
   const moduleName = name;
   assertSwiftNameNotReserved(moduleName, {
-    label: `the 'spm.modules' entry '${moduleName}'`,
+    label: `the 'swiftpmConfig.modules' entry '${moduleName}'`,
     remedy,
     extraReservedNames: reservedNamesForRun(),
   });
-  const clash = taken.get(moduleName.toLowerCase());
+  const clash = taken.get(swiftNameKey(moduleName));
   if (clash != null) {
     throw new SpmNameCollisionError(
-      `react-native autolinking: SPM Swift name collision: the 'spm.modules' entry '${moduleName}' ` +
-        (clash === moduleName
-          ? `is already the name of another autolinked target.`
-          : `differs from the existing target '${clash}' only in case, which collides on case-insensitive filesystems.`) +
+      `react-native autolinking: SPM Swift name collision: the 'swiftpmConfig.modules' entry '${moduleName}' ` +
+        moduleClashDiagnosis(moduleName, clash) +
         ` ${remedy}`,
     );
   }
 }
 
 /**
- * Reads the app's `spm.denyPlugins` — npm names of autolinking plugins to
- * skip. The escape hatch for the transitive plugin discovery (an app opts a
- * framework's plugin OUT); no allowlist is required.
+ * The app's `denyPlugins` — npm names of autolinking plugins to skip. The
+ * escape hatch for transitive plugin discovery (an app opts a framework's
+ * plugin OUT); no allowlist is required.
  */
 function readDenyPluginsFromConfig(appRoot /*: string */) /*: Array<string> */ {
-  const configPath = path.join(appRoot, 'react-native.config.js');
-  if (!fs.existsSync(configPath)) {
-    return [];
-  }
-  try {
-    // $FlowFixMe[unsupported-syntax] dynamic require by computed path
-    const config = require(configPath);
-    return config.spm?.denyPlugins ?? [];
-  } catch (e) {
-    return [];
-  }
+  return stringList(appConfigField(appRoot, 'denyPlugins')?.value);
 }
 
 /**
@@ -433,21 +473,9 @@ function findSelfManagedPackageDir(absSource /*: string */) /*: ?string */ {
  * the scaffolder translates the podspec into a Package.swift.
  */
 function hasPodspec(absSource /*: string */) /*: boolean */ {
-  for (const sub of ['', 'ios']) {
-    const dir = sub === '' ? absSource : path.join(absSource, sub);
-    try {
-      if (
-        fs
-          .readdirSync(dir)
-          .some(e => e.endsWith('.podspec') && !e.startsWith('.spm-scaffold-'))
-      ) {
-        return true;
-      }
-    } catch {
-      // dir does not exist; try the next candidate
-    }
-  }
-  return false;
+  return [absSource, path.join(absSource, 'ios')].some(
+    dir => findPodspecs(dir).length > 0,
+  );
 }
 
 /**
@@ -778,9 +806,9 @@ function expandSpmSourceGlobs(
  * Returns null if the dependency doesn't have iOS support.
  *
  * `swiftNameByNpm` maps each autolinked dep's npm name to its resolved Swift
- * name (populated by expandSpmDependencies, honoring the dep's `spm.name`
- * config and scope disambiguation). Every name this function emits comes from
- * there — see requireSwiftName.
+ * name (populated by expandSpmDependencies from the dep's podspec and
+ * `spm.name`). Every name this function emits comes from there — see
+ * requireSwiftName.
  */
 /**
  * Read the dep's podspec (if any) and extract its declared
@@ -799,24 +827,12 @@ function expandSpmSourceGlobs(
 function extractPodspecHeaderSearchPaths(
   sourceDir /*: string */,
 ) /*: Array<string> */ {
-  let podspecPath /*: ?string */ = null;
-  try {
-    const entries = fs.readdirSync(sourceDir);
-    // Skip a crashed run's leftover `.spm-scaffold-<pid>-<name>.podspec` copy.
-    const candidate = entries.find(
-      e => e.endsWith('.podspec') && !e.startsWith('.spm-scaffold-'),
-    );
-    if (candidate != null) {
-      podspecPath = path.join(sourceDir, candidate);
-    }
-  } catch {
-    return [];
-  }
+  const podspecPath /*: ?string */ = findPodspecs(sourceDir)[0];
   if (podspecPath == null) return [];
 
   let model;
   try {
-    model = readPodspec(podspecPath);
+    model = readPodspecCached(podspecPath);
   } catch {
     return [];
   }
@@ -936,6 +952,8 @@ function generateAutolinkedPackageSwift(
     input.pluginPackageDeps ?? [];
   const pluginProductDeps /*: ReadonlyArray<PluginProductDep> */ =
     input.pluginProductDeps ?? [];
+  const iosDeploymentTarget /*: string */ =
+    input.iosDeploymentTarget ?? MIN_IOS_VERSION_SUPPORTED;
 
   // Package-level dependencies: one .package(path:) per autolinked dep,
   // plus ReactNative if any inline target needs to import React headers.
@@ -1069,7 +1087,7 @@ import Foundation
 
 ${guardBlock}let package = Package(
     name: "${AUTOLINKED_PACKAGE_NAME}",
-    platforms: [.iOS(.v15)],
+    platforms: [.iOS("${iosDeploymentTarget}")],
     products: [
         .library(name: "${AUTOLINKED_PACKAGE_NAME}", targets: ["AutolinkedAggregate"]),
     ],
@@ -1119,6 +1137,8 @@ function generateSynthPackageSwift(spec /*: SynthPackageSpec */) /*: string */ {
   const targetPath /*: string */ = spec.targetPath ?? `Sources/${swiftName}`;
   const siblingSynthAbsolutePaths /*: {[string]: string} */ =
     spec.siblingSynthAbsolutePaths ?? {};
+  const iosDeploymentTarget /*: string */ =
+    spec.iosDeploymentTarget ?? MIN_IOS_VERSION_SUPPORTED;
 
   // Package dependencies — ReactNative + each spm sibling synth package.
   // The React + codegen package paths are plain relative strings computed by
@@ -1217,7 +1237,7 @@ import PackageDescription
 
 let package = Package(
     name: "${swiftName}",
-    platforms: [.iOS(.v15)],
+    platforms: [.iOS("${iosDeploymentTarget}")],
     products: [
         .library(name: "${swiftName}"${isDynamic ? ', type: .dynamic' : ''}, targets: ["${swiftName}"]),
     ],
@@ -1312,8 +1332,8 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
     const allDeps = expandSpmDependencies(directDeps, {
       readConfig: defaultReadConfig,
       resolveDep: defaultResolveDep,
+      readPodspec: defaultReadPodspec,
       extraReservedNames: reservedNamesForRun(),
-      log,
     });
 
     // Map every autolinked npm name to its resolved Swift name so transitive
@@ -1380,7 +1400,7 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
         const dependents = pluginHostDependents.get(dep.name);
         if (dependents != null) {
           throw new Error(
-            `react-native autolinking: '${dep.name}' ships an SPM autolinking plugin, which owns its native contribution — so React Native does not build it as a sibling target for anything to depend on. It is declared in 'spm.dependencies' by ${dependents.map(name => `'${name}'`).join(', ')}. Remove it there; nothing is lost. Its plugin links its products into the app and resolves its own ecosystem's dependencies, so a library that builds against it does not declare it here.`,
+            `react-native autolinking: '${dep.name}' ships an SPM autolinking plugin, which owns its native contribution — so React Native does not build it as a sibling target for anything to depend on. It is declared as a SwiftPM dependency by ${dependents.map(name => `'${name}'`).join(', ')}. Remove it there; nothing is lost. Its plugin links its products into the app and resolves its own ecosystem's dependencies, so a library that builds against it does not declare it here.`,
           );
         }
         log(
@@ -1414,17 +1434,20 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
   // If the module declares `sources: [glob, ...]` (CocoaPods-style), expand
   // the globs now relative to its dir and attach the file list to the target
   // so the emission loop below renders `sources: [...]` literally.
-  const configModules = readSpmModulesFromConfig(appRoot);
+  const {modules: configModules, root: configModulesRoot} =
+    readSpmModulesFromConfig(appRoot);
   // Module names land in the manifest exactly as written, so they get the same
   // checks a dep's Swift name gets. Seeded with the dep target names already
   // emitted so a module can't shadow an autolinked library either.
   const takenSwiftNames /*: Map<string, string> */ = new Map(
-    entries.map(entry => [entry.target.name.toLowerCase(), entry.target.name]),
+    entries.map(entry => [swiftNameKey(entry.target.name), entry.target.name]),
   );
   for (const mod of configModules) {
     assertSpmModuleName(mod.name, takenSwiftNames);
-    takenSwiftNames.set(mod.name.toLowerCase(), mod.name);
-    const absPath = path.resolve(appRoot, mod.path);
+    takenSwiftNames.set(swiftNameKey(mod.name), mod.name);
+    // Relative to the package.json (or config file) that declared it, so a
+    // path reads correctly from where it is written.
+    const absPath = path.resolve(configModulesRoot, mod.path);
     const relPath = path.relative(outputDir, absPath);
     const userSources =
       Array.isArray(mod.sources) && mod.sources.length > 0
@@ -1689,6 +1712,7 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
 
     const synthContent = generateSynthPackageSwift({
       swiftName: target.name,
+      iosDeploymentTarget: args.iosDeploymentTarget,
       exclude: prefixedExclude,
       sources: prefixedSources,
       // Stub include/ subdir lives in the wrapper dir; satisfies SPM's
@@ -1863,6 +1887,7 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
   // autolinked dep is a real SPM package in its own source dir.
   const aggregatorContent = generateAutolinkedPackageSwift({
     npmDeps: aggregatorPackageDeps,
+    iosDeploymentTarget: args.iosDeploymentTarget,
     hasReactDep,
     xcframeworksRelPath,
     pluginPackageDeps,
@@ -1999,6 +2024,7 @@ module.exports = {
   findSelfManagedPackageDir,
   hasPodspec,
   hasMixedLanguageSources,
+  readDenyPluginsFromConfig,
   MissingManifestError,
   reportMissingManifests,
   AUTOGEN_MARKER,

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

@@ -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),
     },
   };
@@ -899,7 +903,8 @@ function generateXcscheme(
             ActionType = "Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction">
             <ActionContent
                title = "Sync SPM Autolinking"
-               scriptText = "${escapedSync}">
+               scriptText = "${escapedSync}"
+               shellToInvoke = "/bin/bash">
                <EnvironmentBuildable>
                   <BuildableReference
                      BuildableIdentifier = "primary"
@@ -1361,27 +1366,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);
@@ -1429,7 +1436,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]);
@@ -1606,6 +1618,7 @@ function injectSpmIntoPbxproj(
           'shellScript',
           'inputPaths',
           'outputPaths',
+          'shellPath',
         ]) {
           const current = findObjectByUuid(text, uuid);
           if (current != null) {
@@ -1876,11 +1889,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(
@@ -1907,7 +1949,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` +
@@ -2181,7 +2224,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
@@ -2718,6 +2761,7 @@ module.exports = {
   buildSchemePreActionScript,
   buildEmbedFrameworksScript,
   flavorForBuildConfiguration,
+  targetBuildConfigUuids,
   frameworkConditionalSettings,
   ensureStubPackages,
   buildSpmDependencyGraph,
@@ -2732,6 +2776,7 @@ module.exports = {
   addPreActionToScheme,
   removePreActionFromScheme,
   findInjectedXcodeproj,
+  readMarker,
   readArtifactsVersionOverride,
   readPinnedConfigCommand,
   readScriptPhasesManifest,