@blumintinc/eslint-plugin-blumint 0.1.24 → 1.0.3

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -19,7 +19,7 @@ const require_memo_1 = require("./rules/require-memo");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '0.1.23',
+        version: '1.0.3',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/array-methods-this-context.d.ts

@@ -0,0 +1,3 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const ARRAY_METHODS: string[];
+export declare const arrayMethodsThisContext: TSESLint.RuleModule<'preferArrow' | 'unexpected', never[]>;

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

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const classMethodsReadTopToBottom: TSESLint.RuleModule<'classMethodsReadTopToBottom', never[]>;

package/lib/rules/dynamic-https-errors.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const dynamicHttpsErrors: TSESLint.RuleModule<'dynamicHttpsErrors', never[]>;

package/lib/rules/export-if-in-doubt.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const exportIfInDoubt: TSESLint.RuleModule<'exportIfInDoubt', never[]>;

package/lib/rules/extract-global-constants.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const extractGlobalConstants: TSESLint.RuleModule<'extractGlobalConstants', never[]>;

package/lib/rules/generic-starts-with-t.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const genericStartsWithT: TSESLint.RuleModule<'genericStartsWithT', never[]>;

package/lib/rules/no-async-array-filter.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noAsyncArrayFilter: TSESLint.RuleModule<'unexpected', never[]>;

package/lib/rules/no-async-foreach.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noAsyncForEach: TSESLint.RuleModule<'noAsyncForEach', []>;

package/lib/rules/no-conditional-literals-in-jsx.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noConditionalLiteralsInJsx: TSESLint.RuleModule<'unexpected', any[]>;

package/lib/rules/no-filter-without-return.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noFilterWithoutReturn: TSESLint.RuleModule<'unexpected', never[]>;

package/lib/rules/no-misused-switch-case.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noMisusedSwitchCase: TSESLint.RuleModule<'noMisusedSwitchCase', never[]>;

package/lib/rules/no-unpinned-dependencies.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noUnpinnedDependencies: TSESLint.RuleModule<'unexpected', any[]>;

package/lib/rules/no-useless-fragment.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noUselessFragment: TSESLint.RuleModule<'noUselessFragment', []>;

package/lib/rules/prefer-fragment-shorthand.d.ts

@@ -0,0 +1,3 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const preferFragmentShorthand: TSESLint.RuleModule<'preferShorthand', [
+]>;

package/lib/rules/prefer-type-over-interface.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const preferTypeOverInterface: TSESLint.RuleModule<'preferType', never[]>;

package/lib/rules/require-memo.d.ts

@@ -0,0 +1,6 @@
+import { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export type NodeWithParent = TSESTree.Node & {
+    parent: NodeWithParent;
+};
+export type ComponentNode = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration;
+export declare const requireMemo: TSESLint.RuleModule<'requireMemo', []>;

package/lib/rules/require-memo.js

@@ -41,6 +41,10 @@ const isUnmemoizedExportedFunctionComponent = (parentNode, node) => {
         node.id &&
         !isComponentExplicitlyUnmemoized(node.id.name));
 };
