Add support for peer dependencies

Author: lo1tuma

integration-tests/bundler/package-types.test.ts

@@ -47,3 +47,36 @@ test('includes all required local files and references correct node modules but
         ]
     });
 });
+
+test('includes peer dependencies correctly', async (t) => {
+    const fixture = path.join(process.cwd(), 'integration-tests/fixtures/with-peer-dependencies');
+    const result = await bundler.build({
+        name: 'the-package-name',
+        version: '42.0.0',
+        sourcesFolder: path.join(fixture, 'src'),
+        entryPoints: [{ js: path.join(fixture, 'src/entry.js') }],
+        mainPackageJson: await loadPackageJson(fixture)
+    });
+
+    t.deepEqual(result, {
+        packageJson: {
+            dependencies: {},
+            peerDependencies: { 'example-module': '1.2.3' },
+            main: 'entry.js',
+            name: 'the-package-name',
+            version: '42.0.0'
+        },
+        contents: [
+            {
+                kind: 'source',
+                source: '{\n    "dependencies": {},\n    "main": "entry.js",\n    "name": "the-package-name",\n    "peerDependencies": {\n        "example-module": "1.2.3"\n    },\n    "version": "42.0.0"\n}',
+                targetFilePath: 'package.json'
+            },
+            {
+                kind: 'reference',
+                sourceFilePath: path.join(fixture, 'src/entry.js'),
+                targetFilePath: 'entry.js'
+            }
+        ]
+    });
+});

integration-tests/fixtures/with-peer-dependencies/node_modules/example-module/index.js

@@ -0,0 +1,7 @@
+{
+    "name": "test-fixture",
+    "version": "0.0.0-dev",
+    "peerDependencies": {
+        "example-module": "1.2.3"
+    }
+}

integration-tests/fixtures/with-peer-dependencies/node_modules/example-module/package.json

@@ -0,0 +1,2 @@
+import { example } from 'example-module';
+export const foo = example;

integration-tests/fixtures/with-peer-dependencies/package.json

@@ -177,6 +177,40 @@ test('builds a bundle for a single file with the correct package.json', async (t
     });
 });
 
