@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.1

package/README.md

@@ -57,66 +57,88 @@ Or use the recommended config:
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
 💭 Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
-| Name                                                                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                 | 💼 | ⚠️ | 🔧 | 💭 |
-| :--------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- | :- |
-| [array-methods-this-context](docs/rules/array-methods-this-context.md)                   | Prevent misuse of Array methods in OOP                                                                                                                                                                                                                                                                                                                                                                      | ✅  |    |    |    |
-| [avoid-utils-directory](docs/rules/avoid-utils-directory.md)                             | Enforce using util/ instead of utils/ directory                                                                                                                                                                                                                                                                                                                                                             | ✅  |    | 🔧 |    |
-| [class-methods-read-top-to-bottom](docs/rules/class-methods-read-top-to-bottom.md)       | Ensures classes read linearly from top to bottom.                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
-| [consistent-callback-naming](docs/rules/consistent-callback-naming.md)                   | Enforce consistent naming conventions for callback props and functions                                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
-| [dynamic-https-errors](docs/rules/dynamic-https-errors.md)                               | Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id.                                                                                                                                                                                                                                                             | ✅  |    |    |    |
-| [enforce-assert-throws](docs/rules/enforce-assert-throws.md)                             | Enforce that functions with assert- prefix must throw an error                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
-| [enforce-callable-types](docs/rules/enforce-callable-types.md)                           | Enforce Params and Response type exports in callable functions                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
-| [enforce-callback-memo](docs/rules/enforce-callback-memo.md)                             | Enforce useCallback for inline functions and useMemo for objects/arrays containing functions in JSX props to prevent unnecessary re-renders. This improves React component performance by ensuring stable function references across renders and memoizing complex objects.                                                                                                                                 | ✅  |    |    |    |
-| [enforce-dynamic-firebase-imports](docs/rules/enforce-dynamic-firebase-imports.md)       | Enforce dynamic importing for modules within the firebaseCloud directory to optimize initial bundle size. This ensures Firebase-related code is only loaded when needed, improving application startup time and reducing the main bundle size.                                                                                                                                                              | ✅  |    |    |    |
-| [enforce-exported-function-types](docs/rules/enforce-exported-function-types.md)         | Enforce exporting types for function props and return values                                                                                                                                                                                                                                                                                                                                                | ✅  |    |    |    |
-| [enforce-firestore-doc-ref-generic](docs/rules/enforce-firestore-doc-ref-generic.md)     | Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup                                                                                                                                                                                                                                                                                                           | ✅  |    |    | 💭 |
-| [enforce-firestore-facade](docs/rules/enforce-firestore-facade.md)                       | Enforce usage of Firestore facades instead of direct Firestore methods                                                                                                                                                                                                                                                                                                                                      | ✅  |    |    |    |
-| [enforce-firestore-path-utils](docs/rules/enforce-firestore-path-utils.md)               | Enforce usage of utility functions for Firestore paths to ensure type safety, maintainability, and consistent path construction. This prevents errors from manual string concatenation and makes path changes easier to manage.                                                                                                                                                                             | ✅  |    |    |    |
-| [enforce-firestore-set-merge](docs/rules/enforce-firestore-set-merge.md)                 | Enforce using set() with { merge: true } instead of update() for Firestore operations to ensure consistent behavior. The update() method fails if the document does not exist, while set() with { merge: true } creates the document if needed and safely merges fields, making it more reliable and predictable.                                                                                           | ✅  |    | 🔧 |    |
-| [enforce-identifiable-firestore-type](docs/rules/enforce-identifiable-firestore-type.md) | Enforce that Firestore type definitions extend Identifiable and match their folder name                                                                                                                                                                                                                                                                                                                     | ✅  |    |    |    |
-| [enforce-memoize-async](docs/rules/enforce-memoize-async.md)                             | Enforce @Memoize() decorator on async methods with 0-1 parameters to cache results and prevent redundant API calls or expensive computations. This improves performance by reusing previous results when the same parameters are provided, particularly useful for data fetching methods.                                                                                                                   | ✅  |    | 🔧 |    |
-| [enforce-mock-firestore](docs/rules/enforce-mock-firestore.md)                           | Enforce using the standardized mockFirestore utility instead of manual Firestore mocking or third-party mocks. This ensures consistent test behavior across the codebase, reduces boilerplate, and provides type-safe mocking of Firestore operations.                                                                                                                                                      | ✅  |    |    |    |
-| [enforce-realtimedb-path-utils](docs/rules/enforce-realtimedb-path-utils.md)             | Enforce usage of utility functions for Realtime Database paths                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
-| [enforce-safe-stringify](docs/rules/enforce-safe-stringify.md)                           | Enforce using safe-stable-stringify instead of JSON.stringify to handle circular references and ensure deterministic output. JSON.stringify can throw errors on circular references and produce inconsistent output for objects with the same properties in different orders. safe-stable-stringify handles these cases safely.                                                                             | ✅  |    | 🔧 |    |
-| [enforce-serializable-params](docs/rules/enforce-serializable-params.md)                 | Enforce serializable parameters in Firebase Callable/HTTPS Cloud Functions to prevent runtime errors. Firebase Functions can only pass JSON-serializable data, so using non-serializable types like Date, DocumentReference, or Map will cause failures. Use primitive types, plain objects, and arrays instead, converting complex types to their serializable representations (e.g., Date to ISO string). | ✅  |    |    |    |
-| [enforce-verb-noun-naming](docs/rules/enforce-verb-noun-naming.md)                       | Enforce verb phrases for functions and methods                                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
-| [export-if-in-doubt](docs/rules/export-if-in-doubt.md)                                   | All top-level const definitions, type definitions, and functions should be exported                                                                                                                                                                                                                                                                                                                         |    |    |    |    |
-| [extract-global-constants](docs/rules/extract-global-constants.md)                       | Extract static constants and functions to the global scope when possible                                                                                                                                                                                                                                                                                                                                    | ✅  |    |    |    |
-| [generic-starts-with-t](docs/rules/generic-starts-with-t.md)                             | Enforce TypeScript generic types to start with T                                                                                                                                                                                                                                                                                                                                                            | ✅  |    |    |    |
-| [global-const-style](docs/rules/global-const-style.md)                                   | Enforce UPPER_SNAKE_CASE and as const for global static constants                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
-| [no-async-array-filter](docs/rules/no-async-array-filter.md)                             | Disallow async callbacks in Array.filter() as they lead to incorrect filtering. Since async functions return Promises which are always truthy, the filter will keep all elements regardless of the async check's result. Use Promise.all() with map() first, then filter based on the resolved results.                                                                                                     | ✅  |    |    |    |
-| [no-async-foreach](docs/rules/no-async-foreach.md)                                       | Disallow Array.forEach with an async callback function as it does not wait for promises to resolve. This can lead to race conditions and unexpected behavior. Use a standard for...of loop for sequential execution or Promise.all with map for concurrent execution.                                                                                                                                       | ✅  |    |    |    |
-| [no-class-instance-destructuring](docs/rules/no-class-instance-destructuring.md)         | Disallow destructuring of class instances to prevent loss of `this` context                                                                                                                                                                                                                                                                                                                                 | ✅  |    | 🔧 |    |
-| [no-complex-cloud-params](docs/rules/no-complex-cloud-params.md)                         | Disallow passing complex objects to cloud functions                                                                                                                                                                                                                                                                                                                                                         | ✅  |    |    |    |
-| [no-compositing-layer-props](docs/rules/no-compositing-layer-props.md)                   | Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. Consider alternatives or explicitly document intentional layer promotion.                              | ✅  |    |    |    |
-| [no-conditional-literals-in-jsx](docs/rules/no-conditional-literals-in-jsx.md)           | Disallow use of conditional literals in JSX code                                                                                                                                                                                                                                                                                                                                                            | ✅  |    |    |    |
-| [no-entire-object-hook-deps](docs/rules/no-entire-object-hook-deps.md)                   | Avoid using entire objects in React hook dependency arrays when only specific fields are used, as this can cause unnecessary re-renders. When a hook only uses obj.name but obj is in the deps array, any change to obj.age will trigger the hook. Use individual fields (obj.name) instead of the entire object. Requires TypeScript and `parserOptions.project` to be configured.                         | ✅  |    | 🔧 | 💭 |
-| [no-explicit-return-type](docs/rules/no-explicit-return-type.md)                         | Disallow explicit return type annotations on functions when TypeScript can infer them. This reduces code verbosity and maintenance burden while leveraging TypeScript's powerful type inference. Exceptions are made for type guard functions (using the `is` keyword), recursive functions, overloaded functions, interface methods, and abstract methods where explicit types improve clarity.            | ✅  |    | 🔧 |    |
-| [no-filter-without-return](docs/rules/no-filter-without-return.md)                       | Disallow Array.filter callbacks without an explicit return (if part of a block statement)                                                                                                                                                                                                                                                                                                                   | ✅  |    |    |    |
-| [no-firestore-object-arrays](docs/rules/no-firestore-object-arrays.md)                   | Disallow arrays of objects in Firestore type definitions to optimize performance and avoid unnecessary fetches                                                                                                                                                                                                                                                                                              |    | ✅  |    |    |
-| [no-jsx-in-hooks](docs/rules/no-jsx-in-hooks.md)                                         | Prevent hooks from returning JSX                                                                                                                                                                                                                                                                                                                                                                            | ✅  |    |    |    |
-| [no-jsx-whitespace-literal](docs/rules/no-jsx-whitespace-literal.md)                     | Disallow the use of {" "} elements in JSX code                                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
-| [no-memoize-on-static](docs/rules/no-memoize-on-static.md)                               | Prevent using @Memoize() decorator on static methods                                                                                                                                                                                                                                                                                                                                                        | ✅  |    |    |    |
-| [no-misused-switch-case](docs/rules/no-misused-switch-case.md)                           | Prevent misuse of logical OR (\|\|) in switch case statements, which can lead to confusing and error-prone code. Instead of using OR operators in case expressions, use multiple case statements in sequence to handle multiple values. This improves code readability and follows the standard switch-case pattern.                                                                                        | ✅  |    |    |    |
-| [no-mixed-firestore-transactions](docs/rules/no-mixed-firestore-transactions.md)         | Prevent mixing transactional and non-transactional Firestore operations within a transaction                                                                                                                                                                                                                                                                                                                | ✅  |    |    |    |
-| [no-redundant-param-types](docs/rules/no-redundant-param-types.md)                       | Disallow redundant parameter type annotations                                                                                                                                                                                                                                                                                                                                                               | ✅  |    | 🔧 |    |
-| [no-unpinned-dependencies](docs/rules/no-unpinned-dependencies.md)                       | Enforces pinned dependencies                                                                                                                                                                                                                                                                                                                                                                                | ✅  |    | 🔧 |    |
-| [no-unsafe-firestore-spread](docs/rules/no-unsafe-firestore-spread.md)                   | Prevent unsafe object/array spreads in Firestore updates                                                                                                                                                                                                                                                                                                                                                    | ✅  |    | 🔧 |    |
-| [no-unused-props](docs/rules/no-unused-props.md)                                         | Detect unused props in React component type definitions                                                                                                                                                                                                                                                                                                                                                     | ✅  |    | 🔧 |    |
-| [no-useless-fragment](docs/rules/no-useless-fragment.md)                                 | Prevent unnecessary use of React fragments                                                                                                                                                                                                                                                                                                                                                                  |    |    | 🔧 |    |
-| [prefer-batch-operations](docs/rules/prefer-batch-operations.md)                         | Enforce using setAll() and overwriteAll() instead of multiple set() or overwrite() calls                                                                                                                                                                                                                                                                                                                    | ✅  |    | 🔧 |    |
-| [prefer-fragment-shorthand](docs/rules/prefer-fragment-shorthand.md)                     | Prefer <> shorthand for <React.Fragment>                                                                                                                                                                                                                                                                                                                                                                    | ✅  |    | 🔧 |    |
-| [prefer-settings-object](docs/rules/prefer-settings-object.md)                           | Enforce using a settings object for functions with multiple parameters                                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
-| [prefer-type-over-interface](docs/rules/prefer-type-over-interface.md)                   | Prefer using type alias over interface                                                                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
-| [require-dynamic-firebase-imports](docs/rules/require-dynamic-firebase-imports.md)       | Enforce dynamic imports for Firebase dependencies                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
-| [require-https-error](docs/rules/require-https-error.md)                                 | Enforce using proprietary HttpsError instead of throw new Error or firebase-admin HttpsError in functions/src                                                                                                                                                                                                                                                                                               | ✅  |    |    |    |
-| [require-image-optimized](docs/rules/require-image-optimized.md)                         | Enforce using ImageOptimized component instead of next/image or img tags                                                                                                                                                                                                                                                                                                                                    | ✅  |    | 🔧 |    |
-| [require-memo](docs/rules/require-memo.md)                                               | React components must be memoized                                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
-| [require-usememo-object-literals](docs/rules/require-usememo-object-literals.md)         | Enforce using useMemo for inline object/array literals passed as props to JSX components to prevent unnecessary re-renders. When object/array literals are defined inline in JSX, they create new references on every render, causing child components to re-render even if the values haven't changed. Wrap them in useMemo to maintain referential equality.                                              | ✅  |    |    |    |
-| [semantic-function-prefixes](docs/rules/semantic-function-prefixes.md)                   | Enforce semantic function prefixes over generic ones like "get" and "update"                                                                                                                                                                                                                                                                                                                                | ✅  |    |    |    |
-| [sync-onwrite-name-func](docs/rules/sync-onwrite-name-func.md)                           | Ensure that the name field matches the func field in onWrite handlers                                                                                                                                                                                                                                                                                                                                       | ✅  |    | 🔧 |    |
-| [use-custom-link](docs/rules/use-custom-link.md)                                         | Enforce using src/components/Link instead of next/link                                                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
-| [use-custom-memo](docs/rules/use-custom-memo.md)                                         | Enforce using src/util/memo instead of React memo                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
-| [use-custom-router](docs/rules/use-custom-router.md)                                     | Enforce using src/hooks/routing/useRouter instead of next/router                                                                                                                                                                                                                                                                                                                                            | ✅  |    | 🔧 |    |
+| Name                                                                                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                 | 💼 | ⚠️ | 🔧 | 💭 |
+| :------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- | :- |
+| [array-methods-this-context](docs/rules/array-methods-this-context.md)                                   | Prevent misuse of Array methods in OOP                                                                                                                                                                                                                                                                                                                                                                      | ✅  |    |    |    |
+| [avoid-utils-directory](docs/rules/avoid-utils-directory.md)                                             | Enforce using util/ instead of utils/ directory                                                                                                                                                                                                                                                                                                                                                             | ✅  |    | 🔧 |    |
+| [class-methods-read-top-to-bottom](docs/rules/class-methods-read-top-to-bottom.md)                       | Ensures classes read linearly from top to bottom.                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
+| [consistent-callback-naming](docs/rules/consistent-callback-naming.md)                                   | Enforce consistent naming conventions for callback props and functions                                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
+| [dynamic-https-errors](docs/rules/dynamic-https-errors.md)                                               | Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id.                                                                                                                                                                                                                                                             | ✅  |    |    |    |
+| [enforce-assert-throws](docs/rules/enforce-assert-throws.md)                                             | Enforce that functions with assert- prefix must throw an error or call process.exit(1)                                                                                                                                                                                                                                                                                                                      | ✅  |    |    |    |
+| [enforce-assertSafe-object-key](docs/rules/enforce-assertSafe-object-key.md)                             | Enforce the use of assertSafe(id) when accessing object properties with computed keys that involve string interpolation or explicit string conversion.                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
+| [enforce-callable-types](docs/rules/enforce-callable-types.md)                                           | Enforce Params and Response type exports in callable functions                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
+| [enforce-callback-memo](docs/rules/enforce-callback-memo.md)                                             | Enforce useCallback for inline functions and useMemo for objects/arrays containing functions in JSX props to prevent unnecessary re-renders. This improves React component performance by ensuring stable function references across renders and memoizing complex objects.                                                                                                                                 | ✅  |    |    |    |
+| [enforce-centralized-mock-firestore](docs/rules/enforce-centralized-mock-firestore.md)                   | Enforce usage of centralized mockFirestore from predefined location                                                                                                                                                                                                                                                                                                                                         | ✅  |    | 🔧 |    |
+| [enforce-dynamic-firebase-imports](docs/rules/enforce-dynamic-firebase-imports.md)                       | Enforce dynamic importing for modules within the firebaseCloud directory to optimize initial bundle size. This ensures Firebase-related code is only loaded when needed, improving application startup time and reducing the main bundle size.                                                                                                                                                              | ✅  |    |    |    |
+| [enforce-exported-function-types](docs/rules/enforce-exported-function-types.md)                         | Enforce exporting types for function props and return values                                                                                                                                                                                                                                                                                                                                                | ✅  |    |    |    |
+| [enforce-firestore-doc-ref-generic](docs/rules/enforce-firestore-doc-ref-generic.md)                     | Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup                                                                                                                                                                                                                                                                                                           | ✅  |    |    | 💭 |
+| [enforce-firestore-facade](docs/rules/enforce-firestore-facade.md)                                       | Enforce usage of Firestore facades instead of direct Firestore methods                                                                                                                                                                                                                                                                                                                                      | ✅  |    |    |    |
+| [enforce-firestore-path-utils](docs/rules/enforce-firestore-path-utils.md)                               | Enforce usage of utility functions for Firestore paths to ensure type safety, maintainability, and consistent path construction. This prevents errors from manual string concatenation and makes path changes easier to manage.                                                                                                                                                                             | ✅  |    |    |    |
+| [enforce-firestore-set-merge](docs/rules/enforce-firestore-set-merge.md)                                 | Enforce using set() with { merge: true } instead of update() for Firestore operations to ensure consistent behavior. The update() method fails if the document does not exist, while set() with { merge: true } creates the document if needed and safely merges fields, making it more reliable and predictable.                                                                                           | ✅  |    | 🔧 |    |
+| [enforce-identifiable-firestore-type](docs/rules/enforce-identifiable-firestore-type.md)                 | Enforce that Firestore type definitions extend Identifiable and match their folder name                                                                                                                                                                                                                                                                                                                     | ✅  |    |    |    |
+| [enforce-memoize-async](docs/rules/enforce-memoize-async.md)                                             | Enforce @Memoize() decorator on async methods with 0-1 parameters to cache results and prevent redundant API calls or expensive computations. This improves performance by reusing previous results when the same parameters are provided, particularly useful for data fetching methods.                                                                                                                   | ✅  |    | 🔧 |    |
+| [enforce-microdiff](docs/rules/enforce-microdiff.md)                                                     | Enforce using microdiff for object and array comparison operations                                                                                                                                                                                                                                                                                                                                          | ✅  |    | 🔧 |    |
+| [enforce-mock-firestore](docs/rules/enforce-mock-firestore.md)                                           | Enforce using the standardized mockFirestore utility instead of manual Firestore mocking or third-party mocks. This ensures consistent test behavior across the codebase, reduces boilerplate, and provides type-safe mocking of Firestore operations.                                                                                                                                                      | ✅  |    |    |    |
+| [enforce-object-literal-as-const](docs/rules/enforce-object-literal-as-const.md)                         | Enforce that object literals returned from functions should be marked with `as const` to ensure type safety and immutability.                                                                                                                                                                                                                                                                               | ✅  |    | 🔧 |    |
+| [enforce-positive-naming](docs/rules/enforce-positive-naming.md)                                         | Enforce positive variable naming patterns and avoid negative naming                                                                                                                                                                                                                                                                                                                                         | ✅  |    |    |    |
+| [enforce-props-argument-name](docs/rules/enforce-props-argument-name.md)                                 | Enforce using "Props" suffix in type names for parameter objects                                                                                                                                                                                                                                                                                                                                            | ✅  |    | 🔧 |    |
+| [enforce-realtimedb-path-utils](docs/rules/enforce-realtimedb-path-utils.md)                             | Enforce usage of utility functions for Realtime Database paths                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
+| [enforce-render-hits-memoization](docs/rules/enforce-render-hits-memoization.md)                         | Enforce proper memoization and usage of useRenderHits and renderHits                                                                                                                                                                                                                                                                                                                                        | ✅  |    |    |    |
+| [enforce-safe-stringify](docs/rules/enforce-safe-stringify.md)                                           | Enforce using safe-stable-stringify instead of JSON.stringify to handle circular references and ensure deterministic output. JSON.stringify can throw errors on circular references and produce inconsistent output for objects with the same properties in different orders. safe-stable-stringify handles these cases safely.                                                                             | ✅  |    | 🔧 |    |
+| [enforce-serializable-params](docs/rules/enforce-serializable-params.md)                                 | Enforce serializable parameters in Firebase Callable/HTTPS Cloud Functions to prevent runtime errors. Firebase Functions can only pass JSON-serializable data, so using non-serializable types like Date, DocumentReference, or Map will cause failures. Use primitive types, plain objects, and arrays instead, converting complex types to their serializable representations (e.g., Date to ISO string). | ✅  |    |    |    |
+| [enforce-timestamp-now](docs/rules/enforce-timestamp-now.md)                                             | Enforce the use of Timestamp.now() for getting the current timestamp in backend code. This rule prevents using alternatives like Timestamp.fromDate(new Date()) or other date creation patterns that could lead to inconsistency.                                                                                                                                                                           | ✅  |    | 🔧 |    |
+| [enforce-verb-noun-naming](docs/rules/enforce-verb-noun-naming.md)                                       | Enforce verb phrases for functions and methods                                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
+| [export-if-in-doubt](docs/rules/export-if-in-doubt.md)                                                   | All top-level const definitions, type definitions, and functions should be exported                                                                                                                                                                                                                                                                                                                         |    |    |    |    |
+| [extract-global-constants](docs/rules/extract-global-constants.md)                                       | Extract static constants and functions to the global scope when possible, and enforce type narrowing with as const for numeric literals in loops                                                                                                                                                                                                                                                            | ✅  |    |    |    |
+| [generic-starts-with-t](docs/rules/generic-starts-with-t.md)                                             | Enforce TypeScript generic types to start with T                                                                                                                                                                                                                                                                                                                                                            | ✅  |    |    |    |
+| [global-const-style](docs/rules/global-const-style.md)                                                   | Enforce UPPER_SNAKE_CASE and as const for global static constants                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
+| [no-always-true-false-conditions](docs/rules/no-always-true-false-conditions.md)                         | Detect conditions that are always truthy or always falsy                                                                                                                                                                                                                                                                                                                                                    | ✅  |    |    |    |
+| [no-async-array-filter](docs/rules/no-async-array-filter.md)                                             | Disallow async callbacks in Array.filter() as they lead to incorrect filtering. Since async functions return Promises which are always truthy, the filter will keep all elements regardless of the async check's result. Use Promise.all() with map() first, then filter based on the resolved results.                                                                                                     | ✅  |    |    |    |
+| [no-async-foreach](docs/rules/no-async-foreach.md)                                                       | Disallow Array.forEach with an async callback function as it does not wait for promises to resolve. This can lead to race conditions and unexpected behavior. Use a standard for...of loop for sequential execution or Promise.all with map for concurrent execution.                                                                                                                                       | ✅  |    |    |    |
+| [no-class-instance-destructuring](docs/rules/no-class-instance-destructuring.md)                         | Disallow destructuring of class instances to prevent loss of `this` context                                                                                                                                                                                                                                                                                                                                 | ✅  |    | 🔧 |    |
+| [no-complex-cloud-params](docs/rules/no-complex-cloud-params.md)                                         | Disallow passing complex objects to cloud functions                                                                                                                                                                                                                                                                                                                                                         | ✅  |    |    |    |
+| [no-compositing-layer-props](docs/rules/no-compositing-layer-props.md)                                   | Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. Consider alternatives or explicitly document intentional layer promotion.                              | ✅  |    |    |    |
+| [no-conditional-literals-in-jsx](docs/rules/no-conditional-literals-in-jsx.md)                           | Disallow use of conditional literals in JSX code                                                                                                                                                                                                                                                                                                                                                            | ✅  |    |    |    |
+| [no-entire-object-hook-deps](docs/rules/no-entire-object-hook-deps.md)                                   | Avoid using entire objects in React hook dependency arrays when only specific fields are used, as this can cause unnecessary re-renders. When a hook only uses obj.name but obj is in the deps array, any change to obj.age will trigger the hook. Use individual fields (obj.name) instead of the entire object. Requires TypeScript and `parserOptions.project` to be configured.                         | ✅  |    | 🔧 | 💭 |
+| [no-explicit-return-type](docs/rules/no-explicit-return-type.md)                                         | Disallow explicit return type annotations on functions when TypeScript can infer them. This reduces code verbosity and maintenance burden while leveraging TypeScript's powerful type inference. Exceptions are made for type guard functions (using the `is` keyword), recursive functions, overloaded functions, interface methods, and abstract methods where explicit types improve clarity.            | ✅  |    | 🔧 |    |
+| [no-filter-without-return](docs/rules/no-filter-without-return.md)                                       | Disallow Array.filter callbacks without an explicit return (if part of a block statement)                                                                                                                                                                                                                                                                                                                   | ✅  |    |    |    |
+| [no-firestore-jest-mock](docs/rules/no-firestore-jest-mock.md)                                           | Prevent importing firestore-jest-mock in test files                                                                                                                                                                                                                                                                                                                                                         | ✅  |    | 🔧 |    |
+| [no-firestore-object-arrays](docs/rules/no-firestore-object-arrays.md)                                   | Disallow arrays of objects in Firestore type definitions to optimize performance and avoid unnecessary fetches                                                                                                                                                                                                                                                                                              |    | ✅  |    |    |
+| [no-hungarian](docs/rules/no-hungarian.md)                                                               | Disallow Hungarian notation in variable names                                                                                                                                                                                                                                                                                                                                                               | ✅  |    | 🔧 |    |
+| [no-jsx-in-hooks](docs/rules/no-jsx-in-hooks.md)                                                         | Prevent hooks from returning JSX                                                                                                                                                                                                                                                                                                                                                                            | ✅  |    |    |    |
+| [no-jsx-whitespace-literal](docs/rules/no-jsx-whitespace-literal.md)                                     | Disallow the use of {" "} elements in JSX code                                                                                                                                                                                                                                                                                                                                                              | ✅  |    |    |    |
+| [no-memoize-on-static](docs/rules/no-memoize-on-static.md)                                               | Prevent using @Memoize() decorator on static methods                                                                                                                                                                                                                                                                                                                                                        | ✅  |    |    |    |
+| [no-misused-switch-case](docs/rules/no-misused-switch-case.md)                                           | Prevent misuse of logical OR (\|\|) in switch case statements, which can lead to confusing and error-prone code. Instead of using OR operators in case expressions, use multiple case statements in sequence to handle multiple values. This improves code readability and follows the standard switch-case pattern.                                                                                        | ✅  |    |    |    |
+| [no-mixed-firestore-transactions](docs/rules/no-mixed-firestore-transactions.md)                         | Prevent mixing transactional and non-transactional Firestore operations within a transaction                                                                                                                                                                                                                                                                                                                | ✅  |    |    |    |
+| [no-mock-firebase-admin](docs/rules/no-mock-firebase-admin.md)                                           | Prevent mocking of functions/src/config/firebaseAdmin                                                                                                                                                                                                                                                                                                                                                       | ✅  |    |    |    |
+| [no-redundant-param-types](docs/rules/no-redundant-param-types.md)                                       | Disallow redundant parameter type annotations                                                                                                                                                                                                                                                                                                                                                               | ✅  |    | 🔧 |    |
+| [no-type-assertion-returns](docs/rules/no-type-assertion-returns.md)                                     | Enforce typing variables before returning them, rather than using type assertions or explicit return types                                                                                                                                                                                                                                                                                                  | ✅  |    | 🔧 |    |
+| [no-unnecessary-verb-suffix](docs/rules/no-unnecessary-verb-suffix.md)                                   | Prevent unnecessary verb suffixes in function and method names                                                                                                                                                                                                                                                                                                                                              | ✅  |    | 🔧 |    |
+| [no-unpinned-dependencies](docs/rules/no-unpinned-dependencies.md)                                       | Enforces pinned dependencies                                                                                                                                                                                                                                                                                                                                                                                | ✅  |    | 🔧 |    |
+| [no-unsafe-firestore-spread](docs/rules/no-unsafe-firestore-spread.md)                                   | Prevent unsafe object/array spreads in Firestore updates                                                                                                                                                                                                                                                                                                                                                    | ✅  |    | 🔧 |    |
+| [no-unused-props](docs/rules/no-unused-props.md)                                                         | Detect unused props in React component type definitions                                                                                                                                                                                                                                                                                                                                                     | ✅  |    | 🔧 |    |
+| [no-unused-usestate](docs/rules/no-unused-usestate.md)                                                   | Disallow unused useState hooks                                                                                                                                                                                                                                                                                                                                                                              | ✅  |    | 🔧 |    |
+| [no-useless-fragment](docs/rules/no-useless-fragment.md)                                                 | Prevent unnecessary use of React fragments                                                                                                                                                                                                                                                                                                                                                                  |    |    | 🔧 |    |
+| [prefer-batch-operations](docs/rules/prefer-batch-operations.md)                                         | Enforce using setAll() and overwriteAll() instead of multiple set() or overwrite() calls                                                                                                                                                                                                                                                                                                                    | ✅  |    | 🔧 |    |
+| [prefer-clone-deep](docs/rules/prefer-clone-deep.md)                                                     | Prefer using cloneDeep over nested spread copying                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
+| [prefer-destructuring-no-class](docs/rules/prefer-destructuring-no-class.md)                             | Enforce destructuring when accessing object properties, except for class instances                                                                                                                                                                                                                                                                                                                          | ✅  |    | 🔧 |    |
+| [prefer-fragment-component](docs/rules/prefer-fragment-component.md)                                     | Enforce using Fragment imported from react over shorthand fragments and React.Fragment                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
+| [prefer-fragment-shorthand](docs/rules/prefer-fragment-shorthand.md)                                     | Prefer <> shorthand for <React.Fragment>                                                                                                                                                                                                                                                                                                                                                                    |    |    | 🔧 |    |
+| [prefer-global-router-state-key](docs/rules/prefer-global-router-state-key.md)                           | Enforce using global constants or type-safe functions for useRouterState key parameter                                                                                                                                                                                                                                                                                                                      |    | ✅  |    |    |
+| [prefer-settings-object](docs/rules/prefer-settings-object.md)                                           | Enforce using a settings object for functions with multiple parameters                                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
+| [prefer-type-over-interface](docs/rules/prefer-type-over-interface.md)                                   | Prefer using type alias over interface                                                                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
+| [prefer-utility-function-over-private-static](docs/rules/prefer-utility-function-over-private-static.md) | Enforce abstraction of private static methods into utility functions                                                                                                                                                                                                                                                                                                                                        | ✅  |    |    |    |
+| [react-usememo-should-be-component](docs/rules/react-usememo-should-be-component.md)                     | Enforce that useMemo hooks returning React nodes should be abstracted into separate React components                                                                                                                                                                                                                                                                                                        | ✅  |    |    |    |
+| [require-dynamic-firebase-imports](docs/rules/require-dynamic-firebase-imports.md)                       | Enforce dynamic imports for Firebase dependencies                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
+| [require-hooks-default-params](docs/rules/require-hooks-default-params.md)                               | Enforce React hooks with optional parameters to default to an empty object                                                                                                                                                                                                                                                                                                                                  | ✅  |    | 🔧 |    |
+| [require-https-error](docs/rules/require-https-error.md)                                                 | Enforce using proprietary HttpsError instead of throw new Error or firebase-admin HttpsError in functions/src                                                                                                                                                                                                                                                                                               | ✅  |    |    |    |
+| [require-image-optimized](docs/rules/require-image-optimized.md)                                         | Enforce using ImageOptimized component instead of next/image or img tags                                                                                                                                                                                                                                                                                                                                    | ✅  |    | 🔧 |    |
+| [require-memo](docs/rules/require-memo.md)                                                               | React components must be memoized                                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
+| [require-usememo-object-literals](docs/rules/require-usememo-object-literals.md)                         | Enforce using useMemo for inline object/array literals passed as props to JSX components to prevent unnecessary re-renders. When object/array literals are defined inline in JSX, they create new references on every render, causing child components to re-render even if the values haven't changed. Wrap them in useMemo to maintain referential equality.                                              | ✅  |    |    |    |
+| [semantic-function-prefixes](docs/rules/semantic-function-prefixes.md)                                   | Enforce semantic function prefixes over generic ones like "get" and "update"                                                                                                                                                                                                                                                                                                                                | ✅  |    |    |    |
+| [sync-onwrite-name-func](docs/rules/sync-onwrite-name-func.md)                                           | Ensure that the name field matches the func field in onWrite handlers                                                                                                                                                                                                                                                                                                                                       | ✅  |    | 🔧 |    |
+| [use-custom-link](docs/rules/use-custom-link.md)                                                         | Enforce using src/components/Link instead of next/link                                                                                                                                                                                                                                                                                                                                                      | ✅  |    | 🔧 |    |
+| [use-custom-memo](docs/rules/use-custom-memo.md)                                                         | Enforce using src/util/memo instead of React memo                                                                                                                                                                                                                                                                                                                                                           | ✅  |    | 🔧 |    |
+| [use-custom-router](docs/rules/use-custom-router.md)                                                     | Enforce using src/hooks/routing/useRouter instead of next/router                                                                                                                                                                                                                                                                                                                                            | ✅  |    | 🔧 |    |
 
 <!-- end auto-generated rules list -->

