@codelaw/rules-js 0.0.0-stage → 0.2.0

package/rules/js/no-obj-calls.md

@@ -0,0 +1,61 @@
+---
+id: js/no-obj-calls
+title: "No calling Math, JSON, Reflect, Atomics or Intl as functions"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "which method was meant needs the author"
+stability: preview
+ported_from: [eslint/no-obj-calls]
+since: 0.1.0
+---
+
+The built-in namespace objects `Math`, `JSON`, `Reflect`, `Atomics` and `Intl` are not called or
+constructed.
+
+**Why:** They are plain objects; calling one throws a TypeError.
+
+```codelaw
+match:
+  any:
+    - pattern: $C($$$ARGS)
+    - pattern: new $C($$$ARGS)
+constraints:
+  C: { regex: ^(Math|JSON|Reflect|Atomics|Intl)$ }
+where:
+  $C: builtin
+message: "`$C` is a namespace object, not a function"
+```
+
+## How to fix
+
+1. Call the method of the namespace that was meant, e.g. `Math.round(x)`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const n = Math(2.5);
+```
+
+#### Do
+
+```js
+const n = Math.round(2.5);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const n = Math(2.5);
+```
+
+#### Do
+
+```jsx
+const n = Math.round(2.5);
+```

package/rules/js/no-octal.md

@@ -0,0 +1,84 @@
+---
+id: js/no-octal
+title: "No legacy octal literals"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether octal or decimal was meant needs the author"
+stability: preview
+ported_from: [eslint/no-octal]
+since: 0.1.0
+---
+
+Number literals don't start with `0` followed by a digit.
+
+**Why:** `071` is octal (57) in sloppy code and an error in strict code; `0o71` says what it means.
+
+```codelaw
+match:
+  kind: number
+  regex: ^0[0-9]
+message: "`$$MATCH` is a legacy octal literal; write 0o… for octal or drop the leading 0"
+```
+
+## How to fix
+
+1. For an octal number, write `0o` and the digits.
+2. For a decimal number, drop the leading zero.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const mode = 0755;
+```
+
+#### Do
+
+```js
+const mode = 0o755;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const mode = 0755;
+```
+
+#### Do
+
+```jsx
+const mode = 0o755;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const mode = 0755;
+```
+
+#### Do
+
+```ts
+const mode = 0o755;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const mode = 0755;
+```
+
+#### Do
+
+```tsx
+const mode = 0o755;
+```

package/rules/js/no-prototype-builtins.md

@@ -0,0 +1,99 @@
+---
+id: js/no-prototype-builtins
+title: "No calling Object.prototype methods on the object itself"
+languages: [javascript, jsx, typescript, tsx]
+fix: suggest
+fix_reason: "an object whose own method is meant would change behaviour"
+stability: preview
+ported_from: [eslint/no-prototype-builtins]
+since: 0.1.0
+---
+
+`hasOwnProperty`, `isPrototypeOf` and `propertyIsEnumerable` are called through `Object.prototype`,
+not on the object being tested.
+
+**Why:** An object can shadow these methods, or have no prototype at all, and then the call breaks
+or lies.
+
+```codelaw
+match:
+  pattern: $O.$M($$$ARGS)
+constraints:
+  M: { regex: ^(hasOwnProperty|isPrototypeOf|propertyIsEnumerable)$ }
+message: "Call `Object.prototype.$M` through `.call`, or use `Object.hasOwn`"
+fix: "Object.prototype.$M.call($O, $$$ARGS)"
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (options.hasOwnProperty("debug")) {
+  enable();
+}
+```
+
+#### Do
+
+```js
+if (Object.prototype.hasOwnProperty.call(options, "debug")) {
+  enable();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (options.hasOwnProperty("debug")) {
+  enable();
+}
+```
+
+#### Do
+
+```jsx
+if (Object.prototype.hasOwnProperty.call(options, "debug")) {
+  enable();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (options.hasOwnProperty("debug")) {
+  enable();
+}
+```
+
+#### Do
+
+```ts
+if (Object.prototype.hasOwnProperty.call(options, "debug")) {
+  enable();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (options.hasOwnProperty("debug")) {
+  enable();
+}
+```
+
+#### Do
+
+```tsx
+if (Object.prototype.hasOwnProperty.call(options, "debug")) {
+  enable();
+}
+```

package/rules/js/no-redeclare.md

@@ -0,0 +1,61 @@
+---
+id: js/no-redeclare
+title: "No variable is declared twice"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "whether to rename or to assign needs the author"
+stability: preview
+ported_from: [eslint/no-redeclare]
+since: 0.1.0
+---
+
+A name is declared once per scope: a second `var` or `function` with the same name is not allowed.
+
+**Why:** Redeclaring silently merges two declarations, so one of them is usually a mistake.
+
+```codelaw
+match:
+  kind: identifier
+where:
+  $$MATCH: [declaration, redeclared]
+message: "`$$MATCH` is already declared in this scope"
+```
+
+## How to fix
+
+1. If it's the same variable, drop the second `var` and assign.
+2. If it's a different one, rename it.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+var count = 1;
+var count = 2;
+```
+
+#### Do
+
+```js
+var count = 1;
+count = 2;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+var count = 1;
+var count = 2;
+```
+
+#### Do
+
+```jsx
+var count = 1;
+count = 2;
+```

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"];
+```