@fenge/eslint-plugin 0.4.0 → 0.4.1

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 };

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

@@ -1,49 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noNestedFunction } from "./no-nested-function.ts";
-
-const valid = [
-  // normal
-  "function foo(){}",
-  "const foo = () => {}",
-
-  // export
-  "export function foo() {}",
-  "export default function foo() {}",
-  "export default function() {}",
-
-  // class
-  "class Foo{bar(){}}",
-];
-
-const invalid = [
-  // normal
-  "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(){})",
-
-  // nested
-  "const foo = () => {function bar(){}}",
-  "function foo() {function bar(){}}",
-  "function foo() {let bar = function(){}}",
-  "function foo() {let bar = function bar(){}}",
-  "if(true) function foo(){}",
-
-  // class
-  "class Foo{bar = function(){}}",
-  "class Foo{bar = function bar(){}}",
-
-  // object
-  "const foo = {bar: function() {}}",
-  "const foo = {bar: function bar() {}}",
-  "const foo = {bar() {}}", // disallow this case
-
-  // callback
-  "setTimeout(function(){},100)",
-  "setTimeout(function callback(){},100)",
-];
-
-test({ valid, invalid, ...noNestedFunction });

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

@@ -1,32 +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:
-        "Non top-level functions are expected to be arrow functions instead of function declarations.",
-    },
-    messages: {
-      [`${name}/error`]:
-        "Non top-level functions are expected to be arrow functions instead of function declarations.",
-    },
-  },
-  create: (context) => {
-    const handle = (node: Node) =>
-      context.report({ node, messageId: `${name}/error` });
-    return {
-      // FunctionDeclaration is only allowed when parent is Program, or parent is ExportNamedDeclaration, or parent is ExportDefaultDeclaration
-      // function foo(){}
-      "FunctionDeclaration[parent.type!='Program'][parent.type!='ExportNamedDeclaration'][parent.type!='ExportDefaultDeclaration']":
-        handle,
-      // FunctionExpression is only allowed when parent is MethodDefinition
-      // function (){}
-      "FunctionExpression[parent.type!='MethodDefinition']": handle,
-    };
-  },
-};
-
-export const noNestedFunction = { name, rule };

package/src/rules/no-restricted-loops.test.ts

@@ -1,13 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noRestrictedLoops } from "./no-restricted-loops.ts";
-
-const valid = ["for(const bar of foo) {}", "while(condition){}"];
-
-const invalid = [
-  "for(let i = 0; i < foo.length; i++) {}",
-  "for(const bar in foo) {}",
-  "do{}while(condition)",
-  "for await (const bar of foo()) {}",
-];
-
-test({ valid, invalid, ...noRestrictedLoops });

package/src/rules/no-restricted-loops.ts