package/lib/index.js

@@ -11,6 +11,8 @@ const enforce_identifiable_firestore_type_1 = require("./rules/enforce-identifia
 const enforce_callback_memo_1 = __importDefault(require("./rules/enforce-callback-memo"));
 const enforce_callable_types_1 = require("./rules/enforce-callable-types");
 const enforce_dynamic_firebase_imports_1 = require("./rules/enforce-dynamic-firebase-imports");
+const enforce_mui_rounded_icons_1 = require("./rules/enforce-mui-rounded-icons");
+const enforce_react_type_naming_1 = require("./rules/enforce-react-type-naming");
 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");
@@ -19,6 +21,7 @@ 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_hungarian_1 = require("./rules/no-hungarian");
 const no_misused_switch_case_1 = require("./rules/no-misused-switch-case");
 const no_unpinned_dependencies_1 = require("./rules/no-unpinned-dependencies");
 const no_unused_props_1 = require("./rules/no-unused-props");
@@ -70,10 +73,33 @@ const require_hooks_default_params_1 = require("./rules/require-hooks-default-pa
 const prefer_destructuring_no_class_1 = require("./rules/prefer-destructuring-no-class");
 const enforce_render_hits_memoization_1 = require("./rules/enforce-render-hits-memoization");
 const prefer_fragment_component_1 = require("./rules/prefer-fragment-component");
+const react_usememo_should_be_component_1 = require("./rules/react-usememo-should-be-component");
+const no_unnecessary_verb_suffix_1 = require("./rules/no-unnecessary-verb-suffix");
+const enforce_assertSafe_object_key_1 = require("./rules/enforce-assertSafe-object-key");
+const enforce_object_literal_as_const_1 = require("./rules/enforce-object-literal-as-const");
+const enforce_positive_naming_1 = require("./rules/enforce-positive-naming");
+const no_type_assertion_returns_1 = require("./rules/no-type-assertion-returns");
+const prefer_utility_function_over_private_static_1 = require("./rules/prefer-utility-function-over-private-static");
+const enforce_microdiff_1 = require("./rules/enforce-microdiff");
+const enforce_timestamp_now_1 = require("./rules/enforce-timestamp-now");
+const no_always_true_false_conditions_1 = require("./rules/no-always-true-false-conditions");
+const enforce_props_argument_name_1 = require("./rules/enforce-props-argument-name");
+const prefer_global_router_state_key_1 = require("./rules/prefer-global-router-state-key");
+const prefer_usememo_over_useeffect_usestate_1 = require("./rules/prefer-usememo-over-useeffect-usestate");
+const enforce_dynamic_imports_1 = __importDefault(require("./rules/enforce-dynamic-imports"));
+const ensure_pointer_events_none_1 = require("./rules/ensure-pointer-events-none");
+const no_object_values_on_strings_1 = require("./rules/no-object-values-on-strings");
+const key_only_outermost_element_1 = require("./rules/key-only-outermost-element");
+const no_unnecessary_destructuring_1 = require("./rules/no-unnecessary-destructuring");
+const enforce_singular_type_names_1 = require("./rules/enforce-singular-type-names");
+const enforce_css_media_queries_1 = require("./rules/enforce-css-media-queries");
+const omit_index_html_1 = require("./rules/omit-index-html");
+const enforce_id_capitalization_1 = require("./rules/enforce-id-capitalization");
+const no_unused_usestate_1 = require("./rules/no-unused-usestate");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.7.3',
+        version: '1.8.1',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -82,6 +108,7 @@ module.exports = {
         recommended: {
             plugins: ['@blumintinc/blumint'],
             rules: {
+                '@blumintinc/blumint/key-only-outermost-element': 'error',
                 '@blumintinc/blumint/avoid-utils-directory': 'error',
                 '@blumintinc/blumint/enforce-firestore-path-utils': 'error',
                 '@blumintinc/blumint/no-jsx-whitespace-literal': 'error',
@@ -89,10 +116,12 @@ module.exports = {
                 '@blumintinc/blumint/class-methods-read-top-to-bottom': 'error',
                 '@blumintinc/blumint/consistent-callback-naming': 'error',
                 '@blumintinc/blumint/dynamic-https-errors': 'error',
+                '@blumintinc/blumint/enforce-mui-rounded-icons': 'error',
                 '@blumintinc/blumint/enforce-identifiable-firestore-type': 'error',
                 '@blumintinc/blumint/enforce-callback-memo': 'error',
                 '@blumintinc/blumint/enforce-callable-types': 'error',
                 '@blumintinc/blumint/enforce-dynamic-firebase-imports': 'error',
+                '@blumintinc/blumint/enforce-react-type-naming': 'error',
                 // '@blumintinc/blumint/export-if-in-doubt': 'warn',
                 '@blumintinc/blumint/extract-global-constants': 'error',
                 '@blumintinc/blumint/generic-starts-with-t': 'error',
@@ -101,6 +130,7 @@ module.exports = {
                 '@blumintinc/blumint/no-async-foreach': 'error',
                 '@blumintinc/blumint/no-conditional-literals-in-jsx': 'error',
                 '@blumintinc/blumint/no-filter-without-return': 'error',
+                '@blumintinc/blumint/no-hungarian': 'error',
                 '@blumintinc/blumint/no-misused-switch-case': 'error',
                 '@blumintinc/blumint/no-unpinned-dependencies': 'error',
                 '@blumintinc/blumint/no-unused-props': 'error',
@@ -149,18 +179,49 @@ module.exports = {
                 '@blumintinc/blumint/prefer-destructuring-no-class': 'error',
                 '@blumintinc/blumint/enforce-render-hits-memoization': 'error',
                 '@blumintinc/blumint/prefer-fragment-component': 'error',
+                '@blumintinc/blumint/react-usememo-should-be-component': 'error',
+                '@blumintinc/blumint/no-unnecessary-verb-suffix': 'error',
+                '@blumintinc/blumint/enforce-assertSafe-object-key': 'error',
+                '@blumintinc/blumint/enforce-object-literal-as-const': 'error',
+                '@blumintinc/blumint/enforce-positive-naming': 'error',
+                '@blumintinc/blumint/no-type-assertion-returns': 'error',
+                '@blumintinc/blumint/prefer-utility-function-over-private-static': 'error',
+                '@blumintinc/blumint/enforce-microdiff': 'error',
+                '@blumintinc/blumint/enforce-timestamp-now': 'error',
+                '@blumintinc/blumint/no-always-true-false-conditions': 'error',
+                '@blumintinc/blumint/enforce-props-argument-name': 'error',
+                '@blumintinc/blumint/prefer-global-router-state-key': 'error',
+                '@blumintinc/blumint/prefer-usememo-over-useeffect-usestate': 'error',
+                '@blumintinc/blumint/enforce-dynamic-imports': [
+                    'error',
+                    {
+                        libraries: ['@stream-io/video-react-sdk', 'some-heavy-lib*'],
+                        allowImportType: true,
+                    },
+                ],
+                '@blumintinc/blumint/ensure-pointer-events-none': 'error',
+                '@blumintinc/blumint/no-object-values-on-strings': 'error',
+                '@blumintinc/blumint/no-unnecessary-destructuring': 'error',
+                '@blumintinc/blumint/enforce-singular-type-names': 'error',
+                '@blumintinc/blumint/enforce-css-media-queries': 'error',
+                '@blumintinc/blumint/omit-index-html': 'error',
+                '@blumintinc/blumint/enforce-id-capitalization': 'error',
+                '@blumintinc/blumint/no-unused-usestate': 'error',
             },
         },
     },
     rules: {
+        'key-only-outermost-element': key_only_outermost_element_1.keyOnlyOutermostElement,
         'array-methods-this-context': array_methods_this_context_1.arrayMethodsThisContext,
         'class-methods-read-top-to-bottom': class_methods_read_top_to_bottom_1.classMethodsReadTopToBottom,
         'consistent-callback-naming': consistent_callback_naming_1.default,
         'dynamic-https-errors': dynamic_https_errors_1.dynamicHttpsErrors,
         'enforce-identifiable-firestore-type': enforce_identifiable_firestore_type_1.enforceIdentifiableFirestoreType,
         'enforce-callback-memo': enforce_callback_memo_1.default,
+        'enforce-react-type-naming': enforce_react_type_naming_1.enforceReactTypeNaming,
         'enforce-callable-types': enforce_callable_types_1.enforceCallableTypes,
         'enforce-dynamic-firebase-imports': enforce_dynamic_firebase_imports_1.enforceFirebaseImports,
+        'enforce-mui-rounded-icons': enforce_mui_rounded_icons_1.enforceMuiRoundedIcons,
         '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,
@@ -169,6 +230,7 @@ module.exports = {
         '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-hungarian': no_hungarian_1.noHungarian,
         'no-misused-switch-case': no_misused_switch_case_1.noMisusedSwitchCase,
         'no-unpinned-dependencies': no_unpinned_dependencies_1.noUnpinnedDependencies,
         'no-unused-props': no_unused_props_1.noUnusedProps,
@@ -220,6 +282,28 @@ module.exports = {
         'prefer-destructuring-no-class': prefer_destructuring_no_class_1.preferDestructuringNoClass,
         'enforce-render-hits-memoization': enforce_render_hits_memoization_1.enforceRenderHitsMemoization,
         'prefer-fragment-component': prefer_fragment_component_1.preferFragmentComponent,
+        'react-usememo-should-be-component': react_usememo_should_be_component_1.reactUseMemoShouldBeComponent,
+        'no-unnecessary-verb-suffix': no_unnecessary_verb_suffix_1.noUnnecessaryVerbSuffix,
+        'enforce-assertSafe-object-key': enforce_assertSafe_object_key_1.enforceAssertSafeObjectKey,
+        'enforce-object-literal-as-const': enforce_object_literal_as_const_1.enforceObjectLiteralAsConst,
+        'enforce-positive-naming': enforce_positive_naming_1.enforcePositiveNaming,
+        'no-type-assertion-returns': no_type_assertion_returns_1.noTypeAssertionReturns,
+        'prefer-utility-function-over-private-static': prefer_utility_function_over_private_static_1.preferUtilityFunctionOverPrivateStatic,
+        'enforce-microdiff': enforce_microdiff_1.enforceMicrodiff,
+        'enforce-timestamp-now': enforce_timestamp_now_1.enforceTimestampNow,
+        'no-always-true-false-conditions': no_always_true_false_conditions_1.noAlwaysTrueFalseConditions,
+        'enforce-props-argument-name': enforce_props_argument_name_1.enforcePropsArgumentName,
+        'prefer-global-router-state-key': prefer_global_router_state_key_1.preferGlobalRouterStateKey,
+        'prefer-usememo-over-useeffect-usestate': prefer_usememo_over_useeffect_usestate_1.preferUseMemoOverUseEffectUseState,
+        'enforce-dynamic-imports': enforce_dynamic_imports_1.default,
+        'ensure-pointer-events-none': ensure_pointer_events_none_1.ensurePointerEventsNone,
+        'no-object-values-on-strings': no_object_values_on_strings_1.noObjectValuesOnStrings,
+        'no-unnecessary-destructuring': no_unnecessary_destructuring_1.noUnnecessaryDestructuring,
+        'enforce-singular-type-names': enforce_singular_type_names_1.enforceSingularTypeNames,
+        'enforce-css-media-queries': enforce_css_media_queries_1.enforceCssMediaQueries,
+        'omit-index-html': omit_index_html_1.omitIndexHtml,
+        'enforce-id-capitalization': enforce_id_capitalization_1.enforceIdCapitalization,
+        'no-unused-usestate': no_unused_usestate_1.noUnusedUseState,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/enforce-assert-throws.js

@@ -8,12 +8,12 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce that functions with assert- prefix must throw an error',
+            description: 'Enforce that functions with assert- prefix must throw an error or call process.exit(1)',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            assertShouldThrow: 'Functions with assert- prefix must throw an error. Either rename the function or add a throw statement.',
+            assertShouldThrow: 'Functions with assert- prefix must throw an error or call process.exit(1). Either rename the function or add a throw/exit statement.',
         },
     },
     defaultOptions: [],
@@ -36,6 +36,32 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
             }
             return false;
         }
+        function isProcessExit1(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                const callee = node.callee;
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.object.name === 'process' &&
+                    callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.property.name === 'exit') {
+                    const args = node.arguments;
+                    if (args.length === 1) {
+                        const arg = args[0];
+                        if (arg.type === utils_1.AST_NODE_TYPES.Literal && arg.value === 1) {
+                            return true;
+                        }
+                        // Handle numeric literal 1 in different forms
+                        if (arg.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                            arg.operator === '+' &&
+                            arg.argument.type === utils_1.AST_NODE_TYPES.Literal &&
+                            arg.argument.value === 1) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
         function hasThrowStatement(node) {
             let hasThrow = false;
             function walk(node) {
@@ -43,6 +69,13 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
                     hasThrow = true;
                     return;
                 }
+                // Check for process.exit(1)
+                if (node.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                    if (isProcessExit1(node.expression)) {
+                        hasThrow = true;
+                        return;
+                    }
+                }
                 // Check for assertion function calls
                 if (isAssertionCall(node)) {
                     hasThrow = true;
@@ -56,8 +89,20 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
                         return;
                     }
                 }
-                // Don't count throws in catch blocks that are just re-throwing
+                // Check catch blocks for process.exit(1)
                 if (node.type === utils_1.AST_NODE_TYPES.CatchClause) {
+                    walk(node.body);
+                    return;
+                }
+                // Handle TryStatement specially
+                if (node.type === utils_1.AST_NODE_TYPES.TryStatement) {
+                    walk(node.block);
+                    if (node.handler) {
+                        walk(node.handler);
+                    }
+                    if (node.finalizer) {
+                        walk(node.finalizer);
+                    }
                     return;
                 }
                 // Handle BlockStatement specially

package/lib/rules/enforce-assertSafe-object-key.d.ts

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