+test('builds a bundle for a single file with the correct peerDependencies in package.json', async (t) => {
+    const graph = buildDependencyGraph({
+        entries: [{ filePath: '/foo/bar.js', content: 'true', topLevelDependencies: new Map([['pkg', '42']]) }]
+    });
+    const scan = fake.resolves(graph);
+    const bundler = bundlerFactory({ scan });
+
+    const bundle = await bundler.build({
+        sourcesFolder: '/foo',
+        entryPoints: [{ js: '/foo/bar.js' }],
+        name: 'the-name',
+        version: 'the-version',
+        mainPackageJson: { peerDependencies: { pkg: '21' } }
+    });
+
+    t.deepEqual(bundle, {
+        contents: [
+            {
+                kind: 'source',
+                source: '{\n    "dependencies": {},\n    "main": "bar.js",\n    "name": "the-name",\n    "peerDependencies": {\n        "pkg": "42"\n    },\n    "version": "the-version"\n}',
+                targetFilePath: 'package.json'
+            },
+            { kind: 'reference', sourceFilePath: '/foo/bar.js', targetFilePath: 'bar.js' }
+        ],
+        packageJson: {
+            name: 'the-name',
+            version: 'the-version',
+            dependencies: {},
+            peerDependencies: { pkg: '42' },
+            main: 'bar.js'
+        }
+    });
+});
+
 test('builds a bundle for a single file with the given additional package.json fields, sorted alphabetically', async (t) => {
     const graph = buildDependencyGraph({
         entries: [{ filePath: '/foo/bar.js', content: 'true' }]

integration-tests/fixtures/with-peer-dependencies/src/entry.js

@@ -32,16 +32,19 @@ type GroupedDependencies = {
 
 function distributeDependencies(
     packageDependencies: Record<string, string>,
-    bundlePeerDependencies: readonly BundleDescription[]
+    bundlePeerDependencies: readonly BundleDescription[],
+    mainPackageJson: MainPackageJson
 ): Readonly<GroupedDependencies> {
     const dependencies: Record<string, string> = {};
     const peerDependencies: Record<string, string> = {};
 
     for (const [dependencyName, dependencyVersion] of Object.entries(packageDependencies)) {
         if (containsBundleWithPackageName(bundlePeerDependencies, dependencyName)) {
             peerDependencies[dependencyName] = dependencyVersion;
-        } else {
+        } else if (mainPackageJson.peerDependencies?.[dependencyName] === undefined) {
             dependencies[dependencyName] = dependencyVersion;
+        } else {
+            peerDependencies[dependencyName] = dependencyVersion;
         }
     }
 
@@ -62,7 +65,11 @@ function buildPackageJson(
         bundlePeerDependencies = []
     } = options;
 
-    const distributedDependencies = distributeDependencies(packageDependencies, bundlePeerDependencies);
+    const distributedDependencies = distributeDependencies(
+        packageDependencies,
+        bundlePeerDependencies,
+        mainPackageJson
+    );
     const types =
         firstEntryPoint.declarationFile === undefined
             ? undefined

source/bundler/bundler.test.ts

@@ -51,6 +51,18 @@ test('main package.json: validation fails when dependencies contains non-string
     expectedMessages: ['At dependencies.foo: expected string; but got number']
 });
 
+test('main package.json: validation fails when peerDependencies is not an object', checkValidationFailure, {
+    schema: mainPackageJsonSchema,
+    data: { peerDependencies: true },
+    expectedMessages: ['At peerDependencies: expected object; but got boolean']
+});
+
+test('main package.json: validation fails when peerDependencies contains non-string values', checkValidationFailure, {
+    schema: mainPackageJsonSchema,
+    data: { peerDependencies: { foo: 123 } },
+    expectedMessages: ['At peerDependencies.foo: expected string; but got number']
+});
+
 test('main package.json: validation fails when devDependencies is not an object', checkValidationFailure, {
     schema: mainPackageJsonSchema,
     data: { devDependencies: true },
@@ -91,6 +103,12 @@ test('additional attributes: validation fails when peerDependencies key is given
     expectedMessages: ['At peerDependencies: unexpected extra key or index']
 });
 
+test('additional attributes: validation fails when devDependencies key is given', checkValidationFailure, {
+    schema: additionalPackageJsonAttributesSchema,
+    data: { devDependencies: {} },
+    expectedMessages: ['At devDependencies: unexpected extra key or index']
+});
+
 test('additional attributes: validation fails when main key is given', checkValidationFailure, {
     schema: additionalPackageJsonAttributesSchema,
     data: { main: 'foo' },

source/bundler/bundler.ts

@@ -24,7 +24,8 @@ const optionalStringRecordSchema = optional(stringRecordSchema, { exact: true })
 const $mainPackageJsonSchema = struct({
     type: optional(literal('module'), { exact: true }),
     dependencies: optionalStringRecordSchema,
-    devDependencies: optionalStringRecordSchema
+    devDependencies: optionalStringRecordSchema,
+    peerDependencies: optionalStringRecordSchema
 }).pipe(extend(record(string, unknown)));
 export type MainPackageJson = NoExpand<Schema.To<typeof $mainPackageJsonSchema>>;
 export const mainPackageJsonSchema: Schema<MainPackageJson> = $mainPackageJsonSchema;
@@ -50,6 +51,7 @@ const attributeValueSchema: Schema<JsonValue> = union(
 const forbiddenAttributeNames = new Set([
     'dependencies',
     'peerDependencies',
+    'devDependencies',
     'main',
     'name',
     'types',

source/config/package-json.test.ts

@@ -263,6 +263,19 @@ test('returns all detected node_modules dependencies with its corresponding vers
     t.deepEqual(result.topLevelDependencies, { 'any-module': 'the-version' });
 });
 
+test('returns the detected node_modules dependencies when they are defined as a peer dependency', async (t) => {
+    const getReferencedSourceFilePaths = fake.returns(['/dir/node_modules/any-module/foo.js']);
+    const analyzeProject = createFakeAnalyzeProject({ getReferencedSourceFilePaths });
+    const dependencyScanner = dependencyScannerFactory({ analyzeProject });
+
+    const graph = await dependencyScanner.scan('/dir/entry.js', '/dir', {
+        mainPackageJson: { peerDependencies: { 'any-module': 'the-version' } }
+    });
+    const result = graph.flatten('/dir/entry.js');
+
+    t.deepEqual(result.topLevelDependencies, { 'any-module': 'the-version' });
+});
+
 test('uses the version from devDependencies when includeDevDependencies is true', async (t) => {
     const getReferencedSourceFilePaths = fake.returns(['/dir/node_modules/any-module/foo.js']);
     const analyzeProject = createFakeAnalyzeProject({ getReferencedSourceFilePaths });

source/config/package-json.ts

@@ -47,7 +47,10 @@ function extractModuleName(nodeModulePath: string): string {
 function isKnownNodeModule(moduleName: string, options: ScanOptions): boolean {
     const { includeDevDependencies, mainPackageJson } = options;
 
-    if (mainPackageJson.dependencies?.[moduleName] !== undefined) {
+    if (
+        mainPackageJson.dependencies?.[moduleName] !== undefined ||
+        mainPackageJson.peerDependencies?.[moduleName] !== undefined
+    ) {
         return true;
     }
 
@@ -70,6 +73,8 @@ function getVersionFromDependencies(
 
     return undefined;
 }
+
+// eslint-disable-next-line max-statements -- this will be removed soon when the dependency scanner doesn’t have to take care about versions anymore
 function determineVersionNumber(moduleName: string, options: ScanOptions): string {
     const { mainPackageJson } = options;
     const version = getVersionFromDependencies(moduleName, mainPackageJson.dependencies);
@@ -78,13 +83,20 @@ function determineVersionNumber(moduleName: string, options: ScanOptions): strin
         return version;
     }
 
+    const peerDependencyVersion = getVersionFromDependencies(moduleName, mainPackageJson.peerDependencies);
+
+    if (peerDependencyVersion !== undefined) {
+        return peerDependencyVersion;
+    }
+
     const devDependencyVersion = getVersionFromDependencies(moduleName, mainPackageJson.devDependencies);
     if (devDependencyVersion !== undefined) {
         return devDependencyVersion;
     }
 
     throw new Error(`Couldn’t determine version number of ${moduleName}`);
 }
+
 function addVersionNumbersToModules(moduleNames: readonly string[], options: ScanOptions): ReadonlyMap<string, string> {
     return new Map<string, string>(
         moduleNames.map((moduleName) => {