@craft-ng/dev-tools 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-ng/dev-tools",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Development tools for ng-craft: ESLint configs, ESLint rules, and codemods",
   "type": "module",
   "main": "./src/index.js",

package/src/scripts/angular-brand-codemod.d.ts

@@ -57,6 +57,13 @@ export type ExistingDependencyGroupsResult = {
     depsObjectNode?: Node;
     propertyNodes: Partial<Record<keyof DependencyGroups, Node>>;
 };
+type InjectedDependencyDescriptor = {
+    dependencyText: string;
+    entry: GeneratedDependencyEntry;
+};
+type InjectCallDependencyExtractionResult = DependencyExtractionResult & {
+    generatedDependencies: InjectedDependencyDescriptor[];
+};
 type RunFileReport = TransformResult & {
     filePath: string;
 };
@@ -74,7 +81,7 @@ export declare function getAngularKind(classDeclaration: ClassDeclaration): Angu
 export declare function isStandaloneDeclarable(classDeclaration: ClassDeclaration): boolean;
 export declare function extractDecoratorMetadataDeps(classDeclaration: ClassDeclaration, angularKind?: AngularKind | undefined, options?: AngularBrandCodemodOptions): DependencyExtractionResult;
 export declare function extractConstructorDeps(classDeclaration: ClassDeclaration): DependencyExtractionResult;
-export declare function extractInjectCallDeps(classDeclaration: ClassDeclaration): DependencyExtractionResult;
+export declare function extractInjectCallDeps(classDeclaration: ClassDeclaration): InjectCallDependencyExtractionResult;
 export declare function mergeDeps(...dependencyGroups: readonly string[][]): string[];
 export declare function writeGeneratedDepsTypeAlias(sourceFile: SourceFile, className: string, generatedDependencyGroups: GeneratedDependencyGroups): void;
 export declare function migrateLegacyBrandExport(sourceFile: SourceFile, classDeclaration: ClassDeclaration, className: string): void;

package/src/scripts/angular-brand-codemod.js

@@ -127,7 +127,13 @@ export function analyzeSourceFileDependencies(sourceFile, options = {}) {
         providers: mergeDeps(metadataDeps.providers, metadataDeps.viewProviders),
     };
     result.generatedTypeName = getGeneratedDepsTypeName(className);
-    result.generatedDependencyGroups = createGeneratedDependencyGroups(sourceFile, result.dependencyGroups.importDeps, result.dependencyGroups.injected, providedDeps.entries);
+    result.generatedDependencyGroups = createGeneratedDependencyGroups(sourceFile, result.dependencyGroups.importDeps, [
+        ...constructorDeps.dependencies.map((dependencyText) => ({
+            dependencyText,
+            entry: createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject'),
+        })),
+        ...injectCallDeps.generatedDependencies,
+    ], providedDeps.entries);
     return result;
 }
 export function findAngularDecoratedClass(sourceFile) {
@@ -233,6 +239,8 @@ export function extractInjectCallDeps(classDeclaration) {
     var _a;
     const warnings = [];
     const dependencies = [];
+    const generatedDependencies = [];
+    const sourceFile = classDeclaration.getSourceFile();
     for (const callExpression of classDeclaration.getDescendantsOfKind(SyntaxKind.CallExpression)) {
         const expression = callExpression.getExpression();
         const injectMethodName = getInjectMethodName(expression);
@@ -247,8 +255,18 @@ export function extractInjectCallDeps(classDeclaration) {
             continue;
         }
         dependencies.push(dependency);
+        generatedDependencies.push({
+            dependencyText: dependency,
+            entry: injectMethodName === 'inject'
+                ? createGeneratedDependencyEntry(sourceFile, dependency, 'inject')
+                : createGeneratedInjectHelperDependencyEntry(sourceFile, callExpression, expression, dependency),
+        });
     }
-    return { dependencies: mergeDeps(dependencies), warnings };
+    return {
+        dependencies: mergeDeps(dependencies),
+        warnings,
+        generatedDependencies,
+    };
 }
 export function mergeDeps(...dependencyGroups) {
     const seen = new Set();
@@ -282,16 +300,20 @@ function getGeneratedDepsTypeName(className) {
     return `GenDeps_${className}`;
 }
 function createGeneratedDependencyGroups(sourceFile, importDependencies, injectedDependencies, providedEntries) {
-    const deps = mergeGeneratedDependencyEntries(importDependencies.map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'import')), injectedDependencies.map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'inject')));
+    const deps = mergeGeneratedDependencyEntries(importDependencies.map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'import')), injectedDependencies.map((dependency) => dependency.entry));
     const provided = mergeGeneratedDependencyEntries(providedEntries);
     const providedKeys = new Set(provided.map((entry) => entry.key));
