@fenge/eslint-plugin 0.4.0 → 0.4.2-beta.0

package/doc/rules/call-arguments-length.md

@@ -1,52 +0,0 @@
-<!-- prettier-ignore-start -->
-# call-arguments-length
-
-Disallow calling a function with incorrect arguments length.
-
-## Rule Details
-
-### Fail
-
-```ts
-[].push()
-foo.push()
-foo.reduce()
-[].reduce(()=>123)
-foo.reduce(()=>123)
-foo.reduce(bar)
-[].reduceRight(()=>123)
-foo.reduceRight(()=>123)
-foo.reduceRight(bar)
-[].reduce(...foo)
-[].reduce(...foo, ...bar)
-Math.max()
-Math.max(1)
-Math.min(foo)
-new Set(...foo)
-new Set(foo,bar)
-```
-
-### Pass
-
-```ts
-push()
-[].push('')
-foo.push('')
-foo.push(bar)
-[].push('', '', '')
-[].push(...foo)
-foo.push(...([]))
-[].reduce(()=>123, 0)
-foo.reduce(()=>123, 0)
-foo.reduce(bar, baz)
-[].reduceRight(()=>123, 0)
-foo.reduceRight(()=>123, 0)
-foo.reduceRight(bar, baz)
-reduce(()=>123)
-foo.reduceLeft(()=>123)
-Math.max(...foo)
-new foo.Set(...bar)
-new Set(bar)
-new Set()
-```
-<!-- prettier-ignore-end -->

package/doc/rules/no-instanceof-builtin.md

@@ -1,50 +0,0 @@
-<!-- prettier-ignore-start -->
-# no-instanceof-builtin
-
-Right hand of `instanceof` can't be a builtin class.
-
-## Rule Details
-
-### Fail
-
-```ts
-const i = {} instanceof Number
-const i = {} instanceof String
-const i = {} instanceof Boolean
-const i = {} instanceof Symbol
-const i = {} instanceof BigInt
-const i = {} instanceof Object
-const i = {} instanceof Array
-const i = {} instanceof Function
-const i = {} instanceof ArrayBuffer
-const i = {} instanceof BigInt64Array
-const i = {} instanceof BigUint64Array
-const i = {} instanceof DataView
-const i = {} instanceof Date
-const i = {} instanceof Float32Array
-const i = {} instanceof Float64Array
-const i = {} instanceof Int16Array
-const i = {} instanceof Int32Array
-const i = {} instanceof Int8Array
-const i = {} instanceof Map
-const i = {} instanceof Error
-const i = {} instanceof Promise
-const i = {} instanceof Proxy
-const i = {} instanceof RegExp
-const i = {} instanceof Set
-const i = {} instanceof SharedArrayBuffer
-const i = {} instanceof Uint16Array
-const i = {} instanceof Uint32Array
-const i = {} instanceof Uint8Array
-const i = {} instanceof Uint8ClampedArray
-const i = {} instanceof WeakMap
-const i = {} instanceof WeakSet
-```
-
-### Pass
-
-```ts
-const i = Math.random() > 0.5 ? true: false
-const i = {} instanceof await import('http')
-```
-<!-- prettier-ignore-end -->

package/doc/rules/no-nested-class.md

@@ -1,31 +0,0 @@
-<!-- prettier-ignore-start -->
-# no-nested-class
-
-Disallow nested class. Classes are expected to place at top level.
-
-## Rule Details
-
-### Fail
-
-```ts
-if(true) class Foo{}
-if(true) const foo = class {}
-function foo(){class Foo{}}
-function foo(){const foo = class {}}
-function foo(){return class Foo{}}
-function foo(){return class{}}
-const Foo = class{}
-let Foo = class Bar{}
-let Foo; Foo = class{}
-(class {})
-```
-
-### Pass
-
-```ts
-class Foo{}
-export class Foo{}
-export default class Foo{}
-export default class {}
-```
-<!-- prettier-ignore-end -->

package/doc/rules/no-nested-function.md

