@ornikar/eslint-plugin-ornikar 0.0.1

package/.eslintrc.json

@@ -0,0 +1,4 @@
+{
+  "root": true,
+  "extends": ["@ornikar/eslint-config/node"]
+}

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "eslint.workingDirectories": ["../../"]
+}

package/configs/all.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  rules: {
+    '@ornikar/ornikar/forbid-fetch-import': 'error',
+    '@ornikar/ornikar/react-function-return-react-node': 'error',
+  },
+};

package/fixtures/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "jsx": "preserve",
+    "target": "es5",
+    "module": "commonjs",
+    "strict": true
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}

package/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const allRulesEnabledConfig = require('./configs/all');
+const loadRules = require('./loadRules');
+
+const recommendedConfig = allRulesEnabledConfig;
+
+module.exports = {
+  rules: {
+    ...loadRules(),
+  },
+  configs: {
+    recommended: recommendedConfig,
+    all: allRulesEnabledConfig,
+  },
+};

package/loadRules.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function loadRule(ruleId) {
+  // eslint-disable-next-line import/no-dynamic-require, global-require, security/detect-non-literal-require
+  const rule = require(path.resolve(__dirname, `./rules/${ruleId}`));
+
+  return {
+    meta: {
+      schema: [],
+      ...rule.meta,
+      docs: {
+        ...rule.meta.docs,
+        // url: getDocumentationUrl(ruleId),
+      },
+    },
+    create: rule.create,
+  };
+}
+
+module.exports = function loadRules() {
+  return Object.fromEntries(
+    fs
+      .readdirSync(path.resolve(__dirname, './rules'), { withFileTypes: true })
+      .filter((file) => file.isFile() && !file.name.endsWith('.test.js'))
+      .map((file) => {
+        const ruleId = path.basename(file.name, '.js');
+        return [ruleId, loadRule(ruleId)];
+      }),
+  );
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@ornikar/eslint-plugin-ornikar",
+  "version": "0.0.1",
+  "description": "eslint plugin for ornikar",
+  "repository": {
+    "directory": "@ornikar/eslint-plugin-ornikar",
+    "type": "git",
+    "url": "https://github.com/ornikar/eslint-configs.git"
+  },
+  "main": "index.js",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "ornikar": {
+    "entries": [],
+    "extraEntries": [
+      "."
+    ]
+  },
+  "peerDependencies": {
+    "eslint": "^8.39.0"
+  },
+  "scripts": {
+    "lint:eslint": "yarn ../.. eslint --report-unused-disable-directives --quiet @ornikar/eslint-plugin-ornikar"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "dependencies": {
+    "eslint-plugin-react": "^7.33.2"
+  },
+  "devDependencies": {
+    "@typescript-eslint/rule-tester": "6.7.0",
+    "@typescript-eslint/utils": "6.7.0"
+  }
+}

package/rules/forbid-fetch-import.js

@@ -0,0 +1,40 @@
+'use strict';
+
+exports.meta = {
+  type: 'problem',
+
+  docs: {
+    description: 'Forbid node-fetch import now that fetch is available in node and browsers',
+    category: 'Best Practices',
+    recommended: true,
+  },
+
+  messages: {
+    forbidden: 'import from "{{value}}" is forbidden. Fetch is available in browsers and node since 18.0.0.',
+  },
+};
+
+const fetchLibs = ['node-fetch', 'cross-fetch', 'isomorphic-fetch'];
+
+exports.create = (context) => {
+  const checkNode = (node) => {
+    const importSource = node.source.value.trim();
+
+    if (fetchLibs.includes(importSource)) {
+      context.report({
+        node,
+        messageId: 'forbidden',
+        data: { value: importSource },
+      });
+    }
+  };
+  return {
+    ImportDeclaration: checkNode,
+    ExportNamedDeclaration(node) {
+      if (node.source) {
+        checkNode(node);
+      }
+    },
+    ExportAllDeclaration: checkNode,
+  };
+};

package/rules/forbid-fetch-import.test.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { RuleTester } = require('eslint');
+const rule = require('./forbid-fetch-import');
+
+const parserOptions = {
+  ecmaVersion: 2018,
+  sourceType: 'module',
+};
+
+const ruleTester = new RuleTester({ parserOptions });
+
+ruleTester.run('forbid-fetch-import', rule, {
+  valid: [
+    {
+      code: `
+      fetch('https://example.com');
+    `,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+      import fetch from 'node-fetch';
+      fetch('https://example.com');
+    `,
+      errors: [
+        {
+          messageId: 'forbidden',
+          data: { value: 'node-fetch' },
+        },
+      ],
+    },
+  ],
+});

package/rules/react-function-return-react-node.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const { AST_NODE_TYPES } = require('@typescript-eslint/utils');
+const Components = require('eslint-plugin-react/lib/util/Components');
+
+exports.meta = {
+  type: 'problem',
+
+  docs: {
+    description: 'Forbid returning ReactElement or ReactElement | null in function components',
+    category: 'Best Practices',
+    recommended: true,
+  },
+
+  messages: {
+    invalidReturnType: 'Returning "{{value}}" is forbidden. Return "ReactNode" instead.',
+    replaceReturnType: 'Replace "{{value}}" by "ReactNode"',
+  },
+
+  hasSuggestions: true,
+};
+
+function getSuggestionFixer(node, range, context) {
+  return (fixer) => {
+    return fixer.replaceTextRange(range, 'ReactNode');
+  };
+}
+
+function checkFunctionReturnType(node, onError) {
+  const { returnType } = node;
+  if (returnType == null) return;
+
+  const { typeAnnotation } = returnType;
+  if (typeAnnotation == null) return;
+
+  const { typeName } = typeAnnotation;
+  if (typeName == null) return;
+
+  if (typeName.name !== 'ReactNode') {
+    onError(typeName.name, typeName.range);
+  }
+}
+
+exports.create = Components.detect((context, components) => {
+  return {
+    FunctionDeclaration(node) {
+      if (!components.get(node)) return;
+
+      checkFunctionReturnType(node, (currentName, range) =>
+        context.report({
+          node,
+          loc: range,
+          messageId: 'invalidReturnType',
+          data: { value: currentName },
+          suggest: [
+            {
+              messageId: 'replaceReturnType',
+              data: { value: currentName },
+              fix: getSuggestionFixer(node, range, context),
+            },
+          ],
+        }),
+      );
+    },
+  };
+});

package/rules/react-function-return-react-node.test.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const path = require('node:path');
+const rule = require('./react-function-return-react-node');
+const { RuleTester } = require('./utils/RuleTester');
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+  parserOptions: {
+    tsconfigRootDir: path.join(__dirname, '../fixtures'),
+    project: './tsconfig.json',
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+});
+
+ruleTester.run('react-function-return-react-node', rule, {
+  valid: [
+    {
+      code: `
+import type { ReactNode } from 'react';
+export function SomeComponent(): ReactNode {
+  return <div />;
+}
+    `,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+import type { ReactElement } from 'react';
+export function SomeComponent(): ReactElement {
+  return <div />;
+}`,
+      errors: [
+        {
+          messageId: 'invalidReturnType',
+          data: { value: 'ReactElement' },
+          suggestions: [
+            {
+              messageId: 'replaceReturnType',
+              data: { value: 'ReactElement' },
+              output: `
+import type { ReactElement } from 'react';
+export function SomeComponent(): ReactNode {
+  return <div />;
+}`,
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});

package/rules/utils/RuleTester.js

@@ -0,0 +1,9 @@
+const { after, describe, it } = require('node:test');
+const { RuleTester } = require('@typescript-eslint/rule-tester');
+
+RuleTester.afterAll = after;
+RuleTester.describe = describe;
+RuleTester.it = it;
+RuleTester.itOnly = it.only;
+
+exports.RuleTester = RuleTester;