Use valid semvers internally (#436)

* Update test position after upgrading Prettier

* Use valid semvers internally

Author: jablko

packages/definitions-parser/package.json

@@ -23,7 +23,8 @@
     "@definitelytyped/typescript-versions": "^0.0.112-next.9",
     "@definitelytyped/utils": "^0.0.112-next.9",
     "@types/node": "^14.14.35",
-    "fs-extra": "^9.1.0"
+    "fs-extra": "^9.1.0",
+    "semver": "^7.3.7"
   },
   "devDependencies": {
     "@types/fs-extra": "^9.0.8"

packages/definitions-parser/src/check-parse-results.ts

@@ -2,18 +2,19 @@ import { ParseDefinitionsOptions } from "./get-definitely-typed";
 import { TypingsData, AllPackages, formatTypingVersion } from "./packages";
 import {
   assertDefined,
-  best,
   mapDefined,
   nAtATime,
   FS,
   logger,
   writeLog,
   Logger,
-  Semver,
   UncachedNpmInfoClient,
   NpmInfoRawVersions,
   NpmInfoVersion,
+  max,
+  min,
 } from "@definitelytyped/utils";
+import * as semver from "semver";
 
 export async function checkParseResults(
   includeNpmChecks: false,
@@ -132,21 +133,19 @@ async function checkNpm(
   }
 
   const versions = getRegularVersions(info.versions);
-  const firstTypedVersion = best(
+  const firstTypedVersion = min(
     mapDefined(versions, ({ hasTypes, version }) => (hasTypes ? version : undefined)),
-    (a, b) => b.greaterThan(a)
+    semver.compare
   );
   // A package might have added types but removed them later, so check the latest version too
-  if (firstTypedVersion === undefined || !best(versions, (a, b) => a.version.greaterThan(b.version))!.hasTypes) {
+  if (firstTypedVersion === undefined || !max(versions, (a, b) => semver.compare(a.version, b.version))!.hasTypes) {
     return;
   }
 
   const ourVersion = `${major}.${minor}`;
 
   log("");
-  log(
-    `Typings already defined for ${name} (${libraryName}) as of ${firstTypedVersion.versionString} (our version: ${ourVersion})`
-  );
+  log(`Typings already defined for ${name} (${libraryName}) as of ${firstTypedVersion} (our version: ${ourVersion})`);
   const contributorUrls = contributors
     .map((c) => {
       const gh = "https://github.com/";
@@ -155,14 +154,14 @@ async function checkNpm(
     .join(", ");
   log("  To fix this:");
   log(`  git checkout -b not-needed-${name}`);
-  const yarnargs = [name, firstTypedVersion.versionString, projectName];
+  const yarnargs = [name, firstTypedVersion, projectName];
   if (libraryName !== name) {
     yarnargs.push(JSON.stringify(libraryName));
   }
   log("  yarn not-needed " + yarnargs.join(" "));
   log(`  git add --all && git commit -m "${name}: Provides its own types" && git push -u origin not-needed-${name}`);
   log(`  And comment PR: This will deprecate \`@types/${name}\` in favor of just \`${name}\`. CC ${contributorUrls}`);
-  if (new Semver(major, minor, 0).greaterThan(firstTypedVersion)) {
+  if (semver.gt(`${major}.${minor}.0`, firstTypedVersion)) {
     log("  WARNING: our version is greater!");
   }
   if (dependedOn.has(name)) {
@@ -177,11 +176,11 @@ export async function packageHasTypes(packageName: string, client: UncachedNpmIn
 
 function getRegularVersions(
   versions: NpmInfoRawVersions
-): readonly { readonly version: Semver; readonly hasTypes: boolean }[] {
-  return mapDefined(Object.entries(versions), ([versionString, info]) => {
-    const version = Semver.tryParse(versionString);
-    return version === undefined ? undefined : { version, hasTypes: versionHasTypes(info) };
-  });
+): readonly { readonly version: semver.SemVer; readonly hasTypes: boolean }[] {
+  return Object.entries(versions).map(([versionString, info]) => ({
+    version: new semver.SemVer(versionString),
+    hasTypes: versionHasTypes(info),
+  }));
 }
 
 function versionHasTypes(info: NpmInfoVersion): boolean {

packages/definitions-parser/src/git.ts

@@ -17,10 +17,10 @@ import {
   FS,
   consoleLogger,
   assertDefined,
-  Semver,
   UncachedNpmInfoClient,
   NpmInfo,
 } from "@definitelytyped/utils";
+import * as semver from "semver";
 import { getAffectedPackages } from "./get-affected-packages";
 
 export interface GitDiff {
@@ -145,20 +145,18 @@ export function checkNotNeededPackage(
 Unneeded packages have to be replaced with a package on npm.`
   );
   typings = assertDefined(typings, `Unexpected error: @types package not found for ${unneeded.fullNpmName}`);
-  const latestTypings = Semver.parse(
-    assertDefined(
-      typings.distTags.get("latest"),
-      `Unexpected error: ${unneeded.fullNpmName} is missing the "latest" tag.`
-    )
+  const latestTypings = assertDefined(
+    typings.distTags.get("latest"),
+    `Unexpected error: ${unneeded.fullNpmName} is missing the "latest" tag.`
   );
   assert(
-    unneeded.version.greaterThan(latestTypings),
-    `The specified version ${unneeded.version.versionString} of ${unneeded.libraryName} must be newer than the version
-it is supposed to replace, ${latestTypings.versionString} of ${unneeded.fullNpmName}.`
+    semver.gt(unneeded.version, latestTypings),
+    `The specified version ${unneeded.version} of ${unneeded.libraryName} must be newer than the version
+it is supposed to replace, ${latestTypings} of ${unneeded.fullNpmName}.`
   );
   assert(
-    source.versions.has(unneeded.version.versionString),
-    `The specified version ${unneeded.version.versionString} of ${unneeded.libraryName} is not on npm.`
+    source.versions.has(String(unneeded.version)),
+    `The specified version ${unneeded.version} of ${unneeded.libraryName} is not on npm.`
   );
 }
 

packages/definitions-parser/src/mocks.ts

@@ -1,5 +1,6 @@
 import { parseHeaderOrFail } from "@definitelytyped/header-parser";
-import { Dir, FS, InMemoryFS, mangleScopedPackage, Semver } from "@definitelytyped/utils";
+import { Dir, FS, InMemoryFS, mangleScopedPackage } from "@definitelytyped/utils";
+import * as semver from "semver";
 
 class DTMock {
   public readonly fs: FS;
@@ -43,7 +44,7 @@ class DTMock {
     const index = latestDir.get("index.d.ts") as string;
     const latestHeader = parseHeaderOrFail(index);
     const latestVersion = `${latestHeader.libraryMajorVersion}.${latestHeader.libraryMinorVersion}`;
-    const olderVersionParsed = Semver.parse(olderVersion, true)!;
+    const olderVersionParsed = semver.coerce(olderVersion)!;
 
     const oldDir = latestDir.subdir(`v${olderVersion}`);
     const tsconfig = JSON.parse(latestDir.get("tsconfig.json") as string);

packages/definitions-parser/src/packages.ts

@@ -1,15 +1,8 @@
 import assert = require("assert");
 import { Author } from "@definitelytyped/header-parser";
-import {
-  FS,
-  mapValues,
-  assertSorted,
-  unmangleScopedPackage,
-  Semver,
-  assertDefined,
-  unique,
-} from "@definitelytyped/utils";
+import { FS, mapValues, assertSorted, unmangleScopedPackage, assertDefined, unique } from "@definitelytyped/utils";
 import { AllTypeScriptVersion, TypeScriptVersion } from "@definitelytyped/typescript-versions";
+import * as semver from "semver";
 import { readDataFile } from "./data-file";
 import { scopeName, typesDirectoryName } from "./lib/settings";
 import { parseVersionFromDirectoryName } from "./lib/definition-parser";
@@ -261,7 +254,7 @@ interface NotNeededPackageRaw extends BaseRaw {
 }
 
 export class NotNeededPackage extends PackageBase {
-  readonly version: Semver;
+  readonly version: semver.SemVer;
 
   get license(): License.MIT {
     return License.MIT;
@@ -286,7 +279,7 @@ export class NotNeededPackage extends PackageBase {
   constructor(readonly name: string, readonly libraryName: string, asOfVersion: string) {
     super({ libraryName });
     assert(libraryName && name && asOfVersion);
-    this.version = Semver.parse(asOfVersion);
+    this.version = new semver.SemVer(asOfVersion);
   }
 
   get major(): number {
@@ -496,22 +489,20 @@ export function getLicenseFromPackageJson(packageJsonLicense: unknown): License
 }
 
 export class TypingsVersions {
-  private readonly map: ReadonlyMap<Semver, TypingsData>;
+  private readonly map: ReadonlyMap<semver.SemVer, TypingsData>;
 
   /**
    * Sorted from latest to oldest.
    */
-  private readonly versions: Semver[];
+  private readonly versions: semver.SemVer[];
 
   constructor(data: TypingsVersionsRaw) {
     /**
      * Sorted from latest to oldest so that we publish the current version first.
      * This is important because older versions repeatedly reset the "latest" tag to the current version.
      */
-    this.versions = Object.keys(data)
-      .map((key) => Semver.parse(key, true))
-      .sort(Semver.compare)
-      .reverse();
+    this.versions = Object.keys(data).map((key) => new semver.SemVer(`${key}.0`));
+    this.versions.sort(semver.rcompare);
 
     this.map = new Map(
       this.versions.map((version, i) => [version, new TypingsData(data[`${version.major}.${version.minor}`], !i)])

packages/definitions-parser/test/packages.test.ts

@@ -219,7 +219,7 @@ describe(NotNeededPackage, () => {
     expect(data.license).toBe(License.MIT);
     expect(data.name).toBe("types-package");
     expect(data.libraryName).toBe("real-package");
-    expect(data.version).toEqual({
+    expect(data.version).toMatchObject({
       major: 1,
       minor: 0,
       patch: 0,

packages/perf/package.json

@@ -21,6 +21,7 @@
     "@octokit/rest": "^16.33.0",
     "@types/node": "^12.12.29",
     "markdown-table": "^1.1.3",
+    "semver": "^7.3.7",
     "typescript": "^4.1.0",
     "yargs": "^15.4.1"
   },

packages/perf/src/measure/measurePerf.ts

@@ -16,7 +16,9 @@ import {
   MeasureBatchCompilationChildProcessResult,
 } from "./measureBatchCompilationWorker";
 import { AllPackages, HeaderParsedTypingVersion } from "@definitelytyped/definitions-parser";
-import { runWithListeningChildProcesses, runWithChildProcesses, Semver } from "@definitelytyped/utils";
+import { TypeScriptVersion } from "@definitelytyped/typescript-versions";
+import { runWithListeningChildProcesses, runWithChildProcesses } from "@definitelytyped/utils";
+import * as semver from "semver";
 
 export interface MeasurePerfOptions {
   packageName: string;
@@ -253,14 +255,12 @@ export async function measurePerf({
 }
 
 function getLatestTypesVersionForTypeScriptVersion(
-  typesVersions: readonly string[],
+  typesVersions: readonly TypeScriptVersion[],
   typeScriptVersion: string
 ): string | undefined {
-  const tsVersion = Semver.parse(typeScriptVersion.replace(/-dev.*$/, ""));
+  const tsVersion = new semver.SemVer(typeScriptVersion);
   for (let i = typesVersions.length - 1; i > 0; i--) {
-    const [major, minor] = typesVersions[i].split(".").map(Number); // e.g. '3.5'
-    const typesVersion = new Semver(major, minor, 0);
-    if (tsVersion.greaterThan(typesVersion)) {
+    if (semver.gte(tsVersion, `${typesVersions[i]}.0-`)) {
       return typesVersions[i];
     }
   }

packages/publisher/package.json

@@ -21,6 +21,7 @@
     "hh-mm-ss": "^1.2.0",
     "longjohn": "^0.2.11",
     "oboe": "^2.1.3",
+    "semver": "^7.3.7",
     "source-map-support": "^0.4.0",
     "typescript": "^4.1.0",
     "yargs": "15.3.1"

packages/publisher/src/generate-packages.ts

@@ -213,7 +213,7 @@ function dependencySemver(dependency: DependencyVersion): string {
 export function createNotNeededPackageJSON({ libraryName, license, fullNpmName, version }: NotNeededPackage): string {
   const out = {
     name: fullNpmName,
-    version: version.versionString,
+    version: String(version),
     typings: null, // tslint:disable-line no-null-keyword
     description: `Stub TypeScript definitions entry for ${libraryName}, which provides its own types definitions`,
     main: "",