Remove pathMapping check in definition-parser

Also all (?) the infrastructure needed to support it.

packages/definitions-parser/src/lib/definition-parser.ts

@@ -24,7 +24,6 @@ import {
   join,
   flatMap,
   unique,
-  unmangleScopedPackage,
   createModuleResolutionHost,
 } from "@definitelytyped/utils";
 import { TypeScriptVersion } from "@definitelytyped/typescript-versions";
@@ -71,7 +70,7 @@ export async function getTypingInfo(packageName: string, dt: FS): Promise<Typing
 
   const latestData: TypingsDataRaw = {
     libraryVersionDirectoryName: undefined,
-    ...(await combineDataForAllTypesVersions(packageName, rootDirectoryLs, fs, undefined, moduleResolutionHost)),
+    ...(await combineDataForAllTypesVersions(packageName, rootDirectoryLs, fs, moduleResolutionHost)),
   };
 
   const older = await Promise.all(
@@ -94,7 +93,6 @@ export async function getTypingInfo(packageName: string, dt: FS): Promise<Typing
           packageName,
           ls,
           fs.subDir(directoryName),
-          directoryVersion,
           moduleResolutionHost
         )),
       };
@@ -215,7 +213,6 @@ async function combineDataForAllTypesVersions(
   typingsPackageName: string,
   ls: readonly string[],
   fs: FS,
-  directoryVersion: DirectoryParsedTypingVersion | undefined,
   moduleResolutionHost: ts.ModuleResolutionHost
 ): Promise<Omit<TypingsDataRaw, "libraryVersionDirectoryName">> {
   const { remainingLs, typesVersions, hasPackageJson } = getTypesVersionsAndPackageJson(ls);
@@ -246,7 +243,6 @@ async function combineDataForAllTypesVersions(
     typingsPackageName,
     remainingLs,
     fs,
-    directoryVersion,
     moduleResolutionHost
   );
   const dataForOtherTypesVersions = typesVersions.map((tsVersion) => {
@@ -256,7 +252,6 @@ async function combineDataForAllTypesVersions(
       typingsPackageName,
       subFs.readdir(),
       subFs,
-      directoryVersion,
       moduleResolutionHost
     );
   });
@@ -322,7 +317,6 @@ function getTypingDataForSingleTypesVersion(
   packageName: string,
   ls: readonly string[],
   fs: FS,
-  directoryVersion: DirectoryParsedTypingVersion | undefined,
   moduleResolutionHost: ts.ModuleResolutionHost
 ): TypingDataFromIndividualTypeScriptVersion {
   const tsconfig = fs.readJson("tsconfig.json") as TsConfig;
@@ -339,7 +333,7 @@ function getTypingDataForSingleTypesVersion(
   ).options;
   checkFilesFromTsConfig(packageName, tsconfig, fs.debugPath());
 
-  const { types, tests, hasNonRelativeImports } = allReferencedFiles(
+  const { types, tests } = allReferencedFiles(
     tsconfig.files!,
     fs,
     packageName,
@@ -380,16 +374,6 @@ function getTypingDataForSingleTypesVersion(
     );
   }
 
-  const { paths } = tsconfig.compilerOptions;
-  const hydratedPackageName = unmangleScopedPackage(packageName) ?? packageName;
-  if (directoryVersion && hasNonRelativeImports && !(paths && `${hydratedPackageName}/*` in paths)) {
-    const mapping = JSON.stringify([`${packageName}/v${formatTypingVersion(directoryVersion)}/*`]);
-    throw new Error(
-      `${hydratedPackageName}: Older version ${formatTypingVersion(
-        directoryVersion
-      )} must have a "paths" entry of "${hydratedPackageName}/*": ${mapping}`
-    );
-  }
   return {
     typescriptVersion,
     globals: getDeclaredGlobals(types),

packages/definitions-parser/src/lib/module-info.ts

@@ -87,7 +87,7 @@ export function allReferencedFiles(
   packageName: string,
   moduleResolutionHost: ts.ModuleResolutionHost,
   compilerOptions: ts.CompilerOptions
-): { types: Map<string, ts.SourceFile>; tests: Map<string, ts.SourceFile>; hasNonRelativeImports: boolean } {
+): { types: Map<string, ts.SourceFile>; tests: Map<string, ts.SourceFile> } {
   const seenReferences = new Set<string>();
   const types = new Map<string, ts.SourceFile>();
   const tests = new Map<string, ts.SourceFile>();
@@ -99,9 +99,8 @@ export function allReferencedFiles(
     baseDirectory.lastIndexOf(`types/${getMangledNameForScopedPackage(packageName)}`) +
       `types/${getMangledNameForScopedPackage(packageName)}`.length
   );
-  let hasNonRelativeImports = false;
   entryFilenames.forEach((fileName) => recur(undefined, { text: fileName, kind: "path" }));
-  return { types, tests, hasNonRelativeImports };
+  return { types, tests };
 
   function recur(containingFileName: string | undefined, ref: Reference): void {
     // An absolute file name for use with TS resolution, e.g. '/DefinitelyTyped/types/foo/index.d.ts'
@@ -147,9 +146,8 @@ export function allReferencedFiles(
         tests.set(relativeFileName, src);
       }
 
-      const { refs, hasNonRelativeImports: result } = findReferencedFiles(src, packageName);
+      const refs = findReferencedFiles(src, packageName);
       refs.forEach((ref) => recur(resolvedFileName, ref));
-      hasNonRelativeImports = hasNonRelativeImports || result;
     }
   }
 
@@ -201,8 +199,6 @@ interface Reference {
  */
 function findReferencedFiles(src: ts.SourceFile, packageName: string) {
   const refs: Reference[] = [];
-  let hasNonRelativeImports = false;
-
   for (const ref of src.referencedFiles) {
     refs.push({
       text: ref.fileName,
@@ -221,10 +217,9 @@ function findReferencedFiles(src: ts.SourceFile, packageName: string) {
     const resolutionMode = ts.getModeForUsageLocation(src, ref);
     if (ref.text.startsWith(".") || getMangledNameForScopedPackage(ref.text).startsWith(packageName + "/")) {
       refs.push({ kind: "import", text: ref.text, resolutionMode });
-      hasNonRelativeImports = !ref.text.startsWith(".");
     }
   }
-  return { refs, hasNonRelativeImports };
+  return refs;
 }
 
 /**

packages/definitions-parser/src/packages.ts

@@ -1,6 +1,6 @@
 import assert = require("assert");
 import { Author } from "@definitelytyped/header-parser";
-import { FS, mapValues, assertSorted, unmangleScopedPackage, assertDefined, unique } from "@definitelytyped/utils";
+import { FS, mapValues, assertSorted, assertDefined, unique } from "@definitelytyped/utils";
 import { AllTypeScriptVersion, TypeScriptVersion } from "@definitelytyped/typescript-versions";
 import * as semver from "semver";
 import { readDataFile } from "./data-file";
@@ -195,10 +195,6 @@ export abstract class PackageBase {
   abstract readonly name: string;
   readonly libraryName: string;
 
-  get unescapedName(): string {
-    return unmangleScopedPackage(this.name) || this.name;
-  }
-
   /** Short description for debug output. */
   get desc(): string {
     return this.isLatest ? this.name : `${this.name} v${this.major}.${this.minor}`;

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

@@ -380,20 +380,6 @@ import route = require('@ember/routing/route');
 
         return expect(getTypingInfo("jquery", dt.fs)).resolves.toBeDefined();
       });
-
-      it("checks that older versions with non-relative imports have wildcard path mappings", () => {
-        const dt = createMockDT();
-        const jquery = dt.pkgDir("jquery");
-        jquery.set(
-          "JQuery.d.ts",
-          `import "jquery/component";
-`
-        );
-        dt.addOldVersionOfPackage("jquery", "1");
-        return expect(getTypingInfo("jquery", dt.fs)).rejects.toThrow(
-          'jquery: Older version 1 must have a "paths" entry of "jquery/*": ["jquery/v1/*"]'
-        );
-      });
     });
   });
 

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

@@ -152,19 +152,6 @@ describe(TypingsData, () => {
     expect(data.isNotNeeded()).toBe(false);
   });
 
-  describe("unescapedName", () => {
-    it("returns the name when unscoped", () => {
-      expect(data.unescapedName).toBe("known");
-    });
-
-    it("returns scoped names correctly", () => {
-      const versions = createTypingsVersionRaw("foo__bar", {}, {});
-      data = new TypingsData(versions["1.0"], true);
-
-      expect(data.unescapedName).toBe("@foo/bar");
-    });
-  });
-
   describe("desc", () => {
     it("returns the name if latest version", () => {
       expect(data.desc).toBe("known");

packages/utils/src/miscellany.ts

@@ -49,12 +49,6 @@ export function isScopedPackage(packageName: string): boolean {
   return packageName.startsWith("@");
 }
 
-// Based on `getPackageNameFromAtTypesDirectory` in TypeScript.
-export function unmangleScopedPackage(packageName: string): string | undefined {
-  const separator = "__";
-  return packageName.includes(separator) ? `@${packageName.replace(separator, "/")}` : undefined;
-}
-
 // Reverts unmangleScopedPackage.
 export function mangleScopedPackage(packageName: string): string {
   return isScopedPackage(packageName) ? packageName.replace(/\//, "__").replace("@", "") : packageName;

packages/utils/test/miscellany.test.ts

@@ -1,15 +0,0 @@
-import { unmangleScopedPackage } from "../src/miscellany";
-
-describe("miscellany", () => {
-  describe(unmangleScopedPackage, () => {
-    it("for unscoped package returns undefined", () => {
-      expect(unmangleScopedPackage("foobar")).toBeUndefined();
-      expect(unmangleScopedPackage("utils")).toBeUndefined();
-    });
-
-    it("for scoped package returns unmangled name", () => {
-      expect(unmangleScopedPackage("foo__bar")).toBe("@foo/bar");
-      expect(unmangleScopedPackage("definitelytyped__utils")).toBe("@definitelytyped/utils");
-    });
-  });
-});