#28399466

Build Type

push

Committed by GitHub

Commit Message

<a href="https://github.com/benmosher/eslint-plugin-import/commit/<a class=hub.com/benmosher/eslint-plugin-import/commit/79ad37dfbf90869a29029b2bc556bd6108018c99">79ad37dfb<a href="https://github.com/benmosher/eslint-plugin-import/commit/79ad37dfbf90869a29029b2bc556bd6108018c99">">Merge </a><a class="double-link" href="https://github.com/benmosher/eslint-plugin-import/commit/<a class="double-link" href="https://github.com/benmosher/eslint-plugin-import/commit/44e85782da066487a4a5f5a62ae9b8d0c1d55aff">44e85782d</a>">44e85782d</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/79ad37dfbf90869a29029b2bc556bd6108018c99"> into 4a9be6384">4a9be6384</a>

Run Details

1462 of 1848 branches covered (79.11%)

1760 of 2595 relevant lines covered (67.82%)

43.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.98

/src/rules/no-duplicates.js

import resolve from 'eslint-module-utils/resolve';
import docsUrl from '../docsUrl';

function checkImports(imported, context) {
  for (const [module, nodes] of imported.entries()) {
    if (nodes.length > 1) {
      const message = `'${module}' imported multiple times.`;
      const [first, ...rest] = nodes;
      const sourceCode = context.getSourceCode();
      const fix = getFix(first, rest, sourceCode);

      context.report({
        node: first.source,
        message,
        fix, // Attach the autofix (if any) to the first import.
      });

      for (const node of rest) {
        context.report({
          node: node.source,
          message,
        });
      }
    }
  }
}

