@codelaw/rules-js 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,75 @@
+---
+id: js/no-regex-spaces
+title: "No runs of spaces in a regular expression"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-regex-spaces]
+since: 0.1.0
+---
+
+A regular expression writes several spaces as ` {n}`, not as a run of spaces.
+
+**Why:** A run of spaces is impossible to count by eye.
+
+```codelaw
+native: js/no-regex-spaces
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = /a   b/;
+```
+
+#### Do
+
+```js
+const re = /a {3}b/;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = /a   b/;
+```
+
+#### Do
+
+```jsx
+const re = /a {3}b/;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = /a   b/;
+```
+
+#### Do
+
+```ts
+const re = /a {3}b/;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = /a   b/;
+```
+
+#### Do
+
+```tsx
+const re = /a {3}b/;
+```

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

@@ -0,0 +1,91 @@
+---
+id: js/no-self-assign
+title: "No assigning a variable to itself"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "assigning a property to itself can run a setter, so removing it may change behaviour"
+stability: preview
+ported_from: [eslint/no-self-assign]
+since: 0.1.0
+---
+
+An assignment's left and right sides are not the same expression.
+
+**Why:** `a = a` has no effect; it is usually a typo for another name.
+
+```codelaw
+match:
+  pattern: $A = $A
+message: "Assigning `$A` to itself does nothing"
+```
+
+## How to fix
+
+1. If another value was meant, assign that.
+2. Otherwise remove the assignment.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+let x = 1;
+x = x;
+```
+
+#### Do
+
+```js
+let x = 1;
+x = y;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+let x = 1;
+x = x;
+```
+
+#### Do
+
+```jsx
+let x = 1;
+x = y;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+let x = 1;
+x = x;
+```
+
+#### Do
+
+```ts
+let x = 1;
+x = y;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+let x = 1;
+x = x;
+```
+
+#### Do
+
+```tsx
+let x = 1;
+x = y;
+```

package/rules/js/no-setter-return.md

@@ -0,0 +1,69 @@
+---
+id: js/no-setter-return
+title: "A setter does not return a value"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "whether the returned expression was meant as a side effect needs a reader"
+stability: preview
+ported_from: [eslint/no-setter-return]
+since: 0.1.0
+---
+
+A setter body contains no `return <value>`; a bare `return;` to leave early is fine.
+
+**Why:** The value a setter returns is discarded, so returning one hides a mistake.
+
+```codelaw
+native: js/no-setter-return
+```
+
+## How to fix
+
+1. Keep the expression's side effect as a statement.
+2. Remove the value from the `return`, or the `return`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const box = {
+  set size(n) {
+    return (this.n = n);
+  },
+};
+```
+
+#### Do
+
+```js
+const box = {
+  set size(n) {
+    this.n = n;
+  },
+};
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const box = {
+  set size(n) {
+    return (this.n = n);
+  },
+};
+```
+
+#### Do
+
+```jsx
+const box = {
+  set size(n) {
+    this.n = n;
+  },
+};
+```

package/rules/js/no-shadow-restricted-names.md

