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

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,
+};

package/scripts/spm/read-podspec.js

@@ -170,6 +170,27 @@ function cleanupPatchedPodspec(patchedPath /*: ?string */) /*: void */ {
 // Regex fallback
 // ---------------------------------------------------------------------------
 
+// Comment-only lines are dropped so a commented-out `# s.header_dir` cannot win
+// over the live one. A trailing `#` and a `#` inside a string survive: only the
+// first non-whitespace character counts.
+function readPodspecSource(podspecPath /*: string */) /*: string */ {
+  return fs
+    .readFileSync(podspecPath, 'utf8')
+    .split('\n')
+    .filter(line => !/^\s*#/.test(line))
+    .join('\n');
+}
+
+// A subspec that re-binds a receiver the identity regexes trust: inside
+// `s.subspec "common" do |s|`, `s` is the CHILD, and no regex over flat text
+// can see that. Any other block variable (`do |ss|`) is unambiguous.
+const SHADOWING_SUBSPEC_RE =
+  /\.subspec\s+["'][^"']*["']\s+do\s*\|\s*(?:s|spec)\s*\|/;
+
+function hasShadowingSubspec(source /*: string */) /*: boolean */ {
+  return SHADOWING_SUBSPEC_RE.test(source);
+}
+
 /**
  * Best-effort Ruby podspec parser. Extracts the literal-string and
  * literal-array fields most RN libs use. Skips subspec blocks, Ruby helper
@@ -178,16 +199,39 @@ function cleanupPatchedPodspec(patchedPath /*: ?string */) /*: void */ {
  * user. Always returns a RawSpec; pure-JS, no Ruby dep required.
  */
 function regexPodspec(podspecPath /*: string */) /*: RawSpec */ {
-  const content = fs.readFileSync(podspecPath, 'utf8');
+  const content = readPodspecSource(podspecPath);
   const warnings /*: Array<string> */ = [];
 
-  // Matches:  s.<field> = "value"   or   s.<field> = 'value'
+  // Matches:  s.<field> = "value"   or   s.<field> = 'value'  — at ANY scope,
+  // so a subspec's value counts. Right for the fields flattenSubspecs merges
+  // (source globs, header mappings); wrong for the fields that identify the
+  // spec, which use getSpecStringField.
   function getStringField(name /*: string */) /*: string | null */ {
     const re = new RegExp(`(?:s|spec)\\.${name}\\s*=\\s*["']([^"']+)["']`);
     const m = content.match(re);
     return m ? m[1] : null;
   }
 
+  // The same, but only where the receiver starts the statement — so a subspec's
+  // block variable (`ss.header_dir`, the shape react-native-screens and
+  // react-native-svg ship) cannot answer for the spec itself.
+  function getSpecStringField(name /*: string */) /*: string | null */ {
+    const re = new RegExp(
+      `(?:^|[;|])\\s*(?:s|spec)\\.${name}\\s*=\\s*["']([^"']+)["']`,
+      'm',
+    );
+    const m = content.match(re);
+    return m ? m[1] : null;
+  }
+
+  // The fields that identify the spec, and only when the receiver spelling
+  // still says which scope declared them: a subspec re-binding `s` puts its own
+  // `header_dir` exactly where the library's would be.
+  const shadowedIdentity = hasShadowingSubspec(content);
+  function getIdentityField(name /*: string */) /*: string | null */ {
+    return shadowedIdentity ? null : getSpecStringField(name);
+  }
+
   // Matches:
   //   s.<field> = ["a", "b"]            (array)
   //   s.<field> = "single"              (single value treated as 1-element array)
@@ -289,6 +333,11 @@ function regexPodspec(podspecPath /*: string */) /*: RawSpec */ {
   }
 
   // Surface known unparseable constructs so the caller can warn the user.
+  if (shadowedIdentity) {
+    warnings.push(
+      "A subspec rebinds the spec variable (`do |s|`), so its `name`, `module_name` and `header_dir` cannot be told from the library's own — those are left unread. Install CocoaPods (`gem install cocoapods`) to enable full `pod ipc spec` parsing.",
+    );
+  }
   if (/(?:s|spec)\.subspec\s+["']/.test(content)) {
     warnings.push(
       'Subspecs detected — regex parser only extracts top-level fields. Install CocoaPods (`gem install cocoapods`) to enable full `pod ipc spec` parsing.',
@@ -306,14 +355,15 @@ function regexPodspec(podspecPath /*: string */) /*: RawSpec */ {
   }
 
   return {
-    name: getStringField('name'),
-    version: getStringField('version'),
+    name: getIdentityField('name'),
+    module_name: getIdentityField('module_name'),
+    version: getSpecStringField('version'),
     source_files: getArrayField('source_files'),
     public_header_files: getArrayField('public_header_files'),
     private_header_files: getArrayField('private_header_files'),
     exclude_files: getArrayField('exclude_files'),
     header_mappings_dir: getStringField('header_mappings_dir'),
-    header_dir: getStringField('header_dir'),
+    header_dir: getIdentityField('header_dir'),
     frameworks: getFrameworks(false),
     weak_frameworks: getFrameworks(true),
     libraries: getArrayField('libraries'),
@@ -432,6 +482,14 @@ function flattenSubspecs(rawSpec /*: RawSpec */) /*: PodspecModel */ {
     return Array.from(new Set(out));
   }
 
+  // Only the spec's own value: a subspec's `header_dir` names that subspec's
+  // headers, and several subspecs can disagree.
+  function specStringField(key /*: string */) /*: string | null */ {
+    // $FlowFixMe[incompatible-use] dynamic shape
+    const value = rawSpec[key];
+    return typeof value === 'string' && value.length > 0 ? value : null;
+  }
+
   function mergeStringField(key /*: string */) /*: string | null */ {
     for (const layer of layers) {
       // $FlowFixMe[incompatible-use] layer narrowed from `mixed`; runtime-validated below
@@ -620,8 +678,8 @@ function flattenSubspecs(rawSpec /*: RawSpec */) /*: PodspecModel */ {
       : true; // RN ecosystem default
 
   return {
-    name: mergeStringField('name') ?? '',
-    version: mergeStringField('version') ?? '',
+    name: specStringField('name') ?? '',
+    version: specStringField('version') ?? '',
     sourceFiles: mergeArrayField('source_files'),
     publicHeaderFiles: mergeArrayField('public_header_files'),
     privateHeaderFiles: mergeArrayField('private_header_files'),
@@ -634,7 +692,8 @@ function flattenSubspecs(rawSpec /*: RawSpec */) /*: PodspecModel */ {
     // resolve from the physical tree — CocoaPods does this via the
     // header_mappings_dir copy step, which SPM has no equivalent for.
     headerMappingsDirs: mergeArrayField('header_mappings_dir'),
-    headerDir: mergeStringField('header_dir'),
+    headerDir: specStringField('header_dir'),
+    moduleName: specStringField('module_name'),
     frameworks: mergeArrayField('frameworks'),
     weakFrameworks: mergeArrayField('weak_frameworks'),
     libraries: mergeArrayField('libraries'),
@@ -687,8 +746,97 @@ function readPodspec(podspecPath /*: string */) /*: PodspecModel */ {
   return model;
 }
 
+const podspecModels /*: Map<string, PodspecModel> */ = new Map();
+
+/**
+ * readPodspec memoized on the resolved path. `pod ipc spec` costs a process
+ * spawn, and one autolinking run reads the same podspec from several sites
+ * (name resolution, header search paths, scaffolding). The model is shared, so
+ * callers must treat it as read-only.
+ */
+function readPodspecCached(podspecPath /*: string */) /*: PodspecModel */ {
+  const key = path.resolve(podspecPath);
+  const cached = podspecModels.get(key);
+  if (cached != null) {
+    return cached;
+  }
+  const model = readPodspec(podspecPath);
+  podspecModels.set(key, model);
+  return model;
+}
+
+/**
+ * The three fields that name a library, read WITHOUT `pod ipc spec`'s process
+ * spawn — name resolution runs for every dep, including self-managed ones that
+ * need nothing else from the podspec.
+ *
+ * Null when the answer cannot be trusted without Ruby: an interpolated value,
+ * or a spec-level `header_dir`/`module_name` the regex could not read. Both
+ * outrank the pod name, so a literal name alone is not enough — resolving
+ * without them would pick the wrong prefix. A value only a subspec declares is
+ * not the library's, so it neither answers nor defers — unless that subspec
+ * re-binds `s` (or `spec`), which makes every field's scope unreadable.
+ */
+function readPodspecNames(
+  podspecPath /*: string */,
+) /*: ?{name: ?string, moduleName: ?string, headerDir: ?string} */ {
+  const raw = regexPodspec(podspecPath);
+  const field = (key /*: string */) /*: ?string */ => {
+    // $FlowFixMe[prop-missing] RawSpec is dynamically shaped
+    const value = raw[key];
+    return typeof value === 'string' &&
+      value.length > 0 &&
+      !value.includes('#{')
+      ? value
+      : null;
+  };
+  const source = readPodspecSource(podspecPath);
+  if (hasShadowingSubspec(source)) {
+    return null;
+  }
+  const declaredUnread = (
+    key /*: string */,
+    value /*: ?string */,
+  ) /*: boolean */ =>
+    value == null &&
+    new RegExp(`(?:^|[;|])\\s*(?:s|spec)\\.${key}\\s*=`, 'm').test(source);
+
+  const name = field('name');
+  const moduleName = field('module_name');
+  const headerDir = field('header_dir');
+  if (
+    declaredUnread('header_dir', headerDir) ||
+    declaredUnread('module_name', moduleName)
+  ) {
+    return null;
+  }
+  return name == null && moduleName == null && headerDir == null
+    ? null
+    : {name, moduleName, headerDir};
+}
+
+/**
+ * Every podspec in `dir`, sorted so two of them name a target the same way on
+ * every machine (readdir order is unspecified). Skips a crashed run's leftover
+ * `.spm-scaffold-<pid>-<name>.podspec` copy.
+ */
+function findPodspecs(dir /*: string */) /*: Array<string> */ {
+  try {
+    return fs
+      .readdirSync(dir)
+      .filter(e => e.endsWith('.podspec') && !e.startsWith('.spm-scaffold-'))
+      .sort()
+      .map(e => path.join(dir, e));
+  } catch {
+    return [];
+  }
+}
+
 module.exports = {
+  findPodspecs,
   readPodspec,
+  readPodspecCached,
+  readPodspecNames,
   runPodIpcSpec,
   regexPodspec,
   flattenSubspecs,