+    const injectedEntriesByKey = new Map(injectedDependencies.map((dependency) => [dependency.entry.key, dependency.entry]));
     const missingProvider = mergeGeneratedDependencyEntries(injectedDependencies
         .filter((dependency) => {
-        const dependencyKey = createGeneratedDependencyKey(dependency);
+        const dependencyKey = dependency.entry.key;
         return (!providedKeys.has(dependencyKey) &&
-            !isProvidedInInjectableTree(sourceFile, dependency));
+            shouldGenerateLocalMissingProvider(sourceFile, dependency.dependencyText));
     })
-        .map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'inject')));
+        .map((dependency) => {
+        var _a;
+        return (_a = injectedEntriesByKey.get(dependency.entry.key)) !== null && _a !== void 0 ? _a : createGeneratedDependencyEntry(sourceFile, dependency.dependencyText, 'inject');
+    }));
     return {
         deps,
         provided,
@@ -331,6 +353,216 @@ function createGeneratedDependencyEntry(sourceFile, dependencyText, context) {
         typeText: createGeneratedDependencyTypeText(sourceFile, dependencyText),
     };
 }
+function createGeneratedInjectHelperDependencyEntry(sourceFile, callExpression, expression, dependencyText) {
+    const trackedHelper = resolveTrackedInjectHelper(expression);
+    if (!trackedHelper) {
+        return createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject');
+    }
+    const exposureTracking = extractHelperExposureTracking(callExpression);
+    return {
+        key: trackedHelper.serviceName,
+        typeText: createTrackedInjectHelperTypeText(dependencyText, exposureTracking),
+    };
+}
+function createTrackedInjectHelperTypeText(dependencyText, exposureTracking) {
+    const baseType = `GetInjectedServiceDependencies<typeof ${dependencyText}>`;
+    if (!exposureTracking) {
+        return baseType;
+    }
+    return [
+        `DerivedService<${baseType}, {`,
+        `  derivedPropertiesUsed: ${formatHelperExposurePropertiesType(dependencyText, exposureTracking.usedProperties.map((sourceKey) => ({
+            propertyKey: sourceKey,
+            sourceKey,
+        })))};`,
+        `  derivedPropertiesExposed: ${formatHelperExposurePropertiesType(dependencyText, exposureTracking.exposedProperties.map(({ exposedKey, sourceKey }) => ({
+            propertyKey: exposedKey,
+            sourceKey,
+        })))};`,
+        '}>',
+    ].join('\n');
+}
+function formatHelperExposurePropertiesType(dependencyText, properties) {
+    if (properties.length === 0) {
+        return '{}';
+    }
+    return [
+        '{',
+        ...properties.map(({ propertyKey, sourceKey }) => `    ${formatObjectKey(propertyKey)}: ${createTrackedHelperOutputTypeText(dependencyText, sourceKey)};`),
+        '  }',
+    ].join('\n');
+}
+function createTrackedHelperOutputTypeText(dependencyText, sourceKey) {
+    if (sourceKey === '$self') {
+        return `GetServiceOutput<typeof ${dependencyText}>`;
+    }
+    return `GetServiceOutput<typeof ${dependencyText}>[${JSON.stringify(sourceKey)}]`;
+}
+function resolveTrackedInjectHelper(expression) {
+    var _a, _b, _c, _d;
+    const symbol = (_a = expression.getSymbol()) !== null && _a !== void 0 ? _a : expression.getType().getSymbol();
+    const declarations = (_d = (_c = (_b = symbol === null || symbol === void 0 ? void 0 : symbol.getAliasedSymbol()) === null || _b === void 0 ? void 0 : _b.getDeclarations()) !== null && _c !== void 0 ? _c : symbol === null || symbol === void 0 ? void 0 : symbol.getDeclarations()) !== null && _d !== void 0 ? _d : [];
+    for (const declaration of declarations) {
+        const helper = resolveTrackedInjectHelperFromDeclaration(declaration);
+        if (helper) {
+            return helper;
+        }
+    }
+    return undefined;
+}
+function resolveTrackedInjectHelperFromDeclaration(declaration) {
+    var _a, _b;
+    if (!Node.isBindingElement(declaration)) {
+        return undefined;
+    }
+    const objectBindingPattern = declaration.getFirstAncestorByKind(SyntaxKind.ObjectBindingPattern);
+    const variableDeclaration = objectBindingPattern === null || objectBindingPattern === void 0 ? void 0 : objectBindingPattern.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+    const initializer = variableDeclaration === null || variableDeclaration === void 0 ? void 0 : variableDeclaration.getInitializer();
+    if (!Node.isCallExpression(initializer) || !isServiceFactoryCall(initializer)) {
+        return undefined;
+    }
+    const [optionsArgument] = initializer.getArguments();
+    if (!Node.isObjectLiteralExpression(optionsArgument)) {
+        return undefined;
+    }
+    const nameInitializer = (_a = getObjectPropertyAssignment(optionsArgument, 'name')) === null || _a === void 0 ? void 0 : _a.getInitializer();
+    const scopeInitializer = (_b = getObjectPropertyAssignment(optionsArgument, 'scope')) === null || _b === void 0 ? void 0 : _b.getInitializer();
+    if (!Node.isStringLiteral(nameInitializer) ||
+        !Node.isStringLiteral(scopeInitializer)) {
+        return undefined;
+    }
+    return {
+        serviceName: nameInitializer.getLiteralText(),
+        scope: scopeInitializer.getLiteralText(),
+    };
+}
+function isServiceFactoryCall(callExpression) {
+    const expression = callExpression.getExpression();
+    if (Node.isIdentifier(expression)) {
+        return expression.getText() === 'craftService' || expression.getText() === 'toCraftService';
+    }
+    if (Node.isPropertyAccessExpression(expression)) {
+        const methodName = expression.getName();
+        return methodName === 'craftService' || methodName === 'toCraftService';
+    }
+    return false;
+}
+function extractHelperExposureTracking(callExpression) {
+    const exposeArgument = [...callExpression.getArguments()]
+        .reverse()
+        .find((argument) => Node.isArrowFunction(argument) || Node.isFunctionExpression(argument));
+    if (!exposeArgument ||
+        (!Node.isArrowFunction(exposeArgument) &&
+            !Node.isFunctionExpression(exposeArgument))) {
+        return undefined;
+    }
+    const parameter = exposeArgument.getParameters()[0];
+    const nameNode = parameter === null || parameter === void 0 ? void 0 : parameter.getNameNode();
+    if (!nameNode || !Node.isObjectBindingPattern(nameNode)) {
+        return undefined;
+    }
+    const bindings = extractHelperExposureBindings(nameNode);
+    if (bindings.length === 0) {
+        return undefined;
+    }
+    const returnObjectLiteral = getExposureReturnObjectLiteral(exposeArgument);
+    if (!returnObjectLiteral) {
+        return undefined;
+    }
+    const exposedProperties = extractHelperExposedProperties(returnObjectLiteral, bindings);
+    const usedProperties = mergeDeps(exposedProperties.map(({ sourceKey }) => sourceKey), extractHelperYieldedProperties(exposeArgument, bindings));
+    return {
+        usedProperties,
+        exposedProperties,
+    };
+}
+function extractHelperExposureBindings(bindingPattern) {
+    var _a;
+    const bindings = [];
+    for (const element of bindingPattern.getElements()) {
+        const nameNode = element.getNameNode();
+        if (!Node.isIdentifier(nameNode)) {
+            continue;
+        }
+        const propertyNameNode = element.getPropertyNameNode();
+        const sourceKey = (_a = getStaticPropertyName(propertyNameNode !== null && propertyNameNode !== void 0 ? propertyNameNode : nameNode)) !== null && _a !== void 0 ? _a : nameNode.getText();
+        bindings.push({
+            localName: nameNode.getText(),
+            sourceKey,
+        });
+    }
+    return bindings;
+}
+function getExposureReturnObjectLiteral(exposeArgument) {
+    const body = exposeArgument.getBody();
+    if (Node.isObjectLiteralExpression(body)) {
+        return body;
+    }
+    if (Node.isParenthesizedExpression(body)) {
+        const expression = body.getExpression();
+        return Node.isObjectLiteralExpression(expression) ? expression : undefined;
+    }
+    if (!Node.isBlock(body)) {
+        return undefined;
+    }
+    const returnStatement = [...body.getDescendantsOfKind(SyntaxKind.ReturnStatement)]
+        .reverse()
+        .find((statement) => Node.isObjectLiteralExpression(statement.getExpression()));
+    const expression = returnStatement === null || returnStatement === void 0 ? void 0 : returnStatement.getExpression();
+    return Node.isObjectLiteralExpression(expression) ? expression : undefined;
+}
+function extractHelperExposedProperties(objectLiteral, bindings) {
+    const bindingMap = new Map(bindings.map((binding) => [binding.localName, binding.sourceKey]));
+    const exposedProperties = [];
+    for (const property of objectLiteral.getProperties()) {
+        if (Node.isShorthandPropertyAssignment(property)) {
+            const sourceKey = bindingMap.get(property.getName());
+            if (sourceKey) {
+                exposedProperties.push({
+                    exposedKey: property.getName(),
+                    sourceKey,
+                });
+            }
+            continue;
+        }
+        if (!Node.isPropertyAssignment(property)) {
+            continue;
+        }
+        const exposedKey = getStaticPropertyName(property.getNameNode());
+        const initializer = property.getInitializer();
+        if (!exposedKey || !Node.isIdentifier(initializer)) {
+            continue;
+        }
+        const sourceKey = bindingMap.get(initializer.getText());
+        if (!sourceKey) {
+            continue;
+        }
+        exposedProperties.push({
+            exposedKey,
+            sourceKey,
+        });
+    }
+    return exposedProperties;
+}
+function extractHelperYieldedProperties(exposeArgument, bindings) {
+    const bindingMap = new Map(bindings.map((binding) => [binding.localName, binding.sourceKey]));
+    const yieldedProperties = [];
+    for (const yieldExpression of exposeArgument.getDescendantsOfKind(SyntaxKind.YieldExpression)) {
+        const expression = yieldExpression.getExpression();
+        if (!Node.isCallExpression(expression)) {
+            continue;
+        }
+        const target = expression.getExpression();
+        if (!Node.isIdentifier(target)) {
+            continue;
+        }
+        const sourceKey = bindingMap.get(target.getText());
+        if (sourceKey) {
+            yieldedProperties.push(sourceKey);
+        }
+    }
+    return yieldedProperties;
+}
 function createGeneratedDependencyKey(dependencyText) {
     var _a;
     const lastSegment = (_a = dependencyText.split('.').pop()) !== null && _a !== void 0 ? _a : dependencyText;
@@ -420,7 +652,11 @@ function formatGeneratedDependencyType(generatedDependencyGroups) {
         '{',
         `  deps: ${formatGeneratedDependencyObject(generatedDependencyGroups.deps)};`,
         `  provided: ${formatGeneratedDependencyObject(generatedDependencyGroups.provided)};`,
-        `  missingProvider: ${formatGeneratedDependencyObject(generatedDependencyGroups.missingProvider)};`,
+        ...(generatedDependencyGroups.missingProvider.length > 0
+            ? [
+                `  missingProvider: ${formatGeneratedDependencyObject(generatedDependencyGroups.missingProvider)};`,
+            ]
+            : []),
         '}',
     ].join('\n');
 }