function getFix(first, rest, sourceCode) {
  // Sorry ESLint <= 3 users, no autofix for you. Autofixing duplicate imports
  // requires multiple `fixer.whatever()` calls in the `fix`: We both need to
  // update the first one, and remove the rest. Support for multiple
  // `fixer.whatever()` in a single `fix` was added in ESLint 4.1.
  // `sourceCode.getCommentsBefore` was added in 4.0, so that's an easy thing to
  // check for.
  if (typeof sourceCode.getCommentsBefore !== 'function') {
    return undefined;
  }

  // Adjusting the first import might make it multiline, which could break
  // `eslint-disable-next-line` comments and similar, so bail if the first
  // import has comments. Also, if the first import is `import * as ns from
  // './foo'` there's nothing we can do.
  if (hasProblematicComments(first, sourceCode) || hasNamespace(first)) {
    return undefined;
  }

  const defaultImportNames = new Set(
    [first, ...rest].map(getDefaultImportName).filter(Boolean)
  );

  // Bail if there are multiple different default import names – it's up to the
  // user to choose which one to keep.
  if (defaultImportNames.size > 1) {
    return undefined;
  }

  // Leave it to the user to handle comments. Also skip `import * as ns from
  // './foo'` imports, since they cannot be merged into another import.
  const restWithoutComments = rest.filter(node => !(
    hasProblematicComments(node, sourceCode) ||
    hasNamespace(node)
  ));

  const specifiers = restWithoutComments
    .map(node => {
      const tokens = sourceCode.getTokens(node);
      const openBrace = tokens.find(token => isPunctuator(token, '{'));
      const closeBrace = tokens.find(token => isPunctuator(token, '}'));

      if (openBrace == null || closeBrace == null) {
        return undefined;
      }

      return {
        importNode: node,
        text: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]),
        hasTrailingComma: isPunctuator(sourceCode.getTokenBefore(closeBrace), ','),
        isEmpty: !hasSpecifiers(node),
      };
    })
    .filter(Boolean);

  const unnecessaryImports = restWithoutComments.filter(node =>
    !hasSpecifiers(node) &&
    !hasNamespace(node) &&
    !specifiers.some(specifier => specifier.importNode === node)
  );

  const shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;
  const shouldAddSpecifiers = specifiers.length > 0;
  const shouldRemoveUnnecessary = unnecessaryImports.length > 0;

  if (!(shouldAddDefault || shouldAddSpecifiers || shouldRemoveUnnecessary)) {
    return undefined;
  }

  return fixer => {
    const tokens = sourceCode.getTokens(first);
    const openBrace = tokens.find(token => isPunctuator(token, '{'));
    const closeBrace = tokens.find(token => isPunctuator(token, '}'));
    const firstToken = sourceCode.getFirstToken(first);
    const [defaultImportName] = defaultImportNames;

    const firstHasTrailingComma =
      closeBrace != null &&
      isPunctuator(sourceCode.getTokenBefore(closeBrace), ',');
    const firstIsEmpty = !hasSpecifiers(first);

    const [specifiersText] = specifiers.reduce(
      ([result, needsComma], specifier) => {
        return [
          needsComma && !specifier.isEmpty
            ? `${result},${specifier.text}`
            : `${result}${specifier.text}`,
          specifier.isEmpty ? needsComma : true,
        ];
      },
      ['', !firstHasTrailingComma && !firstIsEmpty]
    );

    const fixes = [];

    if (shouldAddDefault && openBrace == null && shouldAddSpecifiers) {
      // `import './foo'` → `import def, {...} from './foo'`
      fixes.push(
        fixer.insertTextAfter(firstToken, ` ${defaultImportName}, {${specifiersText}} from`)
      );
    } else if (shouldAddDefault && openBrace == null && !shouldAddSpecifiers) {
      // `import './foo'` → `import def from './foo'`
      fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName} from`));
    } else if (shouldAddDefault && openBrace != null && closeBrace != null) {
      // `import {...} from './foo'` → `import def, {...} from './foo'`
      fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName},`));
      if (shouldAddSpecifiers) {
        // `import def, {...} from './foo'` → `import def, {..., ...} from './foo'`
        fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));
      }
    } else if (!shouldAddDefault && openBrace == null && shouldAddSpecifiers) {
      if (first.specifiers.length === 0) {
        // `import './foo'` → `import {...} from './foo'`
        fixes.push(fixer.insertTextAfter(firstToken, ` {${specifiersText}} from`));
      } else {
        // `import def from './foo'` → `import def, {...} from './foo'`
        fixes.push(fixer.insertTextAfter(first.specifiers[0], `, {${specifiersText}}`));
      }
    } else if (!shouldAddDefault && openBrace != null && closeBrace != null) {
      // `import {...} './foo'` → `import {..., ...} from './foo'`
      fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));
    }

    // Remove imports whose specifiers have been moved into the first import.
    for (const specifier of specifiers) {
      const importNode = specifier.importNode;
      fixes.push(fixer.remove(importNode));

      const charAfterImportRange = [importNode.range[1], importNode.range[1] + 1];
      const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);
      if (charAfterImport === '\n') {
        fixes.push(fixer.removeRange(charAfterImportRange));
      }
    }

    // Remove imports whose default import has been moved to the first import,
    // and side-effect-only imports that are unnecessary due to the first
    // import.
    for (const node of unnecessaryImports) {
      fixes.push(fixer.remove(node));

      const charAfterImportRange = [node.range[1], node.range[1] + 1];
      const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);
      if (charAfterImport === '\n') {
        fixes.push(fixer.removeRange(charAfterImportRange));
      }
    }

    return fixes;
  };
}

function isPunctuator(node, value) {
  return node.type === 'Punctuator' && node.value === value;
}

// Get the name of the default import of `node`, if any.
function getDefaultImportName(node) {
  const defaultSpecifier = node.specifiers
    .find(specifier => specifier.type === 'ImportDefaultSpecifier');
  return defaultSpecifier != null ? defaultSpecifier.local.name : undefined;
}

// Checks whether `node` has a namespace import.
function hasNamespace(node) {
  const specifiers = node.specifiers
    .filter(specifier => specifier.type === 'ImportNamespaceSpecifier');
  return specifiers.length > 0;
}

// Checks whether `node` has any non-default specifiers.
function hasSpecifiers(node) {
  const specifiers = node.specifiers
    .filter(specifier => specifier.type === 'ImportSpecifier');
  return specifiers.length > 0;
}

