eslint-config-typed 4.0.9 → 4.2.0

package/src/plugins/immer-coding-style/rules/prefer-curried-produce.mts

@@ -0,0 +1,293 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import { castDeepMutable, hasKey, isRecord } from 'ts-data-forge';
+
+type MessageIds = 'useCurriedProduce';
+
+type CallExpressionWithLegacyTypeParameters = TSESTree.CallExpression &
+  Readonly<{
+    typeParameters?: TSESTree.TSTypeParameterInstantiation;
+  }>;
+
+export const preferCurriedProduceRule: TSESLint.RuleModule<MessageIds> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer the curried overload of immer produce for shorter updater definitions.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useCurriedProduce:
+        'Use the curried overload of `produce`: `produce(recipe)` instead of `(state) => produce(state, recipe)`.',
+    },
+  },
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    return {
+      ArrowFunctionExpression: (
+        node: DeepReadonly<TSESTree.ArrowFunctionExpression>,
+      ) => {
+        if (node.params.length !== 1) {
+          return;
+        }
+
+        const param = node.params[0];
+
+        if (
+          param === undefined ||
+          param.type !== AST_NODE_TYPES.Identifier ||
+          param.name.length === 0
+        ) {
+          return;
+        }
+
+        const { name: parameterName } = param;
+
+        const callExpression = node.body;
+
+        if (!isProduceCall(callExpression)) {
+          return;
+        }
+
+        const [baseArgument, ...restArguments] = callExpression.arguments;
+
+        if (
+          baseArgument === undefined ||
+          restArguments.length === 0 ||
+          !isSameIdentifier(baseArgument, parameterName)
+        ) {
+          return;
+        }
+
+        if (hasOtherReferences(context, parameterName, baseArgument)) {
+          return;
+        }
+
+        report(context, {
+          arrowFunction: node,
+          callExpression,
+          remainingArguments: restArguments,
+          sourceCode,
+        });
+      },
+    };
+  },
+  defaultOptions: [],
+};
+
+type ReportContext = Readonly<{
+  arrowFunction: DeepReadonly<TSESTree.ArrowFunctionExpression>;
+  callExpression: DeepReadonly<TSESTree.CallExpression>;
+  remainingArguments: readonly DeepReadonly<TSESTree.CallExpressionArgument>[];
+  sourceCode: Readonly<{
+    getText: TSESLint.SourceCode['getText'];
+  }>;
+}>;
+
+const report = (
+  context: DeepReadonly<TSESLint.RuleContext<MessageIds, readonly []>>,
+  {
+    arrowFunction,
+    callExpression,
+    remainingArguments,
+    sourceCode,
+  }: ReportContext,
+): void => {
+  const calleeText = sourceCode.getText(castDeepMutable(callExpression.callee));
+
+  const typeParametersText = getTypeParametersText({
+    arrowFunction,
+    callExpression,
+    sourceCode,
+  });
+
+  const remainingArgumentsText = remainingArguments
+    .map((argument) =>
+      normalizeMultilineText(sourceCode.getText(castDeepMutable(argument))),
+    )
+    .join(', ');
+
+  const replacement = `${calleeText}${typeParametersText}(${remainingArgumentsText})`;
+
+  context.report({
+    node: castDeepMutable(arrowFunction),
+    messageId: 'useCurriedProduce',
+    fix: (fixer) =>
+      fixer.replaceText(castDeepMutable(arrowFunction), replacement),
+  });
+};
+
+const isProduceCall = (
+  node: DeepReadonly<TSESTree.Node>,
+): node is TSESTree.CallExpression => {
+  if (node.type !== AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
+
+  return (
+    node.callee.type === AST_NODE_TYPES.Identifier &&
+    node.callee.name === 'produce'
+  );
+};
+
+const isSameIdentifier = (
+  node: DeepReadonly<TSESTree.CallExpressionArgument>,
+  expectedName: string,
+): node is TSESTree.Identifier =>
+  node.type === AST_NODE_TYPES.Identifier && node.name === expectedName;
+
+const hasOtherReferences = (
+  context: DeepReadonly<TSESLint.RuleContext<MessageIds, readonly []>>,
+  parameterName: string,
+  baseIdentifier: DeepReadonly<TSESTree.Identifier>,
+): boolean => {
+  const scope = context.sourceCode.getScope(castDeepMutable(baseIdentifier));
+
+  const variable = scope.variables.find(
+    (variableItem) => variableItem.name === parameterName,
+  );
+
+  if (variable === undefined) {
+    return true;
+  }
+
+  return variable.references.some(
+    (reference) => reference.identifier !== baseIdentifier,
+  );
+};
+
+const getTypeArguments = (
+  node: DeepReadonly<TSESTree.CallExpression>,
+): TSESTree.TSTypeParameterInstantiation | undefined => {
+  const mutableNode = castDeepMutable(node);
+
+  if (isRecord(mutableNode) && hasKey(mutableNode, 'typeArguments')) {
+    return (
+      mutableNode as TSESTree.CallExpression & {
+        typeArguments?: TSESTree.TSTypeParameterInstantiation;
+      }
+    ).typeArguments;
+  }
+
+  if (isRecord(mutableNode) && hasKey(mutableNode, 'typeParameters')) {
+    return (mutableNode as CallExpressionWithLegacyTypeParameters)
+      .typeParameters;
+  }
+
+  return undefined;
+};
+
+const getTypeParametersText = ({
+  arrowFunction,
+  callExpression,
+  sourceCode,
+}: Readonly<{
+  arrowFunction: DeepReadonly<TSESTree.ArrowFunctionExpression>;
+  callExpression: DeepReadonly<TSESTree.CallExpression>;
+  sourceCode: Readonly<{
+    getText: TSESLint.SourceCode['getText'];
+  }>;
+}>): string => {
+  const typeArguments = getTypeArguments(callExpression);
+
+  if (typeArguments !== undefined) {
+    return sourceCode.getText(castDeepMutable(typeArguments));
+  }
+
+  const parameterType = getArrowFunctionParameterType({
+    arrowFunction,
+    sourceCode,
+  });
+
+  if (parameterType !== undefined) {
+    return `<${parameterType}>`;
+  }
+
+  const returnType = getArrowFunctionReturnType({
+    arrowFunction,
+    sourceCode,
+  });
+
+  if (returnType !== undefined) {
+    return `<${returnType}>`;
+  }
+
+  return '';
+};
+
+const getArrowFunctionParameterType = ({
+  arrowFunction,
+  sourceCode,
+}: Readonly<{
+  arrowFunction: DeepReadonly<TSESTree.ArrowFunctionExpression>;
+  sourceCode: Readonly<{
+    getText: TSESLint.SourceCode['getText'];
+  }>;
+}>): string | undefined => {
+  const [parameter] = arrowFunction.params;
+
+  if (parameter?.type !== AST_NODE_TYPES.Identifier) {
+    return undefined;
+  }
+
+  const typeAnnotation = parameter.typeAnnotation?.typeAnnotation;
+
+  if (typeAnnotation === undefined) {
+    return undefined;
+  }
+
+  return sourceCode.getText(castDeepMutable(typeAnnotation));
+};
+
+const getArrowFunctionReturnType = ({
+  arrowFunction,
+  sourceCode,
+}: Readonly<{
+  arrowFunction: DeepReadonly<TSESTree.ArrowFunctionExpression>;
+  sourceCode: Readonly<{
+    getText: TSESLint.SourceCode['getText'];
+  }>;
+}>): string | undefined => {
+  const typeAnnotation = arrowFunction.returnType?.typeAnnotation;
+
+  if (typeAnnotation === undefined) {
+    return undefined;
+  }
+
+  return sourceCode.getText(castDeepMutable(typeAnnotation));
+};
+
+const normalizeMultilineText = (text: string): string => {
+  const lines = text.split('\n');
+
+  if (lines.length <= 1) {
+    return text;
+  }
+
+  const indents = lines
+    .slice(1)
+    .filter((line) => line.trim().length > 0)
+    .map((line) => /^[\t ]*/u.exec(line)?.[0].length ?? 0);
+
+  if (indents.length === 0) {
+    return text;
+  }
+
+  const minIndent = Math.min(...indents);
+
+  if (minIndent === 0) {
+    return text;
+  }
+
+  const normalized = lines.map((line, index) =>
+    index === 0 ? line : line.slice(minIndent),
+  );
+
+  return normalized.join('\n');
+};

package/src/plugins/immer-coding-style/rules/prefer-curried-produce.test.mts

@@ -0,0 +1,124 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferCurriedProduceRule } from './prefer-curried-produce.mjs';
+
+const ruleName = 'prefer-curried-produce';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  },
+});
+
+describe('prefer-curried-produce', () => {
+  tester.run(ruleName, preferCurriedProduceRule, {
+    valid: [
+      {
+        name: 'Already curried',
+        code: dedent`
+          import { produce } from 'immer';
+
+          const update = produce((draft) => {
+            draft.count += 1;
+          });
+        `,
+      },
+      {
+        name: 'Already curried with type arg',
+        code: dedent`
+          import { produce } from 'immer';
+
+          const update = produce<State>((draft) => {
+            draft.count += 1;
+          });
+        `,
+      },
+      {
+        name: 'Multiple parameters are ignored',
+        code: dedent`
+          import { produce } from 'immer';
+
+          const update = (state, action) =>
+            produce(state, (draft) => {
+              draft.count += action.delta;
+            });
+        `,
+      },
+      {
+        name: 'Base state differs from parameter',
+        code: dedent`
+          import { produce } from 'immer';
+
+          const update = (state) =>
+            produce(other, (draft) => {
+              draft.count += state.delta;
+            });
+        `,
+      },
+      {
+        name: 'Parameter referenced inside recipe is ignored',
+        code: dedent`
+          import { produce } from 'immer';
+
+          const update = (state) =>
+            produce(state, (draft) => {
+              draft.count += state.delta;
+            });
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'Transforms simple updater',
+        code: dedent`
+          import { produce } from 'immer';
+
+          const update = (state) =>
+            produce(state, (draft) => {
+              draft.count += 1;
+            });
+        `,
+        output: dedent`
+          import { produce } from 'immer';
+
+          const update = produce((draft) => {
+            draft.count += 1;
+          });
+        `,
+        errors: [
+          {
+            messageId: 'useCurriedProduce',
+          },
+        ],
+      },
+      {
+        name: 'Transforms simple updater with type annotations',
+        code: dedent`
+          import { produce } from 'immer';
+
+          const update = (state: State): State =>
+            produce(state, (draft) => {
+              draft.count += 1;
+            });
+        `,
+        output: dedent`
+          import { produce } from 'immer';
+
+          const update = produce<State>((draft) => {
+            draft.count += 1;
+          });
+        `,
+        errors: [
+          {
+            messageId: 'useCurriedProduce',
+          },
+        ],
+      },
+    ],
+  });
+});

package/src/plugins/immer-coding-style/rules/rules.mts

@@ -0,0 +1,6 @@
+import { type ESLintPlugin } from '../../../types/index.mjs';
+import { preferCurriedProduceRule } from './prefer-curried-produce.mjs';
+
+export const immerCodingStyleRules = {
+  'prefer-curried-produce': preferCurriedProduceRule,
+} as const satisfies ESLintPlugin['rules'];

package/src/plugins/index.mts

@@ -1,3 +1,4 @@
+export * from './immer-coding-style/index.mjs';
 export * from './react-coding-style/index.mjs';
 export * from './strict-dependencies/index.mjs';
 export * from './total-functions/index.mjs';

package/src/rules/eslint-immer-coding-style-rules.mts

@@ -0,0 +1,5 @@
+import { type EslintImmerCodingStyleRules } from '../types/index.mjs';
+
+export const eslintImmerCodingStyleRules = {
+  'immer-coding-style/prefer-curried-produce': 'error',
+} as const satisfies EslintImmerCodingStyleRules;

package/src/rules/eslint-jest-rules.mts

@@ -82,6 +82,9 @@ export const eslintJestRules = {
   'jest/unbound-method': withDefaultOption('error'),
   'jest/valid-expect-in-promise': 'error',
   'jest/prefer-ending-with-an-expect': withDefaultOption('error'),
+  'jest/no-unneeded-async-expect-function': 'error',
+  'jest/prefer-to-have-been-called': 'error',
+  'jest/prefer-to-have-been-called-times': 'error',
 
   'jest/valid-mock-module-path': withDefaultOption('error'),
 } as const satisfies EslintJestRules;

package/src/rules/eslint-testing-library-rules.mts

@@ -30,6 +30,7 @@ export const eslintTestingLibraryRules = {
   'testing-library/prefer-screen-queries': 'error',
   'testing-library/render-result-naming-convention': 'error',
   'testing-library/no-test-id-queries': 'error',
+  'testing-library/prefer-user-event-setup': 'error',
 
   'testing-library/consistent-data-testid': 'off',
   'testing-library/prefer-explicit-assert': 'off',

package/src/rules/eslint-vitest-rules.mts

@@ -117,6 +117,7 @@ export const eslintVitestRules = {
     },
   ],
   'vitest/require-import-vi-mock': 'error',
+  'vitest/no-unneeded-async-expect-function': 'error',
 
   // deprecated
   'vitest/no-done-callback': 0,

package/src/rules/index.mts

@@ -1,6 +1,7 @@
 export * from './eslint-array-func-rules.mjs';
 export * from './eslint-cypress-rules.mjs';
 export * from './eslint-functional-rules.mjs';
+export * from './eslint-immer-coding-style-rules.mjs';
 export * from './eslint-import-rules.mjs';
 export * from './eslint-jest-rules.mjs';
 export * from './eslint-jsx-a11y-rules.mjs';

package/src/rules/typescript-eslint-rules.mts

@@ -489,6 +489,7 @@ export const typescriptEslintRules = {
   '@typescript-eslint/no-unnecessary-type-conversion': 'error',
 
   '@typescript-eslint/no-unused-private-class-members': 'error',
+  '@typescript-eslint/no-useless-default-assignment': 'error',
 
   // For browser environment only
 

package/src/types/define-known-rules.mts

@@ -2,6 +2,7 @@ import {
   type EslintArrayFuncRules,
   type EslintCypressRules,
   type EslintFunctionalRules,
+  type EslintImmerCodingStyleRules,
   type EslintImportsRules,
   type EslintJestRules,
   type EslintJsxA11yRules,
@@ -60,6 +61,7 @@ type KnownRules = DeepReadonly<
     EslintUnicornRules &
     EslintVitestRules &
     EslintVitestCodingStyleRules &
+    EslintImmerCodingStyleRules &
     EslintReactCodingStyleRules &
     TypeScriptEslintRules
 >;

package/src/types/rules/eslint-immer-coding-style-rules.mts

@@ -0,0 +1,21 @@
+/* cSpell:disable */
+import { type Linter } from 'eslint';
+
+/**
+ * Prefer the curried overload of immer produce for shorter updater definitions.
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+namespace PreferCurriedProduce {
+  export type RuleEntry = Linter.StringSeverity;
+}
+
+export type EslintImmerCodingStyleRules = Readonly<{
+  'immer-coding-style/prefer-curried-produce': PreferCurriedProduce.RuleEntry;
+}>;