@blumintinc/eslint-plugin-blumint 0.1.23 → 1.0.2

package/plugin/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@blumintinc/eslint-plugin-blumint",
+  "version": "0.1.24",
+  "description": "Custom eslint rules for use at BluMint",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin"
+  ],
+  "author": "Brodie McGuire",
+  "main": "./lib/index.js",
+  "exports": "./lib/index.js",
+  "scripts": {
+    "lint": "npm-run-all \"lint:*\"",
+    "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
+    "lint:js": "eslint ./src",
+    "test": "jest",
+    "docs": "./scripts/make-docs.sh && npm run update:eslint-docs",
+    "update:eslint-docs": "eslint-doc-generator"
+  },
+  "dependencies": {
+    "requireindex": "1.2.0"
+  },
+  "devDependencies": {
+    "@types/eslint": "8.37.0",
+    "@typescript-eslint/utils": "5.59.6",
+    "eslint": "8.19.0",
+    "eslint-doc-generator": "1.0.0",
+    "eslint-import-resolver-typescript": "3.5.5",
+    "eslint-plugin-eslint-plugin": "5.0.0",
+    "@blumintinc/eslint-plugin-blumint": "file:./",
+    "eslint-plugin-node": "11.1.0",
+    "jest": "29.3.1",
+    "jsonc-eslint-parser": "2.3.0",
+    "npm-run-all": "4.1.5",
+    "ts-jest": "29.0.5"
+  },
+  "engines": {
+    "node": "^20.0.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=7"
+  },
+  "license": "ISC"
+}

package/tsconfig.json

@@ -0,0 +1,79 @@
+{
+  "compilerOptions": {
+    "target": "ES2015" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
+    "module": "ESNext" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+    "lib": [
+      "esnext",
+      "DOM",
+      "DOM.Iterable",
+      "WebWorker",
+    ],
+    "resolveJsonModule": true,
+    "allowJs": true, /* Allow javascript files to be compiled. */ // "checkJs": true,                       /* Report errors in .js files. */
+    "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    "declaration": true /* Generates corresponding '.d.ts' file. */,
+    "sourceMap": true, /* Generates corresponding '.map' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    // "outDir": "./lib/esm" /* Redirect output structure to the directory. */,
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    "removeComments": true /* Do not emit comments to output. */,
+    "noEmit": true, /* Do not emit outputs. */ // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    "isolatedModules": true, /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */ /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    "noImplicitAny": false, /* Raise error on expressions and declarations with an implied 'any' type. */
+    "strictNullChecks": true /* Enable strict null checks. */,
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    "strictPropertyInitialization": true /* Enable strict checking of property initialization in classes. */,
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+    /* Additional Checks */
+    "noUnusedLocals": true /* Report errors on unused locals. */,
+    "noUnusedParameters": true /* Report errors on unused parameters. */,
+    "noImplicitReturns": true /* Report error when not all code paths in function return a value. */,
+    "noFallthroughCasesInSwitch": true /* Report errors for fallthrough cases in switch statement. */,
+    /* Module Resolution Options */
+    "moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    "baseUrl": ".", /* Base directory to resolve non-absolute module names. */ // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    "typeRoots": [
+      "node_modules/@types"
+    ], /* List of folders to include type definitions from. */
+    "types": [
+      "node",
+      "jest"
+    ], /* Type declaration files to be included in compilation. */ // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+    /* Experimental Options */
+    "experimentalDecorators": true /* Enables experimental support for ES7 decorators. */,
+    "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */ /* Advanced Options */
+    "skipLibCheck": true /* Skip type checking of declaration files. */,
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
+    "incremental": true
+    // "incremental": true /* Disabled to prevent CI build errors */
+  },
+  "incremental": true,
+  "compileOnSave": true,
+  "include": [
+    "*.js",
+    "**/*.test.ts",
+    "**/*.ts",
+    "**/*.js",
+    "**/*.tsx",
+    "types.d.ts"
+  ],
+  "exclude": [
+    "node_modules",
+  ]
+}