@@ -1,42 +0,0 @@
-<!-- prettier-ignore-start -->
-# no-nested-function
-
-Non top-level functions are expected to be arrow functions instead of function declarations.
-
-## Rule Details
-
-### Fail
-
-```ts
-Foo.prototype.bar = function(){}
-Foo.prototype.bar = function bar(){}
-const foo = function(){}
-const foo = function foo(){}
-let foo; foo = function(){}
-let foo; foo = function foo(){}
-(function(){})
-const foo = () => {function bar(){}}
-function foo() {function bar(){}}
-function foo() {let bar = function(){}}
-function foo() {let bar = function bar(){}}
-if(true) function foo(){}
-class Foo{bar = function(){}}
-class Foo{bar = function bar(){}}
-const foo = {bar: function() {}}
-const foo = {bar: function bar() {}}
-const foo = {bar() {}}
-setTimeout(function(){},100)
-setTimeout(function callback(){},100)
-```
-
-### Pass
-
-```ts
-function foo(){}
-const foo = () => {}
-export function foo() {}
-export default function foo() {}
-export default function() {}
-class Foo{bar(){}}
-```
-<!-- prettier-ignore-end -->

package/doc/rules/no-restricted-loops.md

@@ -1,23 +0,0 @@
-<!-- prettier-ignore-start -->
-# no-restricted-loops
-
-Only allow `while` and `for-of` loops. `for`, `for-in`, `do-while` and `for-await-of` loops are disallowed.
-
-## Rule Details
-
-### Fail
-
-```ts
-for(let i = 0; i < foo.length; i++) {}
-for(const bar in foo) {}
-do{}while(condition)
-for await (const bar of foo()) {}
-```
-
-### Pass
-
-```ts
-for(const bar of foo) {}
-while(condition){}
-```
-<!-- prettier-ignore-end -->

package/doc/rules/no-top-level-arrow-function.md

@@ -1,45 +0,0 @@
-<!-- prettier-ignore-start -->
-# no-top-level-arrow-function
-
-Top-level functions are expected to be function declarations instead of arrow functions.
-
-## Rule Details
-
-### Fail
-
-```ts
-let foo = () => {}
-const foo = () => {}
-let foo = () => {
-}
-const foo = () => {
-}
-let foo; foo = () => {
-}
-export const foo = () => {
-}
-export let foo = () => {
-}
-export default () => {
-}
-```
-
-### Pass
-
-```ts
-function foo(){}
-const foo = function(){}
-const foo = function foo(){}
-if(true) const foo = () => {
-}
-let foo = () => ''
-let foo = () => [
-]
-let foo = () => ({})
-const foo = () => ({})
-let foo; foo = () => ({})
-export const foo = () => ({})
-export let foo = () => ({})
-export default () => ({})
-```
-<!-- prettier-ignore-end -->

package/doc/rules/no-unnecessary-template-string.md

@@ -1,34 +0,0 @@
-<!-- prettier-ignore-start -->
-# no-unnecessary-template-string
-
-Disallow using template string when it's unnecessary. Use normal literal string expression instead.
-
-## Rule Details
-
-### Fail
-
-```ts
-outdent`foo`
-``
-`abc`
-`abc\n`
-`\nabc`
-`a\nbc`
-```
-
-### Pass
-
-```ts
-'abc'
-"def"
-`ab${cd}ef`
-`
-`
-`abc
-`
-`
-abc`
-`a
-bc`
-```
-<!-- prettier-ignore-end -->

package/src/index.ts

@@ -1,17 +0,0 @@
-import { callArgumentsLength } from "./rules/call-arguments-length.ts";
-import { noInstanceofBuiltin } from "./rules/no-instanceof-builtin.ts";
-import { noNestedClass } from "./rules/no-nested-class.ts";
-import { noNestedFunction } from "./rules/no-nested-function.ts";
-import { noRestrictedLoops } from "./rules/no-restricted-loops.ts";
-import { noTopLevelArrowFunction } from "./rules/no-top-level-arrow-function.ts";
-import { noUnnecessaryTemplateString } from "./rules/no-unnecessary-template-string.ts";
-
-export const rules = {
-  [callArgumentsLength.name]: callArgumentsLength.rule,
-  [noInstanceofBuiltin.name]: noInstanceofBuiltin.rule,
-  [noNestedClass.name]: noNestedClass.rule,
-  [noNestedFunction.name]: noNestedFunction.rule,
-  [noRestrictedLoops.name]: noRestrictedLoops.rule,
-  [noTopLevelArrowFunction.name]: noTopLevelArrowFunction.rule,
-  [noUnnecessaryTemplateString.name]: noUnnecessaryTemplateString.rule,
-};

