diff --git a/packages/react-native/scripts/spm/__docs__/spm-scripts.md b/packages/react-native/scripts/spm/__docs__/spm-scripts.md index fcf1ab32821..622b75e37f1 100644 --- a/packages/react-native/scripts/spm/__docs__/spm-scripts.md +++ b/packages/react-native/scripts/spm/__docs__/spm-scripts.md @@ -376,6 +376,22 @@ library's target can import it. This is a **library-author** surface, like the podspec dependency it replaces — apps don't normally set it. +### Config module format + +`react-native.config.js` may be CommonJS or ESM, and both named and default +exports are read. A key defined twice — as a named export and on the default +export — resolves to the named one. Avoid that shape anyway: the Community CLI +has two loaders that disagree about it, a sync one that sees named exports and +an async one that takes only the default export. For maximum compatibility, +prefer the one-line CommonJS form: + +```js +module.exports = {dependency: {platforms: {ios: {}}}, spm: {name: 'worklets'}}; +``` + +If the config fails to load, a warning names the file and the reason — the `spm` +settings in it are ignored rather than silently applied. + ## Self-managed community packages A community library that ships its own `Package.swift` is referenced directly by diff --git a/packages/react-native/scripts/spm/__tests__/expand-spm-dependencies-test.js b/packages/react-native/scripts/spm/__tests__/expand-spm-dependencies-test.js index 49e91fdd640..0566c557232 100644 --- a/packages/react-native/scripts/spm/__tests__/expand-spm-dependencies-test.js +++ b/packages/react-native/scripts/spm/__tests__/expand-spm-dependencies-test.js @@ -34,10 +34,14 @@ */ const { + defaultReadConfig, expandSpmDependencies, resolveSwiftName, } = require('../expand-spm-dependencies'); const {toSwiftName} = require('../spm-utils'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); function makeReadConfig(configs /*: {[string]: ?Object} */) { return (root /*: string */) => @@ -391,3 +395,112 @@ describe('expandSpmDependencies', () => { ); }); }); + +// --------------------------------------------------------------------------- +// defaultReadConfig +// +// The community CLI's own loaders disagree — sync reads named exports, async +// reads the default one — so a config that sets only `export default` must not +// be invisible here. Fixtures are transpiled by babel, so they present the +// `__esModule`/`default` interop shape; a Node namespace object from +// `require(ESM)` has no `__esModule` but exposes `.default` alongside +// enumerable named keys the same way, which is what the merge reads. +// --------------------------------------------------------------------------- + +describe('defaultReadConfig', () => { + let tmpRoot; + + beforeAll(() => { + tmpRoot = fs.mkdtempSync( + path.join(fs.realpathSync(os.tmpdir()), 'spm-read-config-'), + ); + }); + + afterAll(() => { + fs.rmSync(tmpRoot, {recursive: true, force: true}); + }); + + function writeConfig(name, source) { + const root = path.join(tmpRoot, name); + fs.mkdirSync(root, {recursive: true}); + fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({name})); + fs.writeFileSync(path.join(root, 'react-native.config.js'), source); + return root; + } + + it('returns null when the library ships no config', () => { + const root = path.join(tmpRoot, 'no-config'); + fs.mkdirSync(root, {recursive: true}); + expect(defaultReadConfig(root)).toBeNull(); + }); + + it('reads a CommonJS config', () => { + const root = writeConfig('cjs', "module.exports = {spm: {name: 'Cjs'}};\n"); + expect(defaultReadConfig(root).spm.name).toBe('Cjs'); + }); + + it('unwraps an ESM config that only has a default export', () => { + const root = writeConfig( + 'esm-default', + "export default {spm: {name: 'EsmDefault'}};\n", + ); + expect(defaultReadConfig(root).spm.name).toBe('EsmDefault'); + }); + + it('reads an ESM config that only has named exports', () => { + const root = writeConfig( + 'esm-named', + "export const spm = {name: 'EsmNamed'};\n", + ); + expect(defaultReadConfig(root).spm.name).toBe('EsmNamed'); + }); + + it('prefers the named export when a config ships both (the PowerSync shape)', () => { + const root = writeConfig( + 'esm-both', + "export const spm = {name: 'Named'};\n" + + "export default {spm: {name: 'Default'}, dependency: {platforms: {ios: {}}}};\n", + ); + const config = defaultReadConfig(root); + expect(config.spm.name).toBe('Named'); + // Only the merge satisfies this: `dependency` exists on the default export + // alone, so reading the module raw would miss it. + expect(config.dependency.platforms.ios).toEqual({}); + }); + + it('keeps sibling keys of the default export (dependency.platforms.ios)', () => { + const root = writeConfig( + 'esm-siblings', + "export default {dependency: {platforms: {ios: {}}}, spm: {name: 'Siblings'}};\n", + ); + const config = defaultReadConfig(root); + expect(config.dependency.platforms.ios).toEqual({}); + expect(config.spm.name).toBe('Siblings'); + }); + + it('passes a function-style config through unchanged (module.exports = () => ({...}))', () => { + const root = writeConfig( + 'fn-style', + "module.exports = () => ({spm: {name: 'FnStyle'}});\n", + ); + const config = defaultReadConfig(root); + expect(typeof config).toBe('function'); + expect(config().spm.name).toBe('FnStyle'); + }); + + it('warns with the config path and the reason when the config fails to load, and returns null', () => { + const root = writeConfig( + 'broken', + "require('a-dev-dependency-that-is-not-installed');\n", + ); + const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {}); + try { + expect(defaultReadConfig(root)).toBeNull(); + const message = warnSpy.mock.calls.map(call => call.join(' ')).join('\n'); + expect(message).toContain(path.join(root, 'react-native.config.js')); + expect(message).toContain('a-dev-dependency-that-is-not-installed'); + } finally { + warnSpy.mockRestore(); + } + }); +}); diff --git a/packages/react-native/scripts/spm/expand-spm-dependencies.js b/packages/react-native/scripts/spm/expand-spm-dependencies.js index 4b529c08afa..bad376f505e 100644 --- a/packages/react-native/scripts/spm/expand-spm-dependencies.js +++ b/packages/react-native/scripts/spm/expand-spm-dependencies.js @@ -10,10 +10,12 @@ 'use strict'; -const {toSwiftName} = require('./spm-utils'); +const {makeLogger, toSwiftName} = require('./spm-utils'); 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. @@ -188,8 +190,34 @@ function defaultReadConfig(root /*: string */) /*: ?RnConfig */ { } try { // $FlowFixMe[unsupported-syntax] - return require(configPath); - } catch { + const mod = require(configPath); + // Read both export styles, because the community CLI's two loaders + // disagree with each other: its sync path (`loadConfig`) requires the + // module and sees named exports at top level, its async path + // (`loadConfigAsync`) takes the default export only. Merging covers both, + // with named exports winning — the shape the sync path already resolves. + // Every sibling key of the default export is preserved + // (`dependency.platforms.ios` is read from this result too). + // A function-style config (`module.exports = () => ({...})`) and other + // non-objects pass through untouched — there is no default export to + // unwrap, and nulling them would hide a config that used to be read. + if (mod == null || typeof mod !== 'object') { + return mod; + } + const dflt = mod.default; + if (dflt == null || typeof dflt !== 'object') { + return mod; + } + const {default: _unused, ...named} = mod; + return {...dflt, ...named}; + } catch (e) { + // A config can fail to load for reasons unrelated to SPM (it may import a + // devDependency absent in a consumer install), so this stays a warning — + // but a silent null turns a dropped `spm` block into a link error much + // later. + warn( + `Failed to load ${configPath}: ${e.message}. Any 'spm' settings in it are ignored.`, + ); return null; } }