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

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

@@ -0,0 +1,301 @@
+import { getProjects } from '@nx/devkit';
+import * as ts from 'typescript';
+import { toolkitArgsFitCreator } from './args-assignability.js';
+import { capitalizeFirstLetter, createSourceFile } from '../migrate-to-query-v3/shared.js';
+import { HTTP_VERBS, findTypeDeclaration } from './feature.js';
+import { TOOLKIT_TASK } from './report.js';
+import { hasExportModifier, lineOf, pruneUnusedImports, relativeSpecifier } from './ts-edits.js';
+export const clientBaseName = (client) => client.replace(/Config$/, '').replace(/Client$/, '');
+export const helperName = (helpers, verb, secure) => `${helpers.baseName}${capitalizeFirstLetter(verb)}${secure ? 'Secure' : ''}`;
+const normalizeType = (text) => text.replace(/\s+/g, ' ').replace(/;\s*}/g, ' }').trim();
+export const isPublicRoute = (helpers, staticPrefix) => {
+    if (!helpers.publicRoutes)
+        return true;
+    return helpers.publicRoutes.some((prefix) => {
+        if (!staticPrefix.startsWith(prefix))
+            return false;
+        const next = staticPrefix[prefix.length];
+        return next === undefined || next === '/' || next === '?' || prefix.endsWith('/');
+    });
+};
+const COMPARED_ARG_KEYS = ['queryParams', 'body'];
+const withoutComments = (text) => text.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, '');
+const memberText = (member) => `${member.questionToken ? '?' : ''}${normalizeType(withoutComments(member.type.getText()))}`;
+const collectArgMembers = (members, into) => {
+    for (const member of members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const key = member.name.getText();
+        if (key === 'queryParams' || key === 'body')
+            into[key] = memberText(member);
+    }
+};
+const referencedMembers = (tree, graph, filePath, sourceFile, reference) => {
+    if (reference.typeArguments || !ts.isIdentifier(reference.typeName))
+        return null;
+    const name = reference.typeName.text;
+    let declaration = findTypeDeclaration(sourceFile, name);
+    for (const statement of sourceFile.statements) {
+        if (declaration)
+            break;
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const named = statement.importClause?.namedBindings;
+        if (!named || !ts.isNamedImports(named))
+            continue;
+        const element = named.elements.find((candidate) => candidate.name.text === name);
+        const importedName = element?.propertyName?.text ?? name;
+        const declaringFile = element
+            ? graph.findDeclaringFile(filePath, statement.moduleSpecifier.text, importedName)
+            : null;
+        const content = declaringFile ? tree.read(declaringFile, 'utf-8') : null;
+        if (declaringFile && content) {
+            declaration = findTypeDeclaration(createSourceFile(content, declaringFile), importedName);
+        }
+    }
+    if (declaration && ts.isInterfaceDeclaration(declaration) && !declaration.typeParameters) {
+        return declaration.heritageClauses?.length ? null : declaration.members;
+    }
+    if (declaration && ts.isTypeAliasDeclaration(declaration) && ts.isTypeLiteralNode(declaration.type)) {
+        return declaration.type.members;
+    }
+    return null;
+};
+const creatorArgsOf = (tree, graph, filePath, sourceFile, typeArgument) => {
+    const texts = { queryParams: null, body: null };
+    if (!typeArgument)
+        return texts;
+    const parts = ts.isIntersectionTypeNode(typeArgument) ? typeArgument.types : [typeArgument];
+    for (const part of parts) {
+        const members = ts.isTypeLiteralNode(part)
+            ? part.members
+            : ts.isTypeReferenceNode(part)
+                ? referencedMembers(tree, graph, filePath, sourceFile, part)
+                : null;
+        if (!members)
+            return null;
+        collectArgMembers(members, texts);
+    }
+    return texts;
+};
+const toolkitArgTexts = (call) => {
+    const text = (key) => {
+        const member = call.args?.members.get(key);
+        return member ? `${member.optional ? '?' : ''}${normalizeType(withoutComments(member.declaredText))}` : null;
+    };
+    return { queryParams: text('params'), body: text('body') };
+};
+const routeOf = (node) => {
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return { normalized: node.text, pathParams: [] };
+    }
+    if (!ts.isArrowFunction(node) || node.parameters.length !== 1)
+        return null;
+    const param = node.parameters[0].name;
+    const body = node.body;
+    if (ts.isStringLiteral(body) || ts.isNoSubstitutionTemplateLiteral(body)) {
+        return { normalized: body.text, pathParams: [] };
+    }
+    if (!ts.isIdentifier(param) || !ts.isTemplateExpression(body))
+        return null;
+    const pathParams = [];
+    let normalized = body.head.text;
+    for (const span of body.templateSpans) {
+        const expression = span.expression;
+        if (!ts.isPropertyAccessExpression(expression) ||
+            !ts.isIdentifier(expression.expression) ||
+            expression.expression.text !== param.text) {
+            return null;
+        }
+        pathParams.push(expression.name.text);
+        normalized += `{}${span.literal.text}`;
+    }
+    return { normalized, pathParams };
+};
+const responseTypeOf = (typeArgument, sourceFile) => {
+    if (!typeArgument)
+        return null;
+    const literals = ts.isIntersectionTypeNode(typeArgument)
+        ? typeArgument.types.filter(ts.isTypeLiteralNode)
+        : ts.isTypeLiteralNode(typeArgument)
+            ? [typeArgument]
+            : [];
+    for (const literal of literals) {
+        for (const member of literal.members) {
+            if (ts.isPropertySignature(member) && member.name.getText(sourceFile) === 'response' && member.type) {
+                return normalizeType(member.type.getText(sourceFile));
+            }
+        }
+    }
+    return null;
+};
+/** Every `export const x = <client><Verb>[Secure](route)` in the scope - the v3 creators D6 may reuse. */
+export const indexExistingCreators = (tree, graph, helpers, visit) => {
+    const helperVerbs = new Map();
+    for (const verb of HTTP_VERBS) {
+        helperVerbs.set(helperName(helpers, verb, false), verb);
+        helperVerbs.set(helperName(helpers, verb, true), verb);
+    }
+    const creators = [];
+    visit((filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts') || filePath.endsWith('.d.ts'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content || ![...helperVerbs.keys()].some((name) => content.includes(name)))
+            return;
+        const sourceFile = createSourceFile(content, filePath);
+        for (const statement of sourceFile.statements) {
+            if (!ts.isVariableStatement(statement) || !hasExportModifier(statement))
+                continue;
+            for (const declaration of statement.declarationList.declarations) {
+                const call = declaration.initializer;
+                if (!ts.isIdentifier(declaration.name) ||
+                    !call ||
+                    !ts.isCallExpression(call) ||
+                    !ts.isIdentifier(call.expression)) {
+                    continue;
+                }
+                const verb = helperVerbs.get(call.expression.text);
+                const route = call.arguments[0] ? routeOf(call.arguments[0]) : null;
+                if (!verb || !route)
+                    continue;
+                creators.push({
+                    filePath,
+                    name: declaration.name.text,
+                    verb,
+                    normalizedRoute: route.normalized,
+                    pathParams: route.pathParams,
+                    responseType: responseTypeOf(call.typeArguments?.[0], sourceFile),
+                    args: creatorArgsOf(tree, graph, filePath, sourceFile, call.typeArguments?.[0]),
+                    argsTypeText: call.typeArguments?.[0]?.getText(sourceFile) ?? null,
+                    line: lineOf(sourceFile, declaration.getStart(sourceFile)),
+                });
+            }
+        }
+    });
+    return creators;
+};
+const projectRootOf = (tree, filePath) => {
+    let best = null;
+    for (const project of getProjects(tree).values()) {
+        const root = project.root === '.' ? '' : project.root;
+        if ((root === '' || filePath.startsWith(`${root}/`)) && (best === null || root.length > best.length)) {
+            best = root;
+        }
+    }
+    return best;
+};
+/** How `fromFile` can import `symbol` from `declaringFile`: relatively inside one project, else through a path alias. */
+export const importSpecifierFor = (tree, graph, fromFile, declaringFile, symbol) => {
+    const fromRoot = projectRootOf(tree, fromFile);
+    if (fromRoot !== null && fromRoot === projectRootOf(tree, declaringFile)) {
+        return relativeSpecifier(fromFile, declaringFile);
+    }
+    for (const alias of graph.pathAliases()) {
+        if (alias.includes('*'))
+            continue;
+        if (graph.findDeclaringFile(fromFile, alias, symbol) === declaringFile)
+            return alias;
+    }
+    return fromRoot === null && projectRootOf(tree, declaringFile) === null
+        ? relativeSpecifier(fromFile, declaringFile)
+        : null;
+};
+const creatorTypeParameter = (call) => {
+    const members = [];
+    const renamed = { queryParams: 'pathParams', params: 'queryParams', body: 'body' };
+    for (const [key, member] of call.args?.members ?? []) {
+        members.push(`${renamed[key]}${member.optional ? '?' : ''}: ${member.typeText}`);
+    }
+    if (call.responseType)
+        members.push(`response: ${call.responseType}`);
+    return members.length > 0 ? `<{ ${members.join('; ')} }>` : '';
+};
+const creatorRoute = (call) => {
+    const hasPathParams = call.args?.members.has('queryParams') ?? false;
+    return hasPathParams && call.route.pathParams.length === 0 && !call.route.text.includes('=>')
+        ? `() => ${call.route.text}`
+        : call.route.text;
+};
+const decideReuse = (tree, graph, feature, call, existing) => {
+    if (call.route.normalized === null)
+        return null;
+    const sameRoute = existing.filter((creator) => creator.verb === call.verb && creator.normalizedRoute === call.route.normalized);
+    if (sameRoute.length === 0)
+        return null;
+    const response = call.responseType ? normalizeType(call.responseType) : null;
+    const argTexts = toolkitArgTexts(call);
+    const argMismatch = (creator) => COMPARED_ARG_KEYS.find((key) => creator.args?.[key] !== argTexts[key]) ?? null;
+    const argsFit = (creator) => argMismatch(creator) === null ||
+        toolkitArgsFitCreator(tree, graph, { file: feature.files.actions, typeText: call.args?.typeText ?? null }, { file: creator.filePath, typeText: creator.argsTypeText });
+    const match = sameRoute.find((creator) => creator.responseType === response &&
+        creator.pathParams.join(',') === call.route.pathParams.join(',') &&
+        argsFit(creator));
+    if (!match) {
+        const other = sameRoute[0];
+        const differingKey = argMismatch(other);
+        const describe = (text) => {
+            if (text === null)
+                return 'none';
+            const type = text.replace(/^\?/, '');
+            return `\`${type.length > 120 ? `${type.slice(0, 120)}…` : type}\``;
+        };
+        const reason = other.pathParams.join(',') !== call.route.pathParams.join(',')
+            ? 'its path params are named differently'
+            : other.responseType === null
+                ? 'its response type is not written inline, so it cannot be compared'
+                : other.responseType !== response
+                    ? `its response is \`${other.responseType}\`, not \`${response ?? 'unknown'}\``
+                    : other.args === null
+                        ? 'its args type is not an interface or type literal, so it cannot be compared'
+                        : `its ${differingKey === 'body' ? 'body' : 'query params'} are ${describe(other.args[differingKey])}, not ${describe(argTexts[differingKey])}`;
+        return {
+            mismatch: `\`${call.name}\` got its own creator: \`${other.name}\` (${other.filePath}:${other.line}) has the same ${call.verb.toUpperCase()} route, but ${reason}.`,
+        };
+    }
+    const specifier = importSpecifierFor(tree, graph, feature.queriesFile, match.filePath, match.name);
+    if (!specifier) {
+        return {
+            mismatch: `\`${call.name}\` got its own creator: \`${match.name}\` (${match.filePath}:${match.line}) matches, but no path alias exports it to ${feature.queriesFile}.`,
+        };
+    }
+    return { reuse: match, specifier };
+};
+const clientSpecifier = (tree, helpers, fromFile) => tree.exists(helpers.importFrom) ? relativeSpecifier(fromFile, helpers.importFrom) : helpers.importFrom;
+/** Writes `x.queries.ts`: one v3 creator per action group, or a re-export of an existing creator for the same route. */
+export const writeQueriesFile = (tree, graph, feature, helpers, existing, report) => {
+    const helperImports = new Set();
+    const reExports = [];
+    const declarations = [];
+    let reused = 0;
+    for (const call of feature.calls) {
+        const decision = decideReuse(tree, graph, feature, call, existing);
+        if (decision && 'reuse' in decision) {
+            const { reuse, specifier } = decision;
+            const binding = reuse.name === call.name ? call.name : `${reuse.name} as ${call.name}`;
+            reExports.push(`export { ${binding} } from '${specifier}';`);
+            reused += 1;
+            continue;
+        }
+        if (decision && 'mismatch' in decision) {
+            report.add({
+                id: TOOLKIT_TASK.DUPLICATE_ROUTE_MISMATCH,
+                summary: decision.mismatch,
+                locations: [{ filePath: feature.queriesFile }],
+            });
+        }
+        const helper = helperName(helpers, call.verb, !isPublicRoute(helpers, call.route.staticPrefix));
+        helperImports.add(helper);
+        declarations.push(`export const ${call.name} = ${helper}${creatorTypeParameter(call)}(${creatorRoute(call)});`);
+    }
+    const imports = [...feature.actionImports];
+    if (helperImports.size > 0) {
+        imports.push(`import { ${[...helperImports].sort().join(', ')} } from '${clientSpecifier(tree, helpers, feature.queriesFile)}';`);
+    }
+    const content = [imports.join('\n'), reExports.join('\n'), declarations.join('\n\n')]
+        .filter((part) => part.length > 0)
+        .join('\n\n');
+    tree.write(feature.queriesFile, `${pruneUnusedImports(`${content}\n`)}`);
+    return { written: declarations.length, reused };
+};
+//# sourceMappingURL=creators.js.map

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

