@definitelytyped/eslint-plugin 0.0.166-next.4

package/dist/rules/redundant-undefined.js

@@ -0,0 +1,53 @@
+"use strict";
+const util_1 = require("../util");
+const utils_1 = require("@typescript-eslint/utils");
+const rule = (0, util_1.createRule)({
+    name: "redundant-undefined",
+    defaultOptions: [],
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Forbids optional parameters from including an explicit `undefined` in their type; requires it in optional properties.",
+            recommended: "error",
+        },
+        messages: {
+            redundantUndefined: `Parameter is optional, so no need to include \`undefined\` in the type.`,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            TSUnionType(node) {
+                const hasUndefinedType = node.types.some((t) => t.type === utils_1.AST_NODE_TYPES.TSUndefinedKeyword);
+                if (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+                    isParameter(node.parent.parent) &&
+                    node.parent.parent.optional &&
+                    isFunctionLike(node.parent.parent.parent) &&
+                    hasUndefinedType) {
+                    context.report({
+                        messageId: "redundantUndefined",
+                        node,
+                    });
+                }
+            },
+        };
+    },
+});
+function isFunctionLike(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.TSDeclareFunction ||
+        node.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression);
+}
+/** Note: Does not include parameter properties because those can't be optional */
+function isParameter(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrayPattern ||
+        node.type === utils_1.AST_NODE_TYPES.AssignmentPattern ||
+        node.type === utils_1.AST_NODE_TYPES.Identifier ||
+        node.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+        node.type === utils_1.AST_NODE_TYPES.RestElement);
+}
+module.exports = rule;
+//# sourceMappingURL=redundant-undefined.js.map

package/dist/rules/redundant-undefined.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redundant-undefined.js","sourceRoot":"","sources":["../../src/rules/redundant-undefined.ts"],"names":[],"mappings":";AAAA,kCAAqC;AACrC,oDAA0D;AAG1D,MAAM,IAAI,GAAG,IAAA,iBAAU,EAAC;IACtB,IAAI,EAAE,qBAAqB;IAC3B,cAAc,EAAE,EAAE;IAClB,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EACT,uHAAuH;YACzH,WAAW,EAAE,OAAO;SACrB;QACD,QAAQ,EAAE;YACR,kBAAkB,EAAE,yEAAyE;SAC9F;QACD,MAAM,EAAE,EAAE;KACX;IACD,MAAM,CAAC,OAAO;QACZ,OAAO;YACL,gEAAgE;YAChE,WAAW,CAAC,IAAI;gBACd,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,sBAAc,CAAC,kBAAkB,CAAC,CAAC;gBAC9F,IACE,IAAI,CAAC,MAAO,CAAC,IAAI,KAAK,sBAAc,CAAC,gBAAgB;oBACrD,WAAW,CAAC,IAAI,CAAC,MAAO,CAAC,MAAO,CAAC;oBACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ;oBAC3B,cAAc,CAAC,IAAI,CAAC,MAAO,CAAC,MAAO,CAAC,MAAO,CAAC;oBAC5C,gBAAgB,EAChB;oBACA,OAAO,CAAC,MAAM,CAAC;wBACb,SAAS,EAAE,oBAAoB;wBAC/B,IAAI;qBACL,CAAC,CAAC;iBACJ;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,SAAS,cAAc,CAAC,IAAmB;IACzC,OAAO,CACL,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,uBAAuB;QACpD,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,mBAAmB;QAChD,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,kBAAkB;QAC/C,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,iBAAiB;QAC9C,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,6BAA6B,CAC3D,CAAC;AACJ,CAAC;AACD,kFAAkF;AAClF,SAAS,WAAW,CAAC,IAAmB;IACtC,OAAO,CACL,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,YAAY;QACzC,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,iBAAiB;QAC9C,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,UAAU;QACvC,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,aAAa;QAC1C,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,WAAW,CACzC,CAAC;AACJ,CAAC;AAED,iBAAS,IAAI,CAAC"}

package/dist/rules/trim-file.d.ts

@@ -0,0 +1,2 @@
+declare const rule: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"leadingBlankLine" | "trailingBlankLine", never[], {}>;
+export = rule;

package/dist/rules/trim-file.js