package/lib/index.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const array_methods_this_context_1 = require("./rules/array-methods-this-context");
-const class_methods_read_top_to_bottom_1 = require("./rules/class-methods-read-top-to-bottom");
-const dynamic_https_errors_1 = require("./rules/dynamic-https-errors");
-const export_if_in_doubt_1 = require("./rules/export-if-in-doubt");
-const extract_global_constants_1 = require("./rules/extract-global-constants");
-const generic_starts_with_t_1 = require("./rules/generic-starts-with-t");
-const no_async_array_filter_1 = require("./rules/no-async-array-filter");
-const no_async_foreach_1 = require("./rules/no-async-foreach");
-const no_conditional_literals_in_jsx_1 = require("./rules/no-conditional-literals-in-jsx");
-const no_filter_without_return_1 = require("./rules/no-filter-without-return");
-const no_misused_switch_case_1 = require("./rules/no-misused-switch-case");
-const no_unpinned_dependencies_1 = require("./rules/no-unpinned-dependencies");
-const no_useless_fragment_1 = require("./rules/no-useless-fragment");
-const prefer_fragment_shorthand_1 = require("./rules/prefer-fragment-shorthand");
-const prefer_type_over_interface_1 = require("./rules/prefer-type-over-interface");
-const require_memo_1 = require("./rules/require-memo");
-module.exports = {
-    meta: {
-        name: '@blumintinc/eslint-plugin-blumint',
-        version: '0.1.23',
-    },
-    parseOptions: {
-        ecmaVersion: 2020,
-    },
-    configs: {
-        recommended: {
-            plugins: ['@blumintinc/blumint'],
-            rules: {
-                '@blumintinc/blumint/array-methods-this-context': 'warn',
-                '@blumintinc/blumint/class-methods-read-top-to-bottom': 'warn',
-                '@blumintinc/blumint/dynamic-https-errors': 'warn',
-                // '@blumintinc/blumint/export-if-in-doubt': 'warn',
-                // '@blumintinc/blumint/extract-global-constants': 'warn',
-                '@blumintinc/blumint/generic-starts-with-t': 'warn',
-                '@blumintinc/blumint/no-async-array-filter': 'error',
-                '@blumintinc/blumint/no-async-foreach': 'error',
-                '@blumintinc/blumint/no-conditional-literals-in-jsx': 'error',
-                '@blumintinc/blumint/no-filter-without-return': 'error',
-                '@blumintinc/blumint/no-misused-switch-case': 'error',
-                '@blumintinc/blumint/no-unpinned-dependencies': 'error',
-                '@blumintinc/blumint/no-useless-fragment': 'warn',
-                '@blumintinc/blumint/prefer-fragment-shorthand': 'warn',
-                '@blumintinc/blumint/prefer-type-over-interface': 'warn',
-                '@blumintinc/blumint/require-memo': 'error',
-            },
-        },
-    },
-    rules: {
-        'array-methods-this-context': array_methods_this_context_1.arrayMethodsThisContext,
-        'class-methods-read-top-to-bottom': class_methods_read_top_to_bottom_1.classMethodsReadTopToBottom,
-        'dynamic-https-errors': dynamic_https_errors_1.dynamicHttpsErrors,
-        'export-if-in-doubt': export_if_in_doubt_1.exportIfInDoubt,
-        'extract-global-constants': extract_global_constants_1.extractGlobalConstants,
-        'generic-starts-with-t': generic_starts_with_t_1.genericStartsWithT,
-        'no-async-array-filter': no_async_array_filter_1.noAsyncArrayFilter,
-        'no-async-foreach': no_async_foreach_1.noAsyncForEach,
-        'no-conditional-literals-in-jsx': no_conditional_literals_in_jsx_1.noConditionalLiteralsInJsx,
-        'no-filter-without-return': no_filter_without_return_1.noFilterWithoutReturn,
-        'no-misused-switch-case': no_misused_switch_case_1.noMisusedSwitchCase,
-        'no-unpinned-dependencies': no_unpinned_dependencies_1.noUnpinnedDependencies,
-        'no-useless-fragment': no_useless_fragment_1.noUselessFragment,
-        'prefer-fragment-shorthand': prefer_fragment_shorthand_1.preferFragmentShorthand,
-        'prefer-type-over-interface': prefer_type_over_interface_1.preferTypeOverInterface,
-        'require-memo': require_memo_1.requireMemo,
-    },
-};
-//# sourceMappingURL=index.js.map

