@codelaw/rules-js 0.0.0-stage → 0.2.0

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;
+  }
+}
+```

package/rules/js/no-dupe-else-if.md

@@ -0,0 +1,113 @@
+---
+id: js/no-dupe-else-if
+title: "No two conditions in an if/else-if chain are the same"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "what the second condition should have been is a decision"
+stability: preview
+ported_from: [eslint/no-dupe-else-if]
+since: 0.1.0
+---
+
+Each condition in an `if … else if …` chain is different from the ones before it.
+
+**Why:** A repeated condition's branch can never run, because the earlier one already took it.
+
+```codelaw
+native: js/no-dupe-else-if
+```
+
+## How to fix
+
+1. Find the repeated condition.
+2. Correct it to the case it was meant to handle, or remove the dead branch.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (isAdmin) {
+  grant();
+} else if (isAdmin) {
+  audit();
+}
+```
+
+#### Do
+
+```js
+if (isAdmin) {
+  grant();
+} else if (isAuditor) {
+  audit();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (isAdmin) {
+  grant();
+} else if (isAdmin) {
+  audit();
+}
+```
+
+#### Do
+
+```jsx
+if (isAdmin) {
+  grant();
+} else if (isAuditor) {
+  audit();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (isAdmin) {
+  grant();
+} else if (isAdmin) {
+  audit();
+}
+```
+
+#### Do
+
+```ts
+if (isAdmin) {
+  grant();
+} else if (isAuditor) {
+  audit();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (isAdmin) {
+  grant();
+} else if (isAdmin) {
+  audit();
+}
+```
+
+#### Do
+
+```tsx
+if (isAdmin) {
+  grant();
+} else if (isAuditor) {
+  audit();
+}
+```

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

@@ -0,0 +1,66 @@
+---
+id: js/no-dupe-keys
+title: "No two keys in an object literal are the same"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "which value should win can't be known from the code"
+stability: preview
+ported_from: [eslint/no-dupe-keys]
+since: 0.1.0
+---
+
+An object literal names each key once; `a`, `'a'` and `["a"]` are the same key, as are `1` and
+`0x1`.
+
+**Why:** The later value silently replaces the earlier one.
+
+```codelaw
+native: js/no-dupe-keys
+```
+
+## How to fix
+
+1. Decide which value the key should have.
+2. Remove the other entry, or give it its own key.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const user = {
+  name: "Ada",
+  name: "Grace",
+};
+```
+
+#### Do
+
+```js
+const user = {
+  name: "Ada",
+  nickname: "Grace",
+};
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const user = {
+  name: "Ada",
+  name: "Grace",
+};
+```
+
+#### Do
+
+```jsx
+const user = {
+  name: "Ada",
+  nickname: "Grace",
+};
+```

package/rules/js/no-duplicate-case.md

@@ -0,0 +1,137 @@
+---
+id: js/no-duplicate-case
+title: "No two case labels in a switch are the same"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "which label was meant is a decision"
+stability: preview
+ported_from: [eslint/no-duplicate-case]
+since: 0.1.0
+---
+
+Each `case` in a `switch` tests a different expression.
+
+**Why:** A repeated case can never match: the first one always wins.
+
+```codelaw
+native: js/no-duplicate-case
+```
+
+## How to fix
+
+1. Find the label that was meant to test something else.
+2. Correct it, or merge the two bodies.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 200:
+    retry();
+    break;
+}
+```
+
+#### Do
+
+```js
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 503:
+    retry();
+    break;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 200:
+    retry();
+    break;
+}
+```
+
+#### Do
+
+```jsx
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 503:
+    retry();
+    break;
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 200:
+    retry();
+    break;
+}
+```
+
+#### Do
+
+```ts
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 503:
+    retry();
+    break;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 200:
+    retry();
+    break;
+}
+```
+
+#### Do
+
+```tsx
+switch (status) {
+  case 200:
+    ok();
+    break;
+  case 503:
+    retry();
+    break;
+}
+```

package/rules/js/no-empty-character-class.md

@@ -0,0 +1,98 @@
+---
+id: js/no-empty-character-class
+title: "No empty character classes in regular expressions"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "which characters the class should hold needs the author"
+stability: preview
+ported_from: [eslint/no-empty-character-class]
+since: 0.1.0
+---
+
+A regular expression contains no empty character class `[]`; `[^]`, which matches any character, is
+fine.
+
+**Why:** `[]` matches no character at all, so the whole pattern can never match.
+
+```codelaw
+native: js/no-empty-character-class
+```
+
+## How to fix
+
+1. Put the characters the class should match inside it.
+2. If `[]` was meant literally, escape it: `\[\]`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = /^abc[]/;
+```
+
+#### Do
+
+```js
+const re = /^abc[a-z]/;
+```
+
+```js
+const brackets = /^\s*[{[]/;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = /^abc[]/;
+```
+
+#### Do
+
+```jsx
+const re = /^abc[a-z]/;
+```
+
+```jsx
+const brackets = /^\s*[{[]/;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = /^abc[]/;
+```
+
+#### Do
+
+```ts
+const re = /^abc[a-z]/;
+```
+
+```ts
+const brackets = /^\s*[{[]/;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = /^abc[]/;
+```
+
+#### Do
+
+```tsx
+const re = /^abc[a-z]/;
+```
+
+```tsx
+const brackets = /^\s*[{[]/;
+```