@codelaw/rules-js 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,69 @@
+---
+id: js/no-unused-vars
+title: "Every declared name is used"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "removing a declaration can drop the side effects of its initialiser"
+stability: preview
+options:
+  vars: { type: string, default: all, description: "all, or local to skip module-level names" }
+  args: { type: string, default: after-used, description: "after-used, all or none" }
+  caughtErrors: { type: string, default: all, description: "all or none" }
+  ignoreRestSiblings: { type: boolean, default: false }
+  varsIgnorePattern: { type: string, description: "a regular expression of names to skip" }
+  argsIgnorePattern: { type: string }
+  caughtErrorsIgnorePattern: { type: string }
+  destructuredArrayIgnorePattern: { type: string }
+ported_from: [eslint/no-unused-vars]
+since: 0.1.0
+---
+
+Every variable, function, class, import, parameter and caught error is read somewhere. Parameters
+before the last used one are allowed (`args: after-used`).
+
+**Why:** An unused declaration is either dead code or a sign the code doesn't do what it was meant
+to.
+
+```codelaw
+native: js/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
+
+### JavaScript
+
+#### Don't
+
+```js
+import { readFile, writeFile } from "node:fs";
+export const load = (path) => readFile(path);
+```
+
+#### Do
+
+```js
+import { readFile } from "node:fs";
+export const load = (path) => readFile(path);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+import { readFile, writeFile } from "node:fs";
+export const load = (path) => readFile(path);
+```
+
+#### Do
+
+```jsx
+import { readFile } from "node:fs";
+export const load = (path) => readFile(path);
+```

package/rules/js/no-useless-assignment.md

@@ -0,0 +1,115 @@
+---
+id: js/no-useless-assignment
+title: "No value is stored that nothing reads"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether the store is dead or the read is missing needs the author"
+stability: preview
+ported_from: [eslint/no-useless-assignment]
+since: 0.1.0
+---
+
+A variable is not assigned a value that is overwritten before anything reads it, or that nothing
+reads after the assignment.
+
+**Why:** A dead store is wasted work and usually means the code reads the wrong variable.
+
+```codelaw
+native: js/no-useless-assignment
+```
+
+## How to fix
+
+1. If the value is not needed, remove the assignment.
+2. If it should be read, read it where it was meant to be used.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function total(items) {
+  let sum = 0;
+  sum = items.length;
+  return sum;
+}
+```
+
+#### Do
+
+```js
+function total(items) {
+  const sum = items.length;
+  return sum;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function total(items) {
+  let sum = 0;
+  sum = items.length;
+  return sum;
+}
+```
+
+#### Do
+
+```jsx
+function total(items) {
+  const sum = items.length;
+  return sum;
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+function total(items) {
+  let sum = 0;
+  sum = items.length;
+  return sum;
+}
+```
+
+#### Do
+
+```ts
+function total(items) {
+  const sum = items.length;
+  return sum;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function total(items) {
+  let sum = 0;
+  sum = items.length;
+  return sum;
+}
+```
+
+#### Do
+
+```tsx
+function total(items) {
+  const sum = items.length;
+  return sum;
+}
+```
+
+## Differences from the source
+
+Only stores a straight-line reading proves dead are reported: an overwrite in the same block, or a
+last assignment outside any loop. A variable a nested function touches is skipped.

package/rules/js/no-useless-backreference.md

@@ -0,0 +1,83 @@
+---
+id: js/no-useless-backreference
+title: "No backreference that can only match the empty string"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "what the reference was meant to repeat needs the author"
+stability: preview
+ported_from: [eslint/no-useless-backreference]
+since: 0.1.0
+---
+
+A backreference such as `\1` or `\k<name>` appears after its group closes, in the same alternative,
+and not into a negative lookaround.
+
+**Why:** A backreference that comes first, sits inside its own group or in another alternative
+always matches the empty string.
+
+```codelaw
+native: js/no-useless-backreference
+```
+
+## How to fix
+
+1. Move the backreference after the group it refers to.
+2. Or remove it if it was meant to be literal text.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = /\1(a)/;
+```
+
+#### Do
+
+```js
+const re = /(a)\1/;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = /\1(a)/;
+```
+
+#### Do
+
+```jsx
+const re = /(a)\1/;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = /\1(a)/;
+```
+
+#### Do
+
+```ts
+const re = /(a)\1/;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = /\1(a)/;
+```
+
+#### Do
+
+```tsx
+const re = /(a)\1/;
+```

package/rules/js/no-useless-catch.md

@@ -0,0 +1,105 @@
+---
+id: js/no-useless-catch
+title: "No catch that only rethrows"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "removing the try block changes the scope of declarations inside it"
+stability: preview
+ported_from: [eslint/no-useless-catch]
+since: 0.1.0
+---
+
+A `catch` clause does more than rethrow the error it caught.
+
+**Why:** `catch (e) { throw e; }` does nothing but add noise and a level of nesting.
+
+```codelaw
+match:
+  kind: catch_clause
+  all:
+    - has: { field: parameter, pattern: $E }
+    - has:
+        field: body
+        regex: ^\{\s*throw\s+[A-Za-z_$][A-Za-z0-9_$]*\s*;?\s*\}$
+        has: { kind: throw_statement, has: { pattern: $E }, stopBy: end }
+message: "This catch only rethrows `$E`; remove it"
+```
+
+## How to fix
+
+1. If there is no `finally`, replace the `try` statement with the statements of its block.
+2. If there is a `finally`, remove only the `catch` clause.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+try {
+  load();
+} catch (e) {
+  throw e;
+}
+```
+
+#### Do
+
+```js
+load();
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+try {
+  load();
+} catch (e) {
+  throw e;
+}
+```
+
+#### Do
+
+```jsx
+load();
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+try {
+  load();
+} catch (e) {
+  throw e;
+}
+```
+
+#### Do
+
+```ts
+load();
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+try {
+  load();
+} catch (e) {
+  throw e;
+}
+```
+
+#### Do
+
+```tsx
+load();
+```

