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

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"]
-}