package/lib/rules/array-methods-this-context.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayMethodsThisContext = exports.ARRAY_METHODS = void 0;
-const createRule_1 = require("../utils/createRule");
-exports.ARRAY_METHODS = [
-    'map',
-    'filter',
-    'forEach',
-    'reduce',
-    'some',
-    'every',
-];
-exports.arrayMethodsThisContext = (0, createRule_1.createRule)({
-    create(context) {
-        return {
-            CallExpression(node) {
-                // Array method called with a class method reference
-                if (node.callee.type === 'MemberExpression' &&
-                    node.callee.property.type === 'Identifier' &&
-                    exports.ARRAY_METHODS.includes(node.callee.property.name) &&
-                    node.arguments.length > 0 &&
-                    node.arguments[0].type === 'MemberExpression' &&
-                    node.arguments[0].object.type === 'ThisExpression') {
-                    context.report({
-                        node: node.arguments[0],
-                        messageId: 'unexpected',
-                    });
-                }
-                // Function expression bound to `this` in array method
-                else if (node.callee.type === 'MemberExpression' &&
-                    node.callee.property.type === 'Identifier' &&
-                    exports.ARRAY_METHODS.includes(node.callee.property.name) &&
-                    node.arguments.length > 0 &&
-                    node.arguments[0].type === 'CallExpression' &&
-                    node.arguments[0].callee.type === 'MemberExpression' &&
-                    node.arguments[0].callee.object.type === 'FunctionExpression' &&
-                    node.arguments[0].callee.property.type === 'Identifier' &&
-                    node.arguments[0].callee.property.name === 'bind' &&
-                    node.arguments[0].arguments.length > 0 &&
-                    node.arguments[0].arguments[0].type === 'ThisExpression') {
-                    context.report({
-                        node: node.arguments[0],
-                        messageId: 'preferArrow',
-                    });
-                }
-            },
-        };
-    },
-    name: 'array-methods-this-context',
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Prevent misuse of Array methods in OOP',
-            recommended: 'error',
-        },
-        schema: [],
-        messages: {
-            unexpected: 'Use an arrow function to preserve "this" context.',
-            preferArrow: 'Use an arrow function instead of binding this.',
-        },
-    },
-    defaultOptions: [],
-});
-//# sourceMappingURL=array-methods-this-context.js.map

package/lib/rules/class-methods-read-top-to-bottom.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.classMethodsReadTopToBottom = void 0;
-const createRule_1 = require("../utils/createRule");
-const ClassGraphBuilder_1 = require("../utils/graph/ClassGraphBuilder");
-function getMemberName(member) {
-    if (member.type === 'MethodDefinition' ||
-        member.type === 'PropertyDefinition') {
-        return member.key.type === 'Identifier' ? member.key.name : null;
-    }
-    return null;
-}
-exports.classMethodsReadTopToBottom = (0, createRule_1.createRule)({
-    name: 'class-methods-read-top-to-bottom',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Ensures classes read linearly from top to bottom.',
-            recommended: 'warn',
-        },
-        schema: [],
-        messages: {
-            classMethodsReadTopToBottom: 'Methods should be ordered for top-down readability.',
-        },
-        fixable: 'code', // To allow ESLint to autofix issues.
-    },
-    defaultOptions: [],
-    create(context) {
-        let className;
-        return {
-            ClassDeclaration(node) {
-                className = node.id?.name || '';
-            },
-            'ClassBody:exit'(node) {
-                const graphBuilder = new ClassGraphBuilder_1.ClassGraphBuilder(className, node);
-                const sortedOrder = graphBuilder.memberNamesSorted;
-                const actualOrder = node.body
-                    .map((member) => member.type === 'MethodDefinition' ||
-                    member.type === 'PropertyDefinition'
-                    ? member.key.name
-                    : null)
-                    .filter(Boolean);
-                for (let i = 0; i < actualOrder.length; i++) {
-                    if (actualOrder[i] !== sortedOrder[i]) {
-                        const sourceCode = context.getSourceCode();
-                        const newClassBody = sortedOrder
-                            .map((n) => {
-                            // Fetch the actual AST node corresponding to the name
-                            const memberNode = node.body.find((member) => getMemberName(member) === n);
-                            const comments = sourceCode.getCommentsBefore(memberNode);
-                            memberNode.range = [
-                                Math.min(memberNode.range[0], Math.min(...comments.map((comment) => comment.range[0]))),
-                                Math.max(memberNode.range[1], Math.max(...comments.map((comment) => comment.range[1]))),
-                            ];
-                            return sourceCode.getText(memberNode);
-                        })
-                            .join('\n');
-                        return context.report({
-                            node,
-                            messageId: 'classMethodsReadTopToBottom',
-                            fix(fixer) {
-                                return fixer.replaceTextRange([node.range[0] + 1, node.range[1] - 1], // Exclude the curly braces
-                                newClassBody);
-                            },
-                        });
-                    }
-                }
-            },
-        };
-    },
-});
-//# sourceMappingURL=class-methods-read-top-to-bottom.js.map