@@ -0,0 +1,295 @@
+import * as ts from 'typescript';
+import { createSourceFile, ensureNamedImports } from '../migrate-to-query-v3/shared.js';
+import { TOOLKIT_MODULE } from './feature.js';
+import { TOOLKIT_TASK } from './report.js';
+import { applyEdits, collapseBlankLines, lineOf, pruneUnusedImports, relativeSpecifier, removeStatement, } from './ts-edits.js';
+export const INTEROP_MODULE = '@ethlete/query/ngrx-toolkit';
+const STORE_TYPES = new Set(['Store', 'Actions']);
+const FACADE_BASE_MEMBERS = new Set([
+    'call',
+    'select',
+    'selectIsInit',
+    'selectIsLoading',
+    'selectIsSuccess',
+    'selectIsError',
+    'selectResponse',
+    'selectCachedResponse',
+    'selectError',
+    'selectArgs',
+    'selectEntityId',
+    'selectTimestamp',
+    'selectType',
+    'selectCallState',
+    'remove',
+    'on',
+    'once',
+]);
+const importTable = (sourceFile) => {
+    const table = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const specifier = statement.moduleSpecifier.text;
+        const clause = statement.importClause;
+        if (clause?.name)
+            table.set(clause.name.text, { specifier, imported: 'default' });
+        const bindings = clause?.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings))
+            table.set(bindings.name.text, { specifier, imported: null });
+        if (bindings && ts.isNamedImports(bindings)) {
+            for (const element of bindings.elements) {
+                table.set(element.name.text, { specifier, imported: element.propertyName?.text ?? element.name.text });
+            }
+        }
+    }
+    return table;
+};
+const typeNameOf = (type) => type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) ? type.typeName.text : null;
+const isInjectOfStore = (expression, storeTypeNames) => !!expression &&
+    ts.isCallExpression(expression) &&
+    ts.isIdentifier(expression.expression) &&
+    expression.expression.text === 'inject' &&
+    !!expression.arguments[0] &&
+    ts.isIdentifier(expression.arguments[0]) &&
+    storeTypeNames.has(expression.arguments[0].text);
+/**
+ * Rewrites a `FacadeBase` facade to call the v3 creators through `toolkitCall`. Returns blockers instead of content
+ * when a member still needs the NgRx store.
+ */
+export const rewriteFacade = (content, feature, graph, storeFiles) => {
+    const facadeFile = feature.files.facade;
+    const sourceFile = createSourceFile(content, facadeFile);
+    const imports = importTable(sourceFile);
+    const callsByName = new Map(feature.calls.map((call) => [call.name, call]));
+    const storeTypeNames = new Set();
+    const storeImportNames = new Set();
+    for (const [local, { specifier, imported }] of imports) {
+        if ((specifier === '@ngrx/store' || specifier === '@ngrx/effects') && imported && STORE_TYPES.has(imported)) {
+            storeTypeNames.add(local);
+        }
+        if (specifier === TOOLKIT_MODULE || specifier.startsWith('@ngrx/'))
+            storeImportNames.add(local);
+        const resolved = graph.resolveFile(facadeFile, specifier);
+        if (resolved && storeFiles.has(resolved))
+            storeImportNames.add(local);
+    }
+    const facadeClass = sourceFile.statements.find((statement) => ts.isClassDeclaration(statement) &&
+        !!statement.heritageClauses?.some((clause) => clause.types.some((type) => type.expression.getText() === 'FacadeBase')));
+    if (!facadeClass) {
+        return {
+            blockers: [
+                {
+                    id: TOOLKIT_TASK.FACADE_STORE_MEMBER,
+                    summary: `${facadeFile} has no class that extends \`FacadeBase\`.`,
+                    locations: [{ filePath: facadeFile }],
+                },
+            ],
+        };
+    }
+    const storeMembers = new Set();
+    for (const member of facadeClass.members) {
+        if (ts.isConstructorDeclaration(member)) {
+            for (const parameter of member.parameters) {
+                if (ts.isIdentifier(parameter.name) && storeTypeNames.has(typeNameOf(parameter.type) ?? '')) {
+                    storeMembers.add(parameter.name.text);
+                }
+            }
+        }
+        if (ts.isPropertyDeclaration(member) &&
+            ts.isIdentifier(member.name) &&
+            (storeTypeNames.has(typeNameOf(member.type) ?? '') || isInjectOfStore(member.initializer, storeTypeNames))) {
+            storeMembers.add(member.name.text);
+        }
+    }
+    const blockers = [];
+    const edits = [];
+    const usedCreators = new Set();
+    let usesActionCallArgs = false;
+    const actionNameOf = (expression) => {
+        if (ts.isIdentifier(expression)) {
+            const imported = imports.get(expression.text);
+            const resolved = imported ? graph.resolveFile(facadeFile, imported.specifier) : null;
+            return resolved === feature.files.actions ? (imported?.imported ?? null) : null;
+        }
+        if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression)) {
+            const imported = imports.get(expression.expression.text);
+            const resolved = imported && imported.imported === null ? graph.resolveFile(facadeFile, imported.specifier) : null;
+            return resolved === feature.files.actions ? expression.name.text : null;
+        }
+        return null;
+    };
+    const simpleCall = (member) => {
+        if (!ts.isMethodDeclaration(member) || member.body?.statements.length !== 1)
+            return null;
+        const statement = member.body.statements[0];
+        const expression = ts.isReturnStatement(statement) ? statement.expression : undefined;
+        if (!expression ||
+            !ts.isCallExpression(expression) ||
+            !ts.isPropertyAccessExpression(expression.expression) ||
+            expression.expression.expression.kind !== ts.SyntaxKind.ThisKeyword ||
+            expression.expression.name.text !== 'call' ||
+            expression.arguments.length !== 2) {
+            return null;
+        }
+        const name = actionNameOf(expression.arguments[0]);
+        const call = name ? callsByName.get(name) : undefined;
+        return call ? { call, argument: expression.arguments[1] } : null;
+    };
+    const storeDependency = (member) => {
+        let found = null;
+        const visit = (node) => {
+            if (found)
+                return;
+            if (ts.isPropertyAccessExpression(node) &&
+                (node.expression.kind === ts.SyntaxKind.ThisKeyword || node.expression.kind === ts.SyntaxKind.SuperKeyword) &&
+                (storeMembers.has(node.name.text) || FACADE_BASE_MEMBERS.has(node.name.text))) {
+                found = node.getText(sourceFile);
+                return;
+            }
+            if (ts.isIdentifier(node) && storeImportNames.has(node.text) && !ts.isPropertyAccessExpression(node.parent)) {
+                found = node.text;
+                return;
+            }
+            if (ts.isIdentifier(node) &&
+                storeImportNames.has(node.text) &&
+                ts.isPropertyAccessExpression(node.parent) &&
+                node.parent.expression === node) {
+                found = node.text;
+                return;
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(member);
+        return found;
+    };
+    const injectorName = facadeClass.members.some((member) => member.name?.getText(sourceFile) === 'injector')
+        ? 'toolkitInjector'
+        : 'injector';
+    for (const member of facadeClass.members) {
+        const call = simpleCall(member);
+        if (call && ts.isMethodDeclaration(member)) {
+            usedCreators.add(call.call.name);
+            const parameter = member.parameters[0];
+            const parameterType = parameter?.type?.getText(sourceFile).replace(/\s+/g, ' ');
+            const args = call.call.args;
+            const toolkitArgsType = /^ActionCallArgs<typeof ([\w.]+)>$/.exec(parameterType ?? '');
+            const replaceType = !!parameter?.type &&
+                ((args && parameterType === args.typeText && args.extraKeys.length === 0) ||
+                    (!!toolkitArgsType && toolkitArgsType[1].split('.').pop() === call.call.name));
+            if (replaceType) {
+                usesActionCallArgs = true;
+                edits.push({
+                    start: parameter.type.getStart(sourceFile),
+                    end: parameter.type.getEnd(),
+                    text: `ActionCallArgs<typeof ${call.call.name}>`,
+                });
+            }
+            edits.push({
+                start: member.body.getStart(sourceFile),
+                end: member.body.getEnd(),
+                text: `{\n    return toolkitCall(${call.call.name}, ${call.argument.getText(sourceFile)}, { injector: this.${injectorName} });\n  }`,
+            });
+            continue;
+        }
+        if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) && storeMembers.has(member.name.text)) {
+            edits.push(removeStatement(member, content));
+            continue;
+        }
+        if (ts.isConstructorDeclaration(member)) {
+            const body = member.body?.statements ?? ts.factory.createNodeArray();
+            const storeLocals = new Set();
+            const keptStatements = body.filter((statement) => {
+                if (ts.isExpressionStatement(statement) &&
+                    ts.isCallExpression(statement.expression) &&
+                    statement.expression.expression.kind === ts.SyntaxKind.SuperKeyword) {
+                    return false;
+                }
+                if (ts.isVariableStatement(statement)) {
+                    const declarations = statement.declarationList.declarations;
+                    if (declarations.every((declaration) => isInjectOfStore(declaration.initializer, storeTypeNames))) {
+                        declarations.forEach((declaration) => storeLocals.add(declaration.name.getText(sourceFile)));
+                        return false;
+                    }
+                }
+                if (ts.isExpressionStatement(statement) &&
+                    ts.isBinaryExpression(statement.expression) &&
+                    ts.isPropertyAccessExpression(statement.expression.left) &&
+                    storeMembers.has(statement.expression.left.name.text)) {
+                    return false;
+                }
+                return true;
+            });
+            const keptParameters = member.parameters.filter((parameter) => !(ts.isIdentifier(parameter.name) && storeMembers.has(parameter.name.text)));
+            for (const statement of keptStatements) {
+                const dependency = storeDependency(statement);
+                if (dependency ||
+                    [...storeLocals].some((local) => new RegExp(`\\b${local}\\b`).test(statement.getText(sourceFile)))) {
+                    blockers.push({
+                        id: TOOLKIT_TASK.FACADE_STORE_MEMBER,
+                        summary: `The constructor of the facade uses the store (\`${dependency ?? statement.getText(sourceFile)}\`).`,
+                        locations: [{ filePath: facadeFile, line: lineOf(sourceFile, statement.getStart(sourceFile)) }],
+                    });
+                }
+            }
+            if (keptStatements.length === 0 && keptParameters.length === 0) {
+                edits.push(removeStatement(member, content));
+                continue;
+            }
+            edits.push({
+                start: member.getStart(sourceFile),
+                end: member.getEnd(),
+                text: `constructor(${keptParameters.map((parameter) => parameter.getText(sourceFile)).join(', ')}) {\n${keptStatements
+                    .map((statement) => `    ${statement.getText(sourceFile)}`)
+                    .join('\n')}\n  }`,
+            });
+            continue;
+        }
+        const dependency = storeDependency(member);
+        if (dependency) {
+            blockers.push({
+                id: TOOLKIT_TASK.FACADE_STORE_MEMBER,
+                summary: `\`${member.name?.getText(sourceFile) ?? 'A member'}\` uses \`${dependency}\`.`,
+                locations: [{ filePath: facadeFile, line: lineOf(sourceFile, member.getStart(sourceFile)) }],
+            });
+        }
+    }
+    if (blockers.length > 0)
+        return { blockers };
+    const heritage = facadeClass.heritageClauses.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword);
+    edits.push({ start: heritage.getFullStart(), end: heritage.getEnd(), text: '' });
+    const bodyStart = facadeClass.members.pos;
+    edits.push({
+        start: bodyStart,
+        end: bodyStart,
+        text: `\n  private ${injectorName} = inject(Injector);\n`,
+    });
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const specifier = statement.moduleSpecifier.text;
+        const resolved = graph.resolveFile(facadeFile, specifier);
+        if (specifier === TOOLKIT_MODULE || (resolved && storeFiles.has(resolved))) {
+            edits.push(removeStatement(statement, content));
+        }
+    }
+    let result = applyEdits(content, edits);
+    result = ensureNamedImports({
+        content: result,
+        importsNeeded: ['inject', 'Injector'],
+        moduleSpecifier: '@angular/core',
+    });
+    result = ensureNamedImports({
+        content: result,
+        importsNeeded: usesActionCallArgs ? ['ActionCallArgs', 'toolkitCall'] : ['toolkitCall'],
+        moduleSpecifier: INTEROP_MODULE,
+    });
+    if (usedCreators.size > 0) {
+        result = ensureNamedImports({
+            content: result,
+            importsNeeded: [...usedCreators],
+            moduleSpecifier: relativeSpecifier(facadeFile, feature.queriesFile),
+        });
+    }
+    return { content: collapseBlankLines(pruneUnusedImports(result)) };
+};
+//# sourceMappingURL=facade.js.map