@codelaw/rules-js 0.0.0-stage → 0.2.0

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.

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