@@ -430,10 +666,19 @@ function formatGeneratedDependencyObject(entries) {
     }
     return [
         '{',
-        ...entries.map((entry) => `    ${formatObjectKey(entry.key)}: ${entry.typeText};`),
+        ...entries.map((entry) => formatGeneratedDependencyEntry(entry)),
         '  }',
     ].join('\n');
 }
+function formatGeneratedDependencyEntry(entry) {
+    const typeLines = entry.typeText.split('\n');
+    const lines = [
+        `    ${formatObjectKey(entry.key)}: ${typeLines[0]}`,
+        ...typeLines.slice(1).map((line) => `    ${line}`),
+    ];
+    lines[lines.length - 1] += ';';
+    return lines.join('\n');
+}
 function formatObjectKey(key) {
     return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : `'${key}'`;
 }
@@ -524,7 +769,12 @@ function getInjectionHelperDependency(expression) {
     return undefined;
 }
 export function ensureHelperImports(sourceFile, helperImportPath) {
-    const missingImports = ['GetDeps'].filter((importName) => !hasLocalNamedImport(sourceFile, helperImportPath, importName));
+    const missingImports = [
+        'DerivedService',
+        'GetDeps',
+        'GetInjectedServiceDependencies',
+        'GetServiceOutput',
+    ].filter((importName) => !hasLocalNamedImport(sourceFile, helperImportPath, importName));
     if (missingImports.length === 0) {
         return;
     }
@@ -1107,6 +1357,43 @@ function isProvidedInInjectableTree(sourceFile, dependencyText) {
         !Node.isFalseLiteral(initializer) &&
         !(Node.isIdentifier(initializer) && initializer.getText() === 'undefined'));
 }
