@less-unsound/eslint-plugin 0.0.1

package/dist/esm/utils/readonly.js

@@ -0,0 +1,14 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+export const isReadonlyType = (node) => {
+    const parent = node.parent;
+    if (parent === undefined) {
+        return false;
+    }
+    if (parent.type !== AST_NODE_TYPES.TSTypeOperator) {
+        return false;
+    }
+    if (parent.operator !== "readonly") {
+        return false;
+    }
+    return parent.typeAnnotation === node;
+};

package/dist/esm/utils/string-case.d.ts

@@ -0,0 +1,3 @@
+export declare const isKebabCase: (value: string) => boolean;
+export declare const isCamelCase: (value: string) => boolean;
+export declare const isPascalCase: (value: string) => boolean;

package/dist/esm/utils/string-case.js

@@ -0,0 +1,6 @@
+const kebabCasePattern = /^[a-z0-9][a-z0-9.-]*$/u;
+const camelCasePattern = /^[a-z][A-Za-z0-9]*$/u;
+const pascalCasePattern = /^[A-Z][A-Za-z0-9]*$/u;
+export const isKebabCase = (value) => value === "" || kebabCasePattern.test(value);
+export const isCamelCase = (value) => camelCasePattern.test(value);
+export const isPascalCase = (value) => pascalCasePattern.test(value);

package/dist/esm/utils/type-reference.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+export declare const containsTypeReference: (node: TSESTree.Node, name: string) => boolean;

package/dist/esm/utils/type-reference.js

