Use TypeScriptVersion.latest instead of "next" (#279)

* Convert latest TS version to "next" on DT

dtslint installs the latest version of typescript as "next" because
that's the npm name.

Probably a better fix is to install typescript@next into a directory
with the same name as the rest, stripping off the .0-dev.20200323 part.

* Just install typescript@next into 3.9 folder

This removes the need to change the name when testing dependencies. I'm
not sure yet about when testing the main package.

* Remove "next" from TsVersion type

Instead, just use TYpeScriptVersion.latest everywhere except when
installing from npm.

* Update TS and fix new compile error

src/index.ts

@@ -154,7 +154,7 @@ async function runTests(
     }
 
     if (onlyTestTsNext || tsLocal) {
-        const tsVersion = tsLocal ? "local" : "next";
+        const tsVersion = tsLocal ? "local" : TypeScriptVersion.latest;
         if (typesVersions.length === 0) {
             await testTypesVersion(dirPath, tsVersion, tsVersion, isOlderVersion, dt, indexText, expectOnly, tsLocal);
         } else {
@@ -177,7 +177,7 @@ async function runTests(
         }
 
         function getTsVersion(i: number): TsVersion {
-            return i === typesVersions.length ? "next" : assertDefined(TypeScriptVersion.previous(typesVersions[i]));
+            return i === typesVersions.length ? TypeScriptVersion.latest : assertDefined(TypeScriptVersion.previous(typesVersions[i]));
         }
     }
 }

src/installer.ts

@@ -21,7 +21,7 @@ export async function installNext() {
     await install("next");
 }
 
-async function install(version: TsVersion): Promise<void> {
+async function install(version: TsVersion | "next"): Promise<void> {
     if (version === "local") {
         return;
     }
@@ -47,8 +47,11 @@ export function typeScriptPath(version: TsVersion, tsLocal: string | undefined):
     return path.join(installDir(version), "node_modules", "typescript");
 }
 
-function installDir(version: TsVersion): string {
+function installDir(version: TsVersion | "next"): string {
     assert(version !== "local");
+    if (version === "next") {
+        version = TypeScriptVersion.latest;
+    }
     return path.join(installsDir, version);
 }
 
@@ -69,7 +72,7 @@ async function execAndThrowErrors(cmd: string, cwd?: string): Promise<void> {
     });
 }
 
-function packageJson(version: TsVersion): {} {
+function packageJson(version: TsVersion | "next"): {} {
     return {
         description: `Installs typescript@${version}`,
         repository: "N/A",

src/lint.ts

@@ -174,24 +174,19 @@ async function getLintConfig(
 }
 
 function range(minVersion: TsVersion, maxVersion: TsVersion): ReadonlyArray<TsVersion> {
-    if (minVersion === "next") {
-        assert(maxVersion === "next");
-        return ["next"];
-    }
     if (minVersion === "local") {
         assert(maxVersion === "local");
         return ["local"];
     }
+    assert(maxVersion !== "local");
 
     // The last item of TypeScriptVersion is the unreleased version of Typescript,
     // which is called 'next' on npm, so replace it with 'next'.
-    const allReleased: TsVersion[] = [...TypeScriptVersion.supported];
-    allReleased[allReleased.length - 1] = "next";
-    const minIdx = allReleased.indexOf(minVersion);
+    const minIdx = TypeScriptVersion.supported.indexOf(minVersion);
     assert(minIdx >= 0);
-    const maxIdx = allReleased.indexOf(maxVersion);
+    const maxIdx = TypeScriptVersion.supported.indexOf(maxVersion as TypeScriptVersion);
     assert(maxIdx >= minIdx);
-    return allReleased.slice(minIdx, maxIdx + 1);
+    return TypeScriptVersion.supported.slice(minIdx, maxIdx + 1);
 }
 
-export type TsVersion = TypeScriptVersion | "next" | "local";
+export type TsVersion = TypeScriptVersion | "local";

src/util.ts

@@ -75,7 +75,7 @@ export function assertDefined<T>(a: T | undefined): T {
     return a;
 }
 
-export async function mapDefinedAsync<T, U>(arr: Iterable<T>, mapper: (t: T) => Promise<U | undefined>): Promise<U[]> {
+export async function mapDefinedAsync<T, U>(arr: Iterable<T>, mapper: (t: T) => Promise<U | undefined>): Promise<(awaited U)[]> {
     const out = [];
     for (const a of arr) {
         const res = await mapper(a);