+function shouldGenerateLocalMissingProvider(sourceFile, dependencyText) {
+    return (!resolveTrackedInjectHelperByName(sourceFile, dependencyText) &&
+        !isProvidedInInjectableTree(sourceFile, dependencyText));
+}
+function resolveTrackedInjectHelperByName(sourceFile, dependencyText) {
+    const [rootIdentifier] = dependencyText.split('.');
+    if (!rootIdentifier) {
+        return undefined;
+    }
+    for (const declaration of resolveDependencyIdentifierDeclarations(sourceFile, rootIdentifier)) {
+        const helper = resolveTrackedInjectHelperFromDeclaration(declaration);
+        if (helper) {
+            return helper;
+        }
+    }
+    return undefined;
+}
+function resolveDependencyIdentifierDeclarations(sourceFile, rootIdentifier) {
+    var _a, _b, _c, _d;
+    for (const importDeclaration of sourceFile.getImportDeclarations()) {
+        const namedImport = importDeclaration.getNamedImports().find((specifier) => {
+            var _a, _b;
+            const localName = (_b = (_a = specifier.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) !== null && _b !== void 0 ? _b : specifier.getNameNode().getText();
+            return localName === rootIdentifier;
+        });
+        if (!namedImport) {
+            continue;
+        }
+        const identifier = (_a = namedImport.getAliasNode()) !== null && _a !== void 0 ? _a : namedImport.getNameNode();
+        const symbol = (_b = identifier.getSymbol()) !== null && _b !== void 0 ? _b : identifier.getType().getSymbol();
+        const aliasedSymbol = (_c = symbol === null || symbol === void 0 ? void 0 : symbol.getAliasedSymbol()) !== null && _c !== void 0 ? _c : symbol;
+        return (_d = aliasedSymbol === null || aliasedSymbol === void 0 ? void 0 : aliasedSymbol.getDeclarations()) !== null && _d !== void 0 ? _d : [namedImport];
+    }
+    return sourceFile
+        .getDescendantsOfKind(SyntaxKind.BindingElement)
+        .filter((bindingElement) => bindingElement.getName() === rootIdentifier);
+}
 function getDependencyTextFromTypeNode(typeNode) {
     if (isPrimitiveTypeNode(typeNode)) {
         return undefined;
@@ -1268,7 +1555,12 @@ function getExportRewriteSafety(sourceFile, classDeclaration, className) {
         : { safe: false, warnings };
 }
 function getHelperImportSafety(sourceFile, helperImportPath) {
-    const warnings = ['GetDeps']
+    const warnings = [
+        'DerivedService',
+        'GetDeps',
+        'GetInjectedServiceDependencies',
+        'GetServiceOutput',
+    ]
         .filter((helperName) => hasConflictingTopLevelBinding(sourceFile, helperImportPath, helperName))
         .map((helperName) => `Skipped file because "${helperName}" is already bound to a different top-level symbol.`);
     return warnings.length === 0