@@ -0,0 +1,102 @@
+---
+id: js/no-shadow-restricted-names
+title: "No declaring undefined, NaN, Infinity, arguments, eval or globalThis"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the new name is the author's choice"
+stability: preview
+ported_from: [eslint/no-shadow-restricted-names]
+since: 0.1.0
+---
+
+No variable, parameter or function is named `undefined`, `NaN`, `Infinity`, `arguments`, `eval` or
+`globalThis`.
+
+**Why:** Shadowing these names makes code that relies on them behave in confusing ways.
+
+```codelaw
+match:
+  kind: identifier
+  regex: ^(undefined|NaN|Infinity|arguments|eval|globalThis)$
+where:
+  $$MATCH: declaration
+message: "`$$MATCH` is a restricted name; don't declare it"
+```
+
+## How to fix
+
+1. Rename the declaration and its uses.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function check(NaN) {
+  return NaN;
+}
+```
+
+#### Do
+
+```js
+function check(value) {
+  return value;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function check(NaN) {
+  return NaN;
+}
+```
+
+#### Do
+
+```jsx
+function check(value) {
+  return value;
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+function check(NaN) {
+  return NaN;
+}
+```
+
+#### Do
+
+```ts
+function check(value) {
+  return value;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function check(NaN) {
+  return NaN;
+}
+```
+
+#### Do
+
+```tsx
+function check(value) {
+  return value;
+}
+```

package/rules/js/no-sparse-arrays.md

@@ -0,0 +1,82 @@
+---
+id: js/no-sparse-arrays
+title: "No holes in array literals"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether a value is missing or a comma is extra needs a reader"
+stability: preview
+ported_from: [eslint/no-sparse-arrays]
+since: 0.1.0
+---
+
+An array literal has no empty slots such as `[1, , 2]`.
+
+**Why:** A hole is usually a typo, and holes behave differently from `undefined` in many array
+methods.
+
+```codelaw
+native: js/no-sparse-arrays
+```
+
+## How to fix
+
+1. Put the missing value in the slot, or remove the extra comma.
+2. If an empty slot is really meant, write `undefined` explicitly.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const colors = ["red", , "blue"];
+```
+
+#### Do
+
+```js
+const colors = ["red", "green", "blue"];
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const colors = ["red", , "blue"];
+```
+
+#### Do
+
+```jsx
+const colors = ["red", "green", "blue"];
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const colors = ["red", , "blue"];
+```
+
+#### Do
+
+```ts
+const colors = ["red", "green", "blue"];
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const colors = ["red", , "blue"];
+```
+
+#### Do
+
+```tsx
+const colors = ["red", "green", "blue"];
+```

package/rules/js/no-this-before-super.md

@@ -0,0 +1,74 @@
+---
+id: js/no-this-before-super
+title: "this is not used before super() in a derived constructor"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "moving statements across `super()` can change what the base class sees"
+stability: preview
+ported_from: [eslint/no-this-before-super]
+since: 0.1.0
+---
+
+In the constructor of a class that extends another, `this` and `super.x` are used only after
+`super()` has been called.
+
+**Why:** Before `super()` runs, `this` is not initialised and touching it throws a ReferenceError.
+
+```codelaw
+native: js/no-this-before-super
+```
+
+## How to fix
+
+1. Move the `super(...)` call above the first use of `this`.
+2. If the base class needs a value computed from `this`, compute it into a local first.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+class Cat extends Animal {
+  constructor() {
+    this.lives = 9;
+    super();
+  }
+}
+```
+
+#### Do
+
+```js
+class Cat extends Animal {
+  constructor() {
+    super();
+    this.lives = 9;
+  }
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+class Cat extends Animal {
+  constructor() {
+    this.lives = 9;
+    super();
+  }
+}
+```
+
+#### Do
+
+```jsx
+class Cat extends Animal {
+  constructor() {
+    super();
+    this.lives = 9;
+  }
+}
+```

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

@@ -0,0 +1,102 @@
+---
+id: js/no-unassigned-vars
+title: "A variable that is read is also assigned"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the value the variable should hold is the author's"
+stability: preview
+ported_from: [eslint/no-unassigned-vars]
+since: 0.1.0
+---
+
+A variable declared without a value is assigned somewhere before it's read.
+
+**Why:** A variable that is read but never assigned always holds `undefined`, which is a bug or dead
+code.
+
+```codelaw
+match:
+  kind: variable_declarator
+  has: { field: name, kind: identifier, pattern: $N }
+  inside:
+    stopBy: neighbor
+    any: [{ kind: lexical_declaration }, { kind: variable_declaration }]
+  not:
+    any:
+      - has: { field: value, pattern: $VALUE }
+      - inside: { kind: ambient_declaration, stopBy: end }
+where:
+  $N: [{ not: reassigned }, { not: unused }]
+message: "`$N` is read but never assigned, so it's always undefined"
+```
+
+## How to fix
+
+1. Assign the value the variable should hold.
+2. If it's meant to be `undefined`, use `undefined` directly.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+let status;
+report(status);
+```
+
+#### Do
+
+```js
+let status = "ok";
+report(status);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+let status;
+report(status);
+```
+
+#### Do
+
+```jsx
+let status = "ok";
+report(status);
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+let status;
+report(status);
+```
+
+#### Do
+
+```ts
+let status = "ok";
+report(status);
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+let status;
+report(status);
+```
+
+#### Do
+
+```tsx
+let status = "ok";
+report(status);
+```

package/rules/js/no-undef.md

@@ -0,0 +1,76 @@
+---
+id: js/no-undef
+title: "No references to undeclared names"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "the right declaration — an import, a local, or an environment — is the author's call"
+stability: preview
+options:
+  env: { type: "string[]", default: ["shared-node-browser"], description: "environments whose globals are declared: browser, node, commonjs, worker, serviceworker, shared-node-browser, jest, mocha, vitest" }
+  globals: { type: "string[]", default: [], description: "more names to treat as declared" }
+  typeof: { type: "boolean", default: false, description: "also report names used only as `typeof x`" }
+ported_from: [eslint/no-undef]
+since: 0.1.0
+---
+
+Every name the code reads or writes is declared in the file, built into JavaScript, or a global of
+an environment the rule's `env` option names. As in ESLint, a `/* global a, b:writable */` comment
+declares names for that file (`name:off` declares nothing), and a `/* eslint-env node */` comment
+adds environments.
+
+**Why:** An undeclared name is usually a typo or a missing import, and throws a ReferenceError when
+that line runs.
+
+```codelaw
+native: js/no-undef
+```
+
+## How to fix
+
+1. If it's a typo, correct the name.
+2. If it comes from another module, import it.
+3. If it's a global of the runtime (browser, Node), add that environment to the rule's `env` option.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const total = prices.reduce(add, 0);
+function add(a, b) {
+  return a + b;
+}
+```
+
+#### Do
+
+```js
+const prices = [1, 2];
+const total = prices.reduce(add, 0);
+function add(a, b) {
+  return a + b;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const total = prices.reduce(add, 0);
+function add(a, b) {
+  return a + b;
+}
+```
+
+#### Do
+
+```jsx
+const prices = [1, 2];
+const total = prices.reduce(add, 0);
+function add(a, b) {
+  return a + b;
+}
+```