eslint-plugin-sonarjs 4.0.2 → 4.1.0

package/cjs/helpers/module.js

@@ -1,46 +1,136 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isESModule = isESModule;
 exports.getImportDeclarations = getImportDeclarations;
-exports.getRequireCalls = getRequireCalls;
+exports.clearFileCaches = clearFileCaches;
+exports.getCurrentFileImports = getCurrentFileImports;
+exports.importsModule = importsModule;
+exports.importsOrDependsOnModule = importsOrDependsOnModule;
 exports.isRequire = isRequire;
 exports.getFullyQualifiedName = getFullyQualifiedName;
 exports.removeNodePrefixIfExists = removeNodePrefixIfExists;
 exports.reduceToIdentifier = reduceToIdentifier;
 const ast_js_1 = require("./ast.js");
+const dependencies_js_1 = require("./dependency-manifests/dependencies.js");
+function getImportDeclarations(context) {
+    return context.sourceCode.ast.body.filter(node => node.type === 'ImportDeclaration');
+}
 /**
- * Checks if the current file is an ES module based on sourceType.
+ * Cache for storing the set of all module names imported or required in the file currently being analyzed.
+ * This set is only needed while the current file is being analyzed.
  *
- * The parser sets sourceType based on file extension (.mjs/.cjs),
- * package.json "type" field, and ESLint configuration.
+ * Keyed by the `sourceCode` object reference rather than a boolean flag so that the cache
+ * self-invalidates when ESLint's RuleTester switches between test cases (each case gets a fresh
+ * SourceCode instance).
  */
