@codelaw/rules-js 0.0.0-stage → 0.1.0

package/rules/js/no-irregular-whitespace.md

@@ -0,0 +1,87 @@
+---
+id: js/no-irregular-whitespace
+title: "No irregular whitespace in templates, regular expressions, JSX text or comments"
+languages: [javascript, jsx, typescript, tsx]
+fix: suggest
+fix_reason: "the escape keeps a template's cooked value but changes the raw string a tagged template such as `String.raw` sees"
+stability: preview
+ported_from: [eslint/no-irregular-whitespace]
+since: 0.1.0
+---
+
+Templates, regular expressions and JSX text spell a no-break space, zero-width space or other
+irregular whitespace as an escape (`\u00A0`, ` `), and comments use ordinary spaces.
+
+**Why:** Irregular whitespace is invisible in most editors. In a template, regular expression or JSX
+text it silently becomes part of the value, so the text looks right and compares wrong.
+
+```codelaw
+native: js/no-irregular-whitespace
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const label = `Total: 1`;
+```
+
+#### Do
+
+```js
+const label = `Total:\u00A01`;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const label = <p>Total: 1</p>;
+```
+
+#### Do
+
+```jsx
+const label = <p>Total:&#x00A0;1</p>;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const label = `Total: 1`;
+```
+
+#### Do
+
+```ts
+const label = `Total:\u00A01`;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const label = <p>Total: 1</p>;
+```
+
+#### Do
+
+```tsx
+const label = <p>Total:&#x00A0;1</p>;
+```
+
+## Differences from the source
+
+- **Between tokens the formatter owns it.** ESLint also reports irregular whitespace between tokens;
+  here that is layout, and `codelaw format` replaces it with a space (SR-FORMATTER decision 3), so
+  this rule does not report it.
+- **Strings are skipped**, as ESLint's `skipStrings` default does.
+- **The fix escapes, it doesn't delete:** `\uXXXX` in a template or regular expression, `&#xXXXX;`
+  in JSX text, so the value is unchanged; a comment gets an ordinary space.

package/rules/js/no-loss-of-precision.md

@@ -0,0 +1,82 @@
+---
+id: js/no-loss-of-precision
+title: "Number literals keep their value"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether to use a BigInt, a string or a rounder value depends on how the number is used"
+stability: preview
+ported_from: [eslint/no-loss-of-precision]
+since: 0.1.0
+---
+
+A number literal can be represented exactly as a JavaScript number.
+
+**Why:** A literal with more precision than a double holds is silently rounded, so the code doesn't
+mean what it says.
+
+```codelaw
+native: js/no-loss-of-precision
+```
+
+## How to fix
+
+1. Use a BigInt (`123n`) for an exact large integer.
+2. Or keep the value as a string, or write the value the code really gets.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const id = 9007199254740993;
+```
+
+#### Do
+
+```js
+const id = 9007199254740993n;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const id = 9007199254740993;
+```
+
+#### Do
+
+```jsx
+const id = 9007199254740993n;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const id = 9007199254740993;
+```
+
+#### Do
+
+```ts
+const id = 9007199254740993n;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const id = 9007199254740993;
+```
+
+#### Do
+
+```tsx
+const id = 9007199254740993n;
+```

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

@@ -0,0 +1,83 @@
+---
+id: js/no-misleading-character-class
+title: "No character class holding a character made of several code points"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether an alternation or a different class was meant needs the author"
+stability: preview
+ported_from: [eslint/no-misleading-character-class]
+since: 0.1.0
+---
+
+A character class contains no character built from several code points — an emoji with a skin-tone
+modifier, a flag, a letter with a combining mark — and no astral character without the `u` flag.
+
+**Why:** A class matches one code point at a time, so `[👍🏻]` matches the thumb or the tone, never
+the pair.
+
+```codelaw
+native: js/no-misleading-character-class
+```
+
+## How to fix
+
+1. Use an alternation such as `(?:👍🏻|👍)` for multi-code-point characters.
+2. Add the `u` flag for astral characters.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = /^[❤️]$/u;
+```
+
+#### Do
+
+```js
+const re = /^(?:❤️)$/u;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = /^[❤️]$/u;
+```
+
+#### Do
+
+```jsx
+const re = /^(?:❤️)$/u;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = /^[❤️]$/u;
+```
+
+#### Do
+
+```ts
+const re = /^(?:❤️)$/u;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = /^[❤️]$/u;
+```
+
+#### Do
+
+```tsx
+const re = /^(?:❤️)$/u;
+```

package/rules/js/no-new-native-nonconstructor.md

@@ -0,0 +1,55 @@
+---
+id: js/no-new-native-nonconstructor
+title: "No new on Symbol or BigInt"
+languages: [javascript, jsx]
+fix: suggest
+fix_reason: "the call throws today, so removing `new` changes what the code does"
+stability: preview
+ported_from: [eslint/no-new-native-nonconstructor]
+since: 0.1.0
+---
+
+`Symbol` and `BigInt` are called as functions, never with `new`.
+
+**Why:** `new Symbol()` and `new BigInt()` throw a TypeError.
+
+```codelaw
+match:
+  pattern: new $C($$$ARGS)
+constraints:
+  C: { regex: ^(Symbol|BigInt)$ }
+where:
+  $C: builtin
+message: "`$C` is not a constructor; call it without `new`"
+fix: "$C($$$ARGS)"
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const id = new Symbol("id");
+```
+
+#### Do
+
+```js
+const id = Symbol("id");
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const id = new Symbol("id");
+```
+
+#### Do
+
+```jsx
+const id = Symbol("id");
+```

package/rules/js/no-nonoctal-decimal-escape.md

@@ -0,0 +1,84 @@
+---
+id: js/no-nonoctal-decimal-escape
+title: "No \\8 or \\9 escapes in strings"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether the digit or a literal backslash was meant needs the author"
+stability: preview
+ported_from: [eslint/no-nonoctal-decimal-escape]
+since: 0.1.0
+---
+
+A string contains no `\8` or `\9` escape.
+
+**Why:** `\8` and `\9` are legacy escapes that just mean the digits, and are errors in template
+literals and strict code.
+
+```codelaw
+match:
+  kind: escape_sequence
+  regex: ^\\[89]$
+message: "`$$MATCH` is not an escape; it's the digit itself"
+```
+
+## How to fix
+
+1. Write the digit without the backslash, or `\\8` for a backslash and a digit.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const msg = "version \8";
+```
+
+#### Do
+
+```js
+const msg = "version 8";
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const msg = "version \8";
+```
+
+#### Do
+
+```jsx
+const msg = "version 8";
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const msg = "version \8";
+```
+
+#### Do
+
+```ts
+const msg = "version 8";
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const msg = "version \8";
+```
+
+#### Do
+
+```tsx
+const msg = "version 8";
+```

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