@ethlete/query 6.0.0-next.5 → 6.0.0-next.50

package/generators/migrate-to-query-v3/module-graph.js

@@ -0,0 +1,153 @@
+import * as ts from 'typescript';
+import { createSourceFile } from './shared.js';
+const MAX_BARREL_DEPTH = 8;
+const normalizePath = (path) => {
+    const segments = [];
+    for (const segment of path.split('/')) {
+        if (segment === '' || segment === '.')
+            continue;
+        if (segment === '..') {
+            segments.pop();
+            continue;
+        }
+        segments.push(segment);
+    }
+    return segments.join('/');
+};
+const dirName = (path) => path.slice(0, Math.max(0, path.lastIndexOf('/')));
+const readTsConfigPaths = (tree) => {
+    const paths = new Map();
+    for (const configPath of ['tsconfig.base.json', 'tsconfig.json']) {
+        const raw = tree.read(configPath, 'utf-8');
+        if (!raw)
+            continue;
+        try {
+            // tsconfig files are JSONC in practice; the TS parser is the only thing that reliably reads
+            // them, comments and trailing commas included.
+            const parsed = ts.parseConfigFileTextToJson(configPath, raw).config;
+            Object.entries(parsed?.compilerOptions?.paths ?? {}).forEach(([key, targets]) => {
+                if (!paths.has(key))
+                    paths.set(key, targets);
+            });
+        }
+        catch {
+            // A tsconfig we cannot parse just means fewer resolvable aliases, not a failed migration.
+        }
+    }
+    return paths;
+};
+/** The files a specifier could point at, most specific first. */
+const candidateFiles = (base) => [
+    base.endsWith('.ts') ? base : `${base}.ts`,
+    `${base}/index.ts`,
+    `${base}.d.ts`,
+];
+export const createModuleGraph = (tree) => {
+    const tsConfigPaths = readTsConfigPaths(tree);
+    const declaringFileCache = new Map();
+    const resolveEntryFile = (fromFile, specifier) => {
+        if (specifier.startsWith('.')) {
+            const base = normalizePath(`${dirName(fromFile)}/${specifier}`);
+            return candidateFiles(base).find((candidate) => tree.exists(candidate)) ?? null;
+        }
+        for (const [pattern, targets] of tsConfigPaths.entries()) {
+            const wildcardIndex = pattern.indexOf('*');
+            let suffix;
+            if (wildcardIndex === -1) {
+                if (pattern !== specifier)
+                    continue;
+                suffix = '';
+            }
+            else {
+                const prefix = pattern.slice(0, wildcardIndex);
+                const patternSuffix = pattern.slice(wildcardIndex + 1);
+                if (!specifier.startsWith(prefix) || !specifier.endsWith(patternSuffix))
+                    continue;
+                suffix = specifier.slice(prefix.length, specifier.length - patternSuffix.length);
+            }
+            for (const target of targets) {
+                const resolvedTarget = normalizePath(target.replace('*', suffix));
+                const candidate = candidateFiles(resolvedTarget).find((option) => tree.exists(option));
+                if (candidate)
+                    return candidate;
+            }
+        }
+        return null;
+    };
+    const declaresSymbol = (sourceFile, symbolName) => {
+        let declares = false;
+        const isExported = (node) => ts.canHaveModifiers(node) &&
+            ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+        ts.forEachChild(sourceFile, (node) => {
+            if (declares)
+                return;
+            if (ts.isVariableStatement(node) && isExported(node)) {
+                declares = node.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === symbolName);
+                return;
+            }
+            if ((ts.isFunctionDeclaration(node) ||
+                ts.isClassDeclaration(node) ||
+                ts.isInterfaceDeclaration(node) ||
+                ts.isTypeAliasDeclaration(node) ||
+                ts.isEnumDeclaration(node)) &&
+                isExported(node) &&
+                node.name?.text === symbolName) {
+                declares = true;
+            }
+        });
+        return declares;
+    };
+    const findDeclaringFileIn = (entryFile, symbolName, depth, seen) => {
+        if (depth > MAX_BARREL_DEPTH || seen.has(`${entryFile}#${symbolName}`))
+            return null;
+        seen.add(`${entryFile}#${symbolName}`);
+        const content = tree.read(entryFile, 'utf-8');
+        if (!content)
+            return null;
+        const sourceFile = createSourceFile(content, entryFile);
+        if (declaresSymbol(sourceFile, symbolName))
+            return entryFile;
+        const starExports = [];
+        for (const node of sourceFile.statements) {
+            if (!ts.isExportDeclaration(node) || !node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) {
+                continue;
+            }
+            const nextEntry = resolveEntryFile(entryFile, node.moduleSpecifier.text);
+            if (!nextEntry)
+                continue;
+            if (!node.exportClause) {
+                starExports.push(nextEntry);
+                continue;
+            }
+            if (!ts.isNamedExports(node.exportClause))
+                continue;
+            for (const element of node.exportClause.elements) {
+                if (element.name.text !== symbolName)
+                    continue;
+                const originalName = element.propertyName?.text ?? symbolName;
+                const found = findDeclaringFileIn(nextEntry, originalName, depth + 1, seen);
+                if (found)
+                    return found;
+            }
+        }
+        for (const starExport of starExports) {
+            const found = findDeclaringFileIn(starExport, symbolName, depth + 1, seen);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    return {
+        findDeclaringFile: (fromFile, specifier, symbolName) => {
+            const cacheKey = `${fromFile}|${specifier}|${symbolName}`;
+            const cached = declaringFileCache.get(cacheKey);
+            if (cached !== undefined)
+                return cached;
+            const entryFile = resolveEntryFile(fromFile, specifier);
+            const declaringFile = entryFile ? findDeclaringFileIn(entryFile, symbolName, 0, new Set()) : null;
+            declaringFileCache.set(cacheKey, declaringFile);
+            return declaringFile;
+        },
+    };
+};
+//# sourceMappingURL=module-graph.js.map

package/generators/migrate-to-query-v3/query-client-migration.js

@@ -1,10 +1,9 @@
-import { visitNotIgnoredFiles } from '@nx/devkit';
 import * as ts from 'typescript';
-import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromQuery, getVariableStatementEnd, } from './shared.js';
-export const migrateQueryClients = (tree, report) => {
+import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromEthleteCore, ensureImportFromQuery, getVariableStatementEnd, } from './shared.js';
+export const migrateQueryClients = (tree, report, scope) => {
     const queryClientFiles = new Map();
     const variableRenames = new Map();
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts')) {
             return;
         }
@@ -69,11 +68,11 @@ export const generateQueryCreators = (tree, queryClientFiles) => {
         generatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
     }
 };
-export const updateImportsAcrossWorkspace = (tree, renames) => {
+export const updateImportsAcrossWorkspace = (tree, renames, scope) => {
     if (renames.size === 0) {
         return;
     }
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts')) {
             return;
         }
@@ -116,17 +115,25 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
     const sourceFile = createSourceFile(content, filePath);
     const replacements = [];
     const variableRenames = new Map();
+    let hasUnmigratedClient = false;
     const visit = (node) => {
-        if (ts.isNewExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === 'V2QueryClient' &&
-            node.arguments &&
-            node.arguments.length > 0) {
-            const configArgument = node.arguments[0];
-            if (ts.isObjectLiteralExpression(configArgument)) {
+        if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'V2QueryClient') {
+            const configArgument = node.arguments?.[0];
+            if (!configArgument || !ts.isObjectLiteralExpression(configArgument)) {
+                hasUnmigratedClient = true;
+                report.addManualReview({
+                    title: 'Migrate a V2QueryClient whose config is not an object literal',
+                    summary: `\`${node.getText(sourceFile)}\` passes its config indirectly, so the migration cannot read it and left the client on v2.`,
+                    action: 'Inline the config object and re-run the migration, or rewrite the client by hand as `createQueryClient({ baseUrl, name })` with provider aliases and creators.',
+                    locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 }],
+                    source: 'query-client-migration',
+                    dedupeKey: `unmigrated-client:${filePath}:${node.getStart(sourceFile)}`,
+                });
+            }
+            else {
                 const oldVariableName = getVariableNameForQueryClient(node);
-                const newVariableName = ensureConfigSuffix(oldVariableName);
-                if (oldVariableName !== newVariableName) {
+                const newVariableName = oldVariableName && ensureConfigSuffix(oldVariableName);
+                if (oldVariableName && newVariableName && oldVariableName !== newVariableName) {
                     const collisionRegex = new RegExp(`\\b(?:const|let|var)\\s+${newVariableName}\\b`);
                     if (collisionRegex.test(content)) {
                         report.addWarning({
@@ -143,6 +150,7 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
                         renamesOut.set(oldVariableName, newVariableName);
                     }
                 }
+                reportDroppedClientOptions({ configArgument, sourceFile, filePath, report });
                 replacements.push({
                     start: node.getStart(sourceFile),
                     end: node.getEnd(),
@@ -158,16 +166,20 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
     replacements.forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
     });
-    result = removeQueryClientImport(result);
+    result = removeQueryClientImport(result, hasUnmigratedClient);
     return renameVariables(result, variableRenames);
 };
-const removeQueryClientImport = (content) => {
+const removeQueryClientImport = (content, keepLegacyClient) => {
     const sourceFile = createSourceFile(content);
     let queryImportNode;
     ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportDeclaration(node) &&
+        if (!queryImportNode &&
+            ts.isImportDeclaration(node) &&
             ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text === '@ethlete/query') {
+            node.moduleSpecifier.text === '@ethlete/query' &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings) &&
+            node.importClause.namedBindings.elements.some((element) => element.name.text === 'V2QueryClient')) {
             queryImportNode = node;
         }
     });
@@ -183,10 +195,10 @@ const removeQueryClientImport = (content) => {
         return ensureImportFromQuery(content, requiredImports);
     }
     const existingElements = queryImportNode.importClause.namedBindings.elements.filter((element) => {
-        return element.name.text !== 'V2QueryClient';
+        return keepLegacyClient || element.name.text !== 'V2QueryClient';
     });
     const nextImports = new Set(requiredImports);
-    existingElements.forEach((element) => nextImports.add(element.name.text));
+    existingElements.forEach((element) => nextImports.add(element.getText(sourceFile)));
     const nextImportStatement = `import { ${Array.from(nextImports).sort().join(', ')} } from '@ethlete/query';`;
     return (content.slice(0, queryImportNode.getStart(sourceFile)) +
         nextImportStatement +
@@ -241,40 +253,113 @@ const renameVariables = (content, renames) => {
     });
     return result;
 };
+/**
+ * What each v2 client option turns into, or why it has nowhere to go.
+ *
+ * Silently dropping these is how two apps here lost their default headers without a single warning.
+ * A dropped option that shows up in the report is a five-minute fix; one that doesn't is a bug
+ * report from production.
+ */
+const DROPPED_CLIENT_OPTIONS = {
+    'request.autoRefreshQueriesOnWindowFocus': 'No direct equivalent. Re-run the affected queries yourself - `withAutoRefresh({ onSignalChanges: [windowFocusSignal] })` per query, or `injectMyClient().refreshQueriesInUse()` from a focus listener.',
+    'request.enableSmartPolling': 'No direct equivalent. `withPolling({ interval })` polls unconditionally; pause it yourself when the tab is hidden if that matters.',
+    'logging.preparedQuerySubscriptions': 'Removed. Use the v3 devtools (`provideQueryDevtools()`) or `withLogging({ logFn })` on the queries you want to trace.',
+    'logging.queryStateChanges': 'Removed. Use the v3 devtools (`provideQueryDevtools()`) or `withLogging({ logFn })` on the queries you want to trace.',
+    'request.autoRefreshOn': 'No direct equivalent. Re-run the affected queries yourself with `withAutoRefresh` or `refreshQueriesInUse()`.',
+};
+const reportDroppedClientOptions = ({ configArgument, sourceFile, filePath, report, }) => {
+    const migrated = new Set(['baseRoute', 'queryParams', 'cacheAdapter', 'retryFn', 'request', 'logging']);
+    const raise = (optionPath, node) => {
+        report.addWarning({
+            title: `Reconfigure dropped query client option "${optionPath}"`,
+            summary: `The v2 client option \`${optionPath}\` has no place in \`createQueryClient\` and was dropped by the migration.`,
+            action: DROPPED_CLIENT_OPTIONS[optionPath] ?? 'Check whether the behaviour is still needed and reimplement it.',
+            locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 }],
+            source: 'query-client-migration',
+            dedupeKey: `dropped-client-option:${filePath}:${optionPath}`,
+        });
+    };
+    const raiseSpread = (spread) => {
+        const text = spread.getText(sourceFile);
+        report.addWarning({
+            title: `Reconfigure spread query client options "${text}"`,
+            summary: `The v2 client config spreads \`${text}\`. The migration cannot see which options it holds, so none of them were carried over to \`createQueryClient\`.`,
+            action: 'Inline the spread options that are still needed (`baseRoute` becomes `baseUrl`) and re-check the result.',
+            locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(spread.getStart(sourceFile)).line + 1 }],
+            source: 'query-client-migration',
+            dedupeKey: `dropped-client-spread:${filePath}:${spread.getStart(sourceFile)}`,
+        });
+    };
+    configArgument.properties.forEach((property) => {
+        if (ts.isSpreadAssignment(property)) {
+            raiseSpread(property);
+            return;
+        }
+        if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
+            !ts.isIdentifier(property.name)) {
+            return;
+        }
+        const name = property.name.text;
+        if ((name === 'request' || name === 'logging') &&
+            ts.isPropertyAssignment(property) &&
+            ts.isObjectLiteralExpression(property.initializer)) {
+            property.initializer.properties.forEach((nested) => {
+                if (ts.isSpreadAssignment(nested)) {
+                    raiseSpread(nested);
+                    return;
+                }
+                if ((!ts.isPropertyAssignment(nested) && !ts.isShorthandPropertyAssignment(nested)) ||
+                    !ts.isIdentifier(nested.name)) {
+                    return;
+                }
+                if (name === 'request' && ['queryParams', 'cacheAdapter', 'retryFn'].includes(nested.name.text)) {
+                    return;
+                }
+                raise(`${name}.${nested.name.text}`, nested);
+            });
+            return;
+        }
+        if (!migrated.has(name)) {
+            raise(name, property);
+        }
+    });
+};
+const getPropertyValueText = (property, sourceFile) => {
+    if (ts.isShorthandPropertyAssignment(property)) {
+        return property.name.text;
+    }
+    return ts.isPropertyAssignment(property) ? property.initializer.getText(sourceFile) : undefined;
+};
+const findProperty = (objectLiteral, name) => objectLiteral.properties.find((property) => {
+    return ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
+        ts.isIdentifier(property.name) &&
+        property.name.text === name);
+});
 const migrateConfigObject = (configArgument, node, sourceFile) => {
-    const variableName = getVariableNameForQueryClient(node);
+    const variableName = getVariableNameForQueryClient(node) ?? 'client';
     const nextConfig = [];
-    const baseRouteProperty = configArgument.properties.find((property) => {
-        return ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'baseRoute';
-    });
-    if (baseRouteProperty && ts.isPropertyAssignment(baseRouteProperty)) {
-        const baseRouteValue = baseRouteProperty.initializer
-            .getText(sourceFile)
-            .replace('as `https://${string}`', '')
-            .trim();
-        nextConfig.push(`baseUrl: ${baseRouteValue}`);
+    const baseRouteProperty = findProperty(configArgument, 'baseRoute');
+    const baseRouteText = baseRouteProperty && getPropertyValueText(baseRouteProperty, sourceFile);
+    if (baseRouteText) {
+        nextConfig.push(`baseUrl: ${baseRouteText.replace('as `https://${string}`', '').trim()}`);
     }
     nextConfig.push(`name: '${variableName}'`);
-    const requestProperty = configArgument.properties.find((property) => {
-        return ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'request';
-    });
+    const requestProperty = findProperty(configArgument, 'request');
     if (requestProperty &&
         ts.isPropertyAssignment(requestProperty) &&
         ts.isObjectLiteralExpression(requestProperty.initializer)) {
-        requestProperty.initializer.properties.forEach((property) => {
-            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                return;
+        const requestConfig = requestProperty.initializer;
+        for (const [from, to] of [
+            ['queryParams', 'queryString'],
+            ['cacheAdapter', 'cacheAdapter'],
+            ['retryFn', 'retryFn'],
+        ]) {
+            const property = findProperty(requestConfig, from);
+            const valueText = property && getPropertyValueText(property, sourceFile);
+            if (valueText) {
+                nextConfig.push(`${to}: ${valueText}`);
             }
-            if (property.name.text === 'queryParams') {
-                nextConfig.push(`queryString: ${property.initializer.getText(sourceFile)}`);
-            }
-            if (property.name.text === 'cacheAdapter') {
-                nextConfig.push(`cacheAdapter: ${property.initializer.getText(sourceFile)}`);
-            }
-            if (property.name.text === 'retryFn') {
-                nextConfig.push(`retryFn: ${property.initializer.getText(sourceFile)}`);
-            }
-        });
+        }
     }
     return `createQueryClient({\n  ${nextConfig.join(',\n  ')}\n})`;
 };
@@ -286,7 +371,7 @@ const getVariableNameForQueryClient = (node) => {
         }
         parent = parent.parent;
     }
-    return 'client';
+    return undefined;
 };
 const extractClientConfigNames = (content) => {
     const sourceFile = createSourceFile(content);
@@ -326,19 +411,20 @@ const addProviderAliasesToFile = (content, configNames) => {
             return;
         }
         const { injectName, provideName } = getProviderAliasNames(variableName);
-        if (result.includes(`export const [${provideName}, ${injectName}] = ${variableName};`)) {
+        if (result.includes(`export const ${injectName} = toInjectFn(${variableName});`)) {
             return;
         }
         insertions.push({
             position,
-            text: `\n\nexport const [${provideName}, ${injectName}] = ${variableName};`,
+            text: `\n\nexport const ${provideName} = toProvideFn(${variableName});` +
+                `\nexport const ${injectName} = toInjectFn(${variableName});`,
         });
     });
     insertions.sort((left, right) => right.position - left.position);
     insertions.forEach(({ position, text }) => {
         result = result.slice(0, position) + text + result.slice(position);
     });
-    return result;
+    return insertions.length > 0 ? ensureImportFromEthleteCore(result, ['toInjectFn', 'toProvideFn']) : result;
 };
 const getProviderAliasNames = (configVariableName) => {
     const baseName = configVariableName.replace(/Config$/, '');
@@ -384,6 +470,19 @@ const generateCreatorsForConfig = (configName) => {
         `export const ${creatorBaseName}Delete = createDeleteQuery(${configVariableName});`,
     ].join('\n');
 };
+const declaresName = (declarations, name) => declarations.some((declaration) => declaration.name && ts.isIdentifier(declaration.name) && declaration.name.text === name);
+const isShadowedByLocalDeclaration = (identifier) => {
+    for (let scope = identifier.parent; scope && !ts.isSourceFile(scope); scope = scope.parent) {
+        if (ts.isFunctionLike(scope) && declaresName(scope.parameters, identifier.text)) {
+            return true;
+        }
+        if (ts.isBlock(scope) &&
+            scope.statements.some((statement) => ts.isVariableStatement(statement) && declaresName(statement.declarationList.declarations, identifier.text))) {
+            return true;
+        }
+    }
+    return false;
+};
 const updateImportsInFile = (content, renames) => {
     const sourceFile = createSourceFile(content);
     const replacements = [];
@@ -394,7 +493,7 @@ const updateImportsInFile = (content, renames) => {
             const nextElements = [];
             let hasChanges = false;
             node.importClause.namedBindings.elements.forEach((element) => {
-                const nextName = renames.get(element.name.text);
+                const nextName = renames.get(element.propertyName?.text ?? element.name.text);
                 if (!nextName) {
                     nextElements.push(element.getText(sourceFile));
                     return;
@@ -445,7 +544,7 @@ const updateImportsInFile = (content, renames) => {
                 ts.forEachChild(node, visit);
                 return;
             }
-            if (ts.isPropertyAssignment(parent) && parent.name === node) {
+            if ((ts.isPropertyAssignment(parent) && parent.name === node) || isShadowedByLocalDeclaration(node)) {
                 ts.forEachChild(node, visit);
                 return;
             }

package/generators/migrate-to-query-v3/rename-symbols.js

@@ -0,0 +1,206 @@
+import * as ts from 'typescript';
+import { createSourceFile } from './shared.js';
+/**
+ * Whether an identifier is a *name* rather than a *reference* - a declaration, a property key, the
+ * right-hand side of a member access. Renaming those is what turned `PeopleDetailDataSource.getPerson`
+ * and the `postLogin` property of a config type into `legacy…` during the first migration run.
+ */
+const isNamePosition = (node) => {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    // `foo.bar` / `Foo.Bar` - the part after the dot is never the imported binding.
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node)
+        return true;
+    if (ts.isQualifiedName(parent) && parent.right === node)
+        return true;
+    // Object literal / type member keys, enum members, JSX-ish attribute names.
+    if (ts.isPropertyAssignment(parent) && parent.name === node)
+        return true;
+    if (ts.isPropertySignature(parent) && parent.name === node)
+        return true;
+    if (ts.isMethodSignature(parent) && parent.name === node)
+        return true;
+    if (ts.isEnumMember(parent) && parent.name === node)
+        return true;
+    if (ts.isBindingElement(parent) && parent.propertyName === node)
+        return true;
+    // Declarations of any kind.
+    if (ts.isVariableDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isFunctionDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isClassDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isInterfaceDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isTypeAliasDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isEnumDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isModuleDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isMethodDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isPropertyDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isGetAccessorDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isSetAccessorDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isParameter(parent) && parent.name === node)
+        return true;
+    if (ts.isTypeParameterDeclaration(parent) && parent.name === node)
+        return true;
+    if (ts.isLabeledStatement(parent) && parent.label === node)
+        return true;
+    // Import / export clauses are rewritten by the caller, never by the reference pass.
+    if (ts.isImportSpecifier(parent))
+        return true;
+    if (ts.isExportSpecifier(parent) &&
+        (parent.parent.parent.moduleSpecifier || (parent.propertyName && parent.name === node))) {
+        return true;
+    }
+    if (ts.isImportClause(parent) || ts.isNamespaceImport(parent))
+        return true;
+    return false;
+};
+const renamedReference = (node, nextName) => {
+    const parent = node.parent;
+    if (ts.isShorthandPropertyAssignment(parent))
+        return `${node.text}: ${nextName}`;
+    if (ts.isExportSpecifier(parent) && !parent.propertyName)
+        return `${nextName} as ${node.text}`;
+    return nextName;
+};
+/** Every name the file declares itself - a local by the same name means the import is shadowed. */
+const collectLocalDeclarations = (sourceFile) => {
+    const declared = new Set();
+    const add = (name) => {
+        if (name && ts.isIdentifier(name))
+            declared.add(name.text);
+    };
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node))
+            add(node.name);
+        if (ts.isFunctionDeclaration(node))
+            add(node.name);
+        if (ts.isClassDeclaration(node))
+            add(node.name);
+        if (ts.isInterfaceDeclaration(node))
+            add(node.name);
+        if (ts.isTypeAliasDeclaration(node))
+            add(node.name);
+        if (ts.isEnumDeclaration(node))
+            add(node.name);
+        if (ts.isParameter(node))
+            add(node.name);
+        if (ts.isBindingElement(node))
+            add(node.name);
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return declared;
+};
+/**
+ * Renames references to imported bindings, and only those.
+ *
+ * `renames` maps a *local binding name* to its new name. The caller is responsible for having
+ * verified that the binding really is the symbol being migrated (see `ModuleGraph`); this pass only
+ * makes sure the rewrite lands on references rather than on same-named properties, declarations or
+ * type members. A name the file also declares locally is skipped entirely and reported back, since
+ * a rename there would silently change which value the code reads.
+ */
+export const renameImportedReferences = (content, renames) => {
+    if (renames.size === 0)
+        return { content, shadowed: [] };
+    const sourceFile = createSourceFile(content);
+    const declaredLocally = collectLocalDeclarations(sourceFile);
+    const shadowed = Array.from(renames.keys()).filter((name) => declaredLocally.has(name));
+    const applicable = new Map(Array.from(renames.entries()).filter(([name]) => !declaredLocally.has(name)));
+    if (applicable.size === 0)
+        return { content, shadowed };
+    const replacements = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node)) {
+            const nextName = applicable.get(node.text);
+            if (nextName && !isNamePosition(node)) {
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: renamedReference(node, nextName),
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    let result = content;
+    replacements.sort((left, right) => right.start - left.start);
+    replacements.forEach(({ start, end, replacement }) => {
+        result = result.slice(0, start) + replacement + result.slice(end);
+    });
+    return { content: result, shadowed };
+};
+/**
+ * Drops named imports whose local name no longer appears anywhere else in the file.
+ *
+ * The migration rewrites away the constructs that needed `def`, `AnyLegacyQueryCreator` and friends;
+ * leaving the imports behind turns every touched file into a lint error, and `formatFiles` runs in
+ * the same generator invocation so they land that way. Identifiers inside template strings count as
+ * usage too - a component referenced only from an inline template must not be pruned.
+ */
+export const pruneUnusedNamedImports = (content) => {
+    const sourceFile = createSourceFile(content);
+    const used = new Set();
+    const addWordsFrom = (text) => {
+        for (const word of text.match(/[A-Za-z_$][\w$]*/g) ?? []) {
+            used.add(word);
+        }
+    };
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && !ts.isImportSpecifier(node.parent) && !ts.isImportClause(node.parent)) {
+            used.add(node.text);
+        }
+        // A symbol referenced only from an inline template or a `styleUrl`-style string is still used.
+        if (ts.isStringLiteralLike(node) && !ts.isImportDeclaration(node.parent)) {
+            addWordsFrom(node.text);
+        }
+        if (ts.isTemplateLiteralToken(node)) {
+            addWordsFrom(node.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    const replacements = [];
+    for (const node of sourceFile.statements) {
+        if (!ts.isImportDeclaration(node) ||
+            !ts.isStringLiteral(node.moduleSpecifier) ||
+            !node.importClause?.namedBindings ||
+            !ts.isNamedImports(node.importClause.namedBindings)) {
+            continue;
+        }
+        const kept = node.importClause.namedBindings.elements.filter((element) => used.has(element.name.text));
+        if (kept.length === node.importClause.namedBindings.elements.length)
+            continue;
+        const hasDefaultImport = !!node.importClause.name;
+        if (kept.length === 0 && !hasDefaultImport) {
+            const end = content[node.getEnd()] === '\n' ? node.getEnd() + 1 : node.getEnd();
+            replacements.push({ start: node.getStart(sourceFile), end, replacement: '' });
+            continue;
+        }
+        const defaultPart = hasDefaultImport ? `${node.importClause.name.text}, ` : '';
+        replacements.push({
+            start: node.getStart(sourceFile),
+            end: node.getEnd(),
+            replacement: `import ${defaultPart}{ ${kept.map((element) => element.getText(sourceFile)).join(', ')} } from '${node.moduleSpecifier.text}';`,
+        });
+    }
+    let result = content;
+    replacements.sort((left, right) => right.start - left.start);
+    replacements.forEach(({ start, end, replacement }) => {
+        result = result.slice(0, start) + replacement + result.slice(end);
+    });
+    return result;
+};
+//# sourceMappingURL=rename-symbols.js.map