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

package/scripts/spm/expand-spm-dependencies.js

@@ -10,53 +10,86 @@
 
 'use strict';
 
-const {RESERVED_SWIFT_NAMES, makeLogger, toSwiftName} = require('./spm-utils');
+const {
+  findPodspecs,
+  readPodspecCached,
+  readPodspecNames,
+} = require('./read-podspec');
+const {
+  RESERVED_SWIFT_NAMES,
+  isValidSwiftName,
+  makeLogger,
+  swiftNameKey,
+  toC99Name,
+  toSwiftName,
+} = require('./spm-utils');
+const {readSwiftpmConfig, stringList} = require('./swiftpm-config');
 const fs = require('node:fs');
 const path = require('node:path');
 
 const {warn} = makeLogger('expand-spm-dependencies');
 
 /**
- * expand-spm-dependencies.js — Resolves transitive native deps declared via
- * `spm.dependencies` in a library's react-native.config.js.
+ * expand-spm-dependencies.js — Resolves transitive native deps a library
+ * declares in its `swiftpmConfig`.
  *
  * SPM has no equivalent of CocoaPods' podspec `s.dependency`, so library
  * authors declare the same relationships explicitly:
  *
- *   // react-native-reanimated/react-native.config.js
- *   module.exports = {
- *     dependency: { platforms: { ios: {} } },
- *     spm: { dependencies: ['react-native-worklets'] },
- *   };
+ *   // react-native-reanimated/package.json
+ *   { "swiftpmConfig": { "dependencies": ["react-native-worklets"] } }
  *
  * This module reads the directly-autolinked deps (from autolinking.json),
- * follows each one's spm.dependencies recursively, and returns the deduped
+ * follows each one's declared dependencies recursively, and returns the deduped
  * list with autolinking-shaped entries so the downstream pipeline can convert
  * each to an SPM target without further branching.
  *
- * I/O is injected (readConfig, resolveDep, log) so the logic stays pure and
- * testable.
+ * It also resolves each dep's Swift target name — see resolveSwiftName.
+ *
+ * I/O is injected (readConfig, resolveDep, readPodspec) so the logic stays pure
+ * and testable.
  */
 
 /*::
 import type {AutolinkedDep} from './spm-types';
+import type {SwiftpmConfig} from './swiftpm-config';
 
 // react-native.config.js entries have a user-defined shape, so we use an
 // inexact object type and access properties dynamically.
 type RnConfig = {...};
 type ReadConfig = (root: string) => ?RnConfig;
 type ResolveDep = (name: string, fromRoot: string) => ?string;
-type Log = (message: string) => void;
-// Keyed by lower case, valued with the canonical spelling: two names differing
-// only in case are not distinct enough for the build to keep the two apart.
+// Where a resolved name came from: what the library declared, what its podspec
+// says, or the npm-name guess. `podspecKey` narrows a podspec-sourced name to
+// the field it was read from — `header_dir` and `module_name` can name the same
+// library differently, and only one of them wins.
+type PodspecNameKey = 'header_dir' | 'module_name' | 'name';
+type ResolvedSwiftName = {
+  name: string,
+  source: 'config' | 'podspec' | 'npm',
+  podspecKey?: PodspecNameKey,
+};
+// The podspec fields that name a library. A PodspecModel satisfies it.
+type PodspecFacts = {
+  readonly name?: ?string,
+  readonly moduleName?: ?string,
+  readonly headerDir?: ?string,
+  ...
+};
+type ReadPodspec = (root: string, podspecPath: ?string) => ?PodspecFacts;
+type ReadSwiftpmConfig = (root: string, rnConfig: ?RnConfig) => ?SwiftpmConfig;
+// Keyed by swiftNameKey, valued with the canonical spelling: a name that only
+// differs from a reserved one in case or punctuation is not distinct enough for
+// the build to keep the two apart.
 type ReservedNames = ReadonlyMap<string, string>;
 type Options = {
   readConfig: ReadConfig,
   resolveDep: ResolveDep,
+  readPodspec?: ?ReadPodspec,
+  readSwiftpmConfig?: ?ReadSwiftpmConfig,
   // Names to reserve alongside RESERVED_SWIFT_NAMES, supplied by the caller
   // (remote mode relabels the RN package) since this module reads no config.
   extraReservedNames?: ?ReadonlyArray<string>,
-  log?: ?Log,
 };
 */
 
