fix: accept different ways of writing a range

Fixes #18

lib/check-version-range.js

@@ -1,5 +1,6 @@
 import { semverIntersect } from '@voxpelli/semver-set';
 import { omit } from '@voxpelli/typed-utils';
+import { validRange } from 'semver';
 
 import { getStringValueByPath } from './utils.js';
 
@@ -63,11 +64,13 @@ export function checkVersionRange (mainPackage, key, installedDependencies, opti
     }
   }
 
+  const valid = intersection !== false && validRange(intersection) === validRange(referenceRange);
+
   return {
-    valid: intersection === referenceRange
+    valid: valid
       ? true
       : ((rawReferenceRange || strict) ? false : undefined),
-    suggested: intersection || undefined,
+    suggested: valid ? undefined : (intersection || undefined),
     packageNotes,
     note: rawReferenceRange === false
       ? `Invalid "${key}" in main package`
@@ -118,7 +121,7 @@ export function checkDependencyRange (referenceRange, key, dependencyPackage, is
     return { valid: false, note: `Incompatible "${key}" requirement: ${range}` };
   }
 
-  return intersection === referenceRange
+  return validRange(intersection) === validRange(referenceRange)
     ? undefined
     : { valid: false, suggested: intersection, note: `Narrower "${key}" is needed: ${intersection}` };
 }

test/check-version-range.spec.js

@@ -0,0 +1,52 @@
+import chai from 'chai';
+import { ErrorWithCause } from 'pony-cause';
+
+import { checkVersionRange, checkDependencyRange } from '../lib/check-version-range.js';
+
+const should = chai.should();
+
+process.on('unhandledRejection', cause => {
+  throw new ErrorWithCause('Unhandled rejection', { cause });
+});
+
+describe('checkVersionRange', () => {
+  describe('checkVersionRange()', () => {
+    it('should handle engine ranges', () => {
+      checkVersionRange(
+        {
+          engines: { node: '^12 || ^14 || ^16' },
+          dependencies: { foo: '^1.0.0' },
+        },
+        'engines.node',
+        {
+          foo: { engines: { node: '^12 || ^14 || ^16' } },
+        }
+      ).should.deep.equal({
+        valid: true,
+        note: undefined,
+        packageNotes: [],
+        suggested: undefined,
+      });
+    });
+  });
+
+  describe('checkDependencyRange()', () => {
+    it('should handle engine ranges', () => {
+      const installedDependencies = new Map();
+
+      installedDependencies.set('foo', {
+        engines: { node: '^12 || ^14 || ^16' },
+      });
+
+      const result = checkDependencyRange(
+        '^12 || ^14 || ^16',
+        'engines.node',
+        {
+          engines: { node: '^12 || ^14 || ^16' },
+        }
+      );
+
+      should.not.exist(result);
+    });
+  });
+});

test/fixtures/engine-ranges/package.json

@@ -0,0 +1,4 @@
+{
+  "engines": { "node": "^12 || ^14 || ^16" },
+  "dependencies": { "foo": "^1.0.0" }
+}

test/installed-check.spec.js

@@ -135,5 +135,17 @@ describe('installedCheck()', () => {
           warnings: [],
         });
     });
+
+    it('should handle engine ranges', async () => {
+      await installedCheck({
+        path: join(import.meta.url, 'fixtures/engine-ranges'),
+        engineCheck: true,
+        versionCheck: false,
+      })
+        .should.eventually.deep.equal({
+          'errors': [],
+          warnings: [],
+        });
+    });
   });
 });