@depup/react-native 0.87.0-depup.0 → 0.87.1-depup.0

package/scripts/spm/scaffold-package-swift.js

@@ -36,6 +36,7 @@ import type {
  */
 
 const {
+  SpmNameCollisionError,
   defaultReadConfig,
   defaultResolveDep,
   expandSpmDependencies,
@@ -43,6 +44,10 @@ const {
 const {expandSpmSourceGlobs} = require('./generate-spm-autolinking');
 const {readPodspec} = require('./read-podspec');
 const {
+  REACT_CODEGEN_PACKAGE_NAME,
+  REACT_CODEGEN_PRODUCTS,
+  REACT_NATIVE_PACKAGE_NAME,
+  REACT_NATIVE_PRODUCTS,
   SCAFFOLDER_MARKER,
   makeLogger,
   remotePackageConfig,
@@ -235,14 +240,18 @@ function translatePodspecToSpmTarget(
   // `s.dependency "RNWorklets"` — a pod-style name the `react-native-*`
   // heuristic can't recognize — to the right sibling package. Empty by default.
   podToNpm /*: Map<string, string> */ = new Map(),
+  // npm name → resolved Swift name for every autolinked dep, so a sibling
+  // reference honors that sibling's `spm.name` instead of re-deriving it.
+  swiftNameByNpm /*: Map<string, string> */ = new Map(),
 ) /*: SpmScaffoldSpec */ {
   const warnings = [...model.warnings];
 
-  // Swift target name: ALWAYS toSwiftName(npm-name). The autolinker
-  // registers each autolinked dep under that name in its aggregator (and in
-  // any sibling spm.dependencies refs), so the scaffolded Package.swift's
-  // product/library name must match — otherwise SPM resolution fails with
-  // a name mismatch on `.product(name: "X", package: "X")`.
+  // Swift target name: whatever the autolinker resolved for this dep — its
+  // `spm.name` override when set, else toSwiftName(npm-name). The autolinker
+  // registers the dep under that name in its aggregator (and in any sibling
+  // spm.dependencies refs), so the scaffolded Package.swift's product/library
+  // name must match it exactly — otherwise SPM resolution fails with a name
+  // mismatch on `.product(name: "X", package: "X")`.
   //
   // The podspec's `header_dir` is captured separately: when it changes the
   // include surface (e.g. `<reanimated/...>` instead of `<ReactNativeReanimated/...>`),
@@ -251,10 +260,8 @@ function translatePodspecToSpmTarget(
   // `<react/renderer/components/safeareacontext/...>` resolve through
   // `-I common/cpp/`). Module-style includes that NEED the target name to
   // match (e.g. reanimated's `<reanimated/X.h>` via SwiftPM's auto-generated
-  // module map) require an explicit `spm.name` override in
-  // react-native.config.js — handled by the existing autolinker flow, not
-  // here.
-  const swiftName = toSwiftName(dep.name);
+  // module map) are what `spm.name` is for.
+  const swiftName = dep.swiftName ?? toSwiftName(dep.name);
 
   // Header search paths — substitute Xcode build-setting tokens against the
   // dep root. Anything we can't substitute is dropped + warned (avoids
@@ -512,6 +519,14 @@ function translatePodspecToSpmTarget(
     );
   }
 
+  const siblingSwiftNames /*: {[npmName: string]: string} */ = {};
+  for (const npmName of siblingNames) {
+    const resolved = swiftNameByNpm.get(npmName);
+    if (resolved != null) {
+      siblingSwiftNames[npmName] = resolved;
+    }
+  }
+
   return {
     swiftName,
     sources: expandedSources,
@@ -520,6 +535,7 @@ function translatePodspecToSpmTarget(
     needsObjCPrefix,
     coreReactNative,
     siblingNames,
+    siblingSwiftNames,
     extraFrameworks: model.frameworks,
     weakFrameworks: model.weakFrameworks,
     compilerFlags: model.compilerFlags,
@@ -652,7 +668,8 @@ function emitScaffoldedPackageSwift(
     // the app by definition, so it stays a path reference — relative,
     // computed at scaffold time.
     const remote = ctx.remote;
-    const rnLabel = remote != null ? remote.identity : 'ReactNative';
+    const rnLabel =
+      remote != null ? remote.identity : REACT_NATIVE_PACKAGE_NAME;
     const codegenDir = ctx.codegenPackageDir;
     if (codegenDir == null) {
       throw new Error(
@@ -670,24 +687,25 @@ function emitScaffoldedPackageSwift(
           'emitScaffoldedPackageSwift: localXcfwPackageDir is required when no remote package is configured.',
         );
       }
-      packageDeps.push(`.package(name: "ReactNative", path: "${xcfwDir}")`);
+      packageDeps.push(
+        `.package(name: "${REACT_NATIVE_PACKAGE_NAME}", path: "${xcfwDir}")`,
+      );
     }
     packageDeps.push(
-      `.package(name: "React-GeneratedCode", path: "${codegenDir}")`,
-    );
-    targetDeps.push(`.product(name: "ReactHeaders", package: "${rnLabel}")`);
-    targetDeps.push(
-      `.product(name: "ReactNativeHeaders", package: "${rnLabel}")`,
-    );
-    targetDeps.push(
-      `.product(name: "ReactNativeDependenciesHeaders", package: "${rnLabel}")`,
-    );
-    targetDeps.push(
-      '.product(name: "ReactAppHeaders", package: "React-GeneratedCode")',
+      `.package(name: "${REACT_CODEGEN_PACKAGE_NAME}", path: "${codegenDir}")`,
     );
+    for (const product of REACT_NATIVE_PRODUCTS) {
+      targetDeps.push(`.product(name: "${product}", package: "${rnLabel}")`);
+    }
+    for (const product of REACT_CODEGEN_PRODUCTS) {
+      targetDeps.push(
+        `.product(name: "${product}", package: "${REACT_CODEGEN_PACKAGE_NAME}")`,
+      );
+    }
   }
   for (const siblingName of spec.siblingNames) {
-    const swiftSibling = toSwiftName(siblingName);
+    const swiftSibling =
+      spec.siblingSwiftNames?.[siblingName] ?? toSwiftName(siblingName);
     // The autolinker references each self-managed (scaffolded) dep through a
     // `libs/<SwiftName>` symlink, and SPM resolves a manifest's relative
     // package paths against that symlink location — so a sibling lives at
@@ -787,6 +805,10 @@ type ScaffoldContext = {
   // podspec-name → npm-name index over all autolinked deps, so pod-style
   // `s.dependency` names (e.g. "RNWorklets") wire to the right sibling.
   podToNpm?: Map<string, string>,
+  // npm-name → resolved Swift name over all autolinked deps, so sibling
+  // references honor each sibling's `spm.name`.
+  swiftNameByNpm?: Map<string, string>,
+  remote: ?{url: string, version: string, identity: string},
 };
 */
 
@@ -945,6 +967,7 @@ function scaffoldPackageSwiftForDep(
     model,
     dep,
     ctx.podToNpm ?? new Map(),
+    ctx.swiftNameByNpm ?? new Map(),
   );
 
   // Mixed-language fail-closed: SPM can't compile Swift + C-family in one
@@ -999,7 +1022,7 @@ function scaffoldPackageSwiftForDep(
       .join('/');
   const content = emitScaffoldedPackageSwift(spec, {
     cacheSlotLabel: ctx.cacheSlotLabel,
-    remote: remotePackageConfig(ctx.appRoot),
+    remote: ctx.remote,
     codegenPackageDir: relFromManifest('build', 'generated', 'ios'),
     localXcfwPackageDir: relFromManifest('build', 'xcframeworks'),
   });
@@ -1126,13 +1149,22 @@ function scaffoldAll(
     directDeps.push({name, root, platforms: {ios: iosPlatform}});
   }
 
+  // Outside the try: a malformed remote config (RemoteVersionError) is a
+  // misconfiguration to surface, not an expansion failure to degrade past.
+  const remote = remotePackageConfig(appRoot);
+
   let allDeps /*: Array<AutolinkedDep> */ = [];
   try {
     allDeps = expandSpmDependencies(directDeps, {
       readConfig: defaultReadConfig,
       resolveDep: defaultResolveDep,
+      extraReservedNames: remote != null ? [remote.identity] : undefined,
+      log,
     });
   } catch (e) {
+    if (e instanceof SpmNameCollisionError) {
+      throw e;
+    }
     // A transitive-resolution failure shouldn't abort the whole scaffold pass;
     // fall back to the direct deps so at least those get manifests.
     log(`Transitive spm.dependencies expansion failed: ${e.message}`);
@@ -1167,6 +1199,13 @@ function scaffoldAll(
     }
   }
 
+  const swiftNameByNpm /*: Map<string, string> */ = new Map();
+  for (const dep of allDeps) {
+    if (dep.swiftName != null) {
+      swiftNameByNpm.set(dep.name, dep.swiftName);
+    }
+  }
+
   const ctx /*: ScaffoldContext */ = {
     appRoot,
     projectRoot,
@@ -1175,6 +1214,8 @@ function scaffoldAll(
     dryRun: opts.dryRun === true,
     cacheSlotLabel: opts.cacheSlotLabel ?? null,
     podToNpm,
+    swiftNameByNpm,
+    remote,
   };
   const skipSet /*: Set<string> */ = new Set(opts.skipDeps ?? []);
 

package/scripts/spm/spm-pbxproj.js

@@ -28,13 +28,55 @@ function generateUUID(seed /*: string */) /*: string */ {
 }
 
 /**
- * Escapes a string for OpenStep plist format if needed.
+ * Escapes a string for OpenStep plist format if needed. A literal CR or tab in
+ * a quoted value is legal but Xcode rewrites it to its escape on the next save,
+ * planting a spurious diff in the user's repo — so escape those too (a plugin
+ * `script` with CRLF line endings is how one gets in).
  */
 function quoteIfNeeded(s /*: string */) /*: string */ {
   if (/^[a-zA-Z0-9._/]+$/.test(s)) {
     return s;
   }
-  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
+  return `"${s
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t')}"`;
+}
+
+/**
+ * Normalize an UNTRUSTED label (a plugin's script-phase name, say) for use
+ * inside a pbxproj `/* … *​/` comment. Such a comment is purely cosmetic — Xcode
+ * regenerates it from the object's own fields — while the text AROUND it is
+ * scanned by delimiter, so every character that could be read as structure (or
+ * split the line) becomes a space, and runs of whitespace collapse:
+ * `findObjectByUuid` takes the first `{` after a UUID as that object's body,
+ * `removeArrayMembersByUuid` identifies a member line by its trailing comma, and
+ * `scanToClose` treats a `"` as opening a string. Stable (same input ⇒ same
+ * output), so re-syncing stays byte-identical. Returns '' when nothing survives;
+ * callers supply the fallback label.
+ *
+ * Comments RN writes to Xcode's OWN convention (`XCLocalSwiftPackageReference
+ * "build/xcframeworks"`, `<file> in Sources`) are NOT run through this: they are
+ * fixed strings, and normalizing them would rewrite bytes Xcode itself produces —
+ * a spurious diff in the user's repo on their next save.
+ */
+function commentSafe(s /*: string */) /*: string */ {
+  return s
+    .replace(/[{}(),;="*/\s]/g, ' ')
+    .replace(/ +/g, ' ')
+    .trim();
+}
+
+/**
+ * Format the ` /* … *​/` suffix pbxproj writes after a UUID, omitted entirely for
+ * an empty label (an uncommented UUID is well-formed — Xcode writes those itself
+ * for unnamed groups). Labels that did not originate in this repo must already
+ * have been through `commentSafe`.
+ */
+function uuidComment(comment /*: ?string */) /*: string */ {
+  return comment != null && comment !== '' ? ` /* ${comment} */` : '';
 }
 
 /**
@@ -47,11 +89,7 @@ function quoteIfNeeded(s /*: string */) /*: string */ {
 function serializeEntry(
   entry /*: {readonly uuid: string, readonly comment?: ?string, readonly fields: {readonly [string]: string}, ...} */,
 ) /*: string */ {
-  const comment =
-    entry.comment != null && entry.comment !== ''
-      ? ` /* ${entry.comment} */`
-      : '';
-  let out = `\t\t${entry.uuid}${comment} = {`;
+  let out = `\t\t${entry.uuid}${uuidComment(entry.comment)} = {`;
   const fieldKeys = Object.keys(entry.fields);
   if (
     fieldKeys.length <= 3 &&
@@ -343,8 +381,7 @@ function addArrayMembers(
   const memberIndent = fieldIndent + '\t';
   const line = (
     m /*: {readonly uuid: string, readonly comment?: ?string, ...} */,
-  ) =>
-    `${memberIndent}${m.uuid}${m.comment != null && m.comment !== '' ? ` /* ${m.comment} */` : ''},\n`;
+  ) => `${memberIndent}${m.uuid}${uuidComment(m.comment)},\n`;
 
   const field = findField(text, obj, key);
   if (field != null) {
@@ -367,6 +404,38 @@ function addArrayMembers(
   return text.slice(0, obj.bodyOpen + 1) + block + text.slice(obj.bodyOpen + 1);
 }
 
+/**
+ * Indices of the `,` separators at an array's top level — a comma inside a
+ * quoted member (`"$(FOO),weird"`) separates nothing.
+ */
+function topLevelCommas(inner /*: string */) /*: Array<number> */ {
+  const out = [];
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === '"') {
+      i = scanString(inner, i);
+    } else if (inner[i] === ',') {
+      out.push(i);
+    }
+  }
+  return out;
+}
+
+/**
+ * The members of an array's inner text (what sits between its parens), trimmed
+ * and with empty slots — e.g. the one a trailing comma leaves — dropped. A bare
+ * scalar value parses as its own single member.
+ */
+function arrayMembers(inner /*: string */) /*: Array<string> */ {
+  const members = [];
+  let start = 0;
+  for (const comma of topLevelCommas(inner)) {
+    members.push(inner.slice(start, comma));
+    start = comma + 1;
+  }
+  members.push(inner.slice(start));
+  return members.map(m => m.trim()).filter(m => m !== '');
+}
+
 /**
  * Append raw string values to a `( … )` array build-setting (e.g.
  * OTHER_LDFLAGS), deduping by exact token. Creates the setting seeded with
@@ -385,31 +454,57 @@ function addArrayStringValues(
 
   const field = findField(text, obj, key);
   if (field != null) {
+    const isArray = field.value.trimStart().startsWith('(');
+    const openParen = isArray
+      ? field.valueStart + field.value.indexOf('(')
+      : -1;
+    const closeParen = isArray ? scanToClose(text, openParen) : -1;
+    const inner = isArray ? text.slice(openParen + 1, closeParen) : field.value;
     // Dedup by EXACT existing member, not substring — a substring check would
     // treat `"-ObjC"` as already present when only `"-ObjCFoo"` is there (and
-    // vice-versa). Parse the current members (array `( … )` or bare scalar).
-    const existingMembers = new Set(
-      field.value
-        .replace(/^\s*\(/, '')
-        .replace(/\)\s*$/, '')
-        .split(',')
-        .map(s => s.trim())
-        .filter(s => s.length > 0),
-    );
+    // vice-versa).
+    const existingMembers = new Set(arrayMembers(inner));
     const fresh = values.filter(v => !existingMembers.has(v));
     if (fresh.length === 0) {
       return text;
     }
-    if (field.value.trimStart().startsWith('(')) {
-      // Existing array — splice fresh members before the closing `)`.
-      const lineStart = text.lastIndexOf('\n', field.tokenEnd - 1) + 1;
-      const lines = fresh.map(v => `${memberIndent}${v},\n`).join('');
-      return text.slice(0, lineStart) + lines + text.slice(lineStart);
+    if (isArray) {
+      if (inner.includes('\n')) {
+        // Multi-line array — one member per line, before the closing `)`.
+        const lineStart = text.lastIndexOf('\n', closeParen) + 1;
+        const lines = fresh.map(v => `${memberIndent}${v},\n`).join('');
+        return text.slice(0, lineStart) + lines + text.slice(lineStart);
+      }
+      // One-line array (hand-edited projects, XcodeGen, Tuist) — splice the
+      // members in ahead of the `)`, in the separator style already there.
+      // Reformatting it multi-line instead would have to record the old shape
+      // to stay reversible on deinit.
+      const commas = topLevelCommas(inner);
+      const gapMatch =
+        commas.length > 0 ? /^[\t ]*/.exec(inner.slice(commas[0] + 1)) : null;
+      const gap = gapMatch != null ? gapMatch[0] : ' ';
+      const core = inner.replace(/[\t ]+$/, '');
+      const joined = fresh.join(`,${gap}`);
+      const insertion =
+        core === ''
+          ? joined
+          : core.endsWith(',')
+            ? `${gap}${joined},`
+            : `,${gap}${joined}`;
+      const at = openParen + 1 + core.length;
+      return text.slice(0, at) + insertion + text.slice(at);
     }
-    // Existing scalar — promote to an array preserving the prior value.
+    // Existing scalar — promote to an array preserving the prior value. Skip it
+    // when it IS the `"$(inherited)"` the array is seeded with (emitted twice),
+    // or when it is empty (a bare `,` is not a valid plist element). The seed
+    // test unquotes first: pbxproj accepts `$(inherited)` bare, and Xcode's own
+    // quoted form is the same value to the build system.
+    const prior = field.value.trim();
+    const carriesPrior =
+      prior !== '' && prior.replace(/^"(.*)"$/s, '$1') !== '$(inherited)';
     const replacement = arrayBlock([
       '"$(inherited)"',
-      field.value.trim(),
+      ...(carriesPrior ? [prior] : []),
       ...fresh,
     ]);
     return (
@@ -464,7 +559,12 @@ function setScalarField(
 // ---------------------------------------------------------------------------
 // Surgical removal — the inverse of the additive helpers above. `deinit` uses
 // these to undo exactly what injection added, leaving every other byte (incl.
-// user edits made after injection) untouched. All are pure string transforms.
+// user edits made after injection) untouched. The exception is a scalar that
+// injection promoted to an array: reversing that rewrites the whole field (see
+// removeRecordedBuildSettings), so members added to it afterwards are lost.
+// That is not deinit-only — every re-sync reverts from the recorded baseline
+// before re-injecting, so an `spm update` discards them just the same.
+// All are pure string transforms.
 // ---------------------------------------------------------------------------
 
 /**
@@ -495,7 +595,8 @@ function removeObjectByUuid(
  * `uuids` from every `( … )` list in the file (packageReferences,
  * packageProductDependencies, a Frameworks phase's `files`, buildPhases, …).
  * Only matches member lines (trailing comma), never the object-definition line
- * (which ends in `= {`), so it composes safely with removeObjectByUuid.
+ * (which ends in `= {`), so it composes safely with removeObjectByUuid — which
+ * holds because no comment can contain a comma (see commentSafe).
  */
 function removeArrayMembersByUuid(
   text /*: string */,
@@ -525,6 +626,33 @@ function removeField(
   return text.slice(0, f.matchStart) + text.slice(f.tokenEnd + 1);
 }
 
+/**
+ * Drop one member from an array field's value text. The patterns mirror the
+ * forms addArrayStringValues inserts, tried in the order that makes the span
+ * removed exactly the span it added: a line of its own (multi-line array), then
+ * after a comma, before a comma, or alone ahead of the `)` (the one-line
+ * shapes). Each is anchored on a delimiter, so a value that is merely a prefix
+ * of a longer member is never mistaken for it.
+ */
+function removeArrayMember(
+  region /*: string */,
+  value /*: string */,
+) /*: string */ {
+  const v = escapeRegExp(value);
+  for (const pattern of [
+    `\\n[\\t ]*${v},`,
+    `,[\\t ]*${v}(?=[\\t ]*[,)])`,
+    `[\\t ]*${v},[\\t ]*`,
+    `[\\t ]*${v}(?=[\\t ]*\\))`,
+  ]) {
+    const shorter = region.replace(new RegExp(pattern), '');
+    if (shorter !== region) {
+      return shorter;
+    }
+  }
+  return region;
+}
+
 /**
  * Remove specific raw string members from an existing `( … )` array field
  * (inverse of addArrayStringValues' append branch). Leaves the field and any
@@ -542,7 +670,7 @@ function removeArrayStringValues(
   }
   let region = text.slice(f.valueStart, f.tokenEnd);
   for (const val of values) {
-    region = region.replace(new RegExp(`\\n[\\t ]*${escapeRegExp(val)},`), '');
+    region = removeArrayMember(region, val);
   }
   return text.slice(0, f.valueStart) + region + text.slice(f.tokenEnd);
 }
@@ -628,6 +756,8 @@ module.exports = {
   namespacedUUID,
   serializeEntry,
   quoteIfNeeded,
+  commentSafe,
+  uuidComment,
   // Surgical-edit toolkit (in-place injection):
   scanString,
   scanToClose,

package/scripts/spm/spm-types.js

@@ -168,7 +168,6 @@ export type SpmModuleConfig = {
   name: string,
   path: string,
   exclude?: Array<string>,
-  publicHeadersPath?: ?string,
   // Optional CocoaPods-style glob allowlist (analog of s.source_files).
   // When set, replaces auto source discovery for the module — only files
   // matching one of these patterns are passed to SPM via `sources:`.
@@ -219,6 +218,21 @@ export type PluginProductDep = {name: string, package: string};
 // in the codegen package so it compiles.
 export type PluginGeneratedSource = {path: string};
 
+// A build-time shell phase for the app target — SwiftPM's missing analog of
+// CocoaPods' `script_phase`. `id` is the stable ledger key and deterministic
+// UUID seed (charset /^[@A-Za-z0-9_./-]+$/, so a scoped npm name works; `:` is
+// excluded because the seed is `plugin:<id>`); `position` is normalized to 'end'
+// by invokePlugins so consumers never re-derive the default.
+export type PluginScriptPhase = {
+  id: string,
+  name: string,
+  script: string,
+  position: 'beforeCompile' | 'end',
+  inputPaths?: Array<string>,
+  outputPaths?: Array<string>,
+  alwaysOutOfDate?: boolean,
+};
+
 // A plugin-declared dynamic XCFramework pair. RN validates both paths, stages
 // immutable app-local slots, and links/embeds the selected framework outside
 // SwiftPM.
@@ -302,6 +316,10 @@ export type PluginResult = {
   // for staleness, e.g. the plugin dep's own `Package.swift` and per-module
   // manifests. Folded into `.spm-sync-watch-paths` by main().
   watchPaths: Array<string>,
+  // Build-time shell phases for the app target, recorded to
+  // `.spm-plugin-script-phases.json` by main() and injected by `spm add`/
+  // `update`.
+  scriptPhases: Array<PluginScriptPhase>,
 };
 
 export type SpmAutolinkingPlugin = (context: PluginContext) => ?{
@@ -310,6 +328,11 @@ export type SpmAutolinkingPlugin = (context: PluginContext) => ?{
   generatedSources?: Array<PluginGeneratedSource>,
   flavoredFrameworks?: Array<PluginFlavoredFramework>,
   watchPaths?: Array<string>,
+  // `position` may be omitted here; invokePlugins normalizes it to 'end'.
+  scriptPhases?: Array<{
+    ...PluginScriptPhase,
+    position?: 'beforeCompile' | 'end',
+  }>,
 };
 
 export type DiscoveredPlugin = {
@@ -458,10 +481,13 @@ export type SpmScaffoldSpec = {
   // Bucketed dependency references — pre-computed by the translation layer.
   // `coreReactNative` is true when ANY React-* / RCT* / RCT-Folly / glog
   // dep is present (so we add React's invariant header products).
-  // `siblingNames` are npm names that match other autolinked deps — resolved
-  // to Swift names by the scaffold orchestrator before emit.
+  // `siblingNames` are npm names that match other autolinked deps.
+  // `siblingSwiftNames` carries each one's resolved Swift name (honoring the
+  // sibling's `spm.name`); a sibling absent from it falls back to
+  // toSwiftName(npmName) at emit time.
   coreReactNative: boolean,
   siblingNames: Array<string>,
+  siblingSwiftNames?: {[npmName: string]: string},
   // Extra frameworks beyond the autolinker's default UIKit/Foundation/CoreGraphics
   // set. Merged with the defaults at emit time.
   extraFrameworks: Array<string>,