// It's not obvious what the user wants to do with comments associated with
// duplicate imports, so skip imports with comments when autofixing.
function hasProblematicComments(node, sourceCode) {
  return (
    hasCommentBefore(node, sourceCode) ||
    hasCommentAfter(node, sourceCode) ||
    hasCommentInsideNonSpecifiers(node, sourceCode)
  );
}

// Checks whether `node` has a comment (that ends) on the previous line or on
// the same line as `node` (starts).
function hasCommentBefore(node, sourceCode) {
  return sourceCode.getCommentsBefore(node)
    .some(comment => comment.loc.end.line >= node.loc.start.line - 1);
}

// Checks whether `node` has a comment (that starts) on the same line as `node`
// (ends).
function hasCommentAfter(node, sourceCode) {
  return sourceCode.getCommentsAfter(node)
    .some(comment => comment.loc.start.line === node.loc.end.line);
}

// Checks whether `node` has any comments _inside,_ except inside the `{...}`
// part (if any).
function hasCommentInsideNonSpecifiers(node, sourceCode) {
  const tokens = sourceCode.getTokens(node);
  const openBraceIndex = tokens.findIndex(token => isPunctuator(token, '{'));
  const closeBraceIndex = tokens.findIndex(token => isPunctuator(token, '}'));
  // Slice away the first token, since we're no looking for comments _before_
  // `node` (only inside). If there's a `{...}` part, look for comments before
  // the `{`, but not before the `}` (hence the `+1`s).
  const someTokens = openBraceIndex >= 0 && closeBraceIndex >= 0
    ? tokens.slice(1, openBraceIndex + 1).concat(tokens.slice(closeBraceIndex + 1))
    : tokens.slice(1);
  return someTokens.some(token => sourceCode.getCommentsBefore(token).length > 0);
}

module.exports = {
  meta: {
    type: 'problem',
    docs: {
      url: docsUrl('no-duplicates'),
    },
    fixable: 'code',
    schema: [
      {
        type: 'object',
        properties: {
          considerQueryString: {
            type: 'boolean',
          },
        },
        additionalProperties: false,
      },
    ],
  },

  create: function (context) {
    // Prepare the resolver from options.
    const considerQueryStringOption = context.options[0] &&
      context.options[0]['considerQueryString'];
    const defaultResolver = sourcePath => resolve(sourcePath, context) || sourcePath;
    const resolver = considerQueryStringOption ? (sourcePath => {
      const parts = sourcePath.match(/^([^?]*)\?(.*)$/);
      if (!parts) {
        return defaultResolver(sourcePath);
      }
      return defaultResolver(parts[1]) + '?' + parts[2];
    }) : defaultResolver;

    const imported = new Map();
    const nsImported = new Map();
    const defaultTypesImported = new Map();
    const namedTypesImported = new Map();

    function getImportMap(n) {
      if (n.importKind === 'type') {
        return n.specifiers.length > 0 && n.specifiers[0].type === 'ImportDefaultSpecifier' ? defaultTypesImported : namedTypesImported;
      }

      return hasNamespace(n) ? nsImported : imported;
    }

    return {
      ImportDeclaration(n) {
        // resolved path will cover aliased duplicates
        const resolvedPath = resolver(n.source.value);
        const importMap = getImportMap(n);

        if (importMap.has(resolvedPath)) {
          importMap.get(resolvedPath).push(n);
        } else {
          importMap.set(resolvedPath, [n]);
        }
      },

      'Program:exit'() {
        checkImports(imported, context);
        checkImports(nsImported, context);
        checkImports(defaultTypesImported, context);
        checkImports(namedTypesImported, context);
      },
    };
  },
};

