This repository has been archived by the owner on Mar 25, 2021. It is now read-only.
/
noDuplicateImportsRule.ts
110 lines (99 loc) · 4.08 KB
/
noDuplicateImportsRule.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
/**
* @license
* Copyright 2017 Palantir Technologies, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { isImportDeclaration, isLiteralExpression, isModuleDeclaration, isNamespaceImport, } from "tsutils";
import * as ts from "typescript";
import * as Lint from "../index";
const OPTION_ALLOW_SEPARATE_NAMESPACE_IMPORTS = "allow-namespace-imports";
export class Rule extends Lint.Rules.AbstractRule {
/* tslint:disable:object-literal-sort-keys */
public static metadata: Lint.IRuleMetadata = {
ruleName: "no-duplicate-imports",
description: Lint.Utils.dedent`
Disallows multiple import statements from the same module.`,
rationale: Lint.Utils.dedent`
Using a single import statement per module will make the code clearer because you can see everything being imported
from that module on one line.`,
optionsDescription: Lint.Utils.dedent`
"${OPTION_ALLOW_SEPARATE_NAMESPACE_IMPORTS}" allows you to import namespaces on separate lines.`,
options: {
type: "string",
enum: [OPTION_ALLOW_SEPARATE_NAMESPACE_IMPORTS],
},
optionExamples: [OPTION_ALLOW_SEPARATE_NAMESPACE_IMPORTS],
type: "maintainability",
typescriptOnly: false,
};
public static FAILURE_STRING(module: string) {
return `Multiple imports from '${module}' can be combined into one.`;
}
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
return this.applyWithFunction(sourceFile, (ctx: Lint.WalkContext<void>) =>
walk(ctx, this.getAllowNamespaceImports()),
);
}
private getAllowNamespaceImports() {
return !!(
this.getOptions().ruleArguments.length > 0 &&
this.getOptions().ruleArguments[0] === OPTION_ALLOW_SEPARATE_NAMESPACE_IMPORTS
);
}
}
function walk(ctx: Lint.WalkContext<void>, allowNamespaceImports: boolean): void {
walkWorker(ctx, ctx.sourceFile.statements, new Set(), allowNamespaceImports);
}
function statementIsNamespaceImport(statement: ts.ImportDeclaration) {
return !!(
statement.importClause !== undefined &&
statement.importClause.namedBindings !== undefined &&
isNamespaceImport(statement.importClause.namedBindings)
);
}
function walkWorker(
ctx: Lint.WalkContext<void>,
statements: ReadonlyArray<ts.Statement>,
seen: Set<string>,
allowNamespaceImports: boolean,
): void {
for (const statement of statements) {
if (
isImportDeclaration(statement) &&
isLiteralExpression(statement.moduleSpecifier) &&
(!statementIsNamespaceImport(statement) || !allowNamespaceImports)
) {
const { text } = statement.moduleSpecifier;
if (seen.has(text)) {
ctx.addFailureAtNode(statement, Rule.FAILURE_STRING(text));
}
seen.add(text);
}
if (
isModuleDeclaration(statement) &&
statement.body !== undefined &&
statement.name.kind === ts.SyntaxKind.StringLiteral
) {
// If this is a module augmentation, re-use `seen` since those imports could be moved outside.
// If this is an ambient module, create a fresh `seen`
// because they should have separate imports to avoid becoming augmentations.
walkWorker(
ctx,
(statement.body as ts.ModuleBlock).statements,
ts.isExternalModule(ctx.sourceFile) ? seen : new Set(),
allowNamespaceImports,
);
}
}
}