How to use the semver.major function in semver

.reduce((results, [offender, current, _, latest]) => {
        // check if semver can parse the versions at all
        if (!semver.parse(current) || !semver.parse(latest)) return results

        const mitigation = `Upgrade to v${latest} (Current: v${current})`

        if (semver.major(current) < semver.major(latest)) {
          results.high({ offender, mitigation, code: `${offender}-1`, description: 'Module is one or more major versions out of date' })
        } else if (semver.minor(current) < semver.minor(latest)) {
          results.medium({ offender, mitigation, code: `${offender}-2`, description: 'Module is one or more minor versions out of date' })
        } else if (semver.patch(current) < semver.patch(latest)) {
          results.low({ offender, mitigation, code: `${offender}-3`, description: 'Module is one or more patch versions out of date' })
        }

        return results
      }, new ModuleResults(key))
  }

if (semver.major(min) === 0 && semver.major(max) === 0) {
        // ^0.0.5
        if (semver.minor(min) === 0 && semver.minor(max) === 0) {
            return `^${min}`;
        }

        // ~0.0.5
        if (semver.minor(min) === 0) {
            return `~${min}`;
        }

        // ^0.5.0
        return `^${min}`;
    }

    if (semver.major(min) !== semver.major(max)) {
        if (semver.major(min) === 0) {
            return '0';
        }

        return `^${min}`;
    }

    return `~${min}`;
}

_migrateData(data, dataVersion, schemaVersion) {
      let dataMjVer = Number(semver.major(dataVersion));
      let schemaMjVer = Number(semver.major(schemaVersion));
      switch (true) {
        // identical
        case (dataMjVer === schemaMjVer):
          return data;
        // 0->1: add schema id
        case (dataMjVer === 0 && schemaMjVer === 1):
          data.$schema = this.getSchemaUri();
          break;
        // throw otherwise
        default:
          throw new Error(`Configuration file schema version mismatch: expected v${schemaMjVer}, found v${dataMjVer}. Could not migrate data.`);
      }
      this.setDirty(true);
      return data;
    },

projectRoot,
        'expo',
        `Warning: Not using the Expo fork of react-native. See ${Config.helpUrl}.`,
        'doctor-not-using-expo-fork'
      );
      return WARNING;
    }
    ProjectUtils.clearNotification(projectRoot, 'doctor-not-using-expo-fork');

    try {
      let reactNativeTag = reactNative.match(/sdk-\d+\.\d+\.\d+/)[0];
      let sdkVersionObject = sdkVersions[sdkVersion];

      // TODO: Want to be smarter about this. Maybe warn if there's a newer version.
      if (
        semver.major(Versions.parseSdkVersionFromTag(reactNativeTag)) !==
        semver.major(Versions.parseSdkVersionFromTag(sdkVersionObject['expoReactNativeTag']))
      ) {
        ProjectUtils.logWarning(
          projectRoot,
          'expo',
          `Warning: Invalid version of react-native for sdkVersion ${sdkVersion}. Use github:expo/react-native#${sdkVersionObject['expoReactNativeTag']}`,
          'doctor-invalid-version-of-react-native'
        );
        return WARNING;
      }
      ProjectUtils.clearNotification(projectRoot, 'doctor-invalid-version-of-react-native');

      ProjectUtils.clearNotification(projectRoot, 'doctor-malformed-version-of-react-native');
    } catch (e) {
      ProjectUtils.logWarning(
        projectRoot,

forEach(sdkVersions, (value, key) => {
    if (
      semver.major(value.facebookReactNativeVersion) === semver.major(facebookReactNativeVersion) &&
      semver.minor(value.facebookReactNativeVersion) === semver.minor(facebookReactNativeVersion) &&
      (!currentSdkVersion || semver.gt(key, currentSdkVersion))
    ) {
      currentSdkVersion = key;
    }
  });

patchedOut = out.map((version) => {
        return `${ major(version) }.${ minor(version) }.x`;
      });
    }

helpers.checkFrameworkVersion(versionJson, function(error, data) {
            if(error) return cb(error);
            details.frameworkVersions = data;
            if (semver.major(data.imported) > semver.major(data.installed)) {
              details.frameworkVersions.downgrade = true;
              return done();
            }
            cb();
          });
        });

function generateVersionCode(versionName) {
	const major = semver.major(versionName);
	const minor = semver.minor(versionName);
	const patch = semver.patch(versionName);

	return 10 ** 6 * major + 10 ** 3 * minor + patch;
}

exports.getReactScriptsVersion = function getReactScriptsVersion(cliVersion) {
  if (cliVersion) {
    const versions = {
      major: Number(semver.major(cliVersion)),
      minor: Number(semver.minor(cliVersion)),
      patch: Number(semver.patch(cliVersion)),
    };
    return versions;
  }

  const reactScriptsPkg = importCwd.silent('react-scripts/package.json');
  if (!reactScriptsPkg || !reactScriptsPkg.version) {
    return DEFAULT_VERSION;
  }

  const { version } = reactScriptsPkg;
  const versions = {
    major: Number(semver.major(version)),
    minor: Number(semver.minor(version)),
    patch: Number(semver.patch(version)),