@@ -71,74 +104,133 @@ class SpmNameCollisionError extends Error {
   }
 }
 
-// The charset `spm.name` must satisfy — permissive on purpose, since it has to
-// admit header-dir style (lowercase with hyphens) as well as Swift identifiers.
-// Shared with the app's own `spm.modules` names.
-function isValidSwiftName(name /*: unknown */) /*: boolean */ {
-  return typeof name === 'string' && /^[A-Za-z_][A-Za-z0-9_-]*$/.test(name);
-}
-
 function reservedSwiftNames(
   extraReservedNames /*: ?ReadonlyArray<string> */,
 ) /*: ReservedNames */ {
   return new Map(
     [...RESERVED_SWIFT_NAMES, ...(extraReservedNames ?? [])].map(name => [
-      name.toLowerCase(),
+      swiftNameKey(name),
       name,
     ]),
   );
 }
 
-// The scope-borrowed form of a name: `@powersync/react-native`'s `ReactNative`
-// becomes `PowersyncReactNative`.
-function scopeBorrowedName(
+// The prefix a podspec publishes its headers under, and the field it came from
+// — or null when the podspec declares none. A prefix Swift cannot spell is
+// normalized rather than abandoned: reverting to the npm name would silently
+// produce a prefix nothing imports.
+function podspecSwiftName(
   npmName /*: string */,
-  swiftName /*: string */,
-) /*: ?string */ {
-  const scope = /^@([^/]+)\//.exec(npmName)?.[1];
-  return scope == null ? null : `${toSwiftName(scope)}${swiftName}`;
+  podspec /*: ?PodspecFacts */,
+) /*: ?{name: string, key: PodspecNameKey} */ {
+  // CocoaPods' own order is `module_name` first (specification.rb), but our
+  // single name is the ObjC include prefix as well as the Swift module: a
+  // declared `header_dir` IS the prefix a library's consumers write, so it keeps
+  // winning. `module_name` comes next, being what Swift and `@import` consumers
+  // spell, and the pod name — often dashed — is the last resort.
+  const candidates /*: ReadonlyArray<[PodspecNameKey, ?string]> */ = [
+    ['header_dir', podspec?.headerDir],
+    ['module_name', podspec?.moduleName],
+    ['name', podspec?.name],
+  ];
+  for (const [key, candidate] of candidates) {
+    if (typeof candidate !== 'string' || candidate.length === 0) {
+      continue;
+    }
+    // Ruby the evaluator never ran: what the prefix would be is unknowable, so
+    // the npm name is the honest answer — and, not being derived, it is not
+    // recorded in the library's package.json.
+    if (candidate.includes('#{')) {
+      return null;
+    }
+    if (isValidSwiftName(candidate)) {
+      return {name: candidate, key};
+    }
+    const normalized = toC99Name(candidate);
+    warn(
+      `'${npmName}' declares the podspec prefix '${candidate}', which is not a valid Swift target name; using '${normalized}'. ` +
+        `Set 'swiftpmConfig.name' in ${npmName}'s package.json to choose the prefix yourself.`,
+    );
+    return {name: normalized, key};
+  }
+  return null;
 }
 
-// The Swift target name for one dep, judged in isolation. `spm.name` is for
-// libraries whose import prefix differs from the derived name:
-// `react-native-worklets` ships headers as `<worklets/...>` (podspec
-// `s.header_dir`), so its target is `worklets`, not `ReactNativeWorklets`. A
-// derived name that lands on a reserved one borrows the npm scope instead.
+/**
+ * The Swift target name for one dep, which is also the prefix its headers are
+ * imported under (`#import <Name/Header.h>`), and where it came from. The name
+ * a library declares wins; the podspec is the transitional source of truth
+ * behind it — `react-native-svg` publishes `RNSVG`, not `ReactNativeSvg` — in
+ * the order `header_dir` → `module_name` → pod name. The npm name is the last
+ * resort, for a library that ships a `Package.swift` and no podspec.
+ *
+ * The source is what tells the scaffolder which names are safe to write into a
+ * library's package.json: a derived one, never a guessed one.
+ */
 function resolveSwiftName(
   npmName /*: string */,
-  config /*: ?RnConfig */,
-  reserved /*: ReservedNames */,
-  log /*:: ?: ?Log */,
-) /*: string */ {
-  // $FlowFixMe[prop-missing] config has dynamic shape
-  const override = config?.spm?.name;
-  if (override != null) {
-    if (typeof override !== 'string' || override.length === 0) {
+  spmConfig /*: ?SwiftpmConfig */,
+  podspec /*: ?PodspecFacts */,
+) /*: ResolvedSwiftName */ {
+  const declared = spmConfig?.name;
+  if (declared != null) {
+    if (typeof declared !== 'string' || declared.length === 0) {
       throw new Error(
-        `react-native autolinking: '${npmName}' has an invalid 'spm.name' override: expected a non-empty string, got ${JSON.stringify(override)}.`,
+        `react-native autolinking: '${npmName}' declares an invalid SwiftPM name: expected a non-empty string, got ${String(declared)}. Set 'swiftpmConfig.name' in its package.json.`,
       );
     }
-    if (!isValidSwiftName(override)) {
+    if (!isValidSwiftName(declared)) {
       throw new Error(
-        `react-native autolinking: '${npmName}' has an invalid 'spm.name' override '${override}': must start with a letter or underscore and contain only letters, digits, underscores, or hyphens.`,
+        `react-native autolinking: '${npmName}' declares an invalid SwiftPM name '${declared}': must start with a letter or underscore and contain only letters, digits, underscores, or hyphens. Set 'swiftpmConfig.name' in its package.json.`,
       );
     }
-    return override;
+    return {name: declared, source: 'config'};
   }
 
-  const derived = toSwiftName(npmName);
-  if (!reserved.has(derived.toLowerCase())) {
-    return derived;
+  const fromPodspec = podspecSwiftName(npmName, podspec);
+  if (fromPodspec != null) {
+    return {
+      name: fromPodspec.name,
+      source: 'podspec',
+      podspecKey: fromPodspec.key,
+    };
   }
-  const disambiguated = scopeBorrowedName(npmName, derived);
-  if (disambiguated == null || reserved.has(disambiguated.toLowerCase())) {
-    return derived;
+  const fromNpm = toSwiftName(npmName);
+  if (podspec != null) {
+    warn(
+      `'${npmName}' ships a podspec React Native could not read a name from (CocoaPods may not be installed), so it is named '${fromNpm}' after its npm package instead. ` +
+        `A machine that can read the podspec may resolve a different name — set 'swiftpmConfig.name' in ${npmName}'s package.json to settle it everywhere.`,
+    );
   }
-  log?.(
-    `'${npmName}' would take React Native's reserved name '${derived}', so its npm scope is prepended: '${disambiguated}'. ` +
-      `Set 'spm.name' in ${npmName}'s react-native.config.js to choose the name yourself.`,
-  );
-  return disambiguated;
+  return {name: fromNpm, source: 'npm'};
+}
+
+function collisionDiagnosis(
+  existing /*: string */,
+  swiftName /*: string */,
+) /*: string */ {
+  if (existing === swiftName) {
+    return `both resolve to '${swiftName}'.`;
+  }
+  if (existing.toLowerCase() === swiftName.toLowerCase()) {
+    return `differ only in case, which collides on case-insensitive filesystems.`;
+  }
+  return `both compile as the module '${toC99Name(swiftName)}' — SwiftPM replaces every character C99 rejects.`;
+}
+
+// Vaguer about the clash than the dep-vs-dep message on purpose: this set spans
+// package identities and product names, which collide differently.
+function reservedDiagnosis(
+  swiftName /*: string */,
+  reservedName /*: string */,
+) /*: string */ {
+  if (reservedName === swiftName) {
+    return `which React Native reserves for its own SPM package and products.`;
+  }
+  if (reservedName.toLowerCase() === swiftName.toLowerCase()) {
+    return `which differs from React Native's reserved '${reservedName}' only in case — not distinct enough for the build to keep the two apart.`;
+  }
+  return `which compiles as the same module as React Native's reserved '${reservedName}'.`;
 }
 
 function assertNameNotReserved(
@@ -146,24 +238,21 @@ function assertNameNotReserved(
   reserved /*: ReservedNames */,
   labels /*: {label: string, remedy: string} */,
 ) /*: void */ {
-  const reservedName = reserved.get(swiftName.toLowerCase());
+  const reservedName = reserved.get(swiftNameKey(swiftName));
   if (reservedName == null) {
     return;
   }
-  // Vaguer about the case clash than the dep-vs-dep message on purpose: this
-  // set spans package identities and product names, which collide differently.
   throw new SpmNameCollisionError(
     `react-native autolinking: SPM Swift name collision: ${labels.label} resolves to '${swiftName}', ` +
-      (reservedName === swiftName
-        ? `which React Native reserves for its own SPM package and products.`
-        : `which differs from React Native's reserved '${reservedName}' only in case — not distinct enough for the build to keep the two apart.`) +
+      reservedDiagnosis(swiftName, reservedName) +
       ` ${labels.remedy}`,
   );
 }
 
 /**
  * Throws when `swiftName` is one React Native's own manifests use. `remedy` is
- * the fix: a library sets `spm.name`, an app renames its `spm.modules` entry.
+ * the fix: a library sets `swiftpmConfig.name`, an app renames its
+ * `swiftpmConfig.modules` entry.
  */
 function assertSwiftNameNotReserved(
   swiftName /*: string */,
@@ -194,83 +283,36 @@ function assertNoReservedSwiftNames(
     }
     assertNameNotReserved(swiftName, reserved, {
       label: `'${dep.name}'`,
-      remedy: `Set a different 'spm.name' in ${dep.name}'s react-native.config.js.`,
+      remedy: `Set a different 'swiftpmConfig.name' in ${dep.name}'s package.json.`,
     });
   }
 }
 
-// Pulls apart deps that resolved to the same name by borrowing their npm scopes.
-// Every scoped member of a colliding group moves: there is no non-arbitrary
-// winner to keep. Exactly one pass — retrying would trade a diagnosable error
-// for a name nobody can predict.
-function disambiguateSharedSwiftNames(
-  deps /*: ReadonlyArray<AutolinkedDep> */,
-  autoNamed /*: ReadonlySet<string> */,
-  log /*: ?Log */,
-) /*: void */ {
-  const groups /*: Map<string, Array<{dep: AutolinkedDep, swiftName: string}>> */ =
-    new Map();
-  for (const dep of deps) {
-    const swiftName = dep.swiftName;
-    if (swiftName == null) {
-      continue;
-    }
-    const key = swiftName.toLowerCase();
-    const group = groups.get(key);
-    if (group == null) {
-      groups.set(key, [{dep, swiftName}]);
-    } else {
-      group.push({dep, swiftName});
-    }
-  }
-
-  for (const group of groups.values()) {
-    if (group.length < 2) {
-      continue;
-    }
-    for (const {dep, swiftName} of group) {
-      // A name we derived can borrow a second time (`AAReactNative`); the
-      // member whose name we did not derive is the incumbent and keeps it.
-      if (!autoNamed.has(dep.name)) {
-        continue;
-      }
-      const borrowed = scopeBorrowedName(dep.name, swiftName);
-      if (borrowed == null) {
-        continue;
-      }
-      const others = group
-        .filter(other => other.dep !== dep)
-        .map(other => `'${other.dep.name}'`)
-        .join(', ');
-      log?.(
-        `'${dep.name}' would share the name '${swiftName}' with ${others}, so its npm scope is prepended: '${borrowed}'. ` +
-          `Set 'spm.name' in ${dep.name}'s react-native.config.js to choose the name yourself.`,
-      );
-      dep.swiftName = borrowed;
-    }
-  }
-}
-
 function expandSpmDependencies(
   directDeps /*: Array<AutolinkedDep> */,
   options /*: Options */,
 ) /*: Array<AutolinkedDep> */ {
-  const {readConfig, resolveDep, extraReservedNames, log} = options;
+  const {readConfig, resolveDep, readPodspec, extraReservedNames} = options;
+  const spmConfigOf = options.readSwiftpmConfig ?? readSwiftpmConfig;
   const reserved = reservedSwiftNames(extraReservedNames);
   const byName /*: Map<string, AutolinkedDep> */ = new Map();
   for (const dep of directDeps) {
     byName.set(dep.name, {...dep, spmDependencies: []});
   }
-  const autoNamed /*: Set<string> */ = new Set();
-  const resolveName = (
-    npmName /*: string */,
-    config /*: ?RnConfig */,
-  ) /*: string */ => {
-    // $FlowFixMe[prop-missing] config has dynamic shape
-    if (config?.spm?.name == null) {
-      autoNamed.add(npmName);
+  // A podspec that cannot be read leaves the name to the next precedence step,
+  // rather than failing a build over a file only CocoaPods needs.
+  const podspecFor = (
+    root /*: string */,
+    podspecPath /*: ?string */,
+  ) /*: ?PodspecFacts */ => {
+    if (readPodspec == null) {
+      return null;
+    }
+    try {
+      return readPodspec(root, podspecPath);
+    } catch {
+      return null;
     }
-    return resolveSwiftName(npmName, config, reserved, log);
   };
 
   const queue /*: Array<string> */ = directDeps.map(d => d.name);
@@ -283,14 +325,18 @@ function expandSpmDependencies(
     if (current == null) {
       continue;
     }
-    const config = readConfig(current.root);
-    // Resolve swiftName lazily from the same config read we already need for
-    // spm.dependencies — saves a duplicate readConfig call per direct dep.
+    const spmConfig = spmConfigOf(current.root, readConfig(current.root));
     if (current.swiftName == null) {
-      current.swiftName = resolveName(currentName, config);
+      const resolved = resolveSwiftName(
+        currentName,
+        spmConfig,
+        podspecFor(current.root, current.platforms.ios.podspecPath),
+      );
+      current.swiftName = resolved.name;
+      current.swiftNameSource = resolved.source;
+      current.swiftNamePodspecKey = resolved.podspecKey;
     }
-    // $FlowFixMe[prop-missing] config has dynamic shape
-    const transitives /*: Array<string> */ = config?.spm?.dependencies ?? [];
+    const transitives = stringList(spmConfig?.dependencies);
 
     const currentSpmDeps /*: Array<string> */ = [];
     for (const transitiveName of transitives) {
@@ -298,7 +344,7 @@ function expandSpmDependencies(
         const transitiveRoot = resolveDep(transitiveName, current.root);
         if (transitiveRoot == null) {
           throw new Error(
-            `react-native autolinking: '${currentName}' declares an unresolvable spm.dependency '${transitiveName}'. Ensure '${transitiveName}' is installed and visible via Node module resolution from ${current.root}.`,
+            `react-native autolinking: '${currentName}' declares an unresolvable SwiftPM dependency '${transitiveName}'. Ensure '${transitiveName}' is installed and visible via Node module resolution from ${current.root}.`,
           );
         }
 
@@ -312,11 +358,18 @@ function expandSpmDependencies(
           continue;
         }
 
+        const resolved = resolveSwiftName(
+          transitiveName,
+          spmConfigOf(transitiveRoot, transitiveConfig),
+          podspecFor(transitiveRoot, iosPlatform.podspecPath),
+        );
         byName.set(transitiveName, {
           name: transitiveName,
           root: transitiveRoot,
           platforms: {ios: iosPlatform},
-          swiftName: resolveName(transitiveName, transitiveConfig),
+          swiftName: resolved.name,
+          swiftNameSource: resolved.source,
+          swiftNamePodspecKey: resolved.podspecKey,
           spmDependencies: [],
         });
         queue.push(transitiveName);
@@ -328,37 +381,26 @@ function expandSpmDependencies(
 
   const allDeps /*: Array<AutolinkedDep> */ = Array.from(byName.values());
 
-  disambiguateSharedSwiftNames(allDeps, autoNamed, log);
-
-  // Both checks below validate the FINAL set, after that pass: a borrowed scope
-  // can land on a reserved name, or on one another dep already holds.
   assertNoReservedSwiftNames(allDeps, reserved);
 
-  // Collision check: two deps mapping to the same Swift name (whether via
-  // override or auto-derivation) would clobber each other in the synth
-  // package layout and the centralized headers tree. Surface it now with a
-  // clear message instead of letting SPM emit a confusing duplicate-target
-  // error later.
-  // Key case-INSENSITIVELY: resolveSwiftName permits lowercase ('worklets')
-  // while toSwiftName produces TitleCase ('Worklets') — an exact-equality check
-  // passes but the two still collide as directories on the default
-  // case-insensitive macOS filesystem (synth package layout + headers tree).
+  // Collision check: two deps mapping to the same Swift name would clobber each
+  // other in the synth package layout and the centralized headers tree. Surface
+  // it now with a clear message instead of letting SPM emit a confusing
+  // duplicate-target error later. swiftNameKey is what makes two names two
+  // targets — punctuation collapses into one module, case into one directory.
   const seen /*: Map<string, {name: string, swiftName: string}> */ = new Map();
   for (const dep of allDeps) {
     const swiftName = dep.swiftName;
     if (swiftName == null) {
       continue;
     }
-    const key = swiftName.toLowerCase();
+    const key = swiftNameKey(swiftName);
     const existing = seen.get(key);
     if (existing != null) {
-      const same = existing.swiftName === swiftName;
       throw new SpmNameCollisionError(
         `react-native autolinking: SPM Swift name collision: '${existing.name}' ('${existing.swiftName}') and '${dep.name}' ('${swiftName}') ` +
-          (same
-            ? `both resolve to '${swiftName}'.`
-            : `differ only in case, which collides on case-insensitive filesystems.`) +
-          ` Set a distinct 'spm.name' in one of their react-native.config.js files.`,
+          collisionDiagnosis(existing.swiftName, swiftName) +
+          ` Set a distinct 'swiftpmConfig.name' in one of their package.json files.`,
       );
     }
     seen.set(key, {name: dep.name, swiftName});
@@ -424,12 +466,31 @@ function defaultResolveDep(
   }
 }
 
+function defaultReadPodspec(
+  root /*: string */,
+  podspecPath /*: ?string */,
+) /*: ?PodspecFacts */ {
+  // Deps synthesized from declared dependencies carry no podspecPath — only
+  // autolinking.json records one — so the dep root is searched as well.
+  const found = podspecPath ?? findPodspecs(root)[0];
+  if (found == null) {
+    return null;
+  }
+  try {
+    // Ruby-computed fields need the real evaluator; everything else is spared
+    // the `pod ipc spec` spawn.
+    return readPodspecNames(found) ?? readPodspecCached(found);
+  } catch {
+    return null;
+  }
+}
+
 module.exports = {
   SpmNameCollisionError,
   assertSwiftNameNotReserved,
   expandSpmDependencies,
-  isValidSwiftName,
   resolveSwiftName,
   defaultReadConfig,
+  defaultReadPodspec,
   defaultResolveDep,
 };