package/lib/rules/dynamic-https-errors.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dynamicHttpsErrors = void 0;
-/* eslint-disable @blumintinc/blumint/extract-global-constants */
-const createRule_1 = require("../utils/createRule");
-const isHttpsErrorCall = (callee) => {
-    if (callee.type === 'MemberExpression') {
-        return (callee.object.type === 'Identifier' &&
-            callee.object.name === 'https' &&
-            callee.property.type === 'Identifier' &&
-            callee.property.name === 'HttpsError');
-    }
-    else if (callee.type === 'Identifier') {
-        return callee.name === 'HttpsError';
-    }
-    return false;
-};
-exports.dynamicHttpsErrors = (0, createRule_1.createRule)({
-    name: 'dynamic-https-errors',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id.',
-            recommended: 'warn',
-        },
-        schema: [],
-        messages: {
-            dynamicHttpsErrors: 'Found dynamic error details in the second argument of the HttpsError constructor - the "message" field. This field is hashed to produce a unique id for error monitoring. Move any dynamic details to the third argument - the "details" field - to preserve the unique id and to monitor the error correctly.',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const checkForHttpsError = (node) => {
-            const callee = node.callee;
-            if (isHttpsErrorCall(callee)) {
-                const secondArg = node.arguments[1];
-                if (secondArg && secondArg.type === 'TemplateLiteral') {
-                    if (secondArg.expressions.length > 0) {
-                        context.report({
-                            node: secondArg,
-                            messageId: 'dynamicHttpsErrors',
-                        });
-                    }
-                }
-            }
-        };
-        return {
-            NewExpression(node) {
-                return checkForHttpsError(node);
-            },
-            CallExpression(node) {
-                return checkForHttpsError(node);
-            },
-        };
-    },
-});
-//# sourceMappingURL=dynamic-https-errors.js.map

package/lib/rules/export-if-in-doubt.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportIfInDoubt = void 0;
-/* eslint-disable @blumintinc/blumint/extract-global-constants */
-// import { ASTHelpers } from '../utils/ASTHelpers';
-const createRule_1 = require("../utils/createRule");
-exports.exportIfInDoubt = (0, createRule_1.createRule)({
-    name: 'export-if-in-doubt',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'All top-level const definitions, type definitions, and functions should be exported',
-            recommended: 'warn',
-        },
-        schema: [],
-        messages: {
-            exportIfInDoubt: 'Top-level const definitions, type definitions, and functions should be exported.',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        // List of top-level declarations
-        // List of exported identifiers
-        const topLevelDeclarations = [];
-        const exportedIdentifiers = [];
-        return {
-            'Program > VariableDeclaration > VariableDeclarator, Program > FunctionDeclaration, Program > TSTypeAliasDeclaration'(node) {
-                topLevelDeclarations.push(node);
-            },
-            ExportNamedDeclaration: (node) => {
-                if (node.specifiers) {
-                    node.specifiers.forEach((specifier) => {
-                        if (specifier.type === 'ExportSpecifier') {
-                            // Handle both normal and default export
-                            const exportedName = specifier.exported.name;
-                            if (!exportedIdentifiers.includes(exportedName)) {
-                                exportedIdentifiers.push(exportedName);
-                            }
-                            // If the specifier is a default export
-                            if (specifier.local.name !== exportedName) {
-                                const localName = specifier.local.name;
-                                if (!exportedIdentifiers.includes(localName)) {
-                                    exportedIdentifiers.push(localName);
-                                }
-                            }
-                        }
-                    });
-                }
-            },
-            'Program:exit': () => {
-                topLevelDeclarations.forEach((node) => {
-                    if ('id' in node &&
-                        node.id &&
-                        (node.type === 'VariableDeclarator' ||
-                            node.type === 'FunctionDeclaration' ||
-                            node.type === 'TSTypeAliasDeclaration') &&
-                        node.id.type === 'Identifier' &&
-                        !exportedIdentifiers.includes(node.id.name)) {
-                        context.report({
-                            node,
-                            messageId: 'exportIfInDoubt',
-                        });
-                    }
-                });
-            },
-        };
-    },
-});
-//# sourceMappingURL=export-if-in-doubt.js.map

