@codelaw/rules-ts 0.0.0-stage → 0.1.0

package/rules/ts/no-require-imports.md

@@ -0,0 +1,54 @@
+---
+id: ts/no-require-imports
+title: "No require() calls"
+languages: [typescript, tsx]
+fix: manual
+fix_reason: "an import may need the module's default or named exports chosen by hand"
+stability: preview
+ported_from: [typescript-eslint/no-require-imports]
+since: 0.1.0
+---
+
+Modules are loaded with `import`, not `require()`.
+
+**Why:** `require()` is untyped and invisible to TypeScript's module checks.
+
+```codelaw
+match:
+  pattern: require($$$ARGS)
+message: "Use `import` instead of `require()`"
+```
+
+## How to fix
+
+1. Replace the call with an `import` of the names the code uses.
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+const fs = require("node:fs");
+```
+
+#### Do
+
+```ts
+import fs from "node:fs";
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const fs = require("node:fs");
+```
+
+#### Do
+
+```tsx
+import fs from "node:fs";
+```

package/rules/ts/no-this-alias.md

@@ -0,0 +1,68 @@
+---
+id: ts/no-this-alias
+title: "No aliasing this to a variable"
+languages: [typescript, tsx]
+fix: manual
+fix_reason: "the callbacks that use the alias must become arrow functions by hand"
+stability: preview
+ported_from: [typescript-eslint/no-this-alias]
+since: 0.1.0
+---
+
+`this` is not stored in a variable such as `self` or `that`; destructuring it is fine.
+
+**Why:** Arrow functions keep the outer `this`, so an alias only adds a name to keep track of.
+
+```codelaw
+match:
+  kind: variable_declarator
+  all:
+    - has: { field: name, kind: identifier }
+    - has: { field: value, kind: this }
+message: "Use an arrow function instead of aliasing `this`"
+```
+
+## How to fix
+
+1. Turn the callbacks that use the alias into arrow functions.
+2. Use `this` directly and remove the alias.
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+const self = this;
+button.onclick = function () {
+  self.save();
+};
+```
+
+#### Do
+
+```ts
+button.onclick = () => {
+  this.save();
+};
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const self = this;
+button.onclick = function () {
+  self.save();
+};
+```
+
+#### Do
+
+```tsx
+button.onclick = () => {
+  this.save();
+};
+```

package/rules/ts/no-unnecessary-type-constraint.md

