@blumintinc/eslint-plugin-blumint 1.15.0 → 1.16.1

package/lib/rules/warn-https-error-message-user-friendly.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnHttpsErrorMessageUserFriendly = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+exports.warnHttpsErrorMessageUserFriendly = (0, createRule_1.createRule)({
+    name: 'warn-https-error-message-user-friendly',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Warn when messageUserFriendly is used in HttpsError or toHttpsError to ensure it is truly a user-caused error.',
+            recommended: 'warn',
+        },
+        fixable: undefined,
+        schema: [],
+        messages: {
+            warnHttpsErrorMessageUserFriendly: "What's wrong: '{{propertyName}}' is set on an HttpsError/toHttpsError options object. " +
+                'Why it matters: this marks the error as user-caused and can suppress automated error monitoring and QA issue creation for real defects. ' +
+                "How to fix: remove '{{propertyName}}' unless the error is genuinely user-caused; if it is, keep it and add // eslint-disable-next-line to document the exception.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * Extracts problematic property definitions to provide precise reporting locations,
+         * even when properties are deeply nested or mixed via spread elements.
+         */
+        const findMessageUserFriendlyProperties = (node, visited = new Set()) => {
+            const matches = [];
+            for (const prop of node.properties) {
+                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                    if ((!prop.computed &&
+                        ((prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.key.name === 'messageUserFriendly') ||
+                            (prop.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                                prop.key.value === 'messageUserFriendly'))) ||
+                        (prop.computed &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                            prop.key.value === 'messageUserFriendly')) {
+                        matches.push(prop);
+                    }
+                }
+                else if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    if (checkNode(prop.argument, visited)) {
+                        matches.push(prop);
+                    }
+                }
+            }
+            return matches;
+        };
+        /**
+         * Analyzes variable assignments to prevent rule bypass via intermediate identifiers,
+         * ensuring that 'messageUserFriendly' cannot be hidden behind a variable name.
+         */
+        const traceVariable = (identifier, visited = new Set()) => {
+            if (visited.has(identifier.name))
+                return false;
+            visited.add(identifier.name);
+            const scope = ASTHelpers_1.ASTHelpers.getScope(context, identifier);
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, identifier.name);
+            if (!variable)
+                return false;
+            for (const def of variable.defs) {
+                if (def.type === 'Variable' && def.node.init) {
+                    if (checkNode(def.node.init, visited)) {
+                        return true;
+                    }
+                }
+                else if (def.type === 'FunctionName' &&
+                    def.node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                    if (traceFunctionReturn(def.node, visited)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        /**
+         * Inspects function bodies to detect cases where the options object is generated
+         * dynamically, closing a common bypass pattern where factories or helpers are used.
+         */
+        const traceFunctionReturn = (node, visited = new Set()) => {
+            if (!node.body)
+                return false;
+            const sourceCode = context.sourceCode ?? context.getSourceCode();
+            const walk = (current) => {
+                if (current !== node &&
+                    (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                        current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                        current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
+                    return false;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                    current.argument) {
+                    return checkNode(current.argument, visited);
+                }
+                const keys = sourceCode.visitorKeys[current.type] ?? [];
+                return keys.some((key) => {
+                    const value = current[key];
+                    if (Array.isArray(value)) {
+                        return value.some((child) => child &&
+                            typeof child === 'object' &&
+                            'type' in child &&
+                            walk(child));
+                    }
+                    if (value && typeof value === 'object' && 'type' in value) {
+                        return walk(value);
+                    }
+                    return false;
+                });
+            };
+            if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                return walk(node.body);
+            }
+            else {
+                // Arrow function with expression body
+                return checkNode(node.body, visited);
+            }
+        };
+        /**
+         * Recursively evaluates diverse AST structures (logical, conditional, calls) to ensure
+         * that the presence of 'messageUserFriendly' is detected regardless of expression complexity.
+         *
+         * Note: This implementation intentionally covers only Identifier callees for simplicity,
+         * as MemberExpression callees (e.g., optionsFactory.build()) are not currently used in
+         * the codebase for HttpsError options. Handling for MemberExpression callees can be
+         * added as a future enhancement if such patterns emerge.
+         */
+        const checkNode = (node, visited = new Set()) => {
+            const unwrappedNode = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(node);
+            if (unwrappedNode.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return (findMessageUserFriendlyProperties(unwrappedNode, visited).length > 0);
+            }
+            else if (unwrappedNode.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return traceVariable(unwrappedNode, visited);
+            }
+            else if (unwrappedNode.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                return (checkNode(unwrappedNode.left, visited) ||
+                    checkNode(unwrappedNode.right, visited));
+            }
+            else if (unwrappedNode.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                return (checkNode(unwrappedNode.consequent, visited) ||
+                    checkNode(unwrappedNode.alternate, visited));
+            }
+            else if (unwrappedNode.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                unwrappedNode.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                if (unwrappedNode.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const calleeName = unwrappedNode.callee.name;
+                    if (visited.has(calleeName))
+                        return false;
+                    visited.add(calleeName);
+                    const scope = ASTHelpers_1.ASTHelpers.getScope(context, unwrappedNode.callee);
+                    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, calleeName);
+                    if (variable) {
+                        for (const def of variable.defs) {
+                            if (def.type === 'FunctionName' &&
+                                def.node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                                if (traceFunctionReturn(def.node, visited)) {
+                                    return true;
+                                }
+                            }
+                            else if (def.type === 'Variable' && def.node.init) {
+                                if (def.node.init.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                                    def.node.init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                                    if (traceFunctionReturn(def.node.init, visited)) {
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return false;
+        };
+        const validateOptions = (node) => {
+            const unwrappedNode = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(node);
+            if (unwrappedNode.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                findMessageUserFriendlyProperties(unwrappedNode).forEach((prop) => {
+                    context.report({
+                        node: prop.type === utils_1.AST_NODE_TYPES.Property ? prop.key : prop,
+                        messageId: 'warnHttpsErrorMessageUserFriendly',
+                        data: { propertyName: 'messageUserFriendly' },
+                    });
+                });
+            }
+            else if (unwrappedNode.type === utils_1.AST_NODE_TYPES.Identifier) {
+                if (traceVariable(unwrappedNode)) {
+                    context.report({
+                        node: unwrappedNode,
+                        messageId: 'warnHttpsErrorMessageUserFriendly',
+                        data: { propertyName: 'messageUserFriendly' },
+                    });
+                }
+            }
+            else if (unwrappedNode.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                unwrappedNode.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                if (checkNode(unwrappedNode)) {
+                    context.report({
+                        node,
+                        messageId: 'warnHttpsErrorMessageUserFriendly',
+                        data: { propertyName: 'messageUserFriendly' },
+                    });
+                }
+            }
+            else if (unwrappedNode.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                validateOptions(unwrappedNode.left);
+                validateOptions(unwrappedNode.right);
+            }
+            else if (unwrappedNode.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                validateOptions(unwrappedNode.consequent);
+                validateOptions(unwrappedNode.alternate);
+            }
+        };
+        return {
+            NewExpression(node) {
+                if (ASTHelpers_1.ASTHelpers.isHttpsErrorCall(node.callee)) {
+                    if (node.arguments.length > 0) {
+                        validateOptions(node.arguments[0]);
+                    }
+                }
+            },
+            CallExpression(node) {
+                if (ASTHelpers_1.ASTHelpers.isHttpsErrorCall(node.callee)) {
+                    if (node.arguments.length > 0) {
+                        validateOptions(node.arguments[0]);
+                    }
+                }
+                else if (ASTHelpers_1.ASTHelpers.isToHttpsErrorCall(node.callee)) {
+                    if (node.arguments.length > 1) {
+                        validateOptions(node.arguments[1]);
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=warn-https-error-message-user-friendly.js.map

package/lib/utils/ASTHelpers.d.ts

@@ -46,6 +46,21 @@ export declare class ASTHelpers {
      * Compatibility wrapper for getting declared variables across ESLint versions.
      */
     static getDeclaredVariables(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>, node: TSESTree.Node): readonly TSESLint.Scope.Variable[];
+    /**
+     * Checks if a call expression or new expression is a call to HttpsError.
+     * Handles both 'HttpsError' and 'https.HttpsError'.
+     */
+    static isHttpsErrorCall(callee: TSESTree.LeftHandSideExpression): boolean;
+    /**
+     * Checks if a call expression is a call to toHttpsError.
+     * Handles both 'toHttpsError' and 'https.toHttpsError'.
+     */
+    static isToHttpsErrorCall(callee: TSESTree.LeftHandSideExpression): boolean;
+    /**
+     * Unwraps TypeScript-specific nodes (assertions, non-null, satisfies) and
+     * parenthesized expressions to get to the underlying expression.
+     */
+    static unwrapTSAssertions(node: TSESTree.Node): TSESTree.Node;
     /**
      * Helper to get ancestors of a node in a way that is compatible with both ESLint v8 and v9.
      * In ESLint v9, context.getAncestors() is deprecated and moved to context.sourceCode.getAncestors(node).

package/lib/utils/ASTHelpers.js

@@ -613,6 +613,54 @@ class ASTHelpers {
         }
         return fn(node);
     }
+    /**
+     * Checks if a call expression or new expression is a call to HttpsError.
+     * Handles both 'HttpsError' and 'https.HttpsError'.
+     */
+    static isHttpsErrorCall(callee) {
+        if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            return (callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.object.name === 'https' &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.property.name === 'HttpsError');
+        }
+        else if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return callee.name === 'HttpsError';
+        }
+        return false;
+    }
+    /**
+     * Checks if a call expression is a call to toHttpsError.
+     * Handles both 'toHttpsError' and 'https.toHttpsError'.
+     */
+    static isToHttpsErrorCall(callee) {
+        if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            return (callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.object.name === 'https' &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.property.name === 'toHttpsError');
+        }
+        else if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return callee.name === 'toHttpsError';
+        }
+        return false;
+    }
+    /**
+     * Unwraps TypeScript-specific nodes (assertions, non-null, satisfies) and
+     * parenthesized expressions to get to the underlying expression.
+     */
+    static unwrapTSAssertions(node) {
+        let inner = node;
+        while (inner &&
+            (inner.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                inner.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+                inner.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+                inner.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+                inner.type === 'ParenthesizedExpression')) {
+            inner = inner.expression;
+        }
+        return inner;
+    }
     /**
      * Helper to get ancestors of a node in a way that is compatible with both ESLint v8 and v9.
      * In ESLint v9, context.getAncestors() is deprecated and moved to context.sourceCode.getAncestors(node).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.15.0",
+  "version": "1.16.1",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -27,7 +27,7 @@
   "private": false,
   "scripts": {
     "lint": "npm-run-all \"lint:*\"",
-    "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
+    "lint:eslint-docs": "eslint-doc-generator --check",
     "lint:js": "eslint ./src",
     "lint:fix": "tsc && eslint \"./src/**/*\" --quiet --fix",
     "test": "jest --passWithNoTests --reporters=default --reporters=jest-junit",
@@ -36,6 +36,7 @@
     "address-merge-conflicts": "tsx ./.github/scripts/address-merge-conflicts.ts",
     "check-merge-conflicts": "bash ./scripts/check-merge-conflicts.sh",
     "merge-review": "tsx ./.github/scripts/merge-review.ts",
+    "pr-autopilot": "tsx ./.github/scripts/pr-autopilot.ts",
     "fetch-unresolved-comments": "./scripts/pr-check-comments.sh",
     "fetch-unresolved-bot-comments": "./scripts/pr-check-bot-comments.sh",
     "resolve-comments": "./scripts/pr-resolve-comments.sh",
@@ -69,22 +70,22 @@
     "@semantic-release/release-notes-generator": "14.1.0",
     "@types/eslint": "8.37.0",
     "@types/jest": "29.5.14",
-    "@types/node": "18.7.13",
+    "@types/node": "22.20.0",
     "@typescript-eslint/eslint-plugin": "5.34.0",
     "@typescript-eslint/parser": "5.48.0",
     "@typescript-eslint/utils": "5.59.6",
-    "chai": "4.3.6",
+    "chai": "4.5.0",
     "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.57.1",
-    "eslint-config-prettier": "8.5.0",
+    "eslint-config-prettier": "9.1.2",
     "eslint-doc-generator": "2.2.0",
     "eslint-import-resolver-typescript": "3.5.5",
     "eslint-plugin-eslint-plugin": "5.0.0",
-    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-import": "2.32.0",
     "eslint-plugin-jsdoc": "44.0.0",
     "eslint-plugin-node": "11.1.0",
     "eslint-plugin-prettier": "4.2.1",

package/release-manifest.json

@@ -0,0 +1,196 @@
+[
+  {
+    "version": "1.16.1",
+    "date": "2026-06-30T15:58:17.558Z",
+    "rules": [
+      {
+        "name": "enforce-assert-safe-object-key",
+        "changeType": "fix",
+        "issues": [
+          1245
+        ],
+        "summary": "treat assertSafe-cached variables as validated (closes #1245)"
+      },
+      {
+        "name": "enforce-dynamic-imports",
+        "changeType": "fix",
+        "issues": [
+          1244
+        ],
+        "summary": "restore libraries whitelist mode and exempt builtins/internal paths (closes #1244)"
+      },
+      {
+        "name": "require-memo",
+        "changeType": "fix",
+        "issues": [
+          1243
+        ],
+        "summary": "exempt camelCase render-prop callbacks (closes #1243)"
+      }
+    ]
+  },
+  {
+    "version": "1.16.0",
+    "date": "2026-06-29T19:34:27.787Z",
+    "rules": [
+      {
+        "name": "consistent-callback-naming",
+        "changeType": "fix",
+        "issues": [
+          1182
+        ],
+        "summary": "skip union props with non-function members (closes #1182)"
+      },
+      {
+        "name": "enforce-boolean-naming-prefixes",
+        "changeType": "fix",
+        "issues": [
+          1219
+        ],
+        "summary": "make property-signature checks opt-in (closes #1219)"
+      },
+      {
+        "name": "enforce-mui-rounded-icons",
+        "changeType": "fix",
+        "issues": [
+          1218
+        ],
+        "summary": "strip variant suffix in fix and skip brand icons (closes #1218)"
+      },
+      {
+        "name": "enforce-verb-noun-naming",
+        "changeType": "fix",
+        "issues": [
+          1177,
+          1225
+        ],
+        "summary": "add 'bucket'/'bucketize' to verbs allowlist (closes #1225); allow `main` as a function name (closes #1177)"
+      },
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          1186
+        ],
+        "summary": "stop flagging null and boolean literals for `as const` (closes #1186)"
+      },
+      {
+        "name": "logical-top-to-bottom-grouping",
+        "changeType": "fix",
+        "issues": [
+          1191
+        ],
+        "summary": "keep sibling destructures from the same source declarator grouped (closes #1191)"
+      },
+      {
+        "name": "memo-compare-deeply-complex-props",
+        "changeType": "fix",
+        "issues": [
+          1179,
+          1224
+        ],
+        "summary": "skip reserved React ref/key slots (closes #1224); exclude React render types from complex-prop detection"
+      },
+      {
+        "name": "memo-nested-react-components",
+        "changeType": "fix",
+        "issues": [
+          1185
+        ],
+        "summary": "skip HOC factories and render-prop callbacks (closes #1185)"
+      },
+      {
+        "name": "no-array-length-in-deps",
+        "changeType": "fix",
+        "issues": [
+          1196
+        ],
+        "summary": "allow array.length in deps when the body uses only .length (closes #1196)"
+      },
+      {
+        "name": "no-circular-references",
+        "changeType": "fix",
+        "issues": [],
+        "summary": "fix recursive member resolution and use cross-version scope helper; fix false positive for function parameters"
+      },
+      {
+        "name": "no-compositing-layer-props",
+        "changeType": "fix",
+        "issues": [
+          1228
+        ],
+        "summary": "don't flag CSS reset/identity values (closes #1228)"
+      },
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1176
+        ],
+        "summary": "lock in shorthand/JSX usage detection for as-const memo returns (closes #1176); correctly handle TS assertions and optional chaining in parent traversal; resolve PR review comments on TS assertion handling in object literals"
+      },
+      {
+        "name": "no-explicit-return-type",
+        "changeType": "fix",
+        "issues": [
+          1216
+        ],
+        "summary": "exempt explicit `never` return types (closes #1216)"
+      },
+      {
+        "name": "no-hungarian",
+        "changeType": "fix",
+        "issues": [
+          1217
+        ],
+        "summary": "exempt generic type parameters and semantic type-concept names (closes #1217)"
+      },
+      {
+        "name": "no-margin-properties",
+        "changeType": "fix",
+        "issues": [
+          1214
+        ],
+        "summary": "don't flag margins inside createTheme() overrides (closes #1214)"
+      },
+      {
+        "name": "no-unnecessary-verb-suffix",
+        "changeType": "fix",
+        "issues": [
+          1227
+        ],
+        "summary": "exempt phrasal-verb particle endings (closes #1227)"
+      },
+      {
+        "name": "no-unused-props",
+        "changeType": "fix",
+        "issues": [
+          1215
+        ],
+        "summary": "track props through generic wrappers and body destructuring (closes #1215)"
+      },
+      {
+        "name": "no-useless-fragment",
+        "changeType": "fix",
+        "issues": [
+          1195
+        ],
+        "summary": "keep fragments wrapping a single expression container (closes #1195)"
+      },
+      {
+        "name": "react-memoize-literals",
+        "changeType": "fix",
+        "issues": [
+          1169
+        ],
+        "summary": "extend sx/style exemption to conditional, logical, and array values (refs #1169); exempt inline sx/style JSX attribute literals (closes #1169)"
+      },
+      {
+        "name": "require-migration-script-metadata",
+        "changeType": "fix",
+        "issues": [],
+        "summary": "fix @migrationDependencies logic and update filename access for ESLint v9 compatibility; address review comments on JSDoc tag parsing and validation"
+      }
+    ]
+  }
+]

package/lib/rules/prefer-memoized-props.d.ts

@@ -1,3 +0,0 @@
-type MessageIds = 'memoizeReferenceProp' | 'avoidPrimitiveMemo';
-export declare const preferMemoizedProps: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
-export {};