@@ -0,0 +1,43 @@
+"use strict";
+const util_1 = require("../util");
+const rule = (0, util_1.createRule)({
+    name: "trim-file",
+    defaultOptions: [],
+    meta: {
+        type: "layout",
+        docs: {
+            description: "Forbids leading/trailing blank lines in a file. Allows file to end in '\n'",
+            recommended: "error",
+        },
+        messages: {
+            leadingBlankLine: "File should not begin with a blank line.",
+            trailingBlankLine: "File should not end with a blank line. (Ending in one newline OK, ending in two newlines not OK.)",
+        },
+        schema: [],
+    },
+    create(context) {
+        const { lines, text } = context.getSourceCode();
+        if (text.startsWith("\r") || text.startsWith("\n")) {
+            context.report({
+                messageId: "leadingBlankLine",
+                loc: {
+                    start: { line: 1, column: 0 },
+                    end: { line: 1, column: 0 },
+                },
+            });
+        }
+        if (text.endsWith("\n\n") || text.endsWith("\r\n\r\n")) {
+            const line = lines.length;
+            context.report({
+                messageId: "trailingBlankLine",
+                loc: {
+                    start: { line, column: 0 },
+                    end: { line, column: 0 },
+                },
+            });
+        }
+        return {};
+    },
+});
+module.exports = rule;
+//# sourceMappingURL=trim-file.js.map

package/dist/rules/trim-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim-file.js","sourceRoot":"","sources":["../../src/rules/trim-file.ts"],"names":[],"mappings":";AAAA,kCAAqC;AAErC,MAAM,IAAI,GAAG,IAAA,iBAAU,EAAC;IACtB,IAAI,EAAE,WAAW;IACjB,cAAc,EAAE,EAAE;IAClB,IAAI,EAAE;QACJ,IAAI,EAAE,QAAQ;QACd,IAAI,EAAE;YACJ,WAAW,EAAE,4EAA4E;YACzF,WAAW,EAAE,OAAO;SACrB;QACD,QAAQ,EAAE;YACR,gBAAgB,EAAE,0CAA0C;YAC5D,iBAAiB,EACf,mGAAmG;SACtG;QACD,MAAM,EAAE,EAAE;KACX;IACD,MAAM,CAAC,OAAO;QACZ,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;QAChD,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YAClD,OAAO,CAAC,MAAM,CAAC;gBACb,SAAS,EAAE,kBAAkB;gBAC7B,GAAG,EAAE;oBACH,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;oBAC7B,GAAG,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;iBAC5B;aACF,CAAC,CAAC;SACJ;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;YACtD,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC;YAC1B,OAAO,CAAC,MAAM,CAAC;gBACb,SAAS,EAAE,mBAAmB;gBAC9B,GAAG,EAAE;oBACH,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE;oBAC1B,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE;iBACzB;aACF,CAAC,CAAC;SACJ;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;CACF,CAAC,CAAC;AAEH,iBAAS,IAAI,CAAC"}

package/dist/util.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener = import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<TMessageIds, TOptions, TRuleListener>;
+export declare function getCommonDirectoryName(files: readonly string[]): string;
+export declare function isMainFile(fileName: string, allowNested: boolean): boolean;

