@codelaw/rules-js 0.0.0-stage → 0.1.0

package/rules/js/no-constant-condition.md

@@ -0,0 +1,150 @@
+---
+id: js/no-constant-condition
+title: "No conditions that are always true or always false"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether to remove the branch or fix the condition needs the author"
+stability: preview
+ported_from: [eslint/no-constant-condition]
+since: 0.1.0
+---
+
+The condition of an `if`, `while` or `do … while` is not a literal or another value that is always
+truthy or always falsy; `while (true)` is allowed.
+
+**Why:** A constant condition is usually leftover debugging or a typo, and hides dead code.
+
+```codelaw
+match:
+  kind: parenthesized_expression
+  inside:
+    stopBy: neighbor
+    any: [{ kind: if_statement }, { kind: while_statement }, { kind: do_statement }]
+    field: condition
+  has:
+    stopBy: neighbor
+    any:
+      - kind: number
+      - kind: string
+      - kind: "true"
+      - kind: "false"
+      - kind: "null"
+      - kind: undefined
+      - kind: array
+      - kind: object
+      - kind: arrow_function
+      - kind: function_expression
+      - kind: regex
+  not:
+    all:
+      - inside: { stopBy: neighbor, kind: while_statement }
+      - has: { stopBy: neighbor, kind: "true" }
+message: "This condition is a constant, so the branch always or never runs"
+```
+
+## How to fix
+
+1. If the branch is dead, remove it.
+2. Otherwise replace the constant with the condition that was meant.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (0) {
+  debugPanel();
+}
+```
+
+#### Do
+
+```js
+if (debug) {
+  debugPanel();
+}
+```
+
+```js
+while (true) {
+  step();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (0) {
+  debugPanel();
+}
+```
+
+#### Do
+
+```jsx
+if (debug) {
+  debugPanel();
+}
+```
+
+```jsx
+while (true) {
+  step();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (0) {
+  debugPanel();
+}
+```
+
+#### Do
+
+```ts
+if (debug) {
+  debugPanel();
+}
+```
+
+```ts
+while (true) {
+  step();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (0) {
+  debugPanel();
+}
+```
+
+#### Do
+
+```tsx
+if (debug) {
+  debugPanel();
+}
+```
+
+```tsx
+while (true) {
+  step();
+}
+```
+
+## Differences from the source
+
+Only literal conditions are checked; ESLint also folds some expressions such as `typeof x` and `!1`.

package/rules/js/no-control-regex.md

@@ -0,0 +1,84 @@
+---
+id: js/no-control-regex
+title: "No control characters in regular expressions"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "which character was meant needs the author"
+stability: preview
+ported_from: [eslint/no-control-regex]
+since: 0.1.0
+---
+
+A regular expression literal doesn't match ASCII control characters (`\x00`–`\x1F`).
+
+**Why:** Control characters rarely appear in text, so matching them is usually an escaping mistake.
+
+```codelaw
+match:
+  kind: regex_pattern
+  regex: \\x[01][0-9a-fA-F]|\\u00[01][0-9a-fA-F]|[\x00-\x1f]
+message: "Control characters in a regular expression are almost always a mistake"
+```
+
+## How to fix
+
+1. Use the named escape (`\t`, `\n`, `\f`) if one was meant.
+2. Otherwise remove the control character from the pattern.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = /\x0C/;
+```
+
+#### Do
+
+```js
+const re = /\f/;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = /\x0C/;
+```
+
+#### Do
+
+```jsx
+const re = /\f/;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = /\x0C/;
+```
+
+#### Do
+
+```ts
+const re = /\f/;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = /\x0C/;
+```
+
+#### Do
+
+```tsx
+const re = /\f/;
+```

package/rules/js/no-debugger.md

@@ -0,0 +1,99 @@
+---
+id: js/no-debugger
+title: "No debugger statements"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-debugger]
+since: 0.1.0
+---
+
+Code contains no `debugger` statements.
+
+**Why:** `debugger` pauses execution wherever developer tools are open, which nobody wants in
+shipped code.
+
+```codelaw
+match:
+  kind: debugger_statement
+message: "Remove `debugger` before committing"
+fix: [remove]
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function load() {
+  debugger;
+  return fetchAll();
+}
+```
+
+#### Do
+
+```js
+function load() {
+  return fetchAll();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function load() {
+  debugger;
+  return fetchAll();
+}
+```
+
+#### Do
+
+```jsx
+function load() {
+  return fetchAll();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+function load() {
+  debugger;
+  return fetchAll();
+}
+```
+
+#### Do
+
+```ts
+function load() {
+  return fetchAll();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function load() {
+  debugger;
+  return fetchAll();
+}
+```
+
+#### Do
+
+```tsx
+function load() {
+  return fetchAll();
+}
+```

package/rules/js/no-default-export.md

@@ -0,0 +1,88 @@
+---
+id: js/no-default-export
+title: "No default exports"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "every importer of the default export must change"
+stability: preview
+since: 0.1.0
+---
+
+Modules export by name; `export default` is not used.
+
+**Why:** A named export has one name everywhere, so it can be found, renamed and auto-imported
+reliably.
+
+```codelaw
+match:
+  kind: export_statement
+  has: { regex: ^default$ }
+message: "Export this by name instead of as the default"
+```
+
+## How to fix
+
+1. Give the exported value a name and export it with `export { name }`.
+2. Change every `import x from` of this module to `import { name } from`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+export default function load() {}
+```
+
+#### Do
+
+```js
+function load() {}
+export { load };
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+export default function load() {}
+```
+
+#### Do
+
+```jsx
+function load() {}
+export { load };
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+export default function load() {}
+```
+
+#### Do
+
+```ts
+function load() {}
+export { load };
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+export default function load() {}
+```
+
+#### Do
+
+```tsx
+function load() {}
+export { load };
+```

package/rules/js/no-delete-var.md

@@ -0,0 +1,93 @@
+---
+id: js/no-delete-var
+title: "No delete on a variable"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "what the code meant to clear is a decision"
+stability: preview
+ported_from: [eslint/no-delete-var]
+since: 0.1.0
+---
+
+`delete` is applied to object properties, never to a variable.
+
+**Why:** Deleting a variable does nothing in sloppy mode and is a syntax error in strict mode.
+
+```codelaw
+match:
+  pattern: delete $X
+constraints:
+  X: { kind: identifier }
+message: "`delete` works on properties, not on the variable `$X`"
+```
+
+## How to fix
+
+1. To clear the value, assign `undefined` or a fresh value.
+2. To remove a property, `delete obj.key`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+let cache = {};
+delete cache;
+```
+
+#### Do
+
+```js
+let cache = {};
+cache = {};
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+let cache = {};
+delete cache;
+```
+
+#### Do
+
+```jsx
+let cache = {};
+cache = {};
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+let cache = {};
+delete cache;
+```
+
+#### Do
+
+```ts
+let cache = {};
+cache = {};
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+let cache = {};
+delete cache;
+```
+
+#### Do
+
+```tsx
+let cache = {};
+cache = {};
+```

package/rules/js/no-dupe-args.md

@@ -0,0 +1,61 @@
+---
+id: js/no-dupe-args
+title: "No two parameters share a name"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "which parameter was meant can't be known from the code"
+stability: preview
+ported_from: [eslint/no-dupe-args]
+since: 0.1.0
+---
+
+A function's parameters, destructured ones included, all have different names.
+
+**Why:** The later parameter silently hides the earlier one, so one argument can never be read.
+
+```codelaw
+native: js/no-dupe-args
+```
+
+## How to fix
+
+1. Rename the duplicate parameter.
+2. Update the body to read the parameter it meant.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function add(a, b, a) {
+  return a + b;
+}
+```
+
+#### Do
+
+```js
+function add(a, b, c) {
+  return a + b + c;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function add(a, b, a) {
+  return a + b;
+}
+```
+
+#### Do
+
+```jsx
+function add(a, b, c) {
+  return a + b + c;
+}
+```

package/rules/js/no-dupe-class-members.md

@@ -0,0 +1,82 @@
+---
+id: js/no-dupe-class-members
+title: "No two class members share a name"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "which of the two members to keep is a decision"
+stability: preview
+ported_from: [eslint/no-dupe-class-members]
+since: 0.1.0
+---
+
+A class declares each method and field name once, separately for static and instance members; a
+getter and a setter may share a name.
+
+**Why:** The later declaration replaces the earlier one, so one of them is dead code.
+
+```codelaw
+native: js/no-dupe-class-members
+```
+
+## How to fix
+
+1. Decide which declaration is right.
+2. Remove or rename the other.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+class Cart {
+  total() {
+    return 1;
+  }
+  total() {
+    return 2;
+  }
+}
+```
+
+#### Do
+
+```js
+class Cart {
+  total() {
+    return 1;
+  }
+  subtotal() {
+    return 2;
+  }
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+class Cart {
+  total() {
+    return 1;
+  }
+  total() {
+    return 2;
+  }
+}
+```
+
+#### Do
+
+```jsx
+class Cart {
+  total() {
+    return 1;
+  }
+  subtotal() {
+    return 2;
+  }
+}
+```