package/src/rules/call-arguments-length.test.ts

@@ -1,48 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { callArgumentsLength } from "./call-arguments-length.ts";
-
-const valid = [
-  "push()",
-  "[].push('')",
-  "foo.push('')",
-  "foo.push(bar)",
-  "[].push('', '', '')",
-  "[].push(...foo)",
-  "foo.push(...([]))",
-
-  "[].reduce(()=>123, 0)",
-  "foo.reduce(()=>123, 0)",
-  "foo.reduce(bar, baz)",
-  "[].reduceRight(()=>123, 0)",
-  "foo.reduceRight(()=>123, 0)",
-  "foo.reduceRight(bar, baz)",
-  "reduce(()=>123)",
-  "foo.reduceLeft(()=>123)",
-  "Math.max(...foo)",
-
-  "new foo.Set(...bar)",
-  "new Set(bar)",
-  "new Set()",
-];
-const invalid = [
-  "[].push()",
-  "foo.push()",
-
-  "foo.reduce()",
-  "[].reduce(()=>123)",
-  "foo.reduce(()=>123)",
-  "foo.reduce(bar)",
-  "[].reduceRight(()=>123)",
-  "foo.reduceRight(()=>123)",
-  "foo.reduceRight(bar)",
-  "[].reduce(...foo)",
-  "[].reduce(...foo, ...bar)",
-  "Math.max()",
-  "Math.max(1)",
-  "Math.min(foo)",
-
-  "new Set(...foo)",
-  "new Set(foo,bar)",
-];
-
-test({ valid, invalid, ...callArgumentsLength });

package/src/rules/call-arguments-length.ts

