@definitelytyped/definitions-parser 0.0.177 → 0.0.179

package/dist/lib/definition-parser.js

@@ -26,26 +26,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFileAndThrowOnBOM = exports.parsePackageVersion = exports.tryParsePackageVersion = exports.parseVersionFromDirectoryName = exports.getTypingInfo = void 0;
-const ts = __importStar(require("typescript"));
+exports.readFileAndThrowOnBOM = exports.parseVersionFromDirectoryName = exports.getTypingInfo = void 0;
 const header_parser_1 = require("@definitelytyped/header-parser");
-const module_info_1 = require("./module-info");
-const packages_1 = require("../packages");
-const settings_1 = require("./settings");
 const utils_1 = require("@definitelytyped/utils");
+const assert_1 = __importDefault(require("assert"));
 const path_1 = __importDefault(require("path"));
+const ts = __importStar(require("typescript"));
+const packages_1 = require("../packages");
+const module_info_1 = require("./module-info");
+const settings_1 = require("./settings");
+const utils_2 = require("./utils");
 function matchesVersion(typingsDataRaw, version, considerLibraryMinorVersion) {
-    return (typingsDataRaw.libraryMajorVersion === version.major &&
+    return (typingsDataRaw.header.libraryMajorVersion === version.major &&
         (considerLibraryMinorVersion
-            ? version.minor === undefined || typingsDataRaw.libraryMinorVersion === version.minor
+            ? version.minor === undefined || typingsDataRaw.header.libraryMinorVersion === version.minor
             : true));
 }
 function formattedLibraryVersion(typingsDataRaw) {
-    return `${typingsDataRaw.libraryMajorVersion}.${typingsDataRaw.libraryMinorVersion}`;
+    return `${typingsDataRaw.header.libraryMajorVersion}.${typingsDataRaw.header.libraryMinorVersion}`;
 }
 async function getTypingInfo(packageName, dt) {
+    const errors = [];
     if (packageName !== packageName.toLowerCase()) {
-        throw new Error(`Package name \`${packageName}\` should be strictly lowercase`);
+        errors.push(`Package name \`${packageName}\` should be strictly lowercase`);
     }
     const fs = dt.subDir("types").subDir((0, packages_1.getMangledNameForScopedPackage)(packageName));
     const [rootDirectoryLs, olderVersionDirectories] = (0, utils_1.split)(fs.readdir(), (fileOrDirectoryName) => {
@@ -54,37 +57,47 @@ async function getTypingInfo(packageName, dt) {
     });
     const moduleResolutionHost = (0, utils_1.createModuleResolutionHost)(dt, dt.debugPath());
     const considerLibraryMinorVersion = olderVersionDirectories.some(({ version }) => version.minor !== undefined);
-    const latestData = {
-        libraryVersionDirectoryName: undefined,
-        ...(await combineDataForAllTypesVersions(packageName, rootDirectoryLs, fs, undefined, moduleResolutionHost)),
-    };
+    const latestDataResult = await combineDataForAllTypesVersions(packageName, rootDirectoryLs, fs, moduleResolutionHost);
+    if (Array.isArray(latestDataResult)) {
+        return { errors: [...errors, ...latestDataResult] };
+    }
+    const latestData = { libraryVersionDirectoryName: undefined, ...latestDataResult };
     const older = await Promise.all(olderVersionDirectories.map(async ({ directoryName, version: directoryVersion }) => {
+        var _a;
         if (matchesVersion(latestData, directoryVersion, considerLibraryMinorVersion)) {
-            const latest = `${latestData.libraryMajorVersion}.${latestData.libraryMinorVersion}`;
-            throw new Error(`The latest version of the '${packageName}' package is ${latest}, so the subdirectory '${directoryName}' is not allowed` +
+            const latest = `${latestData.header.libraryMajorVersion}.${latestData.header.libraryMinorVersion}`;
+            errors.push(`The latest version of the '${packageName}' package is ${latest}, so the subdirectory '${directoryName}' is not allowed` +
                 (`v${latest}` === directoryName
                     ? "."
-                    : `; since it applies to any ${latestData.libraryMajorVersion}.* version, up to and including ${latest}.`));
+                    : `; since it applies to any ${latestData.header.libraryMajorVersion}.* version, up to and including ${latest}.`));
         }
         // tslint:disable-next-line:non-literal-fs-path -- Not a reference to the fs package
         const ls = fs.readdir(directoryName);
-        const data = {
-            libraryVersionDirectoryName: (0, packages_1.formatTypingVersion)(directoryVersion),
-            ...(await combineDataForAllTypesVersions(packageName, ls, fs.subDir(directoryName), directoryVersion, moduleResolutionHost)),
-        };
+        const result = await combineDataForAllTypesVersions(packageName, ls, fs.subDir(directoryName), moduleResolutionHost);
+        if (Array.isArray(result)) {
+            errors.push(...result);
+            return result;
+        }
+        const data = { libraryVersionDirectoryName: (0, packages_1.formatTypingVersion)(directoryVersion), ...result };
         if (!matchesVersion(data, directoryVersion, considerLibraryMinorVersion)) {
             if (considerLibraryMinorVersion) {
-                throw new Error(`Directory ${directoryName} indicates major.minor version ${directoryVersion.major}.${directoryVersion.minor}, ` +
-                    `but header indicates major.minor version ${data.libraryMajorVersion}.${data.libraryMinorVersion}`);
+                errors.push(`Directory ${directoryName} indicates major.minor version ${directoryVersion.major}.${(_a = directoryVersion.minor) !== null && _a !== void 0 ? _a : "*"}, ` +
+                    `but package.json indicates major.minor version ${data.header.libraryMajorVersion}.${data.header.libraryMinorVersion}`);
+            }
+            else {
+                errors.push(`Directory ${directoryName} indicates major version ${directoryVersion.major}, but package.json indicates major version ` +
+                    data.header.libraryMajorVersion.toString());
             }
-            throw new Error(`Directory ${directoryName} indicates major version ${directoryVersion.major}, but header indicates major version ` +
-                data.libraryMajorVersion.toString());
         }
         return data;
     }));
+    if (errors.length) {
+        return { errors };
+    }
     const res = {};
     res[formattedLibraryVersion(latestData)] = latestData;
     for (const o of older) {
+        (0, assert_1.default)(!Array.isArray(o));
         res[formattedLibraryVersion(o)] = o;
     }
     return res;
@@ -92,6 +105,7 @@ async function getTypingInfo(packageName, dt) {
 exports.getTypingInfo = getTypingInfo;
 const packageJsonName = "package.json";
 function getTypesVersionsAndPackageJson(ls) {
+    const errors = [];
     const withoutPackageJson = ls.filter((name) => name !== packageJsonName);
     const [remainingLs, typesVersions] = (0, utils_1.split)(withoutPackageJson, (fileOrDirectoryName) => {
         const match = /^ts(\d+\.\d+)$/.exec(fileOrDirectoryName);
@@ -100,11 +114,14 @@ function getTypesVersionsAndPackageJson(ls) {
         }
         const version = match[1];
         if (parseInt(version, 10) < 3) {
-            throw new Error(`Directory name starting with 'ts' should be a TypeScript version newer than 3.0. Got: ${version}`);
+            errors.push(`Directory name starting with 'ts' should be a TypeScript version newer than 3.0. Got: ${version}`);
         }
         return version;
     });
-    return { remainingLs, typesVersions, hasPackageJson: withoutPackageJson.length !== ls.length };
+    if (errors.length) {
+        return errors;
+    }
+    return { remainingLs, typesVersions };
 }
 /**
  * Parses a directory name into a version that either holds a single major version or a major and minor version.
@@ -127,84 +144,80 @@ function parseVersionFromDirectoryName(directoryName) {
     };
 }
 exports.parseVersionFromDirectoryName = parseVersionFromDirectoryName;
-/**
- * Like `parseVersionFromDirectoryName`, but the leading 'v' is optional,
- * and falls back to '*' if the input format is not parseable.
- */
-function tryParsePackageVersion(versionString) {
-    const match = /^v?(\d+)(\.(\d+))?$/.exec(versionString);
-    if (match === null) {
-        return "*";
+async function combineDataForAllTypesVersions(typingsPackageName, ls, fs, moduleResolutionHost) {
+    const errors = [];
+    const typesVersionAndPackageJson = getTypesVersionsAndPackageJson(ls);
+    if (Array.isArray(typesVersionAndPackageJson)) {
+        errors.push(...typesVersionAndPackageJson);
+    }
+    const { remainingLs, typesVersions } = Array.isArray(typesVersionAndPackageJson)
+        ? { remainingLs: [], typesVersions: [] }
+        : typesVersionAndPackageJson;
+    const packageJson = fs.readJson(packageJsonName);
+    const dataForRoot = getTypingDataForSingleTypesVersion(undefined, typingsPackageName, remainingLs, fs, moduleResolutionHost);
+    if (Array.isArray(dataForRoot)) {
+        errors.push(...dataForRoot);
     }
-    return {
-        major: Number(match[1]),
-        minor: match[3] !== undefined ? Number(match[3]) : undefined, // tslint:disable-line strict-type-predicates (false positive)
-    };
-}
-exports.tryParsePackageVersion = tryParsePackageVersion;
-/**
- * Like `tryParsePackageVersion`, but throws if the input format is not parseable.
- */
-function parsePackageVersion(versionString) {
-    const version = tryParsePackageVersion(versionString);
-    if (version === "*") {
-        throw new Error(`Version string '${versionString}' is not a valid format.`);
-    }
-    return version;
-}
-exports.parsePackageVersion = parsePackageVersion;
-async function combineDataForAllTypesVersions(typingsPackageName, ls, fs, directoryVersion, moduleResolutionHost) {
-    const { remainingLs, typesVersions, hasPackageJson } = getTypesVersionsAndPackageJson(ls);
-    const packageJson = hasPackageJson
-        ? fs.readJson(packageJsonName)
-        : {};
-    const packageJsonType = checkPackageJsonType(packageJson.type, packageJsonName);
-    // Every typesVersion has an index.d.ts, but only the root index.d.ts should have a header.
-    const { contributors, libraryMajorVersion, libraryMinorVersion, typeScriptVersion: minTsVersion, libraryName, projects, } = (0, header_parser_1.parseHeaderOrFail)(`${typingsPackageName} > index.d.ts`, readFileAndThrowOnBOM("index.d.ts", fs));
-    const dataForRoot = getTypingDataForSingleTypesVersion(undefined, typingsPackageName, remainingLs, fs, directoryVersion, moduleResolutionHost);
     const dataForOtherTypesVersions = typesVersions.map((tsVersion) => {
         const subFs = fs.subDir(`ts${tsVersion}`);
-        return getTypingDataForSingleTypesVersion(tsVersion, typingsPackageName, subFs.readdir(), subFs, directoryVersion, moduleResolutionHost);
+        const data = getTypingDataForSingleTypesVersion(tsVersion, typingsPackageName, subFs.readdir(), subFs, moduleResolutionHost);
+        if (Array.isArray(data)) {
+            errors.push(...data);
+        }
+        return data;
     });
+    const packageJsonType = (0, header_parser_1.checkPackageJsonType)(packageJson.type, packageJsonName);
+    if (Array.isArray(packageJsonType)) {
+        errors.push(...packageJsonType);
+    }
+    const packageJsonResult = (0, header_parser_1.validatePackageJson)(typingsPackageName, packageJson, typesVersions);
+    if (Array.isArray(packageJsonResult)) {
+        errors.push(...packageJsonResult);
+    }
+    const header = Array.isArray(packageJsonResult) ? undefined : packageJsonResult;
+    const allowedDependencies = await (0, settings_1.getAllowedPackageJsonDependencies)();
+    errors.push(...(0, header_parser_1.checkPackageJsonDependencies)(packageJson.dependencies, packageJsonName, allowedDependencies));
+    errors.push(...(0, header_parser_1.checkPackageJsonDependencies)(packageJson.devDependencies, packageJsonName, allowedDependencies, `@${settings_1.scopeName}/${typingsPackageName}`));
+    const imports = (0, header_parser_1.checkPackageJsonImports)(packageJson.imports, packageJsonName);
+    if (Array.isArray(imports)) {
+        errors.push(...imports);
+    }
+    const exports = (0, header_parser_1.checkPackageJsonExportsAndAddPJsonEntry)(packageJson.exports, packageJsonName);
+    if (Array.isArray(exports)) {
+        errors.push(...exports);
+    }
+    const license = (0, header_parser_1.getLicenseFromPackageJson)(packageJson.license);
+    if (Array.isArray(license)) {
+        errors.push(...license);
+    }
+    if (errors.length) {
+        return errors;
+    }
     const allTypesVersions = [dataForRoot, ...dataForOtherTypesVersions];
-    const license = (0, packages_1.getLicenseFromPackageJson)(packageJson.license);
-    const packageJsonDependencies = await checkPackageJsonDependencies(packageJson.dependencies, packageJsonName);
     const files = Array.from((0, utils_1.flatMap)(allTypesVersions, ({ typescriptVersion, declFiles }) => declFiles.map((file) => (typescriptVersion === undefined ? file : `ts${typescriptVersion}/${file}`))));
     // Note that only the first project is collected right now
     return {
-        libraryName,
-        typingsPackageName,
-        projectName: projects[0],
-        contributors,
-        libraryMajorVersion,
-        libraryMinorVersion,
-        minTsVersion,
+        header: (0, utils_1.assertDefined)(header),
         typesVersions,
         files,
-        license,
-        dependencies: Object.assign({}, ...allTypesVersions.map((v) => v.dependencies)),
-        testDependencies: getAllUniqueValues(allTypesVersions, "testDependencies"),
-        pathMappings: Object.assign({}, ...allTypesVersions.map((v) => v.pathMappings)),
-        packageJsonDependencies,
-        contentHash: hash(hasPackageJson ? [...files, packageJsonName] : files, (0, utils_1.mapDefined)(allTypesVersions, (a) => a.tsconfigPathsForHash), fs),
-        globals: getAllUniqueValues(allTypesVersions, "globals"),
-        declaredModules: getAllUniqueValues(allTypesVersions, "declaredModules"),
-        imports: checkPackageJsonImports(packageJson.imports, packageJsonName),
-        exports: checkPackageJsonExportsAndAddPJsonEntry(packageJson.exports, packageJsonName),
+        license: license,
+        dependencies: packageJson.dependencies,
+        devDependencies: packageJson.devDependencies,
+        contentHash: hash([...files, packageJsonName], (0, utils_1.mapDefined)(allTypesVersions, (a) => a.tsconfigPathsForHash), fs),
+        imports: imports,
+        exports: exports,
         type: packageJsonType,
     };
 }
-function getAllUniqueValues(records, key) {
-    return (0, utils_1.unique)((0, utils_1.flatMap)(records, (x) => x[key]));
-}
 /**
  * @param typescriptVersion Set if this is in e.g. a `ts3.1` directory.
  * @param packageName Name of the outermost directory; e.g. for "node/v4" this is just "node".
  * @param ls All file/directory names in `directory`.
  * @param fs FS rooted at the directory for this particular TS version, e.g. `types/abs/ts3.1` or `types/abs` when typescriptVersion is undefined.
  */
-function getTypingDataForSingleTypesVersion(typescriptVersion, packageName, ls, fs, directoryVersion, moduleResolutionHost) {
+function getTypingDataForSingleTypesVersion(typescriptVersion, packageName, ls, fs, moduleResolutionHost) {
     var _a;
+    const errors = [];
     const tsconfig = fs.readJson("tsconfig.json");
     const configHost = {
         ...moduleResolutionHost,
@@ -212,9 +225,9 @@ function getTypingDataForSingleTypesVersion(typescriptVersion, packageName, ls,
         useCaseSensitiveFileNames: true,
     };
     const compilerOptions = ts.parseJsonConfigFileContent(tsconfig, configHost, path_1.default.resolve("/", fs.debugPath())).options;
-    checkFilesFromTsConfig(packageName, tsconfig, fs.debugPath());
-    const { types, tests, hasNonRelativeImports } = (0, module_info_1.allReferencedFiles)(tsconfig.files, fs, packageName, moduleResolutionHost, compilerOptions);
-    const usedFiles = new Set([...types.keys(), ...tests.keys(), "tsconfig.json", "tslint.json"]);
+    errors.push(...checkFilesFromTsConfig(packageName, tsconfig, fs.debugPath()));
+    const { types, tests } = (0, module_info_1.allReferencedFiles)((_a = tsconfig.files) !== null && _a !== void 0 ? _a : [], fs, packageName, moduleResolutionHost, compilerOptions);
+    const usedFiles = new Set([...types.keys(), ...tests, "tsconfig.json", "tslint.json"].map((f) => (0, utils_2.slicePrefixes)(f, "node_modules/@types/" + packageName + "/")));
     const otherFiles = ls.includes(unusedFilesName)
         ? fs
             // tslint:disable-next-line:non-literal-fs-path -- Not a reference to the fs package
@@ -223,162 +236,53 @@ function getTypingDataForSingleTypesVersion(typescriptVersion, packageName, ls,
             .filter(Boolean)
         : [];
     if (ls.includes(unusedFilesName) && !otherFiles.length) {
-        throw new Error(`In ${packageName}: OTHER_FILES.txt is empty.`);
+        errors.push(`In ${packageName}: OTHER_FILES.txt is empty.`);
     }
     for (const file of otherFiles) {
         if (!isRelativePath(file)) {
-            throw new Error(`In ${packageName}: A path segment is empty or all dots ${file}`);
+            errors.push(`In ${packageName}: A path segment is empty or all dots ${file}`);
         }
     }
-    checkAllFilesUsed(ls, usedFiles, otherFiles, packageName, fs);
+    // Note: findAllUnusedFiles also modifies usedFiles and otherFiles and errors
+    const unusedFiles = findAllUnusedFiles(ls, usedFiles, otherFiles, errors, packageName, fs);
+    if (unusedFiles.length) {
+        errors.push("\n\t* " +
+            unusedFiles.map((unused) => `Unused file ${unused}`).join("\n\t* ") +
+            `\n\t(used files: ${JSON.stringify(Array.from(usedFiles))})`);
+    }
     for (const untestedTypeFile of (0, utils_1.filter)(otherFiles, (name) => name.endsWith(".d.ts") || name.endsWith(".d.mts") || name.endsWith(".d.cts"))) {
         // add d.ts files from OTHER_FILES.txt in order get their dependencies
         // tslint:disable-next-line:non-literal-fs-path -- Not a reference to the fs package
         types.set(untestedTypeFile, (0, module_info_1.createSourceFile)(untestedTypeFile, fs.readFile(untestedTypeFile), moduleResolutionHost, compilerOptions));
     }
-    const { dependencies: dependenciesWithDeclaredModules, globals, declaredModules } = (0, module_info_1.getModuleInfo)(packageName, types);
-    const declaredModulesSet = new Set(declaredModules);
-    // Don't count an import of "x" as a dependency if we saw `declare module "x"` somewhere.
-    const dependenciesSet = new Set([...dependenciesWithDeclaredModules]
-        .filter((m) => !declaredModulesSet.has(m))
-        .map((m) => rootName(m, types, packageName))
-        .filter((dependency) => dependency !== packageName));
-    const testDependencies = [
-        ...(0, module_info_1.getTestDependencies)(packageName, tests.keys(), dependenciesSet, fs, moduleResolutionHost, compilerOptions),
-    ]
-        .filter((m) => !declaredModulesSet.has(m))
-        .map((m) => rootName(m, types, packageName))
-        .filter((dependency) => dependency !== packageName);
-    const { paths } = tsconfig.compilerOptions;
-    const hydratedPackageName = (_a = (0, utils_1.unmangleScopedPackage)(packageName)) !== null && _a !== void 0 ? _a : packageName;
-    if (directoryVersion && hasNonRelativeImports && !(paths && `${hydratedPackageName}/*` in paths)) {
-        const mapping = JSON.stringify([`${packageName}/v${(0, packages_1.formatTypingVersion)(directoryVersion)}/*`]);
-        throw new Error(`${hydratedPackageName}: Older version ${(0, packages_1.formatTypingVersion)(directoryVersion)} must have a "paths" entry of "${hydratedPackageName}/*": ${mapping}`);
-    }
-    const { dependencies, pathMappings } = calculateDependencies(packageName, tsconfig, dependenciesSet, directoryVersion);
-    const tsconfigPathsForHash = JSON.stringify(tsconfig.compilerOptions.paths);
+    if (errors.length)
+        return errors;
     return {
         typescriptVersion,
-        dependencies,
-        testDependencies,
-        pathMappings,
-        globals,
-        declaredModules,
         declFiles: (0, utils_1.sort)(types.keys()),
-        tsconfigPathsForHash,
+        tsconfigPathsForHash: JSON.stringify(tsconfig.compilerOptions.paths),
     };
 }
-/**
- * "foo/bar/baz" -> "foo"; "@foo/bar/baz" -> "@foo/bar"
- * Note: Throws an error for references like
- * "bar/v3" because referencing old versions of *other* packages is illegal;
- * those directories won't exist in the published @types package.
- */
-function rootName(importText, typeFiles, packageName) {
-    let slash = importText.indexOf("/");
-    // Root of `@foo/bar/baz` is `@foo/bar`
-    if (importText.startsWith("@")) {
-        // Use second "/"
-        slash = importText.indexOf("/", slash + 1);
-    }
-    const root = importText.slice(0, slash);
-    const postImport = importText.slice(slash + 1);
-    if (slash > -1 && postImport.match(/v\d+$/) && !typeFiles.has(postImport + ".d.ts") && root !== packageName) {
-        throw new Error(`${importText}: do not directly import specific versions of another types package.
-You should work with the latest version of ${root} instead.`);
-    }
-    return slash === -1 ? importText : root;
-}
-function checkPackageJsonExportsAndAddPJsonEntry(exports, path) {
-    if (exports === undefined)
-        return exports;
-    if (typeof exports === "string") {
-        return exports;
-    }
-    if (typeof exports !== "object") {
-        throw new Error(`Package exports at path ${path} should be an object or string.`);
-    }
-    if (exports === null) {
-        throw new Error(`Package exports at path ${path} should not be null.`);
-    }
-    if (!exports["./package.json"]) {
-        exports["./package.json"] = "./package.json";
-    }
-    return exports;
-}
-function checkPackageJsonImports(imports, path) {
-    if (imports === undefined)
-        return imports;
-    if (typeof imports !== "object") {
-        throw new Error(`Package imports at path ${path} should be an object or string.`);
-    }
-    if (imports === null) {
-        throw new Error(`Package imports at path ${path} should not be null.`);
-    }
-    return imports;
-}
-function checkPackageJsonType(type, path) {
-    if (type === undefined)
-        return type;
-    if (type !== "module") {
-        throw new Error(`Package type at path ${path} can only be 'module'.`);
-    }
-    return type;
-}
-async function checkPackageJsonDependencies(dependencies, path) {
-    if (dependencies === undefined) {
-        // tslint:disable-line strict-type-predicates (false positive)
-        return [];
-    }
-    if (dependencies === null || typeof dependencies !== "object") {
-        // tslint:disable-line strict-type-predicates
-        throw new Error(`${path} should contain "dependencies" or not exist.`);
-    }
-    const deps = [];
-    for (const dependencyName of Object.keys(dependencies)) {
-        // `dependencies` cannot be null because of check above.
-        if (!(await (0, settings_1.getAllowedPackageJsonDependencies)()).has(dependencyName)) {
-            const msg = dependencyName.startsWith("@types/")
-                ? `Dependency ${dependencyName} not in the allowed dependencies list.
-Don't use a 'package.json' for @types dependencies unless this package relies on
-an old version of types that have since been moved to the source repo.
-For example, if package *P* used to have types on Definitely Typed at @types/P,
-but now has its own types, a dependent package *D* will need to use package.json
-to refer to @types/P if it relies on old versions of P's types.
-In this case, please make a pull request to microsoft/DefinitelyTyped-tools adding @types/P to \`packages/definitions-parser/allowedPackageJsonDependencies.txt\`.`
-                : `Dependency ${dependencyName} not in the allowed dependencies list.
-If you are depending on another \`@types\` package, do *not* add it to a \`package.json\`. Path mapping should make the import work.
-For namespaced dependencies you then have to add a \`paths\` mapping from \`@namespace/*\` to \`namespace__*\` in \`tsconfig.json\`.
-If this is an external library that provides typings,  please make a pull request to microsoft/DefinitelyTyped-tools adding it to \`packages/definitions-parser/allowedPackageJsonDependencies.txt\`.`;
-            throw new Error(`In ${path}: ${msg}`);
-        }
-        const version = dependencies[dependencyName];
-        if (typeof version !== "string") {
-            // tslint:disable-line strict-type-predicates
-            throw new Error(`In ${path}: Dependency version for ${dependencyName} should be a string.`);
-        }
-        deps.push({ name: dependencyName, version });
-    }
-    return deps;
-}
 function checkFilesFromTsConfig(packageName, tsconfig, directoryPath) {
+    const errors = [];
     const tsconfigPath = `${directoryPath}/tsconfig.json`;
     if (tsconfig.include) {
-        throw new Error(`In tsconfig, don't use "include", must use "files"`);
+        errors.push(`In tsconfig, don't use "include", must use "files"`);
     }
     const files = tsconfig.files;
     if (!files) {
-        throw new Error(`${tsconfigPath} needs to specify  "files"`);
+        errors.push(`${tsconfigPath} needs to specify  "files"`);
+        return errors;
     }
     for (const file of files) {
         if (file.startsWith("./")) {
-            throw new Error(`In ${tsconfigPath}: Unnecessary "./" at the start of ${file}`);
+            errors.push(`In ${tsconfigPath}: Unnecessary "./" at the start of ${file}`);
         }
         if (!isRelativePath(file)) {
-            throw new Error(`In ${tsconfigPath}: A path segment is empty or all dots ${file}`);
+            errors.push(`In ${tsconfigPath}: A path segment is empty or all dots ${file}`);
         }
         if (file.endsWith(".d.ts") && file !== "index.d.ts") {
-            throw new Error(`${packageName}: Only index.d.ts may be listed explicitly in tsconfig's "files" entry.
+            errors.push(`${packageName}: Only index.d.ts may be listed explicitly in tsconfig's "files" entry.
 Other d.ts files must either be referenced through index.d.ts, tests, or added to OTHER_FILES.txt.`);
         }
         if (!file.endsWith(".d.ts") && !file.startsWith("test/")) {
@@ -388,136 +292,15 @@ Other d.ts files must either be referenced through index.d.ts, tests, or added t
                     ? `Expected file '${file}' to be named '${expectedName}' or to be inside a '${directoryPath}/test/' directory`
                     : `Unexpected file extension for '${file}' -- expected '.ts' or '.tsx' (maybe this should not be in "files", but ` +
                         "OTHER_FILES.txt)";
-                throw new Error(message);
+                errors.push(message);
             }
         }
     }
+    return errors;
 }
 function isRelativePath(path) {
     return path.split(/\//).every((part) => part.length > 0 && !part.match(/^\.+$|[\\\n\r]/));
 }
-function calculateDependencies(packageName, tsconfig, dependencyNames, directoryVersion) {
-    var _a;
-    const paths = (tsconfig.compilerOptions && tsconfig.compilerOptions.paths) || {};
-    const dependencies = {};
-    const pathMappings = {};
-    const scopedPackageName = (_a = (0, utils_1.unmangleScopedPackage)(packageName)) !== null && _a !== void 0 ? _a : packageName;
-    for (const dependencyName of Object.keys(paths)) {
-        const pathMappingList = paths[dependencyName];
-        if (pathMappingList.length !== 1) {
-            throw new Error(`In ${packageName}: Path mapping for ${dependencyName} may only have 1 entry.`);
-        }
-        const pathMapping = pathMappingList[0];
-        if (pathMapping === "./node_modules/" + dependencyName) {
-            // allow passthrough remappings for packages like webpack that have shipped their own types,
-            // but have some dependents on DT that depend on the new types and some that depend on the old types
-            continue;
-        }
-        // Path mapping may be for "@foo/*" -> "foo__*".
-        const unversionedScopedPackageName = (0, utils_1.removeVersionFromPackageName)((0, utils_1.unmangleScopedPackage)(pathMapping));
-        if (unversionedScopedPackageName !== undefined) {
-            if (dependencyName !== unversionedScopedPackageName) {
-                throw new Error(`Expected directory ${pathMapping} to be the path mapping for ${dependencyName}`);
-            }
-            if (!(0, utils_1.hasVersionNumberInMapping)(pathMapping)) {
-                continue;
-            }
-        }
-        // Might have a path mapping for "foo/*" to support subdirectories
-        const rootDirectory = withoutEnd(dependencyName, "/*");
-        if (rootDirectory !== undefined) {
-            if (!(rootDirectory in paths)) {
-                throw new Error(`In ${packageName}: found path mapping for ${dependencyName} but not for ${rootDirectory}`);
-            }
-            continue;
-        }
-        // buffer -> node/buffer may be required because of the non-node 'buffer' package on npm
-        // which DT infrastructure depends on, and which resolves before node's ambient module 'buffer'
-        if (dependencyName === "buffer" && pathMapping === "node/buffer") {
-            dependencies.node = "*";
-            continue;
-        }
-        const pathMappingVersion = parseDependencyVersionFromPath(dependencyName, dependencyName, pathMapping);
-        if (dependencyName === packageName) {
-            if (directoryVersion === undefined) {
-                throw new Error(`In ${packageName}: Latest version of a package should not have a path mapping for itself.`);
-            }
-            if (directoryVersion.major !== pathMappingVersion.major || directoryVersion.minor !== pathMappingVersion.minor) {
-                const correctPathMapping = [`${dependencyName}/v${(0, packages_1.formatTypingVersion)(directoryVersion)}`];
-                throw new Error(`In ${packageName}: Must have a "paths" entry of "${dependencyName}": ${JSON.stringify(correctPathMapping)}`);
-            }
-        }
-        else {
-            if (dependencyNames.has(dependencyName)) {
-                dependencies[dependencyName] = pathMappingVersion;
-            }
-        }
-        // Else, the path mapping may be necessary if it is for a transitive dependency. We will check this in check-parse-results.
-        pathMappings[dependencyName] = pathMappingVersion;
-    }
-    if (directoryVersion !== undefined && !(paths && scopedPackageName in paths)) {
-        const mapping = JSON.stringify([`${packageName}/v${(0, packages_1.formatTypingVersion)(directoryVersion)}`]);
-        throw new Error(`${scopedPackageName}: Older version ${(0, packages_1.formatTypingVersion)(directoryVersion)} must have a "paths" entry of "${scopedPackageName}": ${mapping}`);
-    }
-    for (const dependency of dependencyNames) {
-        if (!dependencies[dependency] && !nodeBuiltins.has(dependency)) {
-            dependencies[dependency] = "*";
-        }
-    }
-    return { dependencies, pathMappings };
-}
-const nodeBuiltins = new Set([
-    "assert",
-    "async_hooks",
-    "buffer",
-    "child_process",
-    "cluster",
-    "console",
-    "constants",
-    "crypto",
-    "dgram",
-    "dns",
-    "domain",
-    "events",
-    "fs",
-    "http",
-    "http2",
-    "https",
-    "module",
-    "net",
-    "os",
-    "path",
-    "perf_hooks",
-    "process",
-    "punycode",
-    "querystring",
-    "readline",
-    "repl",
-    "stream",
-    "string_decoder",
-    "timers",
-    "tls",
-    "tty",
-    "url",
-    "util",
-    "v8",
-    "vm",
-    "zlib",
-]);
-function parseDependencyVersionFromPath(packageName, dependencyName, dependencyPath) {
-    const versionString = (0, utils_1.withoutStart)(dependencyPath, `${(0, utils_1.mangleScopedPackage)(dependencyName)}/`);
-    const version = versionString === undefined ? undefined : parseVersionFromDirectoryName(versionString);
-    if (version === undefined) {
-        throw new Error(`In ${packageName}, unexpected path mapping for ${dependencyName}: '${dependencyPath}'`);
-    }
-    return version;
-}
-function withoutEnd(s, end) {
-    if (s.endsWith(end)) {
-        return s.slice(0, s.length - end.length);
-    }
-    return undefined;
-}
 function hash(files, tsconfigPathsForHash, fs) {
     const fileContents = files.map((f) => `${f}**${readFileAndThrowOnBOM(f, fs)}`);
     let allContent = fileContents.join("||");
@@ -537,22 +320,24 @@ function readFileAndThrowOnBOM(fileName, fs) {
 }
 exports.readFileAndThrowOnBOM = readFileAndThrowOnBOM;
 const unusedFilesName = "OTHER_FILES.txt";
-function checkAllFilesUsed(ls, usedFiles, otherFiles, packageName, fs) {
+/** Modifies usedFiles and otherFiles and errors */
+function findAllUnusedFiles(ls, usedFiles, otherFiles, errors, packageName, fs) {
     // Double-check that no windows "\\" broke in.
     for (const fileName of usedFiles) {
         if ((0, utils_1.hasWindowsSlashes)(fileName)) {
-            throw new Error(`In ${packageName}: windows slash detected in ${fileName}`);
+            errors.push(`In ${packageName}: windows slash detected in ${fileName}`);
         }
     }
-    checkAllUsedRecur(new Set(ls), usedFiles, new Set(otherFiles), fs);
+    return findAllUnusedRecur(new Set(ls), usedFiles, new Set(otherFiles), errors, fs);
 }
-function checkAllUsedRecur(ls, usedFiles, unusedFiles, fs) {
+function findAllUnusedRecur(ls, usedFiles, otherFiles, errors, fs) {
+    const unused = [];
     for (const lsEntry of ls) {
         if (usedFiles.has(lsEntry)) {
             continue;
         }
-        if (unusedFiles.has(lsEntry)) {
-            unusedFiles.delete(lsEntry);
+        if (otherFiles.has(lsEntry)) {
+            otherFiles.delete(lsEntry);
             continue;
         }
         if (fs.isDirectory(lsEntry)) {
@@ -563,8 +348,7 @@ function checkAllUsedRecur(ls, usedFiles, unusedFiles, fs) {
             }
             const lssubdir = subdir.readdir();
             if (lssubdir.length === 0) {
-                // tslint:disable-next-line strict-string-expressions
-                throw new Error(`Empty directory ${subdir.debugPath()} (${(0, utils_1.join)(usedFiles)})`);
+                errors.push(`Empty directory ${subdir.debugPath()} (${(0, utils_1.join)(usedFiles)})`);
             }
             function takeSubdirectoryOutOfSet(originalSet) {
                 const subdirSet = new Set();
@@ -577,7 +361,7 @@ function checkAllUsedRecur(ls, usedFiles, unusedFiles, fs) {
                 }
                 return subdirSet;
             }
-            checkAllUsedRecur(lssubdir, takeSubdirectoryOutOfSet(usedFiles), takeSubdirectoryOutOfSet(unusedFiles), subdir);
+            findAllUnusedRecur(lssubdir, takeSubdirectoryOutOfSet(usedFiles), takeSubdirectoryOutOfSet(otherFiles), errors, subdir);
         }
         else {
             if (lsEntry.toLowerCase() !== "readme.md" &&
@@ -585,15 +369,16 @@ function checkAllUsedRecur(ls, usedFiles, unusedFiles, fs) {
                 lsEntry !== ".editorconfig" &&
                 lsEntry !== ".eslintrc.json" &&
                 lsEntry !== unusedFilesName) {
-                throw new Error(`Unused file ${fs.debugPath()}/${lsEntry} (used files: ${JSON.stringify(Array.from(usedFiles))})`);
+                unused.push(`${fs.debugPath()}/${lsEntry}`);
             }
         }
     }
-    for (const unusedFile of unusedFiles) {
-        if (usedFiles.has(unusedFile)) {
-            throw new Error(`File ${fs.debugPath()}${unusedFile} listed in ${unusedFilesName} is already reachable from tsconfig.json.`);
+    for (const otherFile of otherFiles) {
+        if (usedFiles.has(otherFile)) {
+            errors.push(`File ${fs.debugPath()}${otherFile} listed in ${unusedFilesName} is already reachable from tsconfig.json.`);
         }
-        throw new Error(`File ${fs.debugPath()}/${unusedFile} listed in ${unusedFilesName} does not exist.`);
+        errors.push(`File ${fs.debugPath()}/${otherFile} listed in ${unusedFilesName} does not exist.`);
     }
+    return unused;
 }
 //# sourceMappingURL=definition-parser.js.map