@@ -0,0 +1,31 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+const isIdentifierTypeName = (typeName, name) => {
+    if (typeName.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return typeName.name === name;
+};
+const containsTypeReferenceValue = (value, name, seen) => {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const objectValue = value;
+    if (seen.has(objectValue)) {
+        return false;
+    }
+    seen.add(objectValue);
+    const typedValue = value;
+    if (typedValue.type === AST_NODE_TYPES.TSTypeReference) {
+        const node = value;
+        if (isIdentifierTypeName(node.typeName, name)) {
+            return true;
+        }
+    }
+    return Object.entries(value).some(([key, child]) => {
+        if (key === "parent") {
+            return false;
+        }
+        return containsTypeReferenceValue(child, name, seen);
+    });
+};
+export const containsTypeReference = (node, name) => containsTypeReferenceValue(node, name, new WeakSet());

package/docs/rules/no-accidental-mutation.md

@@ -0,0 +1,39 @@
+# `no-accidental-mutation`
+
+Disallow in-place `.sort()`, `.reverse()`, and `.splice()` on non-fresh arrays unless mutability is required for performance.
+
+## Rule details
+
+Clone arrays before `.sort()`, `.reverse()`, `.splice()`: `[...arr].sort()`
+
+Examples of **incorrect** code for this rule:
+
+```ts
+values.sort();
+```
+
+```ts
+values.reverse();
+```
+
+```ts
+values.splice(0, 1);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+[...values].sort();
+```
+
+```ts
+values.slice().reverse();
+```
+
+## Options
+
+This rule does not accept options.
+
+## When not to use it
+
+Disable this rule when an algorithm requires in-place array mutation for performance.

package/docs/rules/no-ambient-dom-globals.md

@@ -0,0 +1,37 @@
+# `no-ambient-dom-globals`
+
+Disallow the confusing ambient browser-global surface.
+
+## Rule details
+
+Ban ambient DOM declarations (use of global `name` etc; find existing package that does this and follow suit).
+
+Examples of **incorrect** code for this rule:
+
+```ts
+name;
+```
+
+```ts
+blur;
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const name = 1;
+name;
+```
+
+```ts
+const window = { name: 1 };
+window.name;
+```
+
+```ts
+({ name: 1 });
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-any.md

@@ -0,0 +1,23 @@
+# `no-any`
+
+Disallow the `any` type.
+
+## Rule details
+
+Its actual meaning is "completely disregard type errors here". It has no basis in type theory. This will just break your code. At the very least, use `unknown` or `never`.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+type Value = any;
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+type Value = string;
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-arguments-object.md

@@ -0,0 +1,35 @@
+# `no-arguments-object`
+
+Disallow the `arguments` object.
+
+## Rule details
+
+In general, variadic functions cause typing problems and are unsafe to have in the code. If absolutely needed, use `...rest`, at least it will return an array, and not some quirky array-like object.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+function foo() {
+  return arguments;
+}
+```
+
+```ts
+const foo = () => arguments[0];
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+function foo(arguments: number) {
+  return arguments;
+}
+```
+
+```ts
+const value = { arguments: 1 };
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-as-type-assertion.md

@@ -0,0 +1,26 @@
+# `no-as-type-assertion`
+
+Disallow `as` type assertions except `as const`.
+
+## Rule details
+
+It was meant to gradually type legacy code, not for production use in TS-native projects. Often, instead of `x as T` it should have been:
+- `const y: T = x;`
+- or `x satisfies T`
+- or `foo = new Array<T>()`
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const value = input as Foo;
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const value = [1, 2] as const;
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-bigint.md

@@ -0,0 +1,31 @@
+# `no-bigint`
+
+Disallow `bigint` types and values.
+
+## Rule details
+
+Very rarely needed, and quite slow. If there is actually code that works with large integers, ignore this rule.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const value = 1n;
+```
+
+```ts
+const value: bigint = 1 as never;
+```
+
+```ts
+const value = BigInt(1);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const value = 1;
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-boolean-literal-compare.md

@@ -0,0 +1,31 @@
+# `no-boolean-literal-compare`
+
+Disallow equality comparisons to boolean literals.
+
+## Rule details
+
+Bans bogus boolean operations, such as `=== true` and `=== false`. If you have `boolean | undefined` type and actually have to do such checks, change this type to something better.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const value = isReady === true;
+```
+
+```ts
+const value = isReady !== false;
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const value = isReady;
+```
+
+```ts
+const value = !isReady;
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-broad-types.md

@@ -0,0 +1,27 @@
+# `no-broad-types`
+
+Disallow `Object`, `object`, `{}`, and `Function` types.
+
+## Rule details
+
+There's barely a case when common supertypes of objects and functions are even needed.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+type Value = object;
+```
+
+```ts
+type Value = {};
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+type Value = { readonly name: string };
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-buffer.md

@@ -0,0 +1,31 @@
+# `no-buffer`
+
+Disallow global `Buffer` types and values.
+
+## Rule details
+
+`Buffer` is Node's old, quirky and non-portable type, that has to be polyfilled if the code is ever used in the browser. Use `Uint8Array` instead.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const value = Buffer.from("x");
+```
+
+```ts
+const value: Buffer = data;
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const value = new Uint8Array();
+```
+
+```ts
+const value: Uint8Array = data;
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-class.md

@@ -0,0 +1,56 @@
+# `no-class`
+
+Disallow `class` declarations and expressions.
+
+## Rule details
+
+OOP in TypeScript just doesn't work.
+
+- In TS `private` is only a type system feature, and all the "private" fields are globally accessible at runtime.
+- Objects have part of their description in `prototype`, and can't be worked with as regular objects.
+- Methods don't store a reference to `this` in their closure and take it from object syntactically, i.e., `x.f()` would use `x` as `this`. It means `const { f } = x; f();` will be a runtime error, and TypeScript would emit no error here at compile time.
+- TypeScript doesn't statically ensure that OOP actually works. For example, you can easily break Liskov's substitution principle with class implementations.
+
+If a `class` is converted into a regular function, all the fields are correctly private; accessing them requires no `this.` prefix, and in most frequent cases, the only exposed method can be returned directly.
+
+```typescript
+class Foo {
+    private y: number;
+    constructor(_y: number) {
+        this.y = _y;
+    }
+    bar(x: number) {
+        return x + y;
+    }
+}
+
+const Foo = (y: number) => {
+    const bar = (x: number) => x + y;
+    return { bar };
+};
+// nobody can ever access `y` now: it's actually private
+
+const Foo = (y: number) => (x: number) => x + y;
+```
+
+The only case when `class` might actually be useful is if you create billions of objects. `prototype` is a single pointer to an object with methods for all the instances of the class, while the approach above will create objects with methods 
+
+Examples of **incorrect** code for this rule:
+
+```ts
+class Foo {}
+```
+
+```ts
+const Foo = class {};
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+class Foo extends Bar {}
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-comma-operator.md

@@ -0,0 +1,31 @@
+# `no-comma-operator`
+
+Disallow the comma operator.
+
+## Rule details
+
+Seriously?
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const value = (foo, bar);
+```
+
+```ts
+const value = (readFoo(), readBar());
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const value = bar;
+```
+
+```ts
+const values = [foo, bar];
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-conditional-type.md

@@ -0,0 +1,23 @@
+# `no-conditional-type`
+
+Disallow conditional types.
+
+## Rule details
+
+These lack any theory behind them and were meant to type legacy JS code.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+type Value<T> = T extends string ? 1 : 2;
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+type Value = string | number;
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-default-parameter.md

@@ -0,0 +1,43 @@
+# `no-default-parameter`
+
+Disallow default parameters.
+
+## Rule details
+
+TypeScript has a quirk that allows passing the function with fewer arguments to a parameter list that requires more. Eventually, this leads to passing unexpected values to optional parameters. Prefer decomposing the function into two, where one takes a full set of parameters, and the other one is a simpler version that takes less.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+function f(value = 1) {}
+```
+
+```ts
+const f = (value = 1) => value;
+```
+
+```ts
+class Value {
+  constructor(private value = 1) {}
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+function f(value: number) {}
+```
+
+```ts
+const f = (value: number) => value;
+```
+
+```ts
+class Value {
+  constructor(private value: number) {}
+}
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-enum.md

@@ -0,0 +1,31 @@
+# `no-enum`
+
+Disallow `enum` and `const enum` declarations.
+
+## Rule details
+
+It's equivalent to unions since 5.0, except generates boilerplate JS code. A version that doesn't generate extraneous code, `const enum`, is not properly supported by `babel`. Neither is supported by Node's type stripping.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+enum Value {
+  A
+}
+```
+
+```ts
+const enum Value {
+  A
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const value = 1;
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-eval.md

@@ -0,0 +1,27 @@
+# `no-eval`
+
+Disallow `eval`.
+
+## Rule details
+
+It's impossible to typecheck.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+eval(code);
+```
+
+```ts
+eval?.(code);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const value = run(code);
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-export-default.md

@@ -0,0 +1,28 @@
+# `no-export-default`
+
+Disallow default exports.
+
+## Rule details
+
+It breaks IDE features such as renaming and also has complex semantics. Google for a full page of links to articles that explain why precisely. Next.js enforces these on users? Well, never use Next.js.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+export default 1;
+```
+
+```ts
+const value = 1;
+export { value as default };
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+export const value = 1;
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-for-in.md

@@ -0,0 +1,23 @@
+# `no-for-in`
+
+Disallow `for (... in ...)` loops.
+
+## Rule details
+
+It requires a `hasOwnProperty` check. Prefer `Object.entries`, `Object.keys`, or `Object.values`.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+for (const key in object) {}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+for (const value of values) {}
+```
+
+## Options
+
+This rule does not accept options.

package/docs/rules/no-for-let.md

@@ -0,0 +1,31 @@
+# `no-for-let`
+
+Disallow `for (let ...)` loops.
+
+## Rule details
+
+Prefer built-in array methods, unless mutability is required for performance. But if you really do it for performance, you should probably know that it should be `var`, not `let`?
+
+Examples of **incorrect** code for this rule:
+
+```ts
+for (let index = 0; index < 1; index += 1) {
+  console.log(index);
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+for (const value of values) {
+  console.log(value);
+}
+```
+
+## Options
+
+This rule does not accept options.
+
+## When not to use it
+
+Disable this rule when an algorithm requires mutable loop state for performance.

package/docs/rules/no-function-constructor.md

@@ -0,0 +1,27 @@
+# `no-function-constructor`
+
+Disallow global `Function` constructor usage.
+
+## Rule details
+
+Use normal function types: `(a: A) => B`.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+Function("return 1;");
+```
+
+```ts
+new Function("return 1;");
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const run = (): number => 1;
+```
+
+## Options
+
+This rule does not accept options.