eslint-plugin-zod 1.3.0 → 3.0.0

package/dist/rules/prefer-enum-over-literal-union.js

@@ -0,0 +1,69 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const preferEnumOverLiteralUnion = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'prefer-enum-over-literal-union',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Prefer `z.enum()` over `z.union()` when all members are string literals.',
+        },
+        messages: {
+            useEnum: 'Replace this union of string literals with `z.enum()`.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchema = detectZodSchemaRootNode(node);
+                if ((zodSchema === null || zodSchema === void 0 ? void 0 : zodSchema.schemaType) !== 'union') {
+                    return;
+                }
+                const [unionArgument] = node.arguments;
+                if (unionArgument.type !== AST_NODE_TYPES.ArrayExpression) {
+                    return;
+                }
+                const zodLiteralStrings = unionArgument.elements.map((s) => {
+                    if (!s) {
+                        return null;
+                    }
+                    const maybeLiteralSchema = detectZodSchemaRootNode(s);
+                    if ((maybeLiteralSchema === null || maybeLiteralSchema === void 0 ? void 0 : maybeLiteralSchema.schemaType) !== 'literal') {
+                        return null;
+                    }
+                    const [literalArgument] = maybeLiteralSchema.node.arguments;
+                    if (literalArgument.type === AST_NODE_TYPES.Literal &&
+                        typeof literalArgument.value === 'string') {
+                        return literalArgument.raw;
+                    }
+                    return null;
+                });
+                if (zodLiteralStrings.some((it) => it === null)) {
+                    return;
+                }
+                if (zodSchema.schemaDecl === 'named') {
+                    context.report({
+                        node,
+                        messageId: 'useEnum',
+                    });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useEnum',
+                    fix(fixer) {
+                        return [
+                            fixer.replaceText(node.callee.property, 'enum'),
+                            fixer.replaceText(node.arguments[0], `[${zodLiteralStrings.join(', ')}]`),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-meta-last.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferMetaLast = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const get_outermost_call_js_1 = require("../utils/get-outermost-call.cjs");
+const is_zod_expression_js_1 = require("../utils/is-zod-expression.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.preferMetaLast = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'prefer-meta-last',
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Enforce `.meta()` as last method' },
+        fixable: 'code',
+        messages: {
+            metaNotLast: 'The `.meta()` methods should be the last one called',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                    !(0, is_zod_expression_js_1.isZodExpressionEndingWithMethod)(node.callee, 'meta')) {
+                    return;
+                }
+                const outer = (0, get_outermost_call_js_1.getOutermostCall)(node);
+                if (!outer) {
+                    return;
+                }
+                const zodSchemaMeta = detectZodSchemaRootNode(outer);
+                const chain = collectZodChainMethods(outer);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                const metaIndex = chain.findIndex((c) => c.name === 'meta');
+                if (metaIndex === -1) {
+                    return;
+                }
+                const hasAnyNonMetaAfter = chain
+                    .slice(metaIndex + 1)
+                    .some((c) => c.name !== 'meta');
+                if (!hasAnyNonMetaAfter) {
+                    return;
+                }
+                const metaCall = chain[metaIndex].node;
+                const metaCallCallee = metaCall.callee;
+                context.report({
+                    node: metaCallCallee.property,
+                    messageId: 'metaNotLast',
+                    fix(fixer) {
+                        const source = context.sourceCode;
+                        const metaCallText = source.getText(metaCall);
+                        const objectText = source.getText(metaCallCallee.object);
+                        const onlyMetaSuffix = metaCallText.slice(objectText.length);
+                        const [, removeStart] = metaCallCallee.object.range;
+                        const [, removeEnd] = metaCall.range;
+                        const lastCall = chain[chain.length - 1].node;
+                        return [
+                            fixer.removeRange([removeStart, removeEnd]),
+                            fixer.insertTextAfterRange(lastCall.range, onlyMetaSuffix),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-meta-last.d.cts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const preferMetaLast: ESLintUtils.RuleModule<"metaNotLast", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/prefer-meta-last.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const preferMetaLast: ESLintUtils.RuleModule<"metaNotLast", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/prefer-meta-last.js

@@ -0,0 +1,68 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { getOutermostCall } from "../utils/get-outermost-call.js";
+import { isZodExpressionEndingWithMethod } from "../utils/is-zod-expression.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const preferMetaLast = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'prefer-meta-last',
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Enforce `.meta()` as last method' },
+        fixable: 'code',
+        messages: {
+            metaNotLast: 'The `.meta()` methods should be the last one called',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                if (node.callee.type !== AST_NODE_TYPES.MemberExpression ||
+                    !isZodExpressionEndingWithMethod(node.callee, 'meta')) {
+                    return;
+                }
+                const outer = getOutermostCall(node);
+                if (!outer) {
+                    return;
+                }
+                const zodSchemaMeta = detectZodSchemaRootNode(outer);
+                const chain = collectZodChainMethods(outer);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                const metaIndex = chain.findIndex((c) => c.name === 'meta');
+                if (metaIndex === -1) {
+                    return;
+                }
+                const hasAnyNonMetaAfter = chain
+                    .slice(metaIndex + 1)
+                    .some((c) => c.name !== 'meta');
+                if (!hasAnyNonMetaAfter) {
+                    return;
+                }
+                const metaCall = chain[metaIndex].node;
+                const metaCallCallee = metaCall.callee;
+                context.report({
+                    node: metaCallCallee.property,
+                    messageId: 'metaNotLast',
+                    fix(fixer) {
+                        const source = context.sourceCode;
+                        const metaCallText = source.getText(metaCall);
+                        const objectText = source.getText(metaCallCallee.object);
+                        const onlyMetaSuffix = metaCallText.slice(objectText.length);
+                        const [, removeStart] = metaCallCallee.object.range;
+                        const [, removeEnd] = metaCall.range;
+                        const lastCall = chain[chain.length - 1].node;
+                        return [
+                            fixer.removeRange([removeStart, removeEnd]),
+                            fixer.insertTextAfterRange(lastCall.range, onlyMetaSuffix),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-meta.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferMeta = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.preferMeta = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'prefer-meta',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Enforce usage of `.meta()` over `.describe()`',
+        },
+        messages: {
+            preferMeta: 'The `.describe()` method still exists for compatibility with Zod 3, but `.meta()` is now the recommended approach.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                const describe = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === 'describe');
+                if (!describe) {
+                    return;
+                }
+                const { callee, arguments: [describeArg], } = describe.node;
+                context.report({
+                    node,
+                    messageId: 'preferMeta',
+                    fix(fixer) {
+                        return [
+                            fixer.replaceText(callee.property, 'meta'),
+                            fixer.replaceText(describeArg, `{ description: ${context.sourceCode.getText(describeArg)} }`),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-meta.d.cts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const preferMeta: ESLintUtils.RuleModule<"preferMeta", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/prefer-meta.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const preferMeta: ESLintUtils.RuleModule<"preferMeta", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/prefer-meta.js

@@ -0,0 +1,45 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const preferMeta = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'prefer-meta',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Enforce usage of `.meta()` over `.describe()`',
+        },
+        messages: {
+            preferMeta: 'The `.describe()` method still exists for compatibility with Zod 3, but `.meta()` is now the recommended approach.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                const describe = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === 'describe');
+                if (!describe) {
+                    return;
+                }
+                const { callee, arguments: [describeArg], } = describe.node;
+                context.report({
+                    node,
+                    messageId: 'preferMeta',
+                    fix(fixer) {
+                        return [
+                            fixer.replaceText(callee.property, 'meta'),
+                            fixer.replaceText(describeArg, `{ description: ${context.sourceCode.getText(describeArg)} }`),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-namespace-import.cjs

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferNamespaceImport = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const is_zod_import_source_js_1 = require("../utils/is-zod-import-source.cjs");
+function isGroupFirstImportTypeNamespace(group) {
+    const { hasOnlyTypeImports, nodes: [firstImportNode], } = group;
+    const { specifiers } = firstImportNode;
+    if (specifiers.length === 1 &&
+        specifiers[0].type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (hasOnlyTypeImports) {
+            if (firstImportNode.importKind === 'type') {
+                return true;
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    return false;
+}
+function shouldIdentifierBeRenamed(node) {
+    if (node.parent.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+        return false;
+    }
+    if (node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        node.parent.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.parent.object.name !== node.name) {
+        return false;
+    }
+    return true;
+}
+function getNamespaceAliasNameFrom(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        node.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return node.local.name;
+    }
+    if (node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.imported.name === 'z') {
+        return node.local.name;
+    }
+    return null;
+}
+exports.preferNamespaceImport = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'prefer-namespace-import',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: "Enforce importing zod as a namespace import (`import * as z from 'zod'`)",
+        },
+        fixable: 'code',
+        messages: {
+            useNamespace: 'Import Zod with a namespace import',
+            removeDuplicate: 'Zod is already imported via namespace import',
+            convertUsage: 'Convert to namespace usage',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { sourceCode } = context;
+        const importGroups = {};
+        return {
+            ImportDeclaration(node) {
+                const { source, importKind } = node;
+                if (!(0, is_zod_import_source_js_1.isZodImportSource)(source.value)) {
+                    return;
+                }
+                if (!importGroups[source.value]) {
+                    importGroups[source.value] = {
+                        hasOnlyTypeImports: true,
+                        nodes: [],
+                    };
+                }
+                if (importGroups[source.value].hasOnlyTypeImports &&
+                    importKind === 'value') {
+                    importGroups[source.value].hasOnlyTypeImports = false;
+                }
+                importGroups[source.value].nodes.push(node);
+            },
+            'Program:exit': function () {
+                let namespaceAliasNameIndex = 0;
+                for (const importGroup of Object.values(importGroups)) {
+                    const { hasOnlyTypeImports, nodes } = importGroup;
+                    const [firstImportNode, ...othersImportNodes] = nodes;
+                    const nodesWithVariablesToUpdate = [];
+                    let namespaceAliasName = null;
+                    for (const specifier of nodes.flatMap((it) => it.specifiers)) {
+                        if (!namespaceAliasName) {
+                            namespaceAliasName = getNamespaceAliasNameFrom(specifier);
+                            if (namespaceAliasName) {
+                                continue;
+                            }
+                        }
+                        nodesWithVariablesToUpdate.push(specifier);
+                    }
+                    if (!namespaceAliasName) {
+                        namespaceAliasName = 'z';
+                        if (namespaceAliasNameIndex > 0) {
+                            namespaceAliasName = `z${namespaceAliasNameIndex}`;
+                            namespaceAliasNameIndex += 1;
+                        }
+                    }
+                    const isFirstImportValid = isGroupFirstImportTypeNamespace(importGroup);
+                    if (!isFirstImportValid) {
+                        context.report({
+                            node: firstImportNode,
+                            messageId: 'useNamespace',
+                            fix(fixer) {
+                                const importTypeKeyword = hasOnlyTypeImports ? 'type ' : '';
+                                const newImportText = `import ${importTypeKeyword}* as ${namespaceAliasName} from ${firstImportNode.source.raw};`;
+                                return fixer.replaceText(firstImportNode, newImportText);
+                            },
+                        });
+                    }
+                    const allVariables = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it));
+                    const allReferences = allVariables.flatMap((it) => it.references);
+                    for (const ref of allReferences) {
+                        const { identifier } = ref;
+                        if (shouldIdentifierBeRenamed(identifier)) {
+                            context.report({
+                                node: identifier,
+                                messageId: 'convertUsage',
+                                fix(fixer) {
+                                    const newId = `${namespaceAliasName}.${identifier.name}`;
+                                    return fixer.replaceText(identifier, newId);
+                                },
+                            });
+                        }
+                    }
+                    for (const extraImport of othersImportNodes) {
+                        context.report({
+                            node: extraImport,
+                            messageId: 'removeDuplicate',
+                            fix(fixer) {
+                                return fixer.removeRange(extraImport.range);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/prefer-namespace-import.d.cts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const preferNamespaceImport: ESLintUtils.RuleModule<"useNamespace" | "removeDuplicate" | "convertUsage", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/prefer-namespace-import.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const preferNamespaceImport: ESLintUtils.RuleModule<"useNamespace" | "removeDuplicate" | "convertUsage", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/prefer-namespace-import.js

@@ -0,0 +1,142 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { isZodImportSource } from "../utils/is-zod-import-source.js";
+function isGroupFirstImportTypeNamespace(group) {
+    const { hasOnlyTypeImports, nodes: [firstImportNode], } = group;
+    const { specifiers } = firstImportNode;
+    if (specifiers.length === 1 &&
+        specifiers[0].type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (hasOnlyTypeImports) {
+            if (firstImportNode.importKind === 'type') {
+                return true;
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    return false;
+}
+function shouldIdentifierBeRenamed(node) {
+    if (node.parent.type === AST_NODE_TYPES.ImportSpecifier) {
+        return false;
+    }
+    if (node.parent.type === AST_NODE_TYPES.MemberExpression &&
+        node.parent.object.type === AST_NODE_TYPES.Identifier &&
+        node.parent.object.name !== node.name) {
+        return false;
+    }
+    return true;
+}
+function getNamespaceAliasNameFrom(node) {
+    if (node.type === AST_NODE_TYPES.ImportDefaultSpecifier ||
+        node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return node.local.name;
+    }
+    if (node.imported.type === AST_NODE_TYPES.Identifier &&
+        node.imported.name === 'z') {
+        return node.local.name;
+    }
+    return null;
+}
+export const preferNamespaceImport = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'prefer-namespace-import',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: "Enforce importing zod as a namespace import (`import * as z from 'zod'`)",
+        },
+        fixable: 'code',
+        messages: {
+            useNamespace: 'Import Zod with a namespace import',
+            removeDuplicate: 'Zod is already imported via namespace import',
+            convertUsage: 'Convert to namespace usage',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { sourceCode } = context;
+        const importGroups = {};
+        return {
+            ImportDeclaration(node) {
+                const { source, importKind } = node;
+                if (!isZodImportSource(source.value)) {
+                    return;
+                }
+                if (!importGroups[source.value]) {
+                    importGroups[source.value] = {
+                        hasOnlyTypeImports: true,
+                        nodes: [],
+                    };
+                }
+                if (importGroups[source.value].hasOnlyTypeImports &&
+                    importKind === 'value') {
+                    importGroups[source.value].hasOnlyTypeImports = false;
+                }
+                importGroups[source.value].nodes.push(node);
+            },
+            'Program:exit': function () {
+                let namespaceAliasNameIndex = 0;
+                for (const importGroup of Object.values(importGroups)) {
+                    const { hasOnlyTypeImports, nodes } = importGroup;
+                    const [firstImportNode, ...othersImportNodes] = nodes;
+                    const nodesWithVariablesToUpdate = [];
+                    let namespaceAliasName = null;
+                    for (const specifier of nodes.flatMap((it) => it.specifiers)) {
+                        if (!namespaceAliasName) {
+                            namespaceAliasName = getNamespaceAliasNameFrom(specifier);
+                            if (namespaceAliasName) {
+                                continue;
+                            }
+                        }
+                        nodesWithVariablesToUpdate.push(specifier);
+                    }
+                    if (!namespaceAliasName) {
+                        namespaceAliasName = 'z';
+                        if (namespaceAliasNameIndex > 0) {
+                            namespaceAliasName = `z${namespaceAliasNameIndex}`;
+                            namespaceAliasNameIndex += 1;
+                        }
+                    }
+                    const isFirstImportValid = isGroupFirstImportTypeNamespace(importGroup);
+                    if (!isFirstImportValid) {
+                        context.report({
+                            node: firstImportNode,
+                            messageId: 'useNamespace',
+                            fix(fixer) {
+                                const importTypeKeyword = hasOnlyTypeImports ? 'type ' : '';
+                                const newImportText = `import ${importTypeKeyword}* as ${namespaceAliasName} from ${firstImportNode.source.raw};`;
+                                return fixer.replaceText(firstImportNode, newImportText);
+                            },
+                        });
+                    }
+                    const allVariables = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it));
+                    const allReferences = allVariables.flatMap((it) => it.references);
+                    for (const ref of allReferences) {
+                        const { identifier } = ref;
+                        if (shouldIdentifierBeRenamed(identifier)) {
+                            context.report({
+                                node: identifier,
+                                messageId: 'convertUsage',
+                                fix(fixer) {
+                                    const newId = `${namespaceAliasName}.${identifier.name}`;
+                                    return fixer.replaceText(identifier, newId);
+                                },
+                            });
+                        }
+                    }
+                    for (const extraImport of othersImportNodes) {
+                        context.report({
+                            node: extraImport,
+                            messageId: 'removeDuplicate',
+                            fix(fixer) {
+                                return fixer.removeRange(extraImport.range);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});