+function isMemoImport(importPath) {
+    // Match both absolute and relative paths ending with util/memo
+    return /(?:^|\/)util\/memo$/.test(importPath);
+}
 function checkFunction(context, node) {
     const fileName = context.getFilename();
     if (!fileName.endsWith('.tsx')) {
@@ -67,21 +71,33 @@ function checkFunction(context, node) {
                     ? function fix(fixer) {
                         const sourceCode = context.getSourceCode();
                         let importFix = null;
-                        // Search for React import statement
+                        // Search for memo import statement
                         const importDeclarations = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');
-                        const reactImport = importDeclarations.find((importDeclaration) => importDeclaration.source.value === 'react');
-                        if (reactImport) {
+                        const memoImport = importDeclarations.find((importDeclaration) => isMemoImport(importDeclaration.source.value));
+                        if (memoImport) {
                             // Check if memo is already imported
-                            if (!reactImport.specifiers.some((specifier) => specifier.local.name === 'memo')) {
+                            if (!memoImport.specifiers.some((specifier) => specifier.local.name === 'memo')) {
                                 // Add memo to existing import statement
-                                const lastSpecifier = reactImport.specifiers[reactImport.specifiers.length - 1];
+                                const lastSpecifier = memoImport.specifiers[memoImport.specifiers.length - 1];
                                 importFix = fixer.insertTextAfter(lastSpecifier, ', memo');
                             }
                         }
                         else {
+                            // Calculate relative path based on current file location
+                            const currentFilePath = context.getFilename();
+                            const importPath = calculateImportPath(currentFilePath);
+                            // Find the first import statement to insert after
+                            const firstImport = importDeclarations[0];
                             // Add new import statement for memo
-                            const importStatement = "import { memo } from 'react';\n";
-                            importFix = fixer.insertTextBeforeRange([sourceCode.ast.range[0], sourceCode.ast.range[0]], importStatement);
+                            const importStatement = `import { memo } from '${importPath}';\n`;
+                            if (firstImport) {
+                                // Insert after the first import with a single newline
+                                importFix = fixer.insertTextAfter(firstImport, '\n' + importStatement.trim());
+                            }
+                            else {
+                                // Insert at the start of the file
+                                importFix = fixer.insertTextBeforeRange([sourceCode.ast.range[0], sourceCode.ast.range[0]], importStatement.trim() + '\n');
+                            }
                         }
                         const functionKeywordRange = [
                             node.range[0],
@@ -105,6 +121,22 @@ function checkFunction(context, node) {
         }
     }
 }
+function calculateImportPath(currentFilePath) {
+    // Default to absolute path if we can't calculate relative path
+    if (!currentFilePath)
+        return 'src/util/memo';
+    // Split the current file path into parts and normalize
+    const parts = currentFilePath.split(/[\\/]/); // Handle both Unix and Windows paths
+    const srcIndex = parts.indexOf('src');
+    if (srcIndex === -1) {
+        // If we're not in a src directory, use absolute path
+        return 'src/util/memo';
+    }
+    // Calculate relative path based on current file depth from src
+    // Subtract 1 from depth to exclude the filename itself
+    const depth = parts.length - (srcIndex + 1) - 1;
+    return '../'.repeat(depth) + 'util/memo';
+}
 exports.requireMemo = {
     create: (context) => ({
         ArrowFunctionExpression(node) {

package/lib/utils/ASTHelpers.d.ts

@@ -0,0 +1,12 @@
+import { TSESTree } from '@typescript-eslint/utils';
+import { Graph } from './graph/ClassGraphBuilder';
+export declare class ASTHelpers {
+    static blockIncludesIdentifier(block: TSESTree.BlockStatement): boolean;
+    static declarationIncludesIdentifier(node: TSESTree.Node | null): boolean;
+    static classMethodDependenciesOf(node: TSESTree.Node | null, graph: Graph, className: string): string[];
+    static isNode(value: unknown): value is TSESTree.Node;
+    static hasReturnStatement(node: TSESTree.Node): boolean;
+    static isNodeExported(node: TSESTree.Node): boolean;
+    static returnsJSX(node: TSESTree.Node): boolean;
+    static hasParameters(node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration): boolean;
+}

package/lib/utils/createRule.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener = import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<TMessageIds, TOptions, TRuleListener>;

package/lib/utils/graph/ClassGraphBuilder.d.ts

@@ -0,0 +1,29 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export type GraphNode = {
+    name: string;
+    type: 'method' | 'property' | 'constructor';
+    accessibility?: TSESTree.Accessibility;
+    isStatic: boolean;
+    dependencies: string[];
+};
+export type Graph = Record<string, GraphNode>;
+/**
+ * Builds a graph of class methods and properties with their dependencies from a class declaration.
+ * A dependency in this case is the name of another class method.
+ */
+export declare class ClassGraphBuilder {
+    private className;
+    private classBody;
+    graph: Graph;
+    private sorter;
+    constructor(className: string, classBody: TSESTree.ClassBody);
+    private buildGraph;
+    private static isClassMember;
+    private addMemberToGraph;
+    private static nodeTypeOf;
+    private static createGraphNode;
+    private static isNamedClassMethod;
+    private addDependencies;
+    get graphSorted(): GraphNode[];
+    get memberNamesSorted(): string[];
+}

package/lib/utils/graph/ClassGraphSorter.d.ts

@@ -0,0 +1,7 @@
+import { Graph, GraphNode } from './ClassGraphBuilder';
+export declare abstract class ClassGraphSorter {
+    graph: Graph;
+    constructor(graph: Graph);
+    abstract nodesSorted: GraphNode[];
+    abstract nodeNamesSorted: GraphNode['name'][];
+}

package/lib/utils/graph/ClassGraphSorterReadability.d.ts

@@ -0,0 +1,16 @@
+import { Graph, GraphNode } from './ClassGraphBuilder';
+import { ClassGraphSorter } from './ClassGraphSorter';
+type GraphNodeModifier = 'isStatic' | 'accessibility';
+export declare class ClassGraphSorterReadability extends ClassGraphSorter {
+    graph: Graph;
+    static readonly MODIFIER_PRIORITY_MAP: Record<GraphNodeModifier, any[]>;
+    private static readonly SEARCH_NODE_PRIORITY_FUNCTIONS;
+    constructor(graph: Graph);
+    get nodeNamesSorted(): string[];
+    get nodesSorted(): GraphNode[];
+    sortNodes(): GraphNode[];
+    private groupNodesByType;
+    private static sortMembersForReadability;
+    private dependencyDfs;
+}
+export {};

package/lib/utils/ruleTester.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { RuleTester } from 'eslint';
+export declare const ruleTesterTs: ESLintUtils.RuleTester;
+export declare const ruleTesterJsx: ESLintUtils.RuleTester;
+export declare const ruleTesterJson: RuleTester;

package/package.json

@@ -1,45 +1,114 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "0.1.24",
-  "description": "Custom eslint rules for use at BluMint",
+  "version": "1.0.3",
+  "description": "Custom eslint rules for use within BluMint",
+  "author": {
+    "name": "Brodie McGuire",
+    "email": "brodie@blumint.io"
+  },
+  "main": "lib/index.js",
+  "exports": "./lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BluMintInc/custom-eslint-rules.git"
+  },
+  "bugs": {
+    "url": "https://github.com/BluMintInc/custom-eslint-rules/issues"
+  },
+  "homepage": "https://github.com/BluMintInc/custom-eslint-rules#readme",
   "keywords": [
     "eslint",
     "eslintplugin",
     "eslint-plugin"
   ],
-  "author": "Brodie McGuire",
-  "main": "./lib/index.js",
-  "exports": "./lib/index.js",
+  "private": false,
   "scripts": {
     "lint": "npm-run-all \"lint:*\"",
     "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
     "lint:js": "eslint ./src",
-    "test": "jest",
+    "lint:md": "remark .",
+    "lint:shell": "shellcheck .devcontainer/git-flow-completion.bash",
+    "lint:fix": "tsc && eslint ./**/* --quiet --fix",
+    "test": "jest --passWithNoTests --reporters=default --reporters=jest-junit",
+    "test:ci": "jest --ci --passWithNoTests --reporters=default --reporters=jest-junit",
     "docs": "./scripts/make-docs.sh && npm run update:eslint-docs",
-    "update:eslint-docs": "eslint-doc-generator"
+    "update:eslint-docs": "eslint-doc-generator",
+    "build": "tsc",
+    "prepare": "npm run build",
+    "version": "git add -A src",
+    "postversion": "git push && git push --tags",
+    "remove-hooks": "del-cli ./.husky/",
+    "release:dry-run": "semantic-release --dry-run --no-ci",
+    "test:release": "node scripts/test-release.js"
   },
   "dependencies": {
     "requireindex": "1.2.0"
   },
   "devDependencies": {
+    "@semantic-release/changelog": "6.0.1",
+    "@semantic-release/commit-analyzer": "9.0.2",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/npm": "9.0.1",
+    "@semantic-release/release-notes-generator": "10.0.3",
     "@types/eslint": "8.37.0",
+    "@types/node": "18.7.13",
+    "@typescript-eslint/eslint-plugin": "5.34.0",
+    "@typescript-eslint/parser": "5.48.0",
     "@typescript-eslint/utils": "5.59.6",
-    "eslint": "8.19.0",
+    "chai": "4.3.6",
+    "chai-as-promised": "7.1.1",
+    "cross-env": "7.0.3",
+    "cz-conventional-changelog": "3.3.0",
+    "del-cli": "4.0.1",
+    "dotenv-cli": "5.0.0",
+    "eslint": "8.11.0",
+    "eslint-config-prettier": "8.5.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-import": "2.26.0",
     "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-jsdoc": "44.0.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "eslint-plugin-security": "1.5.0",
+    "fs": "0.0.1-security",
     "jest": "29.3.1",
+    "jest-junit": "14.0.0",
     "jsonc-eslint-parser": "2.3.0",
     "npm-run-all": "4.1.5",
-    "ts-jest": "29.0.5"
+    "prettier": "2.7.1",
+    "remark-cli": "10.0.1",
+    "remark-lint": "9.1.1",
+    "remark-preset-lint-recommended": "6.1.2",
+    "semantic-release": "19.0.3",
+    "ts-jest": "29.0.5",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5",
+    "@types/jest": "^29.3.1",
+    "@semantic-release/exec": "^6.0.3"
+  },
+  "peerDependencies": {
+    "eslint": ">=7"
   },
   "engines": {
     "node": "^20.0.0"
   },
-  "peerDependencies": {
-    "eslint": ">=7"
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "jest-junit": {
+    "outputDirectory": "reports",
+    "outputName": "jest-junit.xml",
+    "ancestorSeparator": " › ",
+    "uniqueOutputName": "false",
+    "suiteNameTemplate": "{filepath}",
+    "classNameTemplate": "{classname}",
+    "titleTemplate": "{title}"
   },
   "license": "ISC"
 }

package/docs/rules/array-methods-this-context.md

@@ -1,30 +0,0 @@
-# Prevent misuse of Array methods in OOP (`@blumintinc/blumint/array-methods-this-context`)
-
-⚠️ This rule _warns_ in the ✅ `recommended` config.
-
-<!-- end auto-generated rule header -->
-
-This rule disallows the direct use of class methods in Array methods like 'map', 'filter', 'forEach', 'reduce', 'some', 'every'. Instead, arrow functions should be used to preserve the 'this' context.
-
-## Rule Details
-
-This rule enforces that no class methods are directly used in Array methods. It also prefers the use of arrow functions over `bind(this)`
-
-### Examples of incorrect code for this rule:
-
-```typescript
-['a', 'b', 'c'].map(this.processItem)
-['a', 'b', 'c'].map(this.processItem, otherArgument)
-['a', 'b', 'c'].filter(this.checkItem)
-['a', 'b', 'c'].forEach(this.printItem)
-['a', 'b', 'c'].some(this.testItem)
-['a', 'b', 'c'].every(this.validateItem)
-['a', 'b', 'c'].reduce(this.combineItems)
-['a', 'b', 'c'].map(function(item) { return this.processItem(item) }.bind(this))
-```
-
-### Examples of correct code for this rule:
-```typescript
-['a', 'b', 'c'].map((item) => this.processItem(item))
-['a', 'b', 'c'].map(processItem)
-```

package/docs/rules/class-methods-read-top-to-bottom.md

@@ -1,46 +0,0 @@
-# Ensures classes read linearly from top to bottom (`@blumintinc/blumint/class-methods-read-top-to-bottom`)
-
-⚠️ This rule _warns_ in the ✅ `recommended` config.
-
-🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
-
-<!-- end auto-generated rule header -->
-
-This rule enforces an ordering of class methods according to BluMint's code style.
-
-## Rule Details
-
-This rule warns for classes that don't follow the 'top to bottom' ordering - such that properties appear at the top of the class, the constructor (if present) follows, and other methods follow in a top-to-bottom order.
-
-### Examples of incorrect code for this rule:
-
-```typescript
-class IncorrectlyOrdered {
-    field1: string;
-    field2: number;
-    methodA() {
-    this.methodB();
-    }
-    constructor() {
-    this.methodA();
-    this.methodC();
-    }
-    methodB() {}
-    methodC() {}
-}
-```
-
-### Examples of correct code for this rule:
-```typescript
-class CorrectlyOrdered {
-    field1: string;
-    field2: number;
-    constructor() {
-        this.methodA();
-    }
-    methodA() {
-        this.methodB();
-    }
-    methodB() {}
-}
-```

package/docs/rules/dynamic-https-errors.md

@@ -1,23 +0,0 @@
-# Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id (`@blumintinc/blumint/dynamic-https-errors`)
-
-⚠️ This rule _warns_ in the ✅ `recommended` config.
-
-<!-- end auto-generated rule header -->
-
-This rule warns against the use of template literals in the `message` field of the `HttpsError` constructor, and suggests their use in the `details` field instead.
-
-## Rule Details
-
-Examples of **incorrect** code for this rule:
-
-```typescript
-throw new https.HttpsError('foo', `Error: ${bar}`, 'baz');
-throw new HttpsError('foo', `Error: ${bar}`, 'baz');
-```
-
-Examples of **correct** code for this rule:
-
-```typescript
-throw new https.HttpsError('foo', 'bar', 'baz');
-throw new https.HttpsError('foo', 'bar', `Details: ${baz}`);
-```

package/docs/rules/export-if-in-doubt.md

@@ -1,26 +0,0 @@
-# All top-level const definitions, type definitions, and functions should be exported (`@blumintinc/blumint/export-if-in-doubt`)
-
-<!-- end auto-generated rule header -->
-
-This rule enforces that all top-level const definitions, type definitions, and functions should always be exported. If not done, this rule will trigger a warning message suggesting to export the declaration.
-
-## Rule Details
-
-This rule targets `VariableDeclaration`, `FunctionDeclaration`, and `TSTypeAliasDeclaration` at the top-level of the file. It will issue a warning if these are not part of an `ExportNamedDeclaration`.
-
-### Examples of incorrect code for this rule:
-
-```typescript
-const someVar = "Hello, world!";
-function someFunc() { return someVar; }
-type SomeType = { val: number };
-```
-
-### Examples of correct code for this rule:
-
-```typescript
-export const someVar = "Hello, world!";
-export function someFunc() { return someVar; }
-export type SomeType = { val: number };
-```
-

package/docs/rules/extract-global-constants.md

@@ -1,33 +0,0 @@
-# Extract constants/functions to the global scope when possible (`@blumintinc/blumint/extract-global-constants`)
-
-<!-- end auto-generated rule header -->
-
-This rule suggests that if a constant or a function within a function or block scope doesn't depend on any other identifiers in that scope, it should be moved to the global scope. This aims to improve the readability of the code and the possibility of reuse.
-
-## Rule Details
-
-This rule enforces that all `const` declarations and `FunctionDeclaration` at a non-global scope, which have no dependencies on other identifiers within the scope, should be extracted to the global scope.
-
-### Examples of incorrect code for this rule:
-
-```typescript
-function someFunc() {
-  const SOME_CONST = "Hello, world!";
-}
-
-function parentFunc() {
-  function childFunc() { return "Hello, world!"; }
-}
-```
-
-### Examples of correct code for this rule:
-
-```typescript
-const SOME_CONST = "Hello, world!";
-function someFunc() { /* ... */ }
-
-function childFunc() { return "Hello, world!"; }
-function parentFunc() { /* ... */ }
-```
-
-In the correct examples, each declaration is moved to the global scope since they don't depend on any identifier in their previous block or function scope. This aligns with the rule and promotes potential reuse of these declarations.

package/docs/rules/generic-starts-with-t.md

@@ -1,33 +0,0 @@
-# Enforce TypeScript generic types to start with T (`@blumintinc/blumint/generic-starts-with-t`)
-
-⚠️ This rule _warns_ in the ✅ `recommended` config.
-
-<!-- end auto-generated rule header -->
-
-This rule enforces that all TypeScript generic types start with the letter "T".
-
-## Rule Details
-
-Generics are a way of creating reusable code components that work with a variety of types as opposed to a single one. By convention, generic type parameters often start with the letter "T". This makes it easier to recognize them as generic types and not regular variables or types.
-
-This rule enforces that all TypeScript generic types start with the letter "T".
-
-Examples of **incorrect** code for this rule:
-
-```typescript
-type GenericType<Param> = Param[];
-type GenericType<TParam, Param> = [TParam, Param];
-type GenericType<P> = P[];
-```
-
-Examples of **correct** code for this rule:
-
-```typescript
-type GenericType<TParam> = TParam[];
-type GenericType<TParam1, TParam2> = [TParam1, TParam2];
-type GenericType<T> = T[];
-```
-
-## When Not To Use It
-If you have a different convention for naming generic types in your codebase, you may want to disable this rule.
-

package/docs/rules/no-async-array-filter.md

@@ -1,32 +0,0 @@
-# Disallow async callbacks for Array.filter (`@blumintinc/blumint/no-async-array-filter`)
-
-💼 This rule is enabled in the ✅ `recommended` config.
-
-<!-- end auto-generated rule header -->
-
-Async callbacks in array filters are dangerous and not picked up by the standard eslint rules.
-
-## Rule Details
-
-This rule prevents the use of async callbacks in Array.filter. These will return a Promise object, which is truthy, thus rendering the filter function useless.
-
-Examples of **incorrect** code for this rule:
-
-```typescript
-
-['a'].filter(async (x) => true)
-['a'].filter(async function(x) {
-        return true
-      })
-```
-
-Examples of **correct** code for this rule:
-
-```typescript
-
-['a'].filter((x) => true)
-['a'].filter(function (x) {
-      return true
-    })
-```
-

package/docs/rules/no-async-foreach.md

@@ -1,41 +0,0 @@
-# Disallow Array.forEach with an async callback function (`@blumintinc/blumint/no-async-foreach`)
-
-💼 This rule is enabled in the ✅ `recommended` config.
-
-<!-- end auto-generated rule header -->
-
-This rule disallows the use of `Array.forEach` callbacks with the async keyword. These are typically found when sequential promise execution is desired, but in fact these will execute almost concurrently. The use of a standard `for` loop is suggested instead, which will execute sequentially. If concurrent execution is required, `Promise.all` or `Promise.allSettled` should be used.
-
-## Rule Details
-
-This rule is aimed at ensuring that the async keyword is not used in an `Array.forEach` callback.
-
-Examples of **incorrect** code for this rule:
-
-```typescript
-['a','b','c'].forEach(async (letter) => {
-    await someAsyncFunction(letter)
-    console.log(letter)
-    })
-['foo','bar'].forEach(async function (letter) {
-    await someAsyncFunction(letter)
-    console.log(letter)
-})
-```
-
-Examples of **correct** code for this rule:
-
-```typescript
-['a','b','c'].forEach(letter) => {
-    someSyncFunction(letter)
-    console.log(letter)
-    })
-['foo','bar'].forEach(function (letter) {
-    someSyncFunction(letter)
-    console.log(letter)
-})
-for (const letter of ['a', 'b', 'c']) {             
-    someSyncFunction(letter);
-    console.log(letter); 
- }
-```

package/docs/rules/no-conditional-literals-in-jsx.md

@@ -1,27 +0,0 @@
-# Disallow use of conditional literals in JSX code (`@blumintinc/blumint/no-conditional-literals-in-jsx`)
-
-💼 This rule is enabled in the ✅ `recommended` config.
-
-<!-- end auto-generated rule header -->
-
-This rule disallows the use of conditional literals in JSX.
-
-## Rule Details
-
-Browser auto-translation will break if pieces of text nodes are be rendered conditionally.
-
-Examples of **incorrect** code for this rule:
-
-```jsx
-<div>This will cause {conditional && 'errors'}</div>
-<div><span>This will {conditional && 'also'} cause errors </span></div>
-```
-
-Examples of **correct** code for this rule:
-
-```jsx
-      <div>Foo</div>
-      <div>
-        Bar {conditional && <span>Baz</span>}
-      </div>
-```

package/docs/rules/no-filter-without-return.md

@@ -1,43 +0,0 @@
-# Disallow Array.filter callbacks without an explicit return (if part of a block statement) (`@blumintinc/blumint/no-filter-without-return`)
-
-💼 This rule is enabled in the ✅ `recommended` config.
-
-<!-- end auto-generated rule header -->
-
-This rule disallows the use of `Array.filter` callbacks that are part of a block statement but do not contain an explicit return statement. When using `Array.filter`, it's common to return a boolean value directly from a concise arrow function. However, if you're using a block statement (enclosed in `{}`), an explicit `return` statement is required.
-
-## Rule Details
-
-This rule is aimed at ensuring that there is an explicit return statement in `Array.filter` callbacks that are part of a block statement.
-
-Examples of **incorrect** code for this rule:
-
-```typescript
-['a'].filter((x) => {console.log(x)})
-['a'].filter((x) => {if (x) {
-    return true
-}
-else {}
-}
-)
-['a'].filter((x) => { if (x !== 'a') { console.log(x) } else { return true } })
-```
-
-Examples of **correct** code for this rule:
-
-```typescript
-['a'].filter((x) => !x)
-['a'].filter((x) => !!x)
-['a'].filter((x) => {
-    if (x === 'test') {
-        return true
-    }
-    else {
-        return false
-    }
-})
-['a'].filter(function (x) {
-  return true
-})
-['a'].filter((x) => x === 'a' ? true : false)
-```

package/docs/rules/no-misused-switch-case.md

@@ -1,38 +0,0 @@
-# Prevent misuse of logical OR in switch case statements (`@blumintinc/blumint/no-misused-switch-case`)
-
-💼 This rule is enabled in the ✅ `recommended` config.
-
-<!-- end auto-generated rule header -->
-
-This rule prevents the misuse of logical OR in switch case statements. Instead, cascading cases should be used. This improves code readability and understanding.
-
-## Rule Details
-
-This rule specifically targets `SwitchStatement` and issues a warning if a case uses a logical OR in its test.
-
-### Examples of incorrect code for this rule:
-
-```typescript
-switch (value) {
-  case 'a' || 'b':
-    console.log('It is a or b');
-    break;
-  default:
-    console.log('Unknown value');
-}
-```
-
-### Examples of correct code for this rule:
-
-```typescript
-switch (value) {
-  case 'a':
-  case 'b':
-    console.log('It is a or b');
-    break;
-  default:
-    console.log('Unknown value');
-}
-```
-
-In the correct example, instead of using a logical OR in the case test, cascading cases are used to capture the multiple possibilities. This is the standard way to handle multiple possibilities in a switch case and adheres to the rule.

package/docs/rules/no-unpinned-dependencies.md

@@ -1,34 +0,0 @@
-# Enforces pinned dependencies (`@blumintinc/blumint/no-unpinned-dependencies`)
-
-💼 This rule is enabled in the ✅ `recommended` config.
-
-🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
-
-<!-- end auto-generated rule header -->
-
-Unpinned dependencies can cause problems, including hard to diagnose breaking changes.
-
-## Rule Details
-
-This rule aims to prevent the use of unpinned dependencies.
-
-Examples of **incorrect** code for this rule:
-
-```json
-
-{dependencies: {eslint: "^8.19.0"}}
-{dependencies: {eslint: "~8.19.0"}}
-
-```
-
-Examples of **correct** code for this rule:
-
-```json
-
-{dependencies: {eslint: "8.19.0"}}
-
-```
-
-## When Not To Use It
-
-If pinned dependencies are ok in your codebase.

package/docs/rules/no-useless-fragment.md

@@ -1,25 +0,0 @@
-# Prevent unnecessary use of React fragments (`@blumintinc/blumint/no-useless-fragment`)
-
-⚠️ This rule _warns_ in the ✅ `recommended` config.
-
-🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
-
-<!-- end auto-generated rule header -->
-
-This rule enforces that React fragments (`<>...</>`) are only used when necessary. A fragment is deemed unnecessary if it wraps only a single child.
-
-## Rule Details
-
-Examples of **incorrect** code for this rule:
-
-```jsx
-<><ChildComponent /></>
-```
-
-Examples of **correct** code for this rule:
-
-```jsx
-<><ChildComponent /><AnotherChild /></>
-<><ChildComponent />Some Text<AnotherChild /></>
-```
-

package/docs/rules/prefer-fragment-shorthand.md

@@ -1,25 +0,0 @@
-# Prefer <> shorthand for <React.Fragment> (`@blumintinc/blumint/prefer-fragment-shorthand`)
-
-⚠️ This rule _warns_ in the ✅ `recommended` config.
-
-🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
-
-<!-- end auto-generated rule header -->
-
-This rule prefers the use of fragment shorthand, `<>` over `<React.Fragment>`
-
-## Rule Details
-
-Examples of **incorrect** code for this rule:
-
-```jsx
-<React.Fragment>Hello World</React.Fragment>
-<React.Fragment><ChildComponent /></React.Fragment>
-```
-
-Examples of **correct** code for this rule:
-
-```jsx
-<>Hello World</>
-<><ChildComponent /></>
-```

package/docs/rules/prefer-type-over-interface.md

@@ -1,25 +0,0 @@
-# Prefer using type alias over interface (`@blumintinc/blumint/prefer-type-over-interface`)
-
-⚠️ This rule _warns_ in the ✅ `recommended` config.
-
-🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
-
-<!-- end auto-generated rule header -->
-
-This rule prefers the use of `Type` over `Interface` in Typescript.
-
-## Rule Details
-
-Examples of **incorrect** code for this rule:
-
-```typescript
-interface SomeInterface { field: string; };
-interface AnotherInterface extends SomeInterface { otherField: number; };
-```
-
-Examples of **correct** code for this rule:
-
-```typescript
-type SomeType = { field: string; };
-type AnotherType = SomeType & { otherField: number; };
-```

package/docs/rules/require-memo.md

@@ -1,33 +0,0 @@
-# React components must be memoized (`@blumintinc/blumint/require-memo`)
-
-💼 This rule is enabled in the ✅ `recommended` config.
-
-🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
-
-<!-- end auto-generated rule header -->
-
-This rule enforces that React components (that are not pure) to be memoized. If the component name includes "Unmemoized", then this rule is ignored.
-
-## Rule Details
-
-Examples of **incorrect** code for this rule:
-
-```jsx
-const Component = ({foo, bar}) => return (
-    <SomeOtherComponent>{foo}{bar}</SomeOtherComponent>
-)
-```
-
-Examples of **correct** code for this rule:
-
-```jsx
-const MemoizedComponent = memo(function BigComponent({foo, bar}) {
-    return (
-        <SomeOtherComponent>{foo}{bar}</SomeOtherComponent>
-    )
-})
-const ComponentUnmemoized = ({foo, bar}) => return (
-    <SomeOtherComponent>{foo}{bar}</SomeOtherComponent>
-)
-```
-