@definitelytyped/dtslint 0.0.182 → 0.0.184

package/src/index.ts

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 
-import { parseTypeScriptVersionLine } from "@definitelytyped/header-parser";
 import { AllTypeScriptVersion, TypeScriptVersion } from "@definitelytyped/typescript-versions";
 import assert = require("assert");
-import { readdir, readFile, stat, existsSync } from "fs-extra";
+import { readFile, existsSync } from "fs-extra";
 import { basename, dirname, join as joinPaths, resolve } from "path";
 
 import { cleanTypeScriptInstalls, installAllTypeScriptVersions, installTypeScriptNext } from "@definitelytyped/utils";
 import { checkPackageJson, checkTsconfig } from "./checks";
 import { checkTslintJson, lint, TsVersion } from "./lint";
-import { getCompilerOptions, mapDefinedAsync, withoutPrefix } from "./util";
+import { getCompilerOptions, packageNameFromPath } from "./util";
+import { getTypesVersions } from "@definitelytyped/header-parser";
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
@@ -130,50 +130,23 @@ async function runTests(
   expectOnly: boolean,
   tsLocal: string | undefined
 ): Promise<void> {
-  const isOlderVersion = /^v(0\.)?\d+$/.test(basename(dirPath));
+  // Assert that we're really on DefinitelyTyped.
+  const dtRoot = findDTRoot(dirPath);
+  const packageName = packageNameFromPath(dirPath);
+  assertPathIsInDefinitelyTyped(dirPath, dtRoot);
+  assertPathIsNotBanned(packageName);
+  assertPackageIsNotDeprecated(packageName, await readFile(joinPaths(dtRoot, "notNeededPackages.json"), "utf-8"));
 
-  const indexText = await readFile(joinPaths(dirPath, "index.d.ts"), "utf-8");
-  // If this *is* on DefinitelyTyped, types-publisher will fail if it can't parse the header.
-  const dt = indexText.includes("// Type definitions for");
-  if (dt) {
-    // Someone may have copied text from DefinitelyTyped to their type definition and included a header,
-    // so assert that we're really on DefinitelyTyped.
-    const dtRoot = findDTRoot(dirPath);
-    const packageName = basename(dirPath);
-    assertPathIsInDefinitelyTyped(dirPath, dtRoot);
-    assertPathIsNotBanned(packageName);
-    assertPackageIsNotDeprecated(packageName, await readFile(joinPaths(dtRoot, "notNeededPackages.json"), "utf-8"));
+  const typesVersions = getTypesVersions(dirPath);
+  const packageJson = checkPackageJson(dirPath, typesVersions);
+  if (Array.isArray(packageJson)) {
+    throw new Error("\n\t* " + packageJson.join("\n\t* "));
   }
 
-  const typesVersions = await mapDefinedAsync(await readdir(dirPath), async (name) => {
-    if (name === "tsconfig.json" || name === "tslint.json" || name === "tsutils") {
-      return undefined;
-    }
-    const version = withoutPrefix(name, "ts");
-    if (version === undefined || !(await stat(joinPaths(dirPath, name))).isDirectory()) {
-      return undefined;
-    }
-
-    if (!TypeScriptVersion.isTypeScriptVersion(version)) {
-      throw new Error(`There is an entry named ${name}, but ${version} is not a valid TypeScript version.`);
-    }
-    if (!TypeScriptVersion.isRedirectable(version)) {
-      throw new Error(`At ${dirPath}/${name}: TypeScript version directories only available starting with ts3.1.`);
-    }
-    return version;
-  });
-
-  if (dt) {
-    await checkPackageJson(dirPath, typesVersions);
-  }
-
-  const minVersion = maxVersion(
-    getMinimumTypeScriptVersionFromComment(indexText),
-    TypeScriptVersion.lowest
-  ) as TypeScriptVersion;
+  const minVersion = maxVersion(packageJson.minimumTypeScriptVersion, TypeScriptVersion.lowest);
   if (onlyTestTsNext || tsLocal) {
     const tsVersion = tsLocal ? "local" : TypeScriptVersion.latest;
-    await testTypesVersion(dirPath, tsVersion, tsVersion, isOlderVersion, dt, expectOnly, tsLocal, /*isLatest*/ true);
+    await testTypesVersion(dirPath, tsVersion, tsVersion, expectOnly, tsLocal, /*isLatest*/ true);
   } else {
     // For example, typesVersions of [3.2, 3.5, 3.6] will have
     // associated ts3.2, ts3.5, ts3.6 directories, for
@@ -194,18 +167,14 @@ async function runTests(
       if (lows.length > 1) {
         console.log("testing from", low, "to", hi, "in", versionPath);
       }
-      await testTypesVersion(versionPath, low, hi, isOlderVersion, dt, expectOnly, undefined, isLatest);
+      await testTypesVersion(versionPath, low, hi, expectOnly, undefined, isLatest);
     }
   }
 }
 
-function maxVersion(v1: TypeScriptVersion | undefined, v2: TypeScriptVersion): TypeScriptVersion;
-function maxVersion(v1: AllTypeScriptVersion | undefined, v2: AllTypeScriptVersion): AllTypeScriptVersion;
-function maxVersion(v1: AllTypeScriptVersion | undefined, v2: AllTypeScriptVersion) {
-  if (!v1) return v2;
-  if (!v2) return v1;
-  if (parseFloat(v1) >= parseFloat(v2)) return v1;
-  return v2;
+function maxVersion(v1: AllTypeScriptVersion, v2: TypeScriptVersion): TypeScriptVersion {
+  // Note: For v1 to be later than v2, it must be a current Typescript version. So the type assertion is safe.
+  return parseFloat(v1) >= parseFloat(v2) ? (v1 as TypeScriptVersion) : v2;
 }
 
 function next(v: TypeScriptVersion): TypeScriptVersion {
@@ -219,17 +188,15 @@ async function testTypesVersion(
   dirPath: string,
   lowVersion: TsVersion,
   hiVersion: TsVersion,
-  isOlderVersion: boolean,
-  dt: boolean,
   expectOnly: boolean,
   tsLocal: string | undefined,
   isLatest: boolean
 ): Promise<void> {
-  await checkTslintJson(dirPath, dt);
-  checkTsconfig(
-    await getCompilerOptions(dirPath),
-    dt ? { relativeBaseUrl: ".." + (isOlderVersion ? "/.." : "") + (isLatest ? "" : "/..") + "/" } : undefined
-  );
+  checkTslintJson(dirPath);
+  const tsconfigErrors = checkTsconfig(dirPath, getCompilerOptions(dirPath));
+  if (tsconfigErrors.length > 0) {
+    throw new Error("\n\t* " + tsconfigErrors.join("\n\t* "));
+  }
   const err = await lint(dirPath, lowVersion, hiVersion, isLatest, expectOnly, tsLocal);
   if (err) {
     throw new Error(err);
@@ -288,20 +255,7 @@ If you want to re-add @types/${packageName}, please remove its entry from notNee
   }
 }
 
-function getMinimumTypeScriptVersionFromComment(text: string): AllTypeScriptVersion | undefined {
-  const match = text.match(/\/\/ (?:Minimum )?TypeScript Version: /);
-  if (!match) {
-    return undefined;
-  }
-
-  let line = text.slice(match.index, text.indexOf("\n", match.index));
-  if (line.endsWith("\r")) {
-    line = line.slice(0, line.length - 1);
-  }
-  return parseTypeScriptVersionLine(line);
-}
-
-if (!module.parent) {
+if (require.main === module) {
   main().catch((err) => {
     console.error(err.stack);
     process.exit(1);

package/src/lint.ts

@@ -1,8 +1,8 @@
 import { TypeScriptVersion } from "@definitelytyped/typescript-versions";
-import { typeScriptPath } from "@definitelytyped/utils";
+import { typeScriptPath, withoutStart } from "@definitelytyped/utils";
 import assert = require("assert");
-import { pathExists } from "fs-extra";
-import { dirname, join as joinPaths, normalize } from "path";
+import { pathExistsSync } from "fs-extra";
+import { join as joinPaths, normalize } from "path";
 import { Configuration, Linter } from "tslint";
 import { ESLint } from "eslint";
 import * as TsType from "typescript";
@@ -10,7 +10,7 @@ type Configuration = typeof Configuration;
 type IConfigurationFile = Configuration.IConfigurationFile;
 
 import { getProgram, Options as ExpectOptions } from "./rules/expectRule";
-import { readJson, withoutPrefix } from "./util";
+import { readJson } from "./util";
 
 export async function lint(
   dirPath: string,
@@ -37,7 +37,7 @@ export async function lint(
   const configPath = expectOnly ? joinPaths(__dirname, "..", "dtslint-expect-only.json") : getConfigPath(dirPath);
   // TODO: To port expect-rule, eslint's config will also need to include [minVersion, maxVersion]
   //   Also: expect-rule should be renamed to expect-type or check-type or something
-  const config = await getLintConfig(configPath, tsconfigPath, minVersion, maxVersion, tsLocal);
+  const config = getLintConfig(configPath, tsconfigPath, minVersion, maxVersion, tsLocal);
   const esfiles = [];
 
   for (const file of lintProgram.getSourceFiles()) {
@@ -108,15 +108,12 @@ function testDependencies(
     (d) => d.code === 2307 && d.messageText.toString().includes("Cannot find module")
   );
   if (cannotFindDepsDiags && cannotFindDepsDiags.file) {
-    const path = cannotFindDepsDiags.file.fileName;
-    const typesFolder = dirname(path);
-
     return `
-A module look-up failed, this often occurs when you need to run \`npm install\` on a dependent module before you can lint.
+A module look-up failed, this often occurs when you need to run \`pnpm install\` on a dependent module before you can lint.
 
 Before you debug, first try running:
 
-   npm install --prefix ${typesFolder}
+   pnpm install -w --filter '...{./types/${dirPath}}...'
 
 Then re-run. Full error logs are below.
 
@@ -140,7 +137,7 @@ function normalizePath(file: string) {
 function isTypesVersionPath(fileName: string, dirPath: string) {
   const normalFileName = normalizePath(fileName);
   const normalDirPath = normalizePath(dirPath);
-  const subdirPath = withoutPrefix(normalFileName, normalDirPath);
+  const subdirPath = withoutStart(normalFileName, normalDirPath);
   return subdirPath && /^\/ts\d+\.\d/.test(subdirPath);
 }
 
@@ -179,25 +176,14 @@ function testNoLintDisables(disabler: "tslint:disable" | "eslint-disable", text:
   }
 }
 
-export async function checkTslintJson(dirPath: string, dt: boolean): Promise<void> {
+export function checkTslintJson(dirPath: string): void {
   const configPath = getConfigPath(dirPath);
-  const shouldExtend = `@definitelytyped/dtslint/${dt ? "dt" : "dtslint"}.json`;
-  const validateExtends = (extend: string | string[]) =>
-    extend === shouldExtend || (!dt && Array.isArray(extend) && extend.some((val) => val === shouldExtend));
-
-  if (!(await pathExists(configPath))) {
-    if (dt) {
-      throw new Error(
-        `On DefinitelyTyped, must include \`tslint.json\` containing \`{ "extends": "${shouldExtend}" }\`.\n` +
-          "This was inferred as a DefinitelyTyped package because it contains a `// Type definitions for` header."
-      );
-    }
-    return;
+  const shouldExtend = "@definitelytyped/dtslint/dt.json";
+  if (!pathExistsSync(configPath)) {
+    throw new Error(`Missing \`tslint.json\` that contains \`{ "extends": "${shouldExtend}" }\`.`);
   }
-
-  const tslintJson = await readJson(configPath);
-  if (!validateExtends(tslintJson.extends)) {
-    throw new Error(`If 'tslint.json' is present, it should extend "${shouldExtend}"`);
+  if (readJson(configPath).extends !== shouldExtend) {
+    throw new Error(`'tslint.json' must extend "${shouldExtend}"`);
   }
 }
 
@@ -205,14 +191,14 @@ function getConfigPath(dirPath: string): string {
   return joinPaths(dirPath, "tslint.json");
 }
 
-async function getLintConfig(
+function getLintConfig(
   expectedConfigPath: string,
   tsconfigPath: string,
   minVersion: TsVersion,
   maxVersion: TsVersion,
   tsLocal: string | undefined
-): Promise<IConfigurationFile> {
-  const configExists = await pathExists(expectedConfigPath);
+): IConfigurationFile {
+  const configExists = pathExistsSync(expectedConfigPath);
   const configPath = configExists ? expectedConfigPath : joinPaths(__dirname, "..", "dtslint.json");
   // Second param to `findConfiguration` doesn't matter, since config path is provided.
   const config = Configuration.findConfiguration(configPath, "").results;

package/src/rules/npmNamingRule.ts

@@ -172,13 +172,6 @@ function toCriticOptions(options: ConfigOptions): Options {
 
 function walk(ctx: Lint.WalkContext<CriticOptions>): void {
   const { sourceFile } = ctx;
-  const { text } = sourceFile;
-  const lookFor = (search: string, explanation: string) => {
-    const idx = text.indexOf(search);
-    if (idx !== -1) {
-      ctx.addFailureAt(idx, search.length, failure(Rule.metadata.ruleName, explanation));
-    }
-  };
   if (isMainFile(sourceFile.fileName, /*allowNested*/ false)) {
     try {
       const optionsWithSuggestions = toOptionsWithSuggestions(ctx.options);
@@ -189,8 +182,6 @@ function walk(ctx: Lint.WalkContext<CriticOptions>): void {
           case ErrorKind.NoMatchingNpmPackage:
           case ErrorKind.NoMatchingNpmVersion:
           case ErrorKind.NonNpmHasMatchingPackage:
-            lookFor("// Type definitions for", errorMessage(error, ctx.options));
-            break;
           case ErrorKind.DtsPropertyNotInJs:
           case ErrorKind.DtsSignatureNotInJs:
           case ErrorKind.JsPropertyNotInDts:

package/src/updateConfig.ts

@@ -245,6 +245,6 @@ function disableRules(allFailures: RuleFailure[]): Config.RawRulesConfig {
   return newRulesConfig;
 }
 
-if (!module.parent) {
+if (require.main === module) {
   main();
 }

package/src/util.ts

@@ -1,11 +1,15 @@
 import assert = require("assert");
-import { pathExists, readFile } from "fs-extra";
+import { pathExistsSync, readFileSync } from "fs-extra";
 import { basename, dirname, join } from "path";
 import stripJsonComments = require("strip-json-comments");
 import * as ts from "typescript";
 
-export async function readJson(path: string) {
-  const text = await readFile(path, "utf-8");
+export function packageNameFromPath(path: string): string {
+  const base = basename(path);
+  return /^v\d+(\.\d+)?$/.exec(base) || /^ts\d\.\d/.exec(base) ? basename(dirname(path)) : base;
+}
+export function readJson(path: string) {
+  const text = readFileSync(path, "utf-8");
   return JSON.parse(stripJsonComments(text));
 }
 
@@ -13,16 +17,12 @@ export function failure(ruleName: string, s: string): string {
   return `${s} See: https://github.com/microsoft/DefinitelyTyped-tools/blob/master/packages/dtslint/docs/${ruleName}.md`;
 }
 
-export async function getCompilerOptions(dirPath: string): Promise<ts.CompilerOptions> {
+export function getCompilerOptions(dirPath: string): ts.CompilerOptions {
   const tsconfigPath = join(dirPath, "tsconfig.json");
-  if (!(await pathExists(tsconfigPath))) {
+  if (!pathExistsSync(tsconfigPath)) {
     throw new Error(`Need a 'tsconfig.json' file in ${dirPath}`);
   }
-  return (await readJson(tsconfigPath)).compilerOptions;
-}
-
-export function withoutPrefix(s: string, prefix: string): string | undefined {
-  return s.startsWith(prefix) ? s.slice(prefix.length) : undefined;
+  return readJson(tsconfigPath).compilerOptions as ts.CompilerOptions;
 }
 
 export function last<T>(a: readonly T[]): T {
@@ -30,17 +30,6 @@ export function last<T>(a: readonly T[]): T {
   return a[a.length - 1];
 }
 
-export async function mapDefinedAsync<T, U>(arr: Iterable<T>, mapper: (t: T) => Promise<U | undefined>): Promise<U[]> {
-  const out = [];
-  for (const a of arr) {
-    const res = await mapper(a);
-    if (res !== undefined) {
-      out.push(res);
-    }
-  }
-  return out;
-}
-
 export function isMainFile(fileName: string, allowNested: boolean) {
   // Linter may be run with cwd of the package. We want `index.d.ts` but not `submodule/index.d.ts` to match.
   if (fileName === "index.d.ts") {

package/test/index.test.ts

@@ -37,43 +37,112 @@ describe("dtslint", () => {
     noImplicitThis: true,
     strictNullChecks: true,
     strictFunctionTypes: true,
-    baseUrl: "../",
-    typeRoots: ["../"],
     types: [],
     noEmit: true,
     forceConsistentCasingInFileNames: true,
   };
   describe("checks", () => {
-    it("disallows unknown compiler options", () => {
-      expect(() => checkTsconfig({ ...base, completelyInvented: true }, { relativeBaseUrl: "../" })).toThrow(
-        "Unexpected compiler option completelyInvented"
-      );
+    describe("checkTsconfig", () => {
+      it("disallows unknown compiler options", () => {
+        expect(checkTsconfig("test", { ...base, completelyInvented: true })).toEqual([
+          "Unexpected compiler option completelyInvented",
+        ]);
+      });
+      it("allows exactOptionalPropertyTypes: true", () => {
+        expect(checkTsconfig("test", { ...base, exactOptionalPropertyTypes: true })).toEqual([]);
+      });
+      it("allows module: node16", () => {
+        expect(checkTsconfig("test", { ...base, module: "node16" })).toEqual([]);
+      });
+      it("allows `paths`", () => {
+        expect(checkTsconfig("test", { ...base, paths: { boom: ["../boom/index.d.ts"] } })).toEqual([]);
+      });
+      it("disallows missing `module`", () => {
+        const options = { ...base };
+        delete options.module;
+        expect(checkTsconfig("test", options)).toEqual([
+          'Must specify "module" to `"module": "commonjs"` or `"module": "node16"`.',
+        ]);
+      });
+      it("disallows exactOptionalPropertyTypes: false", () => {
+        expect(checkTsconfig("test", { ...base, exactOptionalPropertyTypes: false })).toEqual([
+          'When "exactOptionalPropertyTypes" is present, it must be set to `true`.',
+        ]);
+      });
+      it("allows paths: self-reference", () => {
+        expect(checkTsconfig("react-native", { ...base, paths: { "react-native": ["./index.d.ts"] } })).toEqual([]);
+      });
+      it("allows paths: matching ../reference/index.d.ts", () => {
+        expect(
+          checkTsconfig("reactive-dep", { ...base, paths: { "react-native": ["../react-native/index.d.ts"] } })
+        ).toEqual([]);
+        expect(
+          checkTsconfig("reactive-dep", {
+            ...base,
+            paths: { "react-native": ["../react-native/index.d.ts"], react: ["../react/v16/index.d.ts"] },
+          })
+        ).toEqual([]);
+      });
+      it("forbids paths: mapping to multiple things", () => {
+        expect(
+          checkTsconfig("reactive-dep", {
+            ...base,
+            paths: { "react-native": ["./index.d.ts", "../react-native/v0.68/index.d.ts"] },
+          })
+        ).toEqual([`reactive-dep/tsconfig.json: "paths" must map each module specifier to only one file.`]);
+      });
+      it("allows paths: matching ../reference/version/index.d.ts", () => {
+        expect(checkTsconfig("reactive-dep", { ...base, paths: { react: ["../react/v16/index.d.ts"] } })).toEqual([]);
+        expect(
+          checkTsconfig("reactive-dep", { ...base, paths: { "react-native": ["../react-native/v0.69/index.d.ts"] } })
+        ).toEqual([]);
+        expect(
+          checkTsconfig("reactive-dep/v1", {
+            ...base,
+            paths: { "react-native": ["../../react-native/v0.69/index.d.ts"] },
+          })
+        ).toEqual([]);
+      });
+      it("forbids paths: mapping to self-contained file", () => {
+        expect(checkTsconfig("rrrr", { ...base, paths: { "react-native": ["./other.d.ts"] } })).toEqual([
+          `rrrr/tsconfig.json: "paths" must map 'react-native' to react-native's index.d.ts.`,
+        ]);
+      });
+      it("forbids paths: mismatching ../NOT/index.d.ts", () => {
+        expect(checkTsconfig("rrrr", { ...base, paths: { "react-native": ["../cocoa/index.d.ts"] } })).toEqual([
+          `rrrr/tsconfig.json: "paths" must map 'react-native' to react-native's index.d.ts.`,
+        ]);
+      });
+      it("forbids paths: mismatching ../react-native/NOT.d.ts", () => {
+        expect(checkTsconfig("rrrr", { ...base, paths: { "react-native": ["../react-native/other.d.ts"] } })).toEqual([
+          `rrrr/tsconfig.json: "paths" must map 'react-native' to react-native's index.d.ts.`,
+        ]);
+      });
+      it("forbids paths: mismatching ../react-native/NOT/index.d.ts", () => {
+        expect(
+          checkTsconfig("rrrr", { ...base, paths: { "react-native": ["../react-native/deep/index.d.ts"] } })
+        ).toEqual([`rrrr/tsconfig.json: "paths" must map 'react-native' to react-native's index.d.ts.`]);
+      });
+      it("forbids paths: mismatching ../react-native/version/NOT/index.d.ts", () => {
+        expect(
+          checkTsconfig("rrrr", { ...base, paths: { "react-native": ["../react-native/v0.68/deep/index.d.ts"] } })
+        ).toEqual([`rrrr/tsconfig.json: "paths" must map 'react-native' to react-native's index.d.ts.`]);
+      });
+      it("forbids paths: mismatching ../react-native/version/NOT.d.ts", () => {
+        expect(
+          checkTsconfig("rrrr", { ...base, paths: { "react-native": ["../react-native/v0.70/other.d.ts"] } })
+        ).toEqual([`rrrr/tsconfig.json: "paths" must map 'react-native' to react-native's index.d.ts.`]);
+      });
     });
-    it("allows exactOptionalPropertyTypes: true", () => {
-      expect(checkTsconfig({ ...base, exactOptionalPropertyTypes: true }, { relativeBaseUrl: "../" })).toBeFalsy();
-    });
-    it("allows module: node16", () => {
-      expect(checkTsconfig({ ...base, module: "node16" }, { relativeBaseUrl: "../" })).toBeFalsy();
-    });
-    it("disallows missing `module`", () => {
-      const options = { ...base };
-      delete options.module;
-      expect(() => checkTsconfig(options, { relativeBaseUrl: "../" })).toThrow(
-        'Must specify "module" to `"module": "commonjs"` or `"module": "node16"`.'
-      );
-    });
-    it("disallows exactOptionalPropertyTypes: false", () => {
-      expect(() => checkTsconfig({ ...base, exactOptionalPropertyTypes: false }, { relativeBaseUrl: "../" })).toThrow(
-        'When "exactOptionalPropertyTypes" is present, it must be set to `true`.'
-      );
-    });
-    it("disallows packages that are in notNeededPackages.json", () => {
-      expect(() => assertPackageIsNotDeprecated("foo", '{ "packages": { "foo": { } } }')).toThrow(
-        "notNeededPackages.json has an entry for foo."
-      );
-    });
-    it("allows packages that are not in notNeededPackages.json", () => {
-      expect(assertPackageIsNotDeprecated("foo", '{ "packages": { "bar": { } } }')).toBeUndefined();
+    describe("assertPackageIsNotDeprecated", () => {
+      it("disallows packages that are in notNeededPackages.json", () => {
+        expect(() => assertPackageIsNotDeprecated("foo", '{ "packages": { "foo": { } } }')).toThrow(
+          "notNeededPackages.json has an entry for foo."
+        );
+      });
+      it("allows packages that are not in notNeededPackages.json", () => {
+        expect(assertPackageIsNotDeprecated("foo", '{ "packages": { "bar": { } } }')).toBeUndefined();
+      });
     });
   });
   describe("rules", () => {

package/test/npm-naming/code/types/dts-critic/index.d.ts

@@ -1,6 +1 @@
-// Type definitions for package dts-critic 1.0
-// Project: https://https://github.com/DefinitelyTyped/dts-critic
-// Definitions by: Jane Doe <https://github.com/janedoe>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
 export default dtsCritic();

package/test/npm-naming/code/types/dts-critic/package.json

@@ -0,0 +1,17 @@
+{
+    "private": true,
+    "name": "@types/dts-critic",
+    "version": "1.0.9999",
+    "projects": [
+        "https://github.com/microsoft/TypeScript"
+    ],
+    "devDependencies": {
+        "@types/dts-critic": "workspace:."
+    },
+    "owners": [
+        {
+            "name": "Jane Doe",
+            "githubUsername": "janedoe"
+        }
+    ]
+}

package/test/npm-naming/name/types/wenceslas/index.d.ts

@@ -1,4 +1 @@
-// Type definitions for package wenceslas 1.0
-// Project: https://github.com/bobby-headers/dt-header
-// Definitions by: Jane Doe <https://github.com/janedoe>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// hi

package/test/npm-naming/name/types/wenceslas/index.d.ts.lint

@@ -1,6 +1,2 @@
-// Type definitions for package wenceslas 1.0
-~~~~~~~~~~~~~~~~~~~~~~~                          [0]
-// Project: https://github.com/bobby-headers/dt-header
-// Definitions by: Jane Doe <https://github.com/janedoe>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-[0]: Declaration file must have a matching npm package. To resolve this error, either: 1. Change the name to match an npm package. 2. Add a Definitely Typed header with the first line   // Type definitions for non-npm package wenceslas-browser  Add -browser to the end of your name to make sure it doesn't conflict with existing npm packages. If you won't fix this error now or you think this error is wrong, you can disable this check by adding the following options to your project's tslint.json file under "rules":      "npm-naming": false  See: https://github.com/microsoft/DefinitelyTyped-tools/blob/master/packages/dtslint/docs/npm-naming.md
+// hi
+~     [Declaration file must have a matching npm package. To resolve this error, either: 1. Change the name to match an npm package. 2. Add `"nonNpm": true` to the package.json to indicate that this is not an npm package.    Ensure the package name is descriptive enough to avoid conflicts with future npm packages. If you won't fix this error now or you think this error is wrong, you can disable this check by adding the following options to your project's tslint.json file under "rules":      "npm-naming": false  See: https://github.com/microsoft/DefinitelyTyped-tools/blob/master/packages/dtslint/docs/npm-naming.md]

package/test/npm-naming/name/types/wenceslas/package.json

@@ -0,0 +1,17 @@
+{
+    "private": true,
+    "name": "@types/wenceslas",
+    "version": "0.0.9999",
+    "projects": [
+        "https://github.com/bobby-headers/dt-header"
+    ],
+    "devDependencies": {
+        "@types/wenceslas": "workspace:."
+    },
+    "owners": [
+        {
+            "name": "Jane Doe",
+            "githubUsername": "janedoe"
+        }
+    ]
+}