@@ -1,163 +0,0 @@
-import type { Rule } from "eslint";
-import type { CallExpression, NewExpression } from "estree";
-import { getRuleName } from "../utils.ts";
-
-// TODO: If https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1356 is implemented, migrate this rule to `eslint-plugin-unicorn`
-const name = getRuleName(import.meta.url);
-const rule: Rule.RuleModule = {
-  meta: {
-    docs: {
-      description:
-        "Disallow calling a function with incorrect arguments length.",
-    },
-    messages: {
-      [`${name}/error`]:
-        "The arguments length of calling `{{ functionPattern }}` should be {{ lengthMsg }}",
-    },
-    schema: [{ type: "object" }], // TODO: enhance schema for checking options
-  },
-  create: (context) => {
-    const getLengthMsg = (expectedLength: unknown) => {
-      if (typeof expectedLength === "number") {
-        return String(expectedLength);
-      }
-      if (Array.isArray(expectedLength)) {
-        return expectedLength.join(" or ");
-      }
-      const result: string[] = [];
-      if (
-        typeof expectedLength === "object" &&
-        expectedLength &&
-        "min" in expectedLength
-      ) {
-        result.push(`>= ${String(expectedLength.min)}`);
-      }
-      if (
-        typeof expectedLength === "object" &&
-        expectedLength &&
-        "max" in expectedLength
-      ) {
-        result.push(`<= ${String(expectedLength.max)}`);
-      }
-      return result.join(" and ");
-    };
-    const isLengthValid = (length: number, expectedLength: unknown) => {
-      if (typeof expectedLength === "number") {
-        return length === expectedLength;
-      }
-      if (Array.isArray(expectedLength)) {
-        return expectedLength.includes(length);
-      }
-      const result: boolean[] = [];
-      if (
-        typeof expectedLength === "object" &&
-        expectedLength &&
-        "min" in expectedLength &&
-        typeof expectedLength.min === "number"
-      ) {
-        result.push(length >= expectedLength.min);
-      }
-      if (
-        typeof expectedLength === "object" &&
-        expectedLength &&
-        "max" in expectedLength &&
-        typeof expectedLength.max === "number"
-      ) {
-        result.push(length <= expectedLength.max);
-      }
-      return result.every((item) => item);
-    };
-    const report = (
-      node: CallExpression | NewExpression,
-      functionPattern: string,
-      expectedLength: unknown,
-    ) => {
-      const argsLength = node.arguments.some(
-        (arg) => arg.type === "SpreadElement",
-      )
-        ? Infinity
-        : node.arguments.length;
-      if (!isLengthValid(argsLength, expectedLength))
-        context.report({
-          node,
-          messageId: `${name}/error`,
-          data: {
-            functionPattern,
-            lengthMsg: getLengthMsg(expectedLength),
-          },
-        });
-    };
-
-    const options = Object.entries(
-      context.options[0] ?? {
-        // 1
-        "*.reduce": 2,
-        "*.reduceRight": 2,
-        "*.push": { min: 1 },
-        "Math.max": { min: 2 },
-        "Math.min": { min: 2 },
-        // 2
-        "new Set": { max: 1 },
-        "new Map": { max: 1 },
-      },
-    ).map(([pattern, expectedLength]) => ({
-      regex: new RegExp(
-        `^${pattern.replaceAll(".", "\\.").replaceAll("*", ".*")}$`,
-      ),
-      pattern,
-      expectedLength,
-    }));
-
-    const handle = (node: CallExpression | NewExpression) => {
-      const prefix = node.type === "NewExpression" ? "new " : "";
-
-      const { callee } = node;
-      // function call
-      if (callee.type === "Identifier") {
-        // code like `foo()` or `new Foo()`
-        options
-          .filter((option) => option.regex.test(`${prefix}${callee.name}`))
-          .forEach(({ pattern, expectedLength }) => {
-            report(node, pattern, expectedLength);
-          });
-      }
-      // method call
-      else if (
-        callee.type === "MemberExpression" &&
-        callee.property.type === "Identifier"
-      ) {
-        const { object: calleeObject, property: calleeProperty } = callee;
-        options
-          .filter((option) => {
-            // code like `Math.max()` or `new Foo.Bar()`, the calleeObject is `Math` or `Foo`
-            if (
-              "name" in calleeObject &&
-              option.regex.test(
-                `${prefix}${calleeObject.name}.${calleeProperty.name}`,
-              )
-            ) {
-              return true;
-            }
-            // code like `[].reduce()` or `new ({Foo: class{}}).Foo()`, the calleeObject is `[]` or `{Foo: class{}}`
-            if (
-              !("name" in calleeObject) &&
-              option.regex.test(`${prefix}.${calleeProperty.name}`)
-            ) {
-              return true;
-            }
-            return false;
-          })
-          .forEach(({ pattern, expectedLength }) => {
-            report(node, pattern, expectedLength);
-          });
-      }
-    };
-
-    return {
-      CallExpression: handle,
-      NewExpression: handle,
-    };
-  },
-};
-
-export const callArgumentsLength = { name, rule };

package/src/rules/no-instanceof-builtin.test.ts

@@ -1,48 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noInstanceofBuiltin } from "./no-instanceof-builtin.ts";
-
-const invalid = [
-  // Primitive
-  "Number",
-  "String",
-  "Boolean",
-  "Symbol",
-  "BigInt",
-
-  // Object
-  "Object",
-  "Array",
-  "Function",
-
-  // Builtin
-  "ArrayBuffer",
-  "BigInt64Array",
-  "BigUint64Array",
-  "DataView",
-  "Date",
-  "Float32Array",
-  "Float64Array",
-  "Int16Array",
-  "Int32Array",
-  "Int8Array",
-  "Map",
-  "Error",
-  "Promise",
-  "Proxy",
-  "RegExp",
-  "Set",
-  "SharedArrayBuffer",
-  "Uint16Array",
-  "Uint32Array",
-  "Uint8Array",
-  "Uint8ClampedArray",
-  "WeakMap",
-  "WeakSet",
-].map((i) => `const i = {} instanceof ${i}`);
-
-const valid = [
-  "const i = Math.random() > 0.5 ? true: false",
-  "const i = {} instanceof await import('http')",
-];
-
-test({ valid, invalid, ...noInstanceofBuiltin });

