@codelaw/rules-js 0.0.0-stage → 0.1.0

package/rules/js/no-ex-assign.md

@@ -0,0 +1,121 @@
+---
+id: js/no-ex-assign
+title: "A caught error is not reassigned"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "where the original error should go is a decision"
+stability: preview
+ported_from: [eslint/no-ex-assign]
+since: 0.1.0
+---
+
+Code doesn't assign a new value to the parameter of a `catch` clause.
+
+**Why:** Reassigning the caught error discards it, so nothing can report or rethrow it.
+
+```codelaw
+match:
+  kind: identifier
+where:
+  $$MATCH: [write, { binding: catch-param }]
+message: "Assigning to the caught error `$$MATCH` loses it"
+```
+
+## How to fix
+
+1. Use a new variable for the new value.
+2. Keep the original error, e.g. as `{ cause: err }`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+try {
+  load();
+} catch (err) {
+  err = new Error("failed");
+  throw err;
+}
+```
+
+#### Do
+
+```js
+try {
+  load();
+} catch (err) {
+  throw new Error("failed", { cause: err });
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+try {
+  load();
+} catch (err) {
+  err = new Error("failed");
+  throw err;
+}
+```
+
+#### Do
+
+```jsx
+try {
+  load();
+} catch (err) {
+  throw new Error("failed", { cause: err });
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+try {
+  load();
+} catch (err) {
+  err = new Error("failed");
+  throw err;
+}
+```
+
+#### Do
+
+```ts
+try {
+  load();
+} catch (err) {
+  throw new Error("failed", { cause: err });
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+try {
+  load();
+} catch (err) {
+  err = new Error("failed");
+  throw err;
+}
+```
+
+#### Do
+
+```tsx
+try {
+  load();
+} catch (err) {
+  throw new Error("failed", { cause: err });
+}
+```

package/rules/js/no-extra-boolean-cast.md

@@ -0,0 +1,107 @@
+---
+id: js/no-extra-boolean-cast
+title: "No needless !! or Boolean() in a condition"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-extra-boolean-cast]
+since: 0.1.0
+---
+
+A condition (`if`, `while`, `do … while`, `? :`) doesn't convert its value with `!!`.
+
+**Why:** A condition is already evaluated as a boolean, so `!!` only adds noise.
+
+```codelaw
+match:
+  pattern: "!!$X"
+  any:
+    - inside:
+        stopBy: neighbor
+        kind: parenthesized_expression
+        inside:
+          stopBy: neighbor
+          any: [{ kind: if_statement }, { kind: while_statement }, { kind: do_statement }]
+          field: condition
+    - inside: { stopBy: neighbor, kind: ternary_expression, field: condition }
+message: "A condition already converts to boolean; `!!` is redundant"
+fix: "$X"
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (!!user) {
+  greet();
+}
+```
+
+#### Do
+
+```js
+if (user) {
+  greet();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (!!user) {
+  greet();
+}
+```
+
+#### Do
+
+```jsx
+if (user) {
+  greet();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (!!user) {
+  greet();
+}
+```
+
+#### Do
+
+```ts
+if (user) {
+  greet();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (!!user) {
+  greet();
+}
+```
+
+#### Do
+
+```tsx
+if (user) {
+  greet();
+}
+```
+
+## Differences from the source
+
+`Boolean(x)` in a condition is not checked yet.

package/rules/js/no-fallthrough.md

@@ -0,0 +1,178 @@
+---
+id: js/no-fallthrough
+title: "A switch case does not fall through into the next by accident"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether the fall-through is intended needs the author"
+stability: preview
+ported_from: [eslint/no-fallthrough]
+since: 0.1.0
+---
+
+A `case` with statements ends in `break`, `return`, `throw` or `continue`, or says `// falls
+through` before the next case.
+
+**Why:** Falling through is easy to do by accident and hard to see in review.
+
+```codelaw
+native: js/no-fallthrough
+```
+
+## How to fix
+
+1. If the case should stop, end it with `break` (or `return`).
+2. If it should fall through, say so with a `// falls through` comment before the next case.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+switch (kind) {
+  case "a":
+    first();
+  case "b":
+    second();
+    break;
+}
+```
+
+#### Do
+
+```js
+switch (kind) {
+  case "a":
+    first();
+    break;
+  case "b":
+    second();
+    break;
+}
+```
+
+```js
+switch (kind) {
+  case "a":
+    first();
+  // falls through
+  case "b":
+    second();
+    break;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+switch (kind) {
+  case "a":
+    first();
+  case "b":
+    second();
+    break;
+}
+```
+
+#### Do
+
+```jsx
+switch (kind) {
+  case "a":
+    first();
+    break;
+  case "b":
+    second();
+    break;
+}
+```
+
+```jsx
+switch (kind) {
+  case "a":
+    first();
+  // falls through
+  case "b":
+    second();
+    break;
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+switch (kind) {
+  case "a":
+    first();
+  case "b":
+    second();
+    break;
+}
+```
+
+#### Do
+
+```ts
+switch (kind) {
+  case "a":
+    first();
+    break;
+  case "b":
+    second();
+    break;
+}
+```
+
+```ts
+switch (kind) {
+  case "a":
+    first();
+  // falls through
+  case "b":
+    second();
+    break;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+switch (kind) {
+  case "a":
+    first();
+  case "b":
+    second();
+    break;
+}
+```
+
+#### Do
+
+```tsx
+switch (kind) {
+  case "a":
+    first();
+    break;
+  case "b":
+    second();
+    break;
+}
+```
+
+```tsx
+switch (kind) {
+  case "a":
+    first();
+  // falls through
+  case "b":
+    second();
+    break;
+}
+```

package/rules/js/no-func-assign.md

@@ -0,0 +1,62 @@
+---
+id: js/no-func-assign
+title: "A function declaration is not reassigned"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "what the assignment was for is the author's call"
+stability: preview
+ported_from: [eslint/no-func-assign]
+since: 0.1.0
+---
+
+Code doesn't assign a new value to the name a function declaration binds.
+
+**Why:** Overwriting a declared function is almost always a mistake, and every later call means
+something else.
+
+```codelaw
+match:
+  kind: identifier
+where:
+  $$MATCH: [write, { binding: function }]
+message: "`$$MATCH` is a function declaration; don't assign to it"
+```
+
+## How to fix
+
+1. Assign to a new variable instead.
+2. If the function must be replaceable, declare it with `let` as a function expression.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function save() {}
+save = null;
+```
+
+#### Do
+
+```js
+function save() {}
+const saveHandler = null;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function save() {}
+save = null;
+```
+
+#### Do
+
+```jsx
+function save() {}
+const saveHandler = null;
+```

package/rules/js/no-global-assign.md

@@ -0,0 +1,85 @@
+---
+id: js/no-global-assign
+title: "No assignment to built-in globals"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the intended variable needs a name of its own"
+stability: preview
+ported_from: [eslint/no-global-assign]
+since: 0.1.0
+---
+
+Code doesn't assign to JavaScript's built-in globals such as `Object`, `undefined` or `NaN`.
+
+**Why:** Built-in globals are read-only or shared by every module, so assigning to one is a bug or a
+hazard.
+
+```codelaw
+match:
+  kind: identifier
+where:
+  $$MATCH: [write, builtin]
+message: "`$$MATCH` is a built-in global; don't assign to it"
+```
+
+## How to fix
+
+1. Declare a local variable with its own name.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+Object = null;
+```
+
+#### Do
+
+```js
+const object = null;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+Object = null;
+```
+
+#### Do
+
+```jsx
+const object = null;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+Object = null;
+```
+
+#### Do
+
+```ts
+const object = null;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+Object = null;
+```
+
+#### Do
+
+```tsx
+const object = null;
+```

package/rules/js/no-import-assign.md

@@ -0,0 +1,60 @@
+---
+id: js/no-import-assign
+title: "An imported binding is not reassigned"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "the new value needs a variable of its own"
+stability: preview
+ported_from: [eslint/no-import-assign]
+since: 0.1.0
+---
+
+Code doesn't assign a new value to a name bound by `import`.
+
+**Why:** Imported bindings are read-only: assigning to one throws a TypeError.
+
+```codelaw
+match:
+  kind: identifier
+where:
+  $$MATCH: [write, { binding: import }]
+message: "`$$MATCH` is an import; imports are read-only"
+```
+
+## How to fix
+
+1. Copy the import into a local variable and change that.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+import config from "./config.js";
+config = {};
+```
+
+#### Do
+
+```js
+import config from "./config.js";
+const local = { ...config };
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+import config from "./config.js";
+config = {};
+```
+
+#### Do
+
+```jsx
+import config from "./config.js";
+const local = { ...config };
+```

package/rules/js/no-invalid-regexp.md

@@ -0,0 +1,86 @@
+---
+id: js/no-invalid-regexp
+title: "RegExp() is given a valid pattern and flags"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the intended pattern needs the author"
+stability: preview
+ported_from: [eslint/no-invalid-regexp]
+since: 0.1.0
+---
+
+A `RegExp(...)` or `new RegExp(...)` whose pattern and flags are string literals is valid: brackets
+and groups close, quantifiers follow something, and the flags are known and not repeated.
+
+**Why:** An invalid pattern throws a SyntaxError when that line runs, not when the file loads.
+
+```codelaw
+native: js/no-invalid-regexp
+```
+
+## How to fix
+
+1. Correct the pattern or the flags the message names.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = new RegExp("[a-z");
+```
+
+#### Do
+
+```js
+const re = new RegExp("[a-z]");
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = new RegExp("[a-z");
+```
+
+#### Do
+
+```jsx
+const re = new RegExp("[a-z]");
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = new RegExp("[a-z");
+```
+
+#### Do
+
+```ts
+const re = new RegExp("[a-z]");
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = new RegExp("[a-z");
+```
+
+#### Do
+
+```tsx
+const re = new RegExp("[a-z]");
+```
+
+## Differences from the source
+
+Only structural problems are found: unbalanced brackets and groups, misplaced quantifiers, out-of-
+order ranges, invalid group syntax and flags.