@@ -0,0 +1,64 @@
+---
+id: ts/no-unnecessary-type-constraint
+title: "No extends any or extends unknown on a type parameter"
+languages: [typescript, tsx]
+fix: suggest
+fix_reason: "in a .tsx arrow function `<T>` alone parses as JSX and needs `<T,>`"
+stability: preview
+ported_from: [typescript-eslint/no-unnecessary-type-constraint]
+since: 0.1.0
+---
+
+A type parameter isn't constrained to `any` or `unknown`.
+
+**Why:** Every type extends both, so the constraint says nothing.
+
+```codelaw
+match:
+  kind: type_parameter
+  all:
+    - has: { field: name, pattern: $NAME }
+    - has:
+        field: constraint
+        has: { kind: predefined_type, regex: ^(any|unknown)$ }
+message: "Every type already extends `any` and `unknown`; drop the constraint"
+fix: "$NAME"
+```
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+function id<T extends unknown>(x: T) {
+  return x;
+}
+```
+
+#### Do
+
+```ts
+function id<T>(x: T) {
+  return x;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function id<T extends unknown>(x: T) {
+  return x;
+}
+```
+
+#### Do
+
+```tsx
+function id<T>(x: T) {
+  return x;
+}
+```

package/rules/ts/no-unsafe-declaration-merging.md

@@ -0,0 +1,73 @@
+---
+id: ts/no-unsafe-declaration-merging
+title: "No interface that merges with a class of the same name"
+languages: [typescript, tsx]
+fix: manual
+fix_reason: "whether to rename or to move the members into the class needs the author"
+stability: preview
+ported_from: [typescript-eslint/no-unsafe-declaration-merging]
+since: 0.1.0
+---
+
+An interface doesn't share its name with a class in the same scope.
+
+**Why:** The merged interface adds members to the class's type that the class never initialises, and
+the compiler can't tell.
+
+```codelaw
+native: ts/no-unsafe-declaration-merging
+```
+
+## How to fix
+
+1. Move the interface's members into the class, or rename the interface.
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+interface Point {
+  z: number;
+}
+class Point {
+  x = 0;
+}
+```
+
+#### Do
+
+```ts
+interface PointLike {
+  z: number;
+}
+class Point {
+  x = 0;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+interface Point {
+  z: number;
+}
+class Point {
+  x = 0;
+}
+```
+
+#### Do
+
+```tsx
+interface PointLike {
+  z: number;
+}
+class Point {
+  x = 0;
+}
+```

package/rules/ts/no-unsafe-function-type.md

@@ -0,0 +1,57 @@
+---
+id: ts/no-unsafe-function-type
+title: "No Function type"
+languages: [typescript, tsx]
+fix: manual
+fix_reason: "the right signature needs the author"
+stability: preview
+ported_from: [typescript-eslint/no-unsafe-function-type]
+since: 0.1.0
+---
+
+The built-in `Function` type is not used as a type.
+
+**Why:** `Function` accepts any function and its calls are unchecked, like `any` for functions.
+
+```codelaw
+match:
+  kind: type_identifier
+  regex: ^Function$
+where:
+  $$MATCH: builtin
+message: "`Function` accepts any function and calls it unchecked; write the signature"
+```
+
+## How to fix
+
+1. Write the function's real signature, e.g. `(event: Event) => void`.
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+let handler: Function;
+```
+
+#### Do
+
+```ts
+let handler: (event: Event) => void;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+let handler: Function;
+```
+
+#### Do
+
+```tsx
+let handler: (event: Event) => void;
+```

package/rules/ts/no-unused-expressions.md

@@ -0,0 +1,61 @@
+---
+id: ts/no-unused-expressions
+title: "No expression statements that do nothing"
+languages: [typescript, tsx]
+fix: manual
+fix_reason: "whether a call, an assignment or nothing was meant needs the author"
+stability: preview
+ported_from: [typescript-eslint/no-unused-expressions, eslint/no-unused-expressions]
+since: 0.1.0
+---
+
+Every expression statement does something: a call, an assignment, an update, `await`, `yield`,
+`delete` or `void`. Directives such as `"use strict"` are allowed.
+
+**Why:** An expression whose value is thrown away is usually a forgotten call or assignment.
+
+```codelaw
+native: ts/no-unused-expressions
+```
+
+## How to fix
+
+1. Add the call or assignment that was meant, or remove the statement.
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+function close(conn: Connection) {
+  conn.close;
+}
+```
+
+#### Do
+
+```ts
+function close(conn: Connection) {
+  conn.close();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function close(conn: Connection) {
+  conn.close;
+}
+```
+
+#### Do
+
+```tsx
+function close(conn: Connection) {
+  conn.close();
+}
+```

package/rules/ts/no-unused-vars.md

@@ -0,0 +1,68 @@
+---
+id: ts/no-unused-vars
+title: "Every declared name is used"
+languages: [typescript, tsx]
+fix: manual
+fix_reason: "removing a declaration can drop the side effects of its initialiser"
+stability: preview
+options:
+  vars: { type: string, default: all }
+  args: { type: string, default: after-used }
+  caughtErrors: { type: string, default: all }
+  ignoreRestSiblings: { type: boolean, default: false }
+  varsIgnorePattern: { type: string }
+  argsIgnorePattern: { type: string }
+  caughtErrorsIgnorePattern: { type: string }
+  destructuredArrayIgnorePattern: { type: string }
+ported_from: [typescript-eslint/no-unused-vars, eslint/no-unused-vars]
+since: 0.1.0
+---
+
+Every variable, function, class, type, interface, enum, import, parameter and caught error is used
+somewhere. Parameters before the last used one are allowed (`args: after-used`).
+
+**Why:** An unused declaration is dead code or a sign the code doesn't do what it was meant to.
+
+```codelaw
+native: ts/no-unused-vars
+```
+
+## How to fix
+
+1. Check the initialiser has no side effect that matters.
+2. Remove the declaration, or use it where it was meant to be used.
+3. For a parameter that must stay for its position, prefix it with `_` and set `argsIgnorePattern: "^_"`.
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+import { readFile, writeFile } from "node:fs";
+export const load = (path: string) => readFile(path);
+```
+
+#### Do
+
+```ts
+import { readFile } from "node:fs";
+export const load = (path: string) => readFile(path);
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+import { readFile, writeFile } from "node:fs";
+export const load = (path: string) => readFile(path);
+```
+
+#### Do
+
+```tsx
+import { readFile } from "node:fs";
+export const load = (path: string) => readFile(path);
+```

package/rules/ts/no-wrapper-object-types.md

@@ -0,0 +1,49 @@
+---
+id: ts/no-wrapper-object-types
+title: "Primitive types, not wrapper object types"
+languages: [typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [typescript-eslint/no-wrapper-object-types]
+since: 0.1.0
+---
+
+Types use `string`, `number`, `boolean`, `symbol`, `bigint` and `object`, not the wrapper objects
+`String`, `Number`, `Boolean`, `Symbol`, `BigInt` and `Object`.
+
+**Why:** The wrapper types describe boxed objects almost no code uses, and accept values the
+primitive types reject.
+
+```codelaw
+native: ts/no-wrapper-object-types
+```
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+let label: String = "a";
+```
+
+#### Do
+
+```ts
+let label: string = "a";
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+let label: String = "a";
+```
+
+#### Do
+
+```tsx
+let label: string = "a";
+```

package/rules/ts/prefer-as-const.md

@@ -0,0 +1,47 @@
+---
+id: ts/prefer-as-const
+title: "as const instead of repeating a literal as its type"
+languages: [typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [typescript-eslint/prefer-as-const]
+since: 0.1.0
+---
+
+A literal cast to its own literal type (`"a" as "a"`) uses `as const` instead.
+
+**Why:** `as const` says the same thing once, and stays right when the literal changes.
+
+```codelaw
+native: ts/prefer-as-const
+```
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+const mode = "dark" as "dark";
+```
+
+#### Do
+
+```ts
+const mode = "dark" as const;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const mode = "dark" as "dark";
+```
+
+#### Do
+
+```tsx
+const mode = "dark" as const;
+```

package/rules/ts/prefer-namespace-keyword.md

@@ -0,0 +1,63 @@
+---
+id: ts/prefer-namespace-keyword
+title: "namespace, not module, for a TypeScript namespace"
+languages: [typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [typescript-eslint/prefer-namespace-keyword]
+since: 0.1.0
+---
+
+A TypeScript namespace is declared with `namespace`, not `module`; `declare module "x"` is
+unaffected.
+
+**Why:** `module Foo {}` is the old spelling and is easy to confuse with an external module
+declaration.
+
+```codelaw
+match:
+  kind: module
+  all:
+    - has: { field: name, kind: identifier, pattern: $NAME }
+    - has: { field: body, pattern: $BODY }
+message: "Write `namespace` for a TypeScript namespace; `module` is for declaring external modules"
+fix: "namespace $NAME $BODY"
+```
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+module Shapes {
+  export const sides = 4;
+}
+```
+
+#### Do
+
+```ts
+namespace Shapes {
+  export const sides = 4;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+module Shapes {
+  export const sides = 4;
+}
+```
+
+#### Do
+
+```tsx
+namespace Shapes {
+  export const sides = 4;
+}
+```

package/rules/ts/triple-slash-reference.md

@@ -0,0 +1,60 @@
+---
+id: ts/triple-slash-reference
+title: "No /// <reference path> directives"
+languages: [typescript, tsx]
+fix: manual
+fix_reason: "the matching import needs the module path and what it provides"
+stability: preview
+ported_from: [typescript-eslint/triple-slash-reference]
+since: 0.1.0
+---
+
+Files are connected with `import`, not `/// <reference path="…" />`.
+
+**Why:** Reference directives predate ES modules and hide dependencies from bundlers and other
+tools.
+
+```codelaw
+match:
+  kind: comment
+  regex: ^///\s*<reference\s+path=
+message: "Use an `import` instead of a `/// <reference path>` directive"
+```
+
+## How to fix
+
+1. Replace the directive with an `import` of the module it pointed to.
+
+## Examples
+
+### TypeScript
+
+#### Don't
+
+```ts
+/// <reference path="./globals.d.ts" />
+export const x = 1;
+```
+
+#### Do
+
+```ts
+import "./globals";
+export const x = 1;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+/// <reference path="./globals.d.ts" />
+export const x = 1;
+```
+
+#### Do
+
+```tsx
+import "./globals";
+export const x = 1;
+```