-function isESModule(context) {
-    return context.sourceCode.ast.sourceType === 'module';
-}
-function getImportDeclarations(context) {
-    if (isESModule(context)) {
-        return context.sourceCode.ast.body.filter(node => node.type === 'ImportDeclaration');
+const CURRENT_FILE_IMPORTS = {
+    sourceCode: null,
+    imports: new Set(),
+};
+/**
+ * Compute the set of all module names imported or required
+ * in the file currently being analyzed (via import declarations, require(), or dynamic import()).
+ *
+ * Supported patterns:
+ * import foo from 'lodash';
+ * const lodash = require('lodash');
+ * const partition = require('lodash').partition;
+ * const lodash = import('lodash');
+ * const lodash = await import('lodash');
+ *
+ * Unsupported patterns (not stored in a variable):
+ * require('lodash');
+ * import('lodash').then(lodash => ...);
+ */
+function computeCurrentFileImports(sourceCode) {
+    if (CURRENT_FILE_IMPORTS.sourceCode === sourceCode) {
+        return;
     }
-    return [];
-}
-function getRequireCalls(context) {
-    const required = [];
-    const { scopeManager } = context.sourceCode;
-    for (const scope of scopeManager.scopes) {
+    CURRENT_FILE_IMPORTS.sourceCode = sourceCode;
+    CURRENT_FILE_IMPORTS.imports.clear();
+    for (const node of sourceCode.ast.body) {
+        if (node.type === 'ImportDeclaration' && typeof node.source.value === 'string') {
+            CURRENT_FILE_IMPORTS.imports.add(node.source.value);
+        }
+    }
+    for (const scope of sourceCode.scopeManager.scopes) {
         for (const variable of scope.variables) {
             for (const def of variable.defs) {
                 if (def.type === 'Variable' && def.node.init) {
-                    if (isRequire(def.node.init)) {
-                        required.push(def.node.init);
-                    }
-                    else if (def.node.init.type === 'MemberExpression' && isRequire(def.node.init.object)) {
-                        required.push(def.node.init.object);
+                    const name = getRequireModuleName(def.node.init) ?? getDynamicImportModuleName(def.node.init);
+                    if (name !== undefined) {
+                        CURRENT_FILE_IMPORTS.imports.add(name);
                     }
                 }
             }
         }
     }
-    return required;
+}
+/**
+ * Clears the caches related to the given source file
+ */
+function clearFileCaches() {
+    CURRENT_FILE_IMPORTS.sourceCode = null;
+    CURRENT_FILE_IMPORTS.imports.clear();
+    (0, dependencies_js_1.setCurrentFileInlineDependencies)(null);
+}
+function getCurrentFileImports(sourceCode) {
+    computeCurrentFileImports(sourceCode);
+    return CURRENT_FILE_IMPORTS.imports;
+}
+function getRequireModuleName(node) {
+    const requireCall = getRequireCall(node);
+    const moduleName = requireCall?.arguments[0];
+    if (moduleName?.type === 'Literal' && typeof moduleName.value === 'string') {
+        return moduleName.value;
+    }
+    return undefined;
+}
+function getRequireCall(node) {
+    if (isRequire(node)) {
+        return node;
+    }
+    if (node.type === 'MemberExpression' && isRequire(node.object)) {
+        return node.object;
+    }
+    return undefined;
+}
+function getDynamicImportModuleName(node) {
+    const dynamicImportExpression = getDynamicImportExpression(node);
+    const moduleName = dynamicImportExpression?.source;
+    if (moduleName?.type === 'Literal' && typeof moduleName.value === 'string') {
+        return moduleName.value;
+    }
+    return undefined;
+}
+function getDynamicImportExpression(node) {
+    if (node.type === 'ImportExpression') {
+        return node;
+    }
+    if (node.type === 'AwaitExpression' && node.argument.type === 'ImportExpression') {
+        return node.argument;
+    }
+    return undefined;
+}
+/**
+ * Checks if the file imports any of the specified modules, either via require() calls or import declarations.
+ */
+function importsModule(context, moduleNames) {
+    if (moduleNames.length === 0) {
+        return false;
+    }
+    const imports = getCurrentFileImports(context.sourceCode);
+    return moduleNames.some(name => imports.has(name));
+}
+/**
+ * Checks if at least one of the specified imports is imported (via import or require) in the file
+ * or if at least one of the specified dependencies is listed in the corresponding dependency manifest.
+ */
+function importsOrDependsOnModule(context, imports, dependencies) {
+    if (importsModule(context, imports)) {
+        return true;
+    }
+    const sanitizedDeps = (0, dependencies_js_1.getDependenciesSanitizePaths)(context);
+    return dependencies.some(dependency => sanitizedDeps.has(dependency));
 }
 function isRequire(node) {
     return (node.type === 'CallExpression' &&
@@ -257,6 +347,9 @@ function reduceTo(type, node, fqn = []) {
         else if (nodeToCheck.type === 'CallExpression' && !getModuleNameFromRequire(nodeToCheck)) {
             nodeToCheck = nodeToCheck.callee;
         }
+        else if (nodeToCheck.type === 'TaggedTemplateExpression') {
+            nodeToCheck = nodeToCheck.tag;
+        }
         else if (nodeToCheck.type === 'NewExpression') {
             nodeToCheck = nodeToCheck.callee;
         }

package/cjs/helpers/numbers.js

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExactlyRepresentableAsBinaryFraction = isExactlyRepresentableAsBinaryFraction;
+exports.isExactlyRepresentableIntegerDivision = isExactlyRepresentableIntegerDivision;
+exports.greatestCommonDivisor = greatestCommonDivisor;
+exports.isPowerOfTwo = isPowerOfTwo;
+const decimalLiteralPattern = /^(\d*)(?:\.(\d*))?(?:e([+-]?\d+))?$/u;
+function isExactlyRepresentableAsBinaryFraction(raw) {
+    const match = decimalLiteralPattern.exec(raw);
+    if (!match) {
+        return false;
+    }
+    const [, integerPart, fractionalPart = '', exponentPart] = match;
+    const digits = `${integerPart}${fractionalPart}`;
+    if (digits === '') {
+        return false;
+    }
+    const exponent = Number(exponentPart ?? 0) - fractionalPart.length;
+    const numerator = BigInt(digits);
+    if (numerator === 0n || exponent >= 0) {
+        return true;
+    }
+    const denominator = 10n ** BigInt(-exponent);
+    const reducedDenominator = denominator / greatestCommonDivisor(numerator, denominator);
+    return isPowerOfTwo(reducedDenominator);
+}
+function isExactlyRepresentableIntegerDivision(leftValue, rightValue) {
+    if (!Number.isSafeInteger(leftValue) || !Number.isSafeInteger(rightValue) || rightValue === 0) {
+        return false;
+    }
+    const numerator = BigInt(Math.abs(leftValue));
+    const denominator = BigInt(Math.abs(rightValue));
+    const reducedDenominator = denominator / greatestCommonDivisor(numerator, denominator);
+    return isPowerOfTwo(reducedDenominator);
+}
+function greatestCommonDivisor(left, right) {
+    let a = left;
+    let b = right;
+    while (b !== 0n) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+function isPowerOfTwo(value) {
+    return value > 0n && (value & (value - 1n)) === 0n;
+}

package/cjs/helpers/playwright.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDescribe = isDescribe;
+const ast_js_1 = require("./ast.js");
+const describeModifiers = ['parallel', 'serial'];
+function isDescribe(node) {
+    if (node?.type !== 'MemberExpression' || node.computed) {
+        return false;
+    }
+    const { object, property } = node;
+    return (((0, ast_js_1.isIdentifier)(object, 'test') && (0, ast_js_1.isIdentifier)(property, 'describe')) ||
+        ((0, ast_js_1.isIdentifier)(property, ...describeModifiers) && isDescribe(object)));
+}

package/cjs/helpers/recognizers/Detector.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 /*
  * SonarQube JavaScript Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of

package/cjs/helpers/recognizers/detectors/CamelCaseDetector.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /*
  * SonarQube JavaScript Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of

package/cjs/helpers/recognizers/detectors/ContainsDetector.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /*
  * SonarQube JavaScript Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of

package/cjs/helpers/recognizers/detectors/EndWithDetector.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /*
  * SonarQube JavaScript Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of

package/cjs/helpers/recognizers/detectors/KeywordsDetector.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /*
  * SonarQube JavaScript Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of

package/cjs/helpers/regex/extract.js

@@ -58,34 +58,46 @@ function getPatternFromNode(node, context) {
         if (patternOnly && flags !== null) {
             // if we can't extract flags correctly, we skip this
             // to avoid FPs
-            return { pattern: patternOnly.pattern, flags };
+            return { ...patternOnly, flags };
         }
     }
     else if ((0, ast_js_1.isRegexLiteral)(node)) {
-        return node.regex;
+        return literalPattern(node.regex.pattern, node.regex.flags);
     }
     else if ((0, ast_js_1.isStringLiteral)(node)) {
-        return { pattern: node.value, flags: '' };
+        return literalPattern(node.value);
     }
     else if ((0, ast_js_1.isStaticTemplateLiteral)(node)) {
-        return { pattern: node.quasis[0].value.raw, flags: '' };
+        return literalPattern(node.quasis[0].value.raw);
     }
     else if ((0, ast_js_1.isSimpleRawString)(node)) {
-        return { pattern: (0, ast_js_1.getSimpleRawStringValue)(node), flags: '' };
+        return literalPattern((0, ast_js_1.getSimpleRawStringValue)(node));
     }
     else if ((0, ast_js_1.isIdentifier)(node)) {
         const assignedExpression = (0, ast_js_1.getUniqueWriteUsage)(context, node.name, node);
         if (assignedExpression &&
             assignedExpression.parent?.type === 'VariableDeclarator') {
-            return getPatternFromNode(assignedExpression, context);
+            const pattern = getPatternFromNode(assignedExpression, context);
+            return pattern ? { ...pattern, isPureLiteral: false } : null;
         }
     }
     else if ((0, ast_js_1.isBinaryPlus)(node)) {
         const left = getPatternFromNode(node.left, context);
         const right = getPatternFromNode(node.right, context);
-        if (left && right) {
-            return { pattern: left.pattern + right.pattern, flags: '' };
-        }
+        return left && right ? concatPatterns(left, right) : null;
     }
     return null;
 }
+function literalPattern(pattern, flags = '') {
+    return { pattern, flags, seams: [], isPureLiteral: true };
+}
+function concatPatterns(left, right) {
+    const splitOffset = left.pattern.length;
+    const splitSeams = left.isPureLiteral && right.isPureLiteral ? [] : [splitOffset];
+    return {
+        pattern: left.pattern + right.pattern,
+        flags: '',
+        seams: [...left.seams, ...splitSeams, ...right.seams.map(s => s + splitOffset)],
+        isPureLiteral: left.isPureLiteral && right.isPureLiteral,
+    };
+}

package/cjs/helpers/regex/flags.js

@@ -8,18 +8,25 @@ function getFlags(callExpr, context) {
         return '';
     }
     const flags = callExpr.arguments[1];
-    // Matches flags in: new RegExp(pattern, 'u')
-    if ((0, ast_js_1.isStringLiteral)(flags)) {
-        return flags.value;
+    const staticFlags = getStaticFlagsValue(flags);
+    if (staticFlags !== null) {
+        return staticFlags;
     }
     if (flags.type === 'Identifier' && context !== undefined) {
         // it's a variable, so we try to extract its value, but only if it's written once (const)
         const variable = (0, reaching_definitions_js_1.getVariableFromIdentifier)(flags, context.sourceCode.getScope(callExpr));
         const ref = (0, ast_js_1.getUniqueWriteReference)(variable);
-        if (ref !== undefined && (0, ast_js_1.isStringLiteral)(ref)) {
-            return ref.value;
+        if (ref !== undefined) {
+            return getStaticFlagsValue(ref);
         }
     }
+    return null;
+}
+function getStaticFlagsValue(flags) {
+    // Matches flags in: new RegExp(pattern, 'u')
+    if ((0, ast_js_1.isStringLiteral)(flags)) {
+        return flags.value;
+    }
     // Matches flags with basic template literals as in: new RegExp(pattern, `u`)
     // but not: new RegExp(pattern, `${flag}`)
     // The cooked value should always be non-null in this case.

package/cjs/helpers/sinon.js

@@ -3,15 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImported = isImported;
 exports.isAssertion = isAssertion;
 exports.isTSAssertion = isTSAssertion;
 const module_js_1 = require("./module.js");
 const module_ts_js_1 = require("./module-ts.js");
 const typescript_1 = __importDefault(require("typescript"));
-function isImported(context) {
-    return ((0, module_js_1.getRequireCalls)(context).some(r => r.arguments[0].type === 'Literal' && r.arguments[0].value === 'sinon') || (0, module_js_1.getImportDeclarations)(context).some(i => i.source.value === 'sinon'));
-}
 function isAssertion(context, node) {
     return isAssertUsage(context, node);
 }

package/cjs/helpers/supertest.js

@@ -3,15 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImported = isImported;
 exports.isAssertion = isAssertion;
 exports.isTSAssertion = isTSAssertion;
 const module_js_1 = require("./module.js");
 const module_ts_js_1 = require("./module-ts.js");
 const typescript_1 = __importDefault(require("typescript"));
-function isImported(context) {
-    return ((0, module_js_1.getRequireCalls)(context).some(r => r.arguments[0].type === 'Literal' && r.arguments[0].value === 'supertest') || (0, module_js_1.getImportDeclarations)(context).some(i => i.source.value === 'supertest'));
-}
 function isAssertion(context, node) {
     const fqn = extractFQNForCallExpression(context, node);
     return isFQNAssertion(fqn);

package/cjs/helpers/test-file-pattern.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TEST_FILE_EXTENSIONS = void 0;
+exports.isTestFile = isTestFile;
+exports.isTestRelatedFile = isTestRelatedFile;
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+exports.DEFAULT_TEST_FILE_EXTENSIONS = [
+    '.js',
+    '.mjs',
+    '.cjs',
+    '.jsx',
+    '.vue',
+    '.ts',
+    '.mts',
+    '.cts',
+    '.tsx',
+];
+function suffixAlternation(extensions) {
+    const effective = extensions?.length ? extensions : exports.DEFAULT_TEST_FILE_EXTENSIONS;
+    return effective.map(ext => (ext.startsWith('.') ? ext.slice(1) : ext)).join('|');
+}
+function testFilePattern(extensions) {
+    return new RegExp(String.raw `\.(?:test|spec|cy)\.(?:${suffixAlternation(extensions)})$`);
+}
+function testRelatedFilePattern(extensions) {
+    const alternation = suffixAlternation(extensions);
+    return new RegExp(String.raw `\.(?:test|spec|cy)\.(?:${alternation})$|\.(?:e2e|mock)\.(?:${alternation})$|(?:^|[\\/])(?:__tests__|__mocks__)[\\/]`);
+}
+/**
+ * Checks whether a file path matches a test file pattern.
+ *
+ * @param filePath the file path to test.
+ * @param extensions the allowed test file extensions.
+ * @returns true when the path looks like a test file.
+ */
+function isTestFile(filePath, extensions) {
+    return testFilePattern(extensions).test(filePath);
+}
+/**
+ * Checks whether a file path looks test-related.
+ *
+ * @param filePath the file path to test.
+ * @param extensions the allowed test file extensions.
+ * @returns true when the path looks test-related.
+ */
+function isTestRelatedFile(filePath, extensions) {
+    return testRelatedFilePattern(extensions).test(filePath);
+}

package/cjs/helpers/type-origin.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyTypesByOrigin = classifyTypesByOrigin;
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Partitions the syntactic members of a type annotation into "internal"
+ * (user-writable in this project) and "external" (declared in node_modules
+ * or in the TypeScript default lib).
+ *
+ * Operates on the syntactic AST node, not on a resolved `ts.Type`. Returning
+ * the original AST nodes lets callers produce locations, suggestions, or
+ * fixes targeting exactly what the user wrote.
+ *
+ * Classification rules per top-level member:
+ * - Keyword / literal types -> internal (the user wrote them directly).
+ * - TSTypeReference -> resolves the type name to a symbol and inspects its
+ *   declarations. A reference is external only when ALL declarations live in
+ *   files that satisfy `isSourceFileFromExternalLibrary` or
+ *   `isSourceFileDefaultLibrary`. Any local declaration (declaration-merging
+ *   escape hatch) makes the reference internal.
+ * - Any other composite constructor (TSIntersectionType, TSArrayType,
+ *   TSTypeLiteral, TSConditionalType, ...) -> internal at the top level. We
+ *   do not recurse; callers can if they need to.
+ *
+ * Known limitation: alias chains are not followed. If the user re-aliases an
+ * external type locally (e.g. `type Inner = ReactNode`), the local alias is
+ * internal because the user has a place to edit.
+ */
+function classifyTypesByOrigin(typeNode, services) {
+    const members = typeNode.type === 'TSUnionType' ? typeNode.types : [typeNode];
+    const result = { internal: [], external: [] };
+    for (const member of members) {
+        if (isExternalMember(member, services)) {
+            result.external.push(member);
+        }
+        else {
+            result.internal.push(member);
+        }
+    }
+    return result;
+}
+function isExternalMember(member, services) {
+    if (member.type !== 'TSTypeReference') {
+        return false;
+    }
+    const checker = services.program.getTypeChecker();
+    const tsNode = services.esTreeNodeToTSNodeMap.get(member);
+    let symbol = checker.getSymbolAtLocation(tsNode.typeName);
+    // Imported names resolve to a local alias symbol pointing at the import
+    // statement; without following the alias, external imports would look local.
+    if (symbol && symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    if (!symbol?.declarations?.length) {
+        return false;
+    }
+    const program = services.program;
+    return symbol.declarations.every(decl => {
+        const sourceFile = decl.getSourceFile();
+        return (program.isSourceFileFromExternalLibrary(sourceFile) ||
+            program.isSourceFileDefaultLibrary(sourceFile));
+    });
+}