fix: avoid throw for invalid cases when not needed

Author: H4ad

benchmarks/bench-inc.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const Benchmark = require('benchmark')
+const invalidVersions = require('../test/fixtures/invalid-versions')
+const inc = require('../functions/inc')
+const suite = new Benchmark.Suite()
+
+const cases = ['1.2.3', '4.2.0', '1.1.1-928490632884417731e7af463c92b034d6a78268fc993bcb88a57944']
+const invalidCases = invalidVersions.map(invalid => invalid[0])
+
+for (const test of cases) {
+  suite.add(`inc(${test})`, function () {
+    inc(test, 'release')
+  })
+}
+
+for (const test of invalidCases) {
+  suite.add(`invalid inc(${test})`, function () {
+    inc(test, 'release')
+  })
+}
+
+suite
+  .on('cycle', function (event) {
+    console.log(String(event.target))
+  })
+  .run({ async: false })

benchmarks/bench-valid.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const Benchmark = require('benchmark')
+const invalidVersions = require('../test/fixtures/invalid-versions')
+const valid = require('../functions/valid')
+const suite = new Benchmark.Suite()
+
+const cases = ['1.2.3', '4.2.0', '1.1.1-928490632884417731e7af463c92b034d6a78268fc993bcb88a57944']
+const invalidCases = invalidVersions.map(invalid => invalid[0])
+
+for (const test of cases) {
+  suite.add(`valid(${test})`, function () {
+    valid(test)
+  })
+}
+
+for (const test of invalidCases) {
+  suite.add(`invalid valid(${test})`, function () {
+    valid(test)
+  })
+}
+
+suite
+  .on('cycle', function (event) {
+    console.log(String(event.target))
+  })
+  .run({ async: false })

classes/semver.js

@@ -6,8 +6,17 @@ const { safeRe: re, t } = require('../internal/re')
 
 const parseOptions = require('../internal/parse-options')
 const { compareIdentifiers } = require('../internal/identifiers')
+
+function handleErrorOnSemver (semver, errorMessage, throwErrors) {
+  if (throwErrors) {
+    throw new TypeError(errorMessage)
+  } else {
+    semver.errorMessage = errorMessage
+  }
+}
+
 class SemVer {
-  constructor (version, options) {
+  constructor (version, options, throwErrors = true) {
     options = parseOptions(options)
 
     if (version instanceof SemVer) {
@@ -18,13 +27,11 @@ class SemVer {
         version = version.version
       }
     } else if (typeof version !== 'string') {
-      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
+      return handleErrorOnSemver(this, `Invalid version. Must be a string. Got type "${typeof version}".`, throwErrors)
     }
 
     if (version.length > MAX_LENGTH) {
-      throw new TypeError(
-        `version is longer than ${MAX_LENGTH} characters`
-      )
+      return handleErrorOnSemver(this, `version is longer than ${MAX_LENGTH} characters`, throwErrors)
     }
 
     debug('SemVer', version, options)
@@ -37,7 +44,7 @@ class SemVer {
     const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
 
     if (!m) {
-      throw new TypeError(`Invalid Version: ${version}`)
+      return handleErrorOnSemver(this, `Invalid Version: ${version}`, throwErrors)
     }
 
     this.raw = version
@@ -48,15 +55,15 @@ class SemVer {
     this.patch = +m[3]
 
     if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-      throw new TypeError('Invalid major version')
+      return handleErrorOnSemver(this, 'Invalid major version', throwErrors)
     }
 
     if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-      throw new TypeError('Invalid minor version')
+      return handleErrorOnSemver(this, 'Invalid minor version', throwErrors)
     }
 
     if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-      throw new TypeError('Invalid patch version')
+      return handleErrorOnSemver(this, 'Invalid patch version', throwErrors)
     }
 
     // numberify any prerelease numeric ids

functions/inc.js

@@ -1,19 +1,17 @@
 'use strict'
 
 const SemVer = require('../classes/semver')
+const parse = require('./parse')
 
 const inc = (version, release, options, identifier, identifierBase) => {
-  if (typeof (options) === 'string') {
-    identifierBase = identifier
-    identifier = options
-    options = undefined
+  const parsed = parse(version instanceof SemVer ? version.version : version, options)
+
+  if (parsed === null) {
+    return null
   }
 
   try {
-    return new SemVer(
-      version instanceof SemVer ? version.version : version,
-      options
-    ).inc(release, identifier, identifierBase).version
+    return parsed.inc(release, identifier, identifierBase).version
   } catch (er) {
     return null
   }

functions/parse.js

@@ -5,6 +5,7 @@ const parse = (version, options, throwErrors = false) => {
   if (version instanceof SemVer) {
     return version
   }
+
   try {
     return new SemVer(version, options)
   } catch (er) {

test/classes/semver.js

@@ -97,6 +97,19 @@ test('invalid version numbers', (t) => {
   t.end()
 })
 
+test('invalid version numbers without throw', (t) => {
+  ['1.2.3.4', 'NOT VALID', 1.2, null, 'Infinity.NaN.Infinity'].forEach((v) => {
+    const parsed = new SemVer(v, undefined, false)
+
+    t.strictSame(parsed.errorMessage, typeof v === 'string'
+      ? `Invalid Version: ${v}`
+      : `Invalid version. Must be a string. Got type "${typeof v}".`
+    )
+  })
+
+  t.end()
+})
+
 test('incrementing', t => {
   t.plan(increments.length)
   increments.forEach(([