package/lib/rules/extract-global-constants.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractGlobalConstants = void 0;
-const ASTHelpers_1 = require("../utils/ASTHelpers");
-const createRule_1 = require("../utils/createRule");
-exports.extractGlobalConstants = (0, createRule_1.createRule)({
-    create(context) {
-        return {
-            VariableDeclaration(node) {
-                if (node.kind !== 'const') {
-                    return;
-                }
-                const scope = context.getScope();
-                const hasDependencies = node.declarations.some((declaration) => declaration.init &&
-                    ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(declaration.init));
-                if (!hasDependencies &&
-                    (scope.type === 'function' || scope.type === 'block')) {
-                    const constName = node.declarations[0].id.name;
-                    context.report({
-                        node,
-                        messageId: 'extractGlobalConstants',
-                        data: {
-                            declarationName: constName,
-                        },
-                    });
-                }
-            },
-            FunctionDeclaration(node) {
-                if (node.parent &&
-                    (node.parent.type === 'FunctionDeclaration' ||
-                        node.parent.type === 'FunctionExpression' ||
-                        node.parent.type === 'ArrowFunctionExpression')) {
-                    const scope = context.getScope();
-                    const hasDependencies = ASTHelpers_1.ASTHelpers.blockIncludesIdentifier(node.body);
-                    if (!hasDependencies && scope.type === 'function') {
-                        const funcName = node.id.name;
-                        context.report({
-                            node,
-                            messageId: 'extractGlobalConstants',
-                            data: {
-                                declarationName: funcName,
-                            },
-                        });
-                    }
-                }
-            },
-        };
-    },
-    name: 'extract-global-constants',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Extract constants/functions to the global scope when possible',
-            recommended: 'error',
-        },
-        schema: [],
-        messages: {
-            extractGlobalConstants: 'Move this declaration {{ declarationName }} to the global scope and rename it to UPPER_SNAKE_CASE if necessary.',
-        },
-    },
-    defaultOptions: [],
-});
-//# sourceMappingURL=extract-global-constants.js.map

package/lib/rules/generic-starts-with-t.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.genericStartsWithT = void 0;
-const createRule_1 = require("../utils/createRule");
-exports.genericStartsWithT = (0, createRule_1.createRule)({
-    create(context) {
-        return {
-            TSTypeParameterDeclaration(node) {
-                for (const param of node.params) {
-                    if (typeof param.name.name === 'string' &&
-                        param.name.name[0] !== 'T') {
-                        context.report({
-                            node: param,
-                            messageId: 'genericStartsWithT',
-                        });
-                    }
-                }
-            },
-        };
-    },
-    name: 'generic-starts-with-t',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Enforce TypeScript generic types to start with T',
-            recommended: 'error',
-        },
-        schema: [],
-        messages: {
-            genericStartsWithT: 'Generic type parameter should start with T.',
-        },
-    },
-    defaultOptions: [],
-});
-//# sourceMappingURL=generic-starts-with-t.js.map

package/lib/rules/no-async-array-filter.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noAsyncArrayFilter = void 0;
-const createRule_1 = require("../utils/createRule");
-exports.noAsyncArrayFilter = (0, createRule_1.createRule)({
-    create(context) {
-        return {
-            CallExpression(node) {
-                if (node.callee.type === 'MemberExpression' &&
-                    node.callee.property.type === 'Identifier' &&
-                    node.callee.property.name === 'filter' &&
-                    node.arguments.length > 0) {
-                    const callback = node.arguments[0];
-                    if ((callback.type === 'FunctionExpression' ||
-                        callback.type === 'ArrowFunctionExpression') &&
-                        callback.async === true) {
-                        context.report({
-                            node: callback,
-                            messageId: 'unexpected',
-                        });
-                    }
-                }
-            },
-        };
-    },
-    name: 'no-async-array-filter',
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow async callbacks for Array.filter',
-            recommended: 'error',
-        },
-        schema: [],
-        messages: {
-            unexpected: 'Async array filter is dangerous as a Promise object will always be truthy. You should move the asynchronous logic elsewhere.',
-        },
-    },
-    defaultOptions: [],
-});
-//# sourceMappingURL=no-async-array-filter.js.map

package/lib/rules/no-async-foreach.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noAsyncForEach = void 0;
-exports.noAsyncForEach = {
-    create(context) {
-        return {
-            CallExpression(node) {
-                const callee = node.callee;
-                if (callee.type === 'MemberExpression' &&
-                    callee.property.type === 'Identifier' &&
-                    callee.property.name === 'forEach' &&
-                    node.arguments[0] &&
-                    (node.arguments[0].type === 'ArrowFunctionExpression' ||
-                        node.arguments[0].type === 'FunctionExpression') &&
-                    node.arguments[0].async) {
-                    context.report({
-                        node,
-                        messageId: 'noAsyncForEach',
-                    });
-                }
-            },
-        };
-    },
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow Array.forEach with an async callback function',
-            recommended: 'error',
-        },
-        messages: {
-            noAsyncForEach: 'Do not use async function as callback in Array.forEach. Use a standard for loop for sequential execution or Promise.all for concurrent execution.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-};
-//# sourceMappingURL=no-async-foreach.js.map