package/src/rules/no-instanceof-builtin.ts

@@ -1,46 +0,0 @@
-import type { Rule } from "eslint";
-import { getRuleName } from "../utils.ts";
-
-// TODO: If https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2452 is accepted, migrate this rule to `eslint-plugin-unicorn`
-const name = getRuleName(import.meta.url);
-const rule: Rule.RuleModule = {
-  meta: {
-    docs: {
-      description: "Right hand of `instanceof` can't be a builtin class.",
-    },
-    messages: {
-      [`${name}/error`]: "Right hand of `instanceof` can't be a builtin class.",
-    },
-  },
-  create: (context) => {
-    let builtins: Set<string> | undefined = undefined;
-    return {
-      // ESLint visit the Node from root to leaf. The Program Node is the root.
-      // Therefore, Program will be called before BinaryExpression.
-      // https://eslint.org/docs/latest/extend/code-path-analysis
-      Program: (node) => {
-        const scope = context.sourceCode.getScope(node);
-        builtins = new Set([
-          // Variables declared in `globals`
-          ...scope.variables.map((v) => v.name),
-          // Variables not declared at all
-          ...scope.through.map((ref) => ref.identifier.name),
-        ]);
-      },
-      BinaryExpression: (node) => {
-        if (
-          node.operator !== "instanceof" ||
-          node.right.type !== "Identifier"
-        ) {
-          return;
-        }
-
-        if (builtins?.has(node.right.name) ?? true) {
-          context.report({ node: node.right, messageId: `${name}/error` });
-        }
-      },
-    };
-  },
-};
-
-export const noInstanceofBuiltin = { name, rule };

package/src/rules/no-nested-class.test.ts

@@ -1,27 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noNestedClass } from "./no-nested-class.ts";
-
-const valid = [
-  "class Foo{}",
-  "export class Foo{}",
-  "export default class Foo{}",
-  "export default class {}",
-];
-
-const invalid = [
-  // nested
-  "if(true) class Foo{}",
-  "if(true) const foo = class {}",
-  "function foo(){class Foo{}}",
-  "function foo(){const foo = class {}}",
-  "function foo(){return class Foo{}}",
-  "function foo(){return class{}}",
-
-  // normal
-  "const Foo = class{}",
-  "let Foo = class Bar{}",
-  "let Foo; Foo = class{}",
-  "(class {})",
-];
-
-test({ valid, invalid, ...noNestedClass });

package/src/rules/no-nested-class.ts

@@ -1,31 +0,0 @@
-import type { Rule } from "eslint";
-import type { Node } from "estree";
-import { getRuleName } from "../utils.ts";
-
-const name = getRuleName(import.meta.url);
-const rule: Rule.RuleModule = {
-  meta: {
-    docs: {
-      description:
-        "Disallow nested class. Classes are expected to place at top level.",
-    },
-    messages: {
-      [`${name}/error`]:
-        "Disallow nested class. Classes are expected to place at top level.",
-    },
-  },
-  create: (context) => {
-    const handle = (node: Node) =>
-      context.report({ node, messageId: `${name}/error` });
-    return {
-      // ClassDeclaration is only allowed when parent is Program, or parent is ExportNamedDeclaration, or parent is ExportDefaultDeclaration
-      "ClassDeclaration[parent.type!='Program'][parent.type!='ExportNamedDeclaration'][parent.type!='ExportDefaultDeclaration']":
-        handle,
-      // ClassExpression is only allowed when parent is ExportNamedDeclaration, or parent is ExportDefaultDeclaration
-      "ClassExpression[parent.type!='ExportNamedDeclaration'][parent.type!='ExportDefaultDeclaration']":
-        handle,
-    };
-  },
-};
-
-export const noNestedClass = { name, rule };