package/dist/util.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMainFile = exports.getCommonDirectoryName = exports.createRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const path_1 = require("path");
+exports.createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/microsoft/DefinitelyTyped-tools/tree/master/packages/eslint-plugin/docs/rules/${name}.md`);
+function getCommonDirectoryName(files) {
+    let minLen = 999;
+    let minDir = "";
+    for (const file of files) {
+        const dir = (0, path_1.dirname)(file);
+        if (dir.length < minLen) {
+            minDir = dir;
+            minLen = dir.length;
+        }
+    }
+    return (0, path_1.basename)(minDir);
+}
+exports.getCommonDirectoryName = getCommonDirectoryName;
+function isMainFile(fileName, allowNested) {
+    // 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") {
+        return true;
+    }
+    if ((0, path_1.basename)(fileName) !== "index.d.ts") {
+        return false;
+    }
+    let parent = (0, path_1.dirname)(fileName);
+    // May be a directory for an older version, e.g. `v0`.
+    // Note a types redirect `foo/ts3.1` should not have its own header.
+    if (allowNested && /^v(0\.)?\d+$/.test((0, path_1.basename)(parent))) {
+        parent = (0, path_1.dirname)(parent);
+    }
+    // Allow "types/foo/index.d.ts", not "types/foo/utils/index.d.ts"
+    return (0, path_1.basename)((0, path_1.dirname)(parent)) === "types";
+}
+exports.isMainFile = isMainFile;
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;;AAAA,oDAAuD;AACvD,+BAAyC;AAE5B,QAAA,UAAU,GAAG,mBAAW,CAAC,WAAW,CAC/C,CAAC,IAAI,EAAE,EAAE,CACP,oGAAoG,IAAI,KAAK,CAChH,CAAC;AAEF,SAAgB,sBAAsB,CAAC,KAAwB;IAC7D,IAAI,MAAM,GAAG,GAAG,CAAC;IACjB,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,MAAM,GAAG,GAAG,IAAA,cAAO,EAAC,IAAI,CAAC,CAAC;QAC1B,IAAI,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE;YACvB,MAAM,GAAG,GAAG,CAAC;YACb,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;SACrB;KACF;IACD,OAAO,IAAA,eAAQ,EAAC,MAAM,CAAC,CAAC;AAC1B,CAAC;AAXD,wDAWC;AAED,SAAgB,UAAU,CAAC,QAAgB,EAAE,WAAoB;IAC/D,2GAA2G;IAC3G,IAAI,QAAQ,KAAK,YAAY,EAAE;QAC7B,OAAO,IAAI,CAAC;KACb;IAED,IAAI,IAAA,eAAQ,EAAC,QAAQ,CAAC,KAAK,YAAY,EAAE;QACvC,OAAO,KAAK,CAAC;KACd;IAED,IAAI,MAAM,GAAG,IAAA,cAAO,EAAC,QAAQ,CAAC,CAAC;IAC/B,sDAAsD;IACtD,oEAAoE;IACpE,IAAI,WAAW,IAAI,cAAc,CAAC,IAAI,CAAC,IAAA,eAAQ,EAAC,MAAM,CAAC,CAAC,EAAE;QACxD,MAAM,GAAG,IAAA,cAAO,EAAC,MAAM,CAAC,CAAC;KAC1B;IAED,iEAAiE;IACjE,OAAO,IAAA,eAAQ,EAAC,IAAA,cAAO,EAAC,MAAM,CAAC,CAAC,KAAK,OAAO,CAAC;AAC/C,CAAC;AAnBD,gCAmBC"}

package/docs/rules/dt-header.md

@@ -0,0 +1,88 @@
+# dt-header
+
+(This rule is specific to DefinitelyTyped.)
+
+Checks the format of DefinitelyTyped header comments.
+
+---
+
+**Bad**:
+
+```ts
+// Type definitions for foo v1.2.3
+```
+
+* Don't include `v`
+* Don't include a patch version
+
+**Good**:
+
+```ts
+// Type definitions for foo 1.2
+```
+
+---
+
+**Bad**:
+
+```ts
+// Definitions by: My Name <http://geocities.com/myname>
+```
+
+**Good**:
+
+```ts
+// Definitions by: My Name <https://github.com/myname>
+```
+
+* Prefer a GitHub username, not a personal web site.
+
+---
+
+**Bad**:
+
+`foo/index.d.ts`:
+
+```ts
+// Type definitions for abs 1.2
+// Project: https://github.com/foo/foo
+// Definitions by: My Name <https://github.com/myname>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+export { f } from "./subModule";
+```
+
+`foo/subModule.d.ts`:
+
+```ts
+// Type definitions for abs 1.2
+// Project: https://github.com/foo/foo
+// Definitions by: My Name <https://github.com/myname>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+export function f(): number;
+```
+
+`foo/ts3.1/index.d.ts`:
+```ts
+// Type definitions for abs 1.2
+// Project: https://github.com/foo/foo
+// Definitions by: My Name <https://github.com/myname>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+export function f(): number;
+```
+
+
+**Good**:
+
+`foo/index.d.ts`: Same
+
+`foo/subModule.d.ts`:
+```ts
+export function f(): number;
+```
+
+`foo/ts3.1/index.d.ts`:
+```ts
+export function f(): number;
+```
+
+Don't repeat the header -- only do it in the index of the root.

package/docs/rules/export-just-namespace.md

@@ -0,0 +1,29 @@
+# export-just-namespace
+
+Declaring a namespace is unnecessary if that is the module's only content; just use ES6 export syntax instead.
+
+**Bad**:
+
+```ts
+namespace MyLib {
+    export function f(): number;
+}
+export = MyLib;
+```
+
+**Good**:
+
+```ts
+export function f(): number;
+```
+
+**Also good**:
+
+```ts
+namespace MyLib {
+    export function f(): number;
+}
+function MyLib(): number;
+export = MyLib;
+```
+

package/docs/rules/no-any-union.md

@@ -0,0 +1,27 @@
+# no-any-union
+
+Forbids to include `any` in a union. When `any` is used in a union type, the resulting type is still `any`.
+
+**Bad**:
+
+```ts
+function f(x: string | any): void;
+```
+
+**Good**:
+
+```ts
+function f(x: string): void;
+```
+
+Or:
+```ts
+function f(x: any): void;
+```
+
+Or:
+```ts
+function f(x: string | object): void;
+```
+
+While the `string` portion of this type annotation may _look_ useful, it in fact offers no additional typechecking over simply using `any`.

package/docs/rules/no-bad-reference.md

@@ -0,0 +1,28 @@
+# no-bad-reference
+
+(This rule is specific to DefinitelyTyped.)
+Avoid using `<reference path>`.
+
+**Bad**:
+
+```ts
+/// <reference path="../node_modules/@types/foo/index.d.ts" />
+import * as foo from "foo";
+```
+
+**Good**:
+
+If "foo" is written in external module style (see `no-single-declare-module`), the import alone should work thanks to [module resolution](http://www.typescriptlang.org/docs/handbook/module-resolution.html):
+
+```ts
+// TypeScript will look for a definition for "foo" using module resolution
+import * as foo from "foo";
+```
+
+If not, use `<reference types>` instead:
+
+```ts
+/// <reference types="foo" />
+```
+
+The only time `<reference path>` should be necessary if for global (not module) libraries that are separated into multiple files; the index file must include references to the others to bring them into the compilation.

package/docs/rules/no-const-enum.md

@@ -0,0 +1,16 @@
+# no-const-enum
+
+Avoid using `const enum`s. These can't be used by JavaScript users or by TypeScript users with [`--isolatedModules`](https://www.typescriptlang.org/docs/handbook/compiler-options.html) enabled.
+
+**Bad**:
+
+```ts
+const enum Bit { Off, On }
+export function f(b: Bit): void;
+```
+
+**Good**:
+
+```ts
+export function f(b: 0 | 1): void;
+```

package/docs/rules/no-dead-reference.md

@@ -0,0 +1,17 @@
+# no-dead-reference
+
+A `<reference>` comment should go at the top of a file -- otherwise it is just a normal comment.
+
+**Bad**:
+
+```ts
+console.log("Hello world!");
+/// <reference types="jquery" />
+```
+
+**Good**:
+
+```ts
+/// <reference types="jquery" />
+console.log("Hello world!");
+```

package/docs/rules/no-declare-current-package.md

@@ -0,0 +1,35 @@
+# no-declare-current-package
+
+Avoid using `declare module`, and prefer to declare module contents in a file.
+
+**Bad**:
+
+```ts
+// foo/index.d.ts
+declare module "foo" {
+    export const x = 0;
+}
+```
+
+**Good**:
+
+```ts
+// foo/index.d.ts
+export const x = 0;
+```
+
+**Bad**:
+
+```ts
+// foo/index.d.ts
+declare module "foo/bar" {
+    export const x = 0;
+}
+```
+
+**Good**:
+
+```ts
+// foo/bar.d.ts
+export const x = 0;
+```

package/docs/rules/no-import-default-of-export-equals.md

@@ -0,0 +1,22 @@
+# no-import-default-of-export-equals
+
+Don't use a default import of a package that uses `export =`.
+Users who do not have `--allowSyntheticDefaultExports` or `--esModuleInterop` will get different behavior.
+This rule only applies to definition files -- for test files you can use a default import if you prefer.
+
+**Bad**:
+
+```ts
+// foo/index.d.ts
+declare interface I {}
+export = I;
+
+// bar/index.d.ts
+import I from "foo";
+```
+
+**Good**:
+
+```ts
+import I = require("foo");
+```

package/docs/rules/no-outside-dependencies.md

@@ -0,0 +1,23 @@
+# no-outside-dependencies
+
+Don't import from `DefinitelyTyped/node_modules`.
+
+**Bad**:
+
+```ts
+import * as x from "x";
+// where 'x' is defined only in `DefinitelyTyped/node_modules`
+```
+
+**Good**:
+
+Add a `package.json`:
+
+```ts
+{
+    "private": true,
+    "dependencies": {
+        "x": "^1.2.3"
+    }
+}
+```

package/docs/rules/no-self-import.md

@@ -0,0 +1,27 @@
+# no-self-import
+
+A package should not import components of itself using a globally-qualified name; it should use relative imports instead.
+
+**Bad**:
+
+```ts
+import foo from "this-package/foo.d.ts";
+```
+
+**Good**:
+
+```ts
+import foo from "./foo.d.ts";
+```
+
+**Bad**:
+
+```ts
+import myself from "this-package";
+```
+
+**Good**:
+
+```ts
+import myself from ".";
+```

package/docs/rules/no-single-element-tuple-type.md

@@ -0,0 +1,15 @@
+# no-single-element-tuple-type
+
+Some users mistakenly write `[T]` when then intend to write an array type `T[]`.
+
+**Bad**:
+
+```ts
+export const x: [T];
+```
+
+**Good**:
+
+```ts
+export const x: T[];
+```

package/docs/rules/no-unnecessary-generics.md

@@ -0,0 +1,69 @@
+# no-unnecessary-generics
+
+Forbids a function to use a generic type parameter only once.
+Generic type parameters allow you to relate the type of one thing to another;
+if they are used only once, they can be replaced with their type constraint.
+
+**Bad**:
+
+```ts
+function logAnything<T>(x: T): void;
+```
+
+**Good**:
+
+```ts
+function logAnything(x: any): void;
+```
+
+---
+
+**Bad**:
+
+```ts
+function useLogger<T extends Logger>(logger: T): void;
+```
+
+**Good**:
+
+```ts
+function useLogger(logger: Logger): void;
+```
+
+---
+
+**Bad**:
+
+```ts
+function clear<T>(array: T[]): void;
+```
+
+**Good**:
+
+```ts
+function clear(array: any[]): void;
+```
+
+---
+
+`getMeAT<T>(): T`:
+If a type parameter does not appear in the types of any parameters, you don't really have a generic function, you just have a disguised type assertion.
+Prefer to use a real type assertion, e.g. `getMeAT() as number`.
+Example where a type parameter is acceptable: `function id<T>(value: T): T;`.
+Example where it is not acceptable: `function parseJson<T>(json: string): T;`.
+Exception: `new Map<string, number>()` is OK.
+
+**Bad**:
+
+```ts
+function parse<T>(): T;
+const x = parse<number>();
+```
+
+**Good**:
+
+
+```ts
+function parse(): {};
+const x = parse() as number;
+```

package/docs/rules/no-useless-files.md

@@ -0,0 +1,14 @@
+# no-useless-files
+
+Don't include empty files.
+
+**Bad**:
+
+```ts
+```
+
+**Good**:
+
+```ts
+export function something(): void;
+```

package/docs/rules/prefer-declare-function.md

@@ -0,0 +1,15 @@
+# prefer-declare-function
+
+Prefer to declare a function using the `function` keyword instead of a variable of function type.
+
+**Bad**:
+
+```ts
+export const f: () => number;
+```
+
+**Good**:
+
+```ts
+export function f(): number;
+```

package/docs/rules/redundant-undefined.md

@@ -0,0 +1,15 @@
+# redundant-undefined
+
+Avoid explicitly specifying `undefined` as a type for a parameter which is already optional.
+
+**Bad**:
+
+```ts
+function f(s?: string | undefined): void {}
+```
+
+**Good**:
+
+```ts
+function f(s?: string): void {}
+```

package/docs/rules/trim-file.md

@@ -0,0 +1,17 @@
+# trim-file
+
+Don't include blank lines at the beginning or end of a file.
+
+**Bad**:
+
+```ts
+
+export function f(): number;
+
+```
+
+**Good**:
+
+```ts
+export function f(): number;
+```

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@definitelytyped/eslint-plugin",
+  "version": "0.0.166-next.4",
+  "description": "ESLint rules for DefinitelyTyped",
+  "main": "./dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "contributors": [
+    "Nathan Shively-Sanders <nathansa@microsoft.com> (https://github.com/sandersn)",
+    "Andy Hanson <andy-ms@microsoft.com> (https://github.com/andy-ms)",
+    "Dan Vanderkam <danvdk@gmail.com> (https://github.com/danvk)",
+    "Remco Haszing <remcohaszing@gmail.com> (https://github.com/remcohaszing)"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/DefinitelyTyped-tools.git",
+    "directory": "packages/eslint-plugin"
+  },
+  "scripts": {
+    "build": "tsc -b .",
+    "test": "../../node_modules/.bin/jest --config ../../jest.config.js packages/dtslint"
+  },
+  "dependencies": {
+    "@definitelytyped/header-parser": "^0.0.166-next.1",
+    "@typescript-eslint/types": "^5.56.0",
+    "@typescript-eslint/utils": "^5.55.0"
+  },
+  "peerDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "eslint": "^8.0.0",
+    "eslint-plugin-jsdoc": "^44.0.0",
+    "typescript": ">= 3.0.0-dev || >= 3.1.0-dev || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.7.0-dev || >= 3.8.0-dev || >= 3.9.0-dev || >= 4.0.0-dev || >=5.0.0-dev"
+  },
+  "devDependencies": {
+    "@types/eslint": "^8.4.2",
+    "typescript": "^5.0.2"
+  },
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "license": "MIT",
+  "gitHead": "bf315c7ade6b5d9c57e52b7948bd53af5cbc0c08"
+}