@checkdigit/eslint-plugin 6.6.0-PR.75-edd9 → 6.6.0-PR.75-2a52

package/src/no-duplicated-imports.ts

@@ -0,0 +1,116 @@
+// no-duplicated-imports.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import { strict as assert } from 'node:assert';
+import getDocumentationUrl from './get-documentation-url';
+
+export const ruleId = 'no-duplicated-imports';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const rule = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Merge duplicated import statements with the same "from".',
+    },
+    messages: {
+      mergeDuplicatedImports: 'Merge duplicated import statements with the same "from".',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const importDeclarations = new Map<string, TSESTree.ImportDeclaration[]>();
+
+    return {
+      ImportDeclaration(node) {
+        const moduleName = node.source.value;
+        let declarations = importDeclarations.get(moduleName);
+        if (declarations === undefined) {
+          declarations = [];
+          importDeclarations.set(moduleName, declarations);
+        }
+        declarations.push(node);
+      },
+      'Program:exit'() {
+        for (const [moduleName, declarations] of importDeclarations.entries()) {
+          if (declarations.length <= 1) {
+            continue;
+          }
+
+          const firstDeclaration = declarations[0];
+          assert.ok(firstDeclaration);
+
+          const isAllTypeOnly = declarations.every(
+            (declaration) =>
+              declaration.importKind === 'type' ||
+              declaration.specifiers.every(
+                (specifier) =>
+                  specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === 'type',
+              ),
+          );
+
+          context.report({
+            messageId: 'mergeDuplicatedImports',
+            node: firstDeclaration,
+            fix(fixer) {
+              const fixes = [];
+
+              const defaultSpecifier = declarations
+                .flatMap((declaration) =>
+                  declaration.specifiers.map((specifier) =>
+                    specifier.type === TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier ? specifier : undefined,
+                  ),
+                )
+                .filter(Boolean);
+              const defaultSpecifierText = defaultSpecifier[0] ? sourceCode.getText(defaultSpecifier[0]) : undefined;
+
+              const mergedSpecifiers = declarations.flatMap((declaration) => {
+                const isCurrentDeclarationTypeOnly =
+                  declaration.importKind === 'type' ||
+                  declaration.specifiers.every(
+                    (specifier) =>
+                      specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === 'type',
+                  );
+                return declaration.specifiers
+                  .filter((specifier) => specifier.type !== TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier)
+                  .map((specifier) =>
+                    // eslint-disable-next-line no-nested-ternary
+                    isAllTypeOnly
+                      ? sourceCode.getText(specifier).replace('type ', '')
+                      : isCurrentDeclarationTypeOnly
+                        ? `type ${sourceCode.getText(specifier)}`
+                        : sourceCode.getText(specifier),
+                  );
+              });
+              const mergedSpecifiersText = `${isAllTypeOnly ? 'type ' : ''}{ ${mergedSpecifiers.join(', ')} }`;
+
+              // Replace the first import with the merged import
+              const mergedImport = `import ${[defaultSpecifierText, mergedSpecifiersText].filter(Boolean).join(', ')} from '${moduleName}';`;
+              fixes.push(fixer.replaceText(firstDeclaration, mergedImport));
+
+              // Remove the remaining imports
+              declarations.slice(1).forEach((declaration) => {
+                fixes.push(fixer.removeRange([declaration.range[0], declaration.range[1] + 1]));
+              });
+
+              return fixes;
+            },
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;

package/src/require-fixed-services-import.ts

@@ -0,0 +1,52 @@
+// require-fixed-services-import.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import { ESLintUtils } from '@typescript-eslint/utils';
+import getDocumentationUrl from './get-documentation-url';
+
+export const ruleId = 'require-fixed-services-import';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+const SERVICE_TYPINGS_IMPORT_PATH_PREFIX = /(?<path>\.\.\/)+services\/.*/u;
+
+const rule = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require fixed "from" with service typing imports from "src/services".',
+    },
+    messages: {
+      updateServicesImportFrom: 'Update service typing imports to be from the fixed "src/services" path.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const moduleName = node.source.value;
+        if (SERVICE_TYPINGS_IMPORT_PATH_PREFIX.test(moduleName)) {
+          context.report({
+            messageId: 'updateServicesImportFrom',
+            node: node.source,
+            *fix(fixer) {
+              yield fixer.replaceText(
+                node.source,
+                `'${moduleName.slice(0, moduleName.indexOf('../services') + '../services'.length)}'`,
+              );
+            },
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;

package/src/require-type-out-of-type-only-imports.ts

@@ -0,0 +1,63 @@
+// require-type-out-of-type-only-imports.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import getDocumentationUrl from './get-documentation-url';
+
+export const ruleId = 'require-type-out-of-type-only-imports';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const rule = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require "type" to be out side of type-only imports.',
+    },
+    messages: {
+      moveTypeOutside: 'Update the type-only imports to use "tpe" outside of the curly braces.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      ImportDeclaration(declaration) {
+        if (
+          declaration.importKind === 'type' ||
+          !declaration.specifiers.every(
+            (specifier) =>
+              specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === 'type',
+          )
+        ) {
+          return;
+        }
+
+        context.report({
+          messageId: 'moveTypeOutside',
+          node: declaration,
+          *fix(fixer) {
+            const moduleName = declaration.source.value;
+            const mergedSpecifiers = declaration.specifiers
+              .filter((specifier) => specifier.type !== TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier)
+              .map((specifier) => sourceCode.getText(specifier).replace('type ', ''));
+            const updatedImportDeclaration = `import type { ${mergedSpecifiers.join(', ')} } from '${moduleName}';`;
+
+            yield fixer.replaceText(declaration, updatedImportDeclaration);
+          },
+        });
+      },
+    };
+  },
+});
+
+export default rule;