@@ -1,30 +0,0 @@
-import type { Rule } from "eslint";
-import type { Node } from "estree";
-import { getRuleName } from "../utils.ts";
-
-// TODO: If https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2453 is accepted, migrate this rule to `eslint-plugin-unicorn`
-const name = getRuleName(import.meta.url);
-/**
- * Only allow `while` and `for-of` loops. `for`, `for-in`, `do-while` and `for-await-of` loops are disallowed.
- * Visit https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2453 for more details.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    docs: {
-      description:
-        "Only allow `while` and `for-of` loops. `for`, `for-in`, `do-while` and `for-await-of` loops are disallowed.",
-    },
-    messages: {
-      [`${name}/error`]:
-        "Only allow `while` and `for-of` loops. `for`, `for-in`, `do-while` and `for-await-of` loops are disallowed.",
-    },
-  },
-  create: (context) => ({
-    ":matches(ForStatement, ForInStatement, DoWhileStatement, ForOfStatement[await=true])":
-      (node: Node) => {
-        context.report({ node, messageId: `${name}/error` });
-      },
-  }),
-};
-
-export const noRestrictedLoops = { name, rule };

package/src/rules/no-top-level-arrow-function.test.ts

@@ -1,32 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noTopLevelArrowFunction } from "./no-top-level-arrow-function.ts";
-
-const valid = [
-  "function foo(){}",
-  "const foo = function(){}",
-  "const foo = function foo(){}",
-  "if(true) const foo = () => {\n}",
-
-  // allow one-line function
-  "let foo = () => ''",
-  "let foo = () => [\n]",
-  "let foo = () => ({})",
-  "const foo = () => ({})",
-  "let foo; foo = () => ({})",
-  "export const foo = () => ({})",
-  "export let foo = () => ({})",
-  "export default () => ({})",
-];
-
-const invalid = [
-  "let foo = () => {}",
-  "const foo = () => {}",
-  "let foo = () => {\n}",
-  "const foo = () => {\n}",
-  "let foo; foo = () => {\n}",
-  "export const foo = () => {\n}",
-  "export let foo = () => {\n}",
-  "export default () => {\n}",
-];
-
-test({ valid, invalid, ...noTopLevelArrowFunction });

package/src/rules/no-top-level-arrow-function.ts

@@ -1,35 +0,0 @@
-import type { Rule } from "eslint";
-import type { ArrowFunctionExpression } from "estree";
-import { getRuleName } from "../utils.ts";
-
-const name = getRuleName(import.meta.url);
-const rule: Rule.RuleModule = {
-  meta: {
-    docs: {
-      description:
-        "Top-level functions are expected to be function declarations instead of arrow functions.",
-    },
-    messages: {
-      [`${name}/error`]:
-        "Top-level functions are expected to be function declarations instead of arrow functions.",
-    },
-  },
-  create: (context) => {
-    const handle = (node: ArrowFunctionExpression) => {
-      if (node.body.type === "BlockStatement") {
-        context.report({ node, messageId: `${name}/error` });
-      }
-    };
-    return {
-      "VariableDeclaration[parent.type='Program'] > VariableDeclarator > ArrowFunctionExpression":
-        handle,
-      "ExpressionStatement[parent.type='Program'] > AssignmentExpression > ArrowFunctionExpression":
-        handle,
-      "ExportNamedDeclaration > VariableDeclaration > VariableDeclarator > ArrowFunctionExpression":
-        handle,
-      "ExportDefaultDeclaration > ArrowFunctionExpression": handle,
-    };
-  },
-};
-
-export const noTopLevelArrowFunction = { name, rule };

package/src/rules/no-unnecessary-template-string.test.ts

@@ -1,25 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noUnnecessaryTemplateString } from "./no-unnecessary-template-string.ts";
-
-const valid = [
-  "'abc'",
-  '"def"',
-  "`ab${cd}ef`",
-  "`\n`",
-  "`abc\n`",
-  "`\nabc`",
-  "`a\nbc`",
-];
-
-const invalid = [
-  // Currently, tagged template string should be reported as well.
-  // Moving it to `valid` part is also reasonable.
-  "outdent`foo`",
-  "``",
-  "`abc`",
-  "`abc\\n`",
-  "`\\nabc`",
-  "`a\\nbc`",
-];
-
-test({ valid, invalid, ...noUnnecessaryTemplateString });

package/src/rules/no-unnecessary-template-string.ts

@@ -1,29 +0,0 @@
-import type { Rule } from "eslint";
-import { getRuleName } from "../utils.ts";
-
-// TODO deprecate this rule if https://github.com/sindresorhus/eslint-plugin-unicorn/issues/71 is implemented.
-const name = getRuleName(import.meta.url);
-const rule: Rule.RuleModule = {
-  meta: {
-    docs: {
-      description:
-        "Disallow using template string when it's unnecessary. Use normal literal string expression instead.",
-    },
-    messages: {
-      [`${name}/error`]:
-        "Disallow using template string when it's unnecessary. Use normal literal string expression instead.",
-    },
-  },
-  create: (context) => ({
-    TemplateLiteral: (node) => {
-      if (
-        node.quasis.length === 1 &&
-        node.expressions.length === 0 &&
-        node.loc?.start.line === node.loc?.end.line
-      ) {
-        context.report({ node, messageId: `${name}/error` });
-      }
-    },
-  }),
-};
-export const noUnnecessaryTemplateString = { name, rule };

package/src/utils.ts

@@ -1,7 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-export function getRuleName(importMetaUrl: string) {
-  // remove '.js' extension
-  return path.basename(fileURLToPath(importMetaUrl)).slice(0, -3);
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig",
-  "include": ["src"],
-  "exclude": ["**/*.test.ts"]
-}