1	import resolve from 'eslint-module-utils/resolve';
2	import docsUrl from '../docsUrl';
3
4	function checkImports(imported, context) {
5	for (const [module, nodes] of imported.entries()) {	224✔
6	if (nodes.length > 1) {	70✔
7	const message = `'${module}' imported multiple times.`;	43✔
8	const [first, ...rest] = nodes;
9	const sourceCode = context.getSourceCode();	43✔
10	const fix = getFix(first, rest, sourceCode);	43✔
11
12	context.report({	43✔
13	node: first.source,
14	message,
15	fix, // Attach the autofix (if any) to the first import.
16	});
17
18	for (const node of rest) {	43✔
19	context.report({
20	node: node.source,
21	message,
22	});
23	}
24	}
25	}
26	}
27
28	function getFix(first, rest, sourceCode) {	43✔
29	// Sorry ESLint <= 3 users, no autofix for you. Autofixing duplicate imports
30	// requires multiple `fixer.whatever()` calls in the `fix`: We both need to
31	// update the first one, and remove the rest. Support for multiple
32	// `fixer.whatever()` in a single `fix` was added in ESLint 4.1.
33	// `sourceCode.getCommentsBefore` was added in 4.0, so that's an easy thing to
34	// check for.
35	if (typeof sourceCode.getCommentsBefore !== 'function') {	43!
36	return undefined;	×
37	}
38
39	// Adjusting the first import might make it multiline, which could break
40	// `eslint-disable-next-line` comments and similar, so bail if the first
41	// import has comments. Also, if the first import is `import * as ns from
42	// './foo'` there's nothing we can do.
43	if (hasProblematicComments(first, sourceCode) \|\| hasNamespace(first)) {
44	return undefined;	4✔
45	}
46
47	const defaultImportNames = new Set(
48	[first, ...rest].map(getDefaultImportName).filter(Boolean)
49	);
50
51	// Bail if there are multiple different default import names – it's up to the
52	// user to choose which one to keep.
53	if (defaultImportNames.size > 1) {
54	return undefined;	5✔
55	}
56
57	// Leave it to the user to handle comments. Also skip `import * as ns from
58	// './foo'` imports, since they cannot be merged into another import.
59	const restWithoutComments = rest.filter(node => !(	40✔
60	hasProblematicComments(node, sourceCode) \|\|	72✔
61	hasNamespace(node)
62	));
63
64	const specifiers = restWithoutComments	34✔
65	.map(node => {
66	const tokens = sourceCode.getTokens(node);	32✔
67	const openBrace = tokens.find(token => isPunctuator(token, '{'));	82✔
68	const closeBrace = tokens.find(token => isPunctuator(token, '}'));	127✔
69
70	if (openBrace == null \|\| closeBrace == null) {	32✔
71	return undefined;	7✔
72	}
73
74	return {
75	importNode: node,
76	text: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]),
77	hasTrailingComma: isPunctuator(sourceCode.getTokenBefore(closeBrace), ','),
78	isEmpty: !hasSpecifiers(node),
79	};
80	})
81	.filter(Boolean);
82
83	const unnecessaryImports = restWithoutComments.filter(node =>
84	!hasSpecifiers(node) &&	32✔
85	!hasNamespace(node) &&
86	!specifiers.some(specifier => specifier.importNode === node)	8✔
87	);
88
89	const shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;	34✔
90	const shouldAddSpecifiers = specifiers.length > 0;	34✔
91	const shouldRemoveUnnecessary = unnecessaryImports.length > 0;	34✔
92
93	if (!(shouldAddDefault \|\| shouldAddSpecifiers \|\| shouldRemoveUnnecessary)) {	34✔
94	return undefined;	8✔
95	}
96
97	return fixer => {	26✔
98	const tokens = sourceCode.getTokens(first);	26✔
99	const openBrace = tokens.find(token => isPunctuator(token, '{'));	93✔
100	const closeBrace = tokens.find(token => isPunctuator(token, '}'));	129✔
101	const firstToken = sourceCode.getFirstToken(first);	26✔
102	const [defaultImportName] = defaultImportNames;
103
104	const firstHasTrailingComma =
105	closeBrace != null &&	26✔
106	isPunctuator(sourceCode.getTokenBefore(closeBrace), ',');
107	const firstIsEmpty = !hasSpecifiers(first);	26✔
108
109	const [specifiersText] = specifiers.reduce(
110	([result, needsComma], specifier) => {
111	return [
112	needsComma && !specifier.isEmpty	66✔
113	? `${result},${specifier.text}`
114	: `${result}${specifier.text}`,
115	specifier.isEmpty ? needsComma : true,	25✔
116	];
117	},
118	['', !firstHasTrailingComma && !firstIsEmpty]	51✔
119	);
120
121	const fixes = [];	26✔
122
123	if (shouldAddDefault && openBrace == null && shouldAddSpecifiers) {	26✔
124	// `import './foo'` → `import def, {...} from './foo'`
125	fixes.push(
126	fixer.insertTextAfter(firstToken, ` ${defaultImportName}, {${specifiersText}} from`)
127	);
128	} else if (shouldAddDefault && openBrace == null && !shouldAddSpecifiers) {	49✔
129	// `import './foo'` → `import def from './foo'`
130	fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName} from`));	1✔
131	} else if (shouldAddDefault && openBrace != null && closeBrace != null) {	78✔
132	// `import {...} from './foo'` → `import def, {...} from './foo'`
133	fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName},`));	4✔
134	if (shouldAddSpecifiers) {	4✔
135	// `import def, {...} from './foo'` → `import def, {..., ...} from './foo'`
136	fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));	1✔
137	}
138	} else if (!shouldAddDefault && openBrace == null && shouldAddSpecifiers) {	20✔
139	if (first.specifiers.length === 0) {	4✔
140	// `import './foo'` → `import {...} from './foo'`
141	fixes.push(fixer.insertTextAfter(firstToken, ` {${specifiersText}} from`));	3✔
142	} else {
143	// `import def from './foo'` → `import def, {...} from './foo'`
144	fixes.push(fixer.insertTextAfter(first.specifiers[0], `, {${specifiersText}}`));	1✔
145	}
146	} else if (!shouldAddDefault && openBrace != null && closeBrace != null) {	16✔
147	// `import {...} './foo'` → `import {..., ...} from './foo'`
148	fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));	14✔
149	}
150
151	// Remove imports whose specifiers have been moved into the first import.
152	for (const specifier of specifiers) {
153	const importNode = specifier.importNode;	25✔
154	fixes.push(fixer.remove(importNode));	25✔
155
156	const charAfterImportRange = [importNode.range[1], importNode.range[1] + 1];	25✔
157	const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);	25✔
158	if (charAfterImport === '\n') {	25✔
159	fixes.push(fixer.removeRange(charAfterImportRange));	3✔
160	}
161	}
162
163	// Remove imports whose default import has been moved to the first import,
164	// and side-effect-only imports that are unnecessary due to the first
165	// import.
166	for (const node of unnecessaryImports) {
167	fixes.push(fixer.remove(node));	7✔
168
169	const charAfterImportRange = [node.range[1], node.range[1] + 1];	7✔
170	const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);	7✔
171	if (charAfterImport === '\n') {	7✔
172	fixes.push(fixer.removeRange(charAfterImportRange));	1✔
173	}
174	}
175
176	return fixes;	26✔
177	};
178	}
179
180	function isPunctuator(node, value) {
181	return node.type === 'Punctuator' && node.value === value;	943✔
182	}
183
184	// Get the name of the default import of `node`, if any.
185	function getDefaultImportName(node) {
186	const defaultSpecifier = node.specifiers	118✔
187	.find(specifier => specifier.type === 'ImportDefaultSpecifier');	96✔
188	return defaultSpecifier != null ? defaultSpecifier.local.name : undefined;	118✔
189	}
190
191	// Checks whether `node` has a namespace import.
192	function hasNamespace(node) {
193	const specifiers = node.specifiers	186✔
194	.filter(specifier => specifier.type === 'ImportNamespaceSpecifier');	152✔
195	return specifiers.length > 0;	186✔
196	}
197
198	// Checks whether `node` has any non-default specifiers.
199	function hasSpecifiers(node) {
200	const specifiers = node.specifiers	83✔
201	.filter(specifier => specifier.type === 'ImportSpecifier');	68✔
202	return specifiers.length > 0;	83✔
203	}
204
205	// It's not obvious what the user wants to do with comments associated with
206	// duplicate imports, so skip imports with comments when autofixing.
207	function hasProblematicComments(node, sourceCode) {
208	return (
209	hasCommentBefore(node, sourceCode) \|\|	240✔
210	hasCommentAfter(node, sourceCode) \|\|
211	hasCommentInsideNonSpecifiers(node, sourceCode)
212	);
213	}
214
215	// Checks whether `node` has a comment (that ends) on the previous line or on
216	// the same line as `node` (starts).
217	function hasCommentBefore(node, sourceCode) {
218	return sourceCode.getCommentsBefore(node)	83✔
219	.some(comment => comment.loc.end.line >= node.loc.start.line - 1);	4✔
220	}
221
222	// Checks whether `node` has a comment (that starts) on the same line as `node`
223	// (ends).
224	function hasCommentAfter(node, sourceCode) {
225	return sourceCode.getCommentsAfter(node)	80✔
226	.some(comment => comment.loc.start.line === node.loc.end.line);	7✔
227	}
228
229	// Checks whether `node` has any comments _inside,_ except inside the `{...}`
230	// part (if any).
231	function hasCommentInsideNonSpecifiers(node, sourceCode) {
232	const tokens = sourceCode.getTokens(node);	77✔
233	const openBraceIndex = tokens.findIndex(token => isPunctuator(token, '{'));	208✔
234	const closeBraceIndex = tokens.findIndex(token => isPunctuator(token, '}'));	313✔
235	// Slice away the first token, since we're no looking for comments _before_
236	// `node` (only inside). If there's a `{...}` part, look for comments before
237	// the `{`, but not before the `}` (hence the `+1`s).
238	const someTokens = openBraceIndex >= 0 && closeBraceIndex >= 0	77✔
239	? tokens.slice(1, openBraceIndex + 1).concat(tokens.slice(closeBraceIndex + 1))	77✔
240	: tokens.slice(1);
241	return someTokens.some(token => sourceCode.getCommentsBefore(token).length > 0);	262✔
242	}
243
244	module.exports = {
245	meta: {
246	type: 'problem',
247	docs: {
248	url: docsUrl('no-duplicates'),
249	},
250	fixable: 'code',
251	schema: [
252	{
253	type: 'object',
254	properties: {
255	considerQueryString: {
256	type: 'boolean',
257	},
258	},
259	additionalProperties: false,
260	},
261	],
262	},
263
264	create: function (context) {
265	// Prepare the resolver from options.
266	const considerQueryStringOption = context.options[0] &&	56✔
267	context.options[0]['considerQueryString'];
268	const defaultResolver = sourcePath => resolve(sourcePath, context) \|\| sourcePath;	119✔
269	const resolver = considerQueryStringOption ? (sourcePath => {	56✔
270	const parts = sourcePath.match(/^([^?])\?(.)$/);	6✔
271	if (!parts) {	6✔
272	return defaultResolver(sourcePath);	2✔
273	}
274	return defaultResolver(parts[1]) + '?' + parts[2];	4✔
275	}) : defaultResolver;
276
277	const imported = new Map();	56✔
278	const nsImported = new Map();	56✔
279	const defaultTypesImported = new Map();	56✔
280	const namedTypesImported = new Map();	56✔
281
282	function getImportMap(n) {
283	if (n.importKind === 'type') {	119✔
284	return n.specifiers.length > 0 && n.specifiers[0].type === 'ImportDefaultSpecifier' ? defaultTypesImported : namedTypesImported;	17✔
285	}
286
287	return hasNamespace(n) ? nsImported : imported;	102✔
288	}
289
290	return {
291	ImportDeclaration(n) {
292	// resolved path will cover aliased duplicates
293	const resolvedPath = resolver(n.source.value);	119✔
294	const importMap = getImportMap(n);	119✔
295
296	if (importMap.has(resolvedPath)) {	119✔
297	importMap.get(resolvedPath).push(n);	49✔
298	} else {
299	importMap.set(resolvedPath, [n]);	70✔
300	}
301	},
302
303	'Program:exit'() {
304	checkImports(imported, context);	56✔
305	checkImports(nsImported, context);	56✔
306	checkImports(defaultTypesImported, context);	56✔
307	checkImports(namedTypesImported, context);	56✔
308	},
309	};
310	},
311	};

benmosher / eslint-plugin-import / #28399466

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous