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

package/generators/generators.json

@@ -24,6 +24,11 @@
       "factory": "./migrate-query-opt-in-features/migration",
       "schema": "./migrate-query-opt-in-features/schema.json",
       "description": "Migrate query clients to the opt-in error pipeline and bearer auth providers to the opt-in multi-tab sync feature"
+    },
+    "migrate-from-ngrx-toolkit": {
+      "factory": "./migrate-from-ngrx-toolkit/migration",
+      "schema": "./migrate-from-ngrx-toolkit/schema.json",
+      "description": "Move @tomtomb/ngrx-toolkit features onto v3 query creators and the @ethlete/query/ngrx-toolkit interop"
     }
   }
 }

package/generators/migrate-from-ngrx-toolkit/args-assignability.js

@@ -0,0 +1,140 @@
+import { dirname } from 'node:path';
+import * as ts from 'typescript';
+const TOOLKIT_PROBE = '__EtToolkitArgs';
+const CREATOR_PROBE = '__EtCreatorArgs';
+const PROBE_FILE = '/__et_args_probe__.ts';
+const MAX_DEPTH = 12;
+const PROBE_SOURCE = `
+import type { ${TOOLKIT_PROBE} as ToolkitArgs } from '__toolkit__';
+import type { ${CREATOR_PROBE} as CreatorArgs } from '__creator__';
+
+type OptionalNullAsUndefined<T> = {
+  [K in keyof T]: undefined extends T[K] ? OptionalNullAsUndefined<Exclude<T[K], null>> : OptionalNullAsUndefined<T[K]>;
+};
+
+export type ToolkitSide = OptionalNullAsUndefined<{
+  [K in keyof ToolkitArgs as K extends 'params' ? 'queryParams' : K extends 'body' ? K : never]: ToolkitArgs[K];
+}>;
+export type CreatorSide = OptionalNullAsUndefined<{
+  [K in keyof CreatorArgs as K extends 'queryParams' | 'body' ? K : never]: CreatorArgs[K];
+}>;
+`;
+const COMPILER_OPTIONS = {
+    strict: true,
+    noEmit: true,
+    skipLibCheck: true,
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    lib: ['lib.es2022.d.ts'],
+    types: [],
+};
+const toTreePath = (fileName) => fileName.replace(/^\//, '');
+const containsAny = (checker, type, seen, depth) => {
+    if (type.flags & ts.TypeFlags.Any)
+        return true;
+    if (seen.has(type) || depth > MAX_DEPTH)
+        return false;
+    seen.add(type);
+    if (type.isUnionOrIntersection())
+        return type.types.some((part) => containsAny(checker, part, seen, depth + 1));
+    if (!(type.flags & ts.TypeFlags.Object))
+        return false;
+    const typeArguments = type.objectFlags & ts.ObjectFlags.Reference
+        ? checker.getTypeArguments(type)
+        : [];
+    return (typeArguments.some((argument) => containsAny(checker, argument, seen, depth + 1)) ||
+        checker
+            .getPropertiesOfType(type)
+            .some((property) => containsAny(checker, checker.getTypeOfSymbol(property), seen, depth + 1)));
+};
+const isRecord = (checker, type) => (type.isIntersection() ? type.types : [type]).every((part) => !!(part.flags & ts.TypeFlags.Object)) &&
+    !checker.isArrayType(type) &&
+    !checker.isTupleType(type) &&
+    checker.getSignaturesOfType(type, ts.SignatureKind.Call).length === 0;
+const hasEveryKey = (checker, source, target, seen, depth) => {
+    const from = checker.getNonNullableType(source);
+    const to = checker.getNonNullableType(target);
+    if (seen.has(from) || depth > MAX_DEPTH || !isRecord(checker, from) || !isRecord(checker, to))
+        return true;
+    seen.add(from);
+    return checker.getPropertiesOfType(from).every((property) => {
+        const counterpart = checker.getPropertyOfType(to, property.name);
+        return (!!counterpart &&
+            hasEveryKey(checker, checker.getTypeOfSymbol(property), checker.getTypeOfSymbol(counterpart), seen, depth + 1));
+    });
+};
+export const toolkitArgsFitCreator = (tree, graph, toolkit, creator) => {
+    if (toolkit.file === creator.file)
+        return false;
+    const appended = new Map([
+        [toolkit.file, `\nexport type ${TOOLKIT_PROBE} = ${toolkit.typeText ?? '{}'};\n`],
+        [creator.file, `\nexport type ${CREATOR_PROBE} = ${creator.typeText ?? '{}'};\n`],
+    ]);
+    const libDirectory = dirname(ts.getDefaultLibFilePath(COMPILER_OPTIONS));
+    const readFile = (fileName) => {
+        if (fileName === PROBE_FILE)
+            return PROBE_SOURCE;
+        if (fileName.startsWith(libDirectory))
+            return ts.sys.readFile(fileName);
+        const path = toTreePath(fileName);
+        const content = tree.read(path, 'utf-8');
+        return content === null ? undefined : content + (appended.get(path) ?? '');
+    };
+    const fileExists = (fileName) => fileName === PROBE_FILE ||
+        (fileName.startsWith(libDirectory) ? ts.sys.fileExists(fileName) : tree.isFile(toTreePath(fileName)));
+    const resolutionHost = {
+        fileExists,
+        readFile,
+        directoryExists: (name) => tree.exists(toTreePath(name)) && !tree.isFile(toTreePath(name)),
+        getCurrentDirectory: () => '/',
+    };
+    const resolveOne = (name, containingFile) => {
+        const workspaceFile = containingFile === PROBE_FILE
+            ? name === '__toolkit__'
+                ? toolkit.file
+                : name === '__creator__'
+                    ? creator.file
+                    : null
+            : graph.resolveFile(toTreePath(containingFile), name);
+        if (workspaceFile)
+            return { resolvedFileName: `/${workspaceFile}`, extension: ts.Extension.Ts };
+        return ts.resolveModuleName(name, containingFile, COMPILER_OPTIONS, resolutionHost).resolvedModule;
+    };
+    const host = {
+        ...resolutionHost,
+        getSourceFile: (fileName, languageVersion) => {
+            const text = readFile(fileName);
+            return text === undefined ? undefined : ts.createSourceFile(fileName, text, languageVersion, true);
+        },
+        getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+        writeFile: () => undefined,
+        getCanonicalFileName: (fileName) => fileName,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => '\n',
+        resolveModuleNameLiterals: (literals, containingFile) => literals.map((literal) => ({ resolvedModule: resolveOne(literal.text, containingFile) })),
+    };
+    const program = ts.createProgram({ rootNames: [PROBE_FILE], options: COMPILER_OPTIONS, host });
+    const checker = program.getTypeChecker();
+    const probe = program.getSourceFile(PROBE_FILE);
+    const exportsOf = probe ? checker.getSymbolAtLocation(probe) : undefined;
+    const typeOf = (name) => {
+        const symbol = exportsOf ? checker.getExportsOfModule(exportsOf).find((each) => each.name === name) : undefined;
+        return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
+    };
+    const toolkitSide = typeOf('ToolkitSide');
+    const creatorSide = typeOf('CreatorSide');
+    if (!toolkitSide || !creatorSide)
+        return false;
+    if (containsAny(checker, toolkitSide, new Set(), 0) || containsAny(checker, creatorSide, new Set(), 0))
+        return false;
+    const keys = (type) => checker
+        .getPropertiesOfType(type)
+        .map((property) => property.name)
+        .sort()
+        .join(',');
+    return (keys(toolkitSide) === keys(creatorSide) &&
+        checker.isTypeAssignableTo(toolkitSide, creatorSide) &&
+        hasEveryKey(checker, toolkitSide, creatorSide, new Set(), 0));
+};
+//# sourceMappingURL=args-assignability.js.map

package/generators/migrate-from-ngrx-toolkit/consumers.js

@@ -0,0 +1,453 @@
+import * as ts from 'typescript';
+import { createSourceFile, ensureNamedImports } from '../migrate-to-query-v3/shared.js';
+import { INTEROP_MODULE } from './facade.js';
+import { TOOLKIT_MODULE } from './feature.js';
+import { applyEdits, collectUsedIdentifiers, lineOf, removeStatement } from './ts-edits.js';
+export const CONSUMER_TASK = {
+    UNSUPPORTED_IMPORT: 'NTK-UNSUPPORTED-IMPORT',
+    UNCONVERTED_ACTION_GROUP: 'NTK-UNCONVERTED-ACTION-GROUP',
+    SELECT_BY_ACTION_ID: 'NTK-SELECT-BY-ACTION-ID',
+    AUTH_INTERCEPTOR: 'NTK-AUTH-INTERCEPTOR',
+};
+const defineConsumerTasks = (report) => {
+    report.define(CONSUMER_TASK.UNSUPPORTED_IMPORT, {
+        title: 'Toolkit symbol without an interop counterpart',
+        action: '`@ethlete/query/ngrx-toolkit` does not export the listed symbols, so the file still imports them from `@tomtomb/ngrx-toolkit`. Rewrite the code that uses them, then drop the import.',
+    });
+    report.define(CONSUMER_TASK.UNCONVERTED_ACTION_GROUP, {
+        title: 'Consumer types name an action group that is still on the toolkit',
+        action: 'The file was left on `@tomtomb/ngrx-toolkit` because a `MappedEntityState` / `ActionCallArgs` type names an action group whose feature was not converted. Resolve that feature’s task, then re-run the generator.',
+    });
+    report.define(CONSUMER_TASK.SELECT_BY_ACTION_ID, {
+        title: 'Handle looked up by action id',
+        action: 'The interop has no action ids. Pass the args instead and look the handle up with `toolkitSelect(creator, args, { injector })` - equal args return the handle `toolkitCall` created.',
+    });
+    report.define(CONSUMER_TASK.AUTH_INTERCEPTOR, {
+        title: 'HTTP interceptor attaches the bearer token',
+        action: 'v3 secure creators already send the token, so this interceptor sends it twice, and it adds it to every other `HttpClient` call too - third-party hosts included. Delete it and its registration. Requests it skipped must use public creators: pass their prefixes as `--publicRoutes` and re-run.',
+    });
+};
+const INTEROP_SYMBOLS = new Set([
+    'toolkitCall',
+    'toolkitSelect',
+    'MappedEntityState',
+    'ActionCallArgs',
+    'ToolkitError',
+    'CallState',
+    'SuspensePipe',
+    'SuspenseMultiPipe',
+    'NgRxToolkitModule',
+    'joinLoading',
+    'joinErrors',
+]);
+const RENAMED_SYMBOLS = new Map([['Error', 'ToolkitError']]);
+const STORE_SIDE_SYMBOLS = new Set([
+    'FacadeBase',
+    'EffectBase',
+    'ServiceBase',
+    'createHttpActionGroup',
+    'createReducerSlice',
+    'createEntitySelectors',
+    'defineArgTypes',
+    'defineResponseType',
+]);
+const HANDLE_TYPES = new Set(['MappedEntityState', 'ActionCallArgs']);
+const code = (text) => (text.includes('`') ? `\`\` ${text} \`\`` : `\`${text}\``);
+const toolkitImportsOf = (sourceFile) => sourceFile.statements.filter((statement) => ts.isImportDeclaration(statement) &&
+    ts.isStringLiteral(statement.moduleSpecifier) &&
+    statement.moduleSpecifier.text === TOOLKIT_MODULE);
+const elementsOf = (declaration) => {
+    const bindings = declaration.importClause?.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings))
+        return [];
+    return bindings.elements.map((element) => ({
+        imported: element.propertyName?.text ?? element.name.text,
+        local: element.name.text,
+        typeOnly: element.isTypeOnly || !!declaration.importClause?.isTypeOnly,
+    }));
+};
+const namedImportOf = (sourceFile, local) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings) && bindings.name.text === local) {
+            return { statement, specifier: statement.moduleSpecifier.text, namespace: true, imported: local };
+        }
+        if (bindings && ts.isNamedImports(bindings)) {
+            const element = bindings.elements.find((candidate) => candidate.name.text === local);
+            if (element) {
+                return {
+                    statement,
+                    specifier: statement.moduleSpecifier.text,
+                    namespace: false,
+                    imported: element.propertyName?.text ?? local,
+                };
+            }
+        }
+    }
+    return null;
+};
+const isToolkitActionsFile = (tree, filePath) => !!filePath && filePath.endsWith('.actions.ts') && !!tree.read(filePath, 'utf-8')?.includes('createHttpActionGroup');
+const unconvertedTypeQueries = (tree, graph, filePath, sourceFile, handleTypeNames) => {
+    const unconverted = [];
+    const resolveQuery = (query) => {
+        const name = query.exprName;
+        const local = ts.isIdentifier(name) ? name.text : ts.isIdentifier(name.left) ? name.left.text : null;
+        const origin = local ? namedImportOf(sourceFile, local) : null;
+        if (!origin || origin.namespace === ts.isIdentifier(name))
+            return;
+        const declaringFile = origin.namespace
+            ? graph.resolveFile(filePath, origin.specifier)
+            : graph.findDeclaringFile(filePath, origin.specifier, origin.imported);
+        if (isToolkitActionsFile(tree, declaringFile))
+            unconverted.push(name.getText(sourceFile));
+    };
+    const visit = (node) => {
+        if (ts.isTypeReferenceNode(node) &&
+            ts.isIdentifier(node.typeName) &&
+            handleTypeNames.has(node.typeName.text) &&
+            node.typeArguments) {
+            const visitArgument = (inner) => {
+                if (ts.isTypeQueryNode(inner))
+                    resolveQuery(inner);
+                ts.forEachChild(inner, visitArgument);
+            };
+            node.typeArguments.forEach(visitArgument);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return unconverted;
+};
+const isCall = (node, name) => ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === name;
+const readActionId = (node, createActionId) => {
+    if (!node || !isCall(node, createActionId) || node.arguments.length !== 1)
+        return null;
+    const inner = node.arguments[0];
+    if (!ts.isCallExpression(inner) ||
+        !ts.isPropertyAccessExpression(inner.expression) ||
+        !ts.isIdentifier(inner.expression.expression) ||
+        inner.expression.name.text !== 'call' ||
+        inner.arguments.length !== 1) {
+        return null;
+    }
+    const options = inner.arguments[0];
+    if (!ts.isObjectLiteralExpression(options) || options.properties.length !== 1)
+        return null;
+    const property = options.properties[0];
+    if (!ts.isPropertyAssignment(property) || property.name.getText() !== 'args')
+        return null;
+    return { group: inner.expression.expression.text, args: property.initializer };
+};
+const selectArgsText = (args, sourceFile) => {
+    if (!ts.isObjectLiteralExpression(args))
+        return args.getText(sourceFile);
+    const kept = args.properties.filter((property) => property.name?.getText(sourceFile) !== 'skipCache');
+    if (kept.length === args.properties.length)
+        return args.getText(sourceFile);
+    return `{ ${kept.map((property) => property.getText(sourceFile)).join(', ')} }`;
+};
+const isFacadeSelect = (node) => ts.isCallExpression(node) &&
+    ts.isPropertyAccessExpression(node.expression) &&
+    node.expression.name.text === 'select' &&
+    node.arguments.length === 2 &&
+    ts.isIdentifier(node.arguments[0]) &&
+    /facade/i.test(node.expression.expression.getText()) &&
+    !/router/i.test(node.expression.expression.getText());
+const countIdentifier = (root, name) => {
+    let count = 0;
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && node.text === name)
+            count += 1;
+        ts.forEachChild(node, visit);
+    };
+    visit(root);
+    return count;
+};
+const injectorOf = (classNode) => {
+    for (const member of classNode.members) {
+        if (ts.isPropertyDeclaration(member) &&
+            ts.isIdentifier(member.name) &&
+            member.initializer &&
+            isCall(member.initializer, 'inject') &&
+            member.initializer.arguments[0]?.getText() === 'Injector') {
+            return member.name.text;
+        }
+        if (ts.isConstructorDeclaration(member)) {
+            const parameter = member.parameters.find((candidate) => candidate.type?.getText() === 'Injector' &&
+                ts.isIdentifier(candidate.name) &&
+                !!ts
+                    .getModifiers(candidate)
+                    ?.some((modifier) => [ts.SyntaxKind.PrivateKeyword, ts.SyntaxKind.ProtectedKeyword, ts.SyntaxKind.PublicKeyword].includes(modifier.kind)));
+            if (parameter)
+                return parameter.name.text;
+        }
+    }
+    return null;
+};
+const planRefreshSites = (filePath, sourceFile, content, createActionId) => {
+    const plan = { edits: [], rewritten: 0, needsInjectorImport: false, tasks: [] };
+    const consumedActionIds = new Set();
+    const classInjectors = new Map();
+    const task = (node, summary) => plan.tasks.push({
+        id: CONSUMER_TASK.SELECT_BY_ACTION_ID,
+        summary,
+        locations: [{ filePath, line: lineOf(sourceFile, node.getStart(sourceFile)) }],
+    });
+    const injectorFor = (node) => {
+        let current = node.parent;
+        while (current && !ts.isClassLike(current))
+            current = current.parent;
+        if (!current)
+            return null;
+        const classNode = current;
+        const known = classInjectors.get(classNode) ?? injectorOf(classNode);
+        if (known) {
+            classInjectors.set(classNode, known);
+            return known;
+        }
+        const taken = classNode.members.some((member) => member.name?.getText(sourceFile) === 'injector');
+        const name = taken ? 'toolkitInjector' : 'injector';
+        classInjectors.set(classNode, name);
+        plan.needsInjectorImport = true;
+        plan.edits.push({
+            start: classNode.members.pos,
+            end: classNode.members.pos,
+            text: `\n  private ${name} = inject(Injector);\n`,
+        });
+        return name;
+    };
+    const localActionId = (select, identifier) => {
+        let block = select.parent;
+        while (block && !ts.isBlock(block))
+            block = block.parent;
+        if (!block || !ts.isBlock(block) || countIdentifier(block, identifier.text) !== 2)
+            return null;
+        for (const statement of block.statements) {
+            if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1)
+                continue;
+            const declaration = statement.declarationList.declarations[0];
+            if (ts.isIdentifier(declaration.name) && declaration.name.text === identifier.text) {
+                const actionId = createActionId ? readActionId(declaration.initializer, createActionId) : null;
+                return actionId ? { ...actionId, statement, initializer: declaration.initializer } : null;
+            }
+        }
+        return null;
+    };
+    const visit = (node) => {
+        if (isFacadeSelect(node)) {
+            const group = node.arguments[0].text;
+            const idArgument = node.arguments[1];
+            const inline = createActionId ? readActionId(idArgument, createActionId) : null;
+            const local = !inline && ts.isIdentifier(idArgument) ? localActionId(node, idArgument) : null;
+            const source = inline ?? local;
+            if (source && source.group === group) {
+                const injector = injectorFor(node);
+                if (injector) {
+                    plan.edits.push({
+                        start: node.getStart(sourceFile),
+                        end: node.getEnd(),
+                        text: `toolkitSelect(${group}, ${selectArgsText(source.args, sourceFile)}, { injector: this.${injector} })`,
+                    });
+                    consumedActionIds.add(inline ? idArgument : local.initializer);
+                    if (local)
+                        plan.edits.push(removeStatement(local.statement, content));
+                    plan.rewritten += 1;
+                    return;
+                }
+            }
+            task(node, `${code(node.getText(sourceFile).replace(/\s+/g, ' '))} looks up a handle by an action id the generator cannot trace to its args.`);
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    const visitActionIds = (node) => {
+        if (createActionId && isCall(node, createActionId) && !consumedActionIds.has(node)) {
+            task(node, `\`${createActionId}(…)\` builds an action id; pass the args on and call \`toolkitSelect\` where the handle is looked up.`);
+        }
+        ts.forEachChild(node, visitActionIds);
+    };
+    visit(sourceFile);
+    visitActionIds(sourceFile);
+    return plan;
+};
+/** Moves one consumer file from `@tomtomb/ngrx-toolkit` to `@ethlete/query/ngrx-toolkit`. */
+export const rewriteConsumer = (tree, graph, filePath, content) => {
+    const sourceFile = createSourceFile(content, filePath);
+    const toolkitImports = toolkitImportsOf(sourceFile);
+    if (toolkitImports.length === 0)
+        return null;
+    const elements = toolkitImports.flatMap(elementsOf);
+    const isInterop = (element) => INTEROP_SYMBOLS.has(RENAMED_SYMBOLS.get(element.imported) ?? element.imported);
+    const hasStoreSide = elements.some((element) => STORE_SIDE_SYMBOLS.has(element.imported));
+    if (hasStoreSide && !elements.some(isInterop))
+        return null;
+    const handleTypeNames = new Set(elements.filter((element) => HANDLE_TYPES.has(element.imported)).map((element) => element.local));
+    const unconverted = unconvertedTypeQueries(tree, graph, filePath, sourceFile, handleTypeNames);
+    if (unconverted.length > 0) {
+        if (hasStoreSide)
+            return null;
+        return {
+            content,
+            rewritten: false,
+            leftOnToolkit: true,
+            refreshSitesRewritten: 0,
+            tasks: [
+                {
+                    id: CONSUMER_TASK.UNCONVERTED_ACTION_GROUP,
+                    summary: `${[...new Set(unconverted)].map((name) => `\`${name}\``).join(', ')} still name toolkit action groups.`,
+                    locations: [{ filePath }],
+                },
+            ],
+        };
+    }
+    const createActionId = elements.find((element) => element.imported === 'createActionId')?.local ?? null;
+    const refresh = planRefreshSites(filePath, sourceFile, content, createActionId);
+    let result = applyEdits(content, refresh.edits);
+    const rewrittenSource = createSourceFile(result, filePath);
+    const used = collectUsedIdentifiers(rewrittenSource);
+    const moved = [];
+    const kept = [];
+    for (const element of elements) {
+        if (!used.has(element.local))
+            continue;
+        const target = RENAMED_SYMBOLS.get(element.imported) ?? element.imported;
+        const binding = target === element.local ? target : `${target} as ${element.local}`;
+        if (INTEROP_SYMBOLS.has(target)) {
+            moved.push(binding);
+        }
+        else {
+            kept.push(element.imported === element.local ? element.local : `${element.imported} as ${element.local}`);
+        }
+    }
+    if (refresh.rewritten > 0)
+        moved.push('toolkitSelect');
+    const hasInteropImport = rewrittenSource.statements.some((statement) => ts.isImportDeclaration(statement) &&
+        ts.isStringLiteral(statement.moduleSpecifier) &&
+        statement.moduleSpecifier.text === INTEROP_MODULE);
+    const replacement = [
+        moved.length > 0 && !hasInteropImport ? `import { ${moved.join(', ')} } from '${INTEROP_MODULE}';` : null,
+        kept.length > 0 ? `import { ${kept.join(', ')} } from '${TOOLKIT_MODULE}';` : null,
+    ].filter((line) => line !== null);
+    const importEdits = toolkitImportsOf(rewrittenSource).map((statement, index) => index === 0 && replacement.length > 0
+        ? { start: statement.getStart(rewrittenSource), end: statement.getEnd(), text: replacement.join('\n') }
+        : removeStatement(statement, result));
+    result = applyEdits(result, importEdits);
+    if (refresh.needsInjectorImport) {
+        result = ensureNamedImports({
+            content: result,
+            importsNeeded: ['inject', 'Injector'],
+            moduleSpecifier: '@angular/core',
+        });
+    }
+    if (moved.length > 0 && hasInteropImport) {
+        result = ensureNamedImports({ content: result, importsNeeded: moved, moduleSpecifier: INTEROP_MODULE });
+    }
+    const tasks = [...refresh.tasks];
+    if (kept.length > 0) {
+        tasks.push({
+            id: CONSUMER_TASK.UNSUPPORTED_IMPORT,
+            summary: `Still imports ${kept.map((name) => `\`${name}\``).join(', ')} from \`${TOOLKIT_MODULE}\`.`,
+            locations: [{ filePath }],
+        });
+    }
+    return {
+        content: result,
+        rewritten: result !== content,
+        leftOnToolkit: kept.length > 0,
+        refreshSitesRewritten: refresh.rewritten,
+        tasks,
+    };
+};
+const isInterceptor = (node, sourceFile) => {
+    if (ts.isClassDeclaration(node)) {
+        return !!node.heritageClauses?.some((clause) => clause.types.some((type) => type.expression.getText(sourceFile) === 'HttpInterceptor'));
+    }
+    if (ts.isVariableDeclaration(node))
+        return node.type?.getText(sourceFile) === 'HttpInterceptorFn';
+    return false;
+};
+const skippedRequests = (node, sourceFile) => {
+    const conditions = [];
+    const prefixes = new Set();
+    const visit = (inner) => {
+        if (ts.isIfStatement(inner) && /\burl\b/i.test(inner.expression.getText(sourceFile))) {
+            const condition = inner.expression.getText(sourceFile).replace(/\s+/g, ' ');
+            conditions.push(condition);
+            const collectPrefixes = (part) => {
+                const text = ts.isStringLiteralLike(part) ? part.text : ts.isTemplateSpan(part) ? part.literal.text : null;
+                const prefix = text && /^\/[\w\-/]*/.exec(text)?.[0];
+                if (prefix && prefix.length > 1)
+                    prefixes.add(prefix);
+                ts.forEachChild(part, collectPrefixes);
+            };
+            collectPrefixes(inner.expression);
+        }
+        ts.forEachChild(inner, visit);
+    };
+    visit(node);
+    return { conditions, prefixes: [...prefixes] };
+};
+const findInterceptors = (tree, inScope, filePath, content) => {
+    if (!/HttpInterceptor/.test(content) || !/authorization|bearer/i.test(content))
+        return [];
+    const sourceFile = createSourceFile(content, filePath);
+    const tasks = [];
+    const visit = (node) => {
+        if (isInterceptor(node, sourceFile) && /authorization|bearer/i.test(node.getText(sourceFile))) {
+            const name = node.name?.getText(sourceFile) ?? 'interceptor';
+            const { conditions, prefixes } = skippedRequests(node, sourceFile);
+            const registrations = [...inScope]
+                .filter((candidate) => candidate !== filePath && tree.exists(candidate))
+                .filter((candidate) => new RegExp(`\\b${name}\\b`).test(tree.read(candidate, 'utf-8') ?? ''))
+                .map((candidate) => ({ filePath: candidate }));
+            const skipped = conditions.length > 0 ? ` It skips requests where ${conditions.map(code).join('; ')}.` : '';
+            const suggestion = prefixes.length > 0 ? ` Candidate \`--publicRoutes=${prefixes.join(',')}\`.` : '';
+            tasks.push({
+                id: CONSUMER_TASK.AUTH_INTERCEPTOR,
+                summary: `\`${name}\` adds an \`Authorization\` header.${skipped}${suggestion}`,
+                locations: [{ filePath, line: lineOf(sourceFile, node.getStart(sourceFile)) }, ...registrations],
+            });
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return tasks;
+};
+/** Runs the consumer side of the migration on every scoped file that still imports `@tomtomb/ngrx-toolkit`. */
+export const migrateToolkitConsumers = (tree, graph, inScope, report) => {
+    defineConsumerTasks(report);
+    const stats = {
+        filesRewritten: 0,
+        filesLeftOnToolkit: 0,
+        refreshSitesRewritten: 0,
+        interceptorsFound: 0,
+    };
+    for (const filePath of inScope) {
+        if (filePath.endsWith('.d.ts'))
+            continue;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            continue;
+        const interceptors = findInterceptors(tree, inScope, filePath, content);
+        interceptors.forEach((task) => report.add(task));
+        stats.interceptorsFound += interceptors.length;
+        if (!content.includes(TOOLKIT_MODULE))
+            continue;
+        const result = rewriteConsumer(tree, graph, filePath, content);
+        if (!result)
+            continue;
+        result.tasks.forEach((task) => report.add(task));
+        if (result.rewritten) {
+            tree.write(filePath, result.content);
+            stats.filesRewritten += 1;
+        }
+        if (result.leftOnToolkit)
+            stats.filesLeftOnToolkit += 1;
+        stats.refreshSitesRewritten += result.refreshSitesRewritten;
+    }
+    return stats;
+};
+//# sourceMappingURL=consumers.js.map