package/rules/js/no-useless-escape.md

@@ -0,0 +1,81 @@
+---
+id: js/no-useless-escape
+title: "No backslash that changes nothing"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-useless-escape]
+since: 0.1.0
+---
+
+A string or template literal escapes only characters that need it: quotes that match the delimiter,
+`\\`, line breaks and the escape letters.
+
+**Why:** A useless escape suggests the author meant something else, and makes the string harder to
+read.
+
+```codelaw
+native: js/no-useless-escape
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const path = "a\.b";
+```
+
+#### Do
+
+```js
+const path = "a.b";
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const path = "a\.b";
+```
+
+#### Do
+
+```jsx
+const path = "a.b";
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const path = "a\.b";
+```
+
+#### Do
+
+```ts
+const path = "a.b";
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const path = "a\.b";
+```
+
+#### Do
+
+```tsx
+const path = "a.b";
+```
+
+## Differences from the source
+
+Escapes inside regular expressions are not checked yet. A tagged template (`String.raw`, `html`) is not checked: its tag sees the raw text, backslashes included, as in ESLint.

package/rules/js/no-var.md

@@ -0,0 +1,76 @@
+---
+id: js/no-var
+title: "let or const instead of var"
+languages: [javascript, jsx, typescript, tsx]
+fix: suggest
+fix_reason: "`let` is block-scoped, so a `var` used outside its block or before its declaration changes meaning"
+stability: preview
+ported_from: [eslint/no-var]
+since: 0.1.0
+---
+
+Variables are declared with `let` or `const`, never `var`.
+
+**Why:** `var` is function-scoped and hoisted, which causes bugs `let` and `const` rule out.
+
+```codelaw
+native: js/no-var
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+var total = 0;
+```
+
+#### Do
+
+```js
+let total = 0;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+var total = 0;
+```
+
+#### Do
+
+```jsx
+let total = 0;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+var total = 0;
+```
+
+#### Do
+
+```ts
+let total = 0;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+var total = 0;
+```
+
+#### Do
+
+```tsx
+let total = 0;
+```

package/rules/js/no-with.md

@@ -0,0 +1,60 @@
+---
+id: js/no-with
+title: "No with statements"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "each name inside needs to be qualified by hand"
+stability: preview
+ported_from: [eslint/no-with]
+since: 0.1.0
+---
+
+Code doesn't use `with`.
+
+**Why:** `with` makes it impossible to tell which names are properties and which are variables, and
+is an error in strict code.
+
+```codelaw
+match:
+  kind: with_statement
+message: "`with` makes every name inside it ambiguous"
+```
+
+## How to fix
+
+1. Replace each property used inside `with` by `object.property`.
+2. Remove the `with`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+with (Math) {
+  area = PI * r * r;
+}
+```
+
+#### Do
+
+```js
+area = Math.PI * r * r;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+with (Math) {
+  area = PI * r * r;
+}
+```
+
+#### Do
+
+```jsx
+area = Math.PI * r * r;
+```

package/rules/js/prefer-const.md

@@ -0,0 +1,83 @@
+---
+id: js/prefer-const
+title: "const for variables that are never reassigned"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/prefer-const]
+since: 0.1.0
+---
+
+A `let` whose names all get their value in the declaration and are never reassigned is a `const`.
+
+**Why:** `const` tells the reader the binding won't change, and the engine enforces it.
+
+```codelaw
+native: js/prefer-const
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+let limit = 10;
+use(limit);
+```
+
+#### Do
+
+```js
+const limit = 10;
+use(limit);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+let limit = 10;
+use(limit);
+```
+
+#### Do
+
+```jsx
+const limit = 10;
+use(limit);
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+let limit = 10;
+use(limit);
+```
+
+#### Do
+
+```ts
+const limit = 10;
+use(limit);
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+let limit = 10;
+use(limit);
+```
+
+#### Do
+
+```tsx
+const limit = 10;
+use(limit);
+```