@living-architecture/riviere-extract-ts 0.2.6 → 0.2.8

package/dist/domain/component-extraction/extractor.d.ts

@@ -1,4 +1,4 @@
-import type { Project } from 'ts-morph';
+import { type Project } from 'ts-morph';
 import type { ResolvedExtractionConfig } from '@living-architecture/riviere-extract-config';
 export type GlobMatcher = (path: string, pattern: string) => boolean;
 export interface DraftComponent {

package/dist/domain/component-extraction/extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/domain/component-extraction/extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,OAAO,EAER,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EACV,wBAAwB,EAIzB,MAAM,6CAA6C,CAAA;AAGpD,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAA;AAEpE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;CACf;AA4BD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,MAAM,EAAE,EACzB,MAAM,EAAE,wBAAwB,EAChC,WAAW,EAAE,WAAW,EACxB,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,EAAE,CAIlB"}
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/domain/component-extraction/extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,OAAO,EAEb,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EACV,wBAAwB,EAIzB,MAAM,6CAA6C,CAAA;AAGpD,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAA;AAEpE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;CACf;AAYD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,MAAM,EAAE,EACzB,MAAM,EAAE,wBAAwB,EAChC,WAAW,EAAE,WAAW,EACxB,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,EAAE,CAIlB"}

package/dist/domain/component-extraction/extractor.js

@@ -1,3 +1,4 @@
+import { Scope, } from 'ts-morph';
 import { posix } from 'node:path';
 import { evaluatePredicate } from '../predicate-evaluation/evaluate-predicate';
 const COMPONENT_TYPES = [
@@ -6,22 +7,9 @@ const COMPONENT_TYPES = [
     'domainOp',
     'event',
     'eventHandler',
+    'eventPublisher',
     'ui',
 ];
-const FIND_TARGETS = ['classes', 'methods', 'functions'];
-function hasProperty(obj, key) {
-    return key in obj;
-}
-function isDetectionRule(rule) {
-    /* istanbul ignore if -- @preserve: unreachable with typed ResolvedExtractionConfig; defensive guard */
-    if (typeof rule !== 'object' || rule === null) {
-        return false;
-    }
-    if (!hasProperty(rule, 'find') || !hasProperty(rule, 'where')) {
-        return false;
-    }
-    return typeof rule.find === 'string' && FIND_TARGETS.includes(rule.find);
-}
 export function extractComponents(project, sourceFilePaths, config, globMatcher, configDir) {
     return sourceFilePaths.flatMap((filePath) => extractFromFile(project, filePath, config, globMatcher, configDir));
 }
@@ -63,7 +51,7 @@ function extractWithRule(sourceFile, filePath, domain, componentType, rule) {
 }
 function extractComponentType(sourceFile, filePath, module, componentType) {
     const rule = module[componentType];
-    if (!isDetectionRule(rule)) {
+    if (!('find' in rule)) {
         return [];
     }
     return extractWithRule(sourceFile, filePath, module.name, componentType, rule);
@@ -78,6 +66,7 @@ function extractMethods(sourceFile, filePath, domain, componentType, rule) {
     return sourceFile
         .getClasses()
         .flatMap((c) => c.getMethods())
+        .filter(isPublicMethod)
         .filter((m) => evaluatePredicate(m, rule.where))
         .flatMap((m) => createMethodComponent(m, filePath, domain, componentType));
 }
@@ -87,6 +76,10 @@ function extractFunctions(sourceFile, filePath, domain, componentType, rule) {
         .filter((f) => evaluatePredicate(f, rule.where))
         .flatMap((f) => createFunctionComponent(f, filePath, domain, componentType));
 }
+function isPublicMethod(method) {
+    const scope = method.getScope();
+    return scope !== Scope.Private && scope !== Scope.Protected;
+}
 function createClassComponent(classDecl, filePath, domain, componentType) {
     const name = classDecl.getName();
     if (name === undefined) {

package/dist/domain/connection-detection/async-detection/detect-publish-connections.js

@@ -7,6 +7,15 @@ export function detectPublishConnections(project, components, options) {
     return publishers.flatMap((publisher) => extractPublisherLinks(project, publisher, events, options));
 }
 function extractPublisherLinks(project, publisher, events, options) {
+    const publishedEventType = publisher.metadata['publishedEventType'];
+    if (typeof publishedEventType === 'string') {
+        const sourceLocation = {
+            repository: '',
+            filePath: publisher.location.file,
+            lineNumber: publisher.location.line,
+        };
+        return resolvePublishTarget(publisher, publishedEventType, events, options, sourceLocation);
+    }
     const classDecl = findClassInProject(project, publisher);
     if (classDecl === undefined) {
         return [];

package/dist/domain/connection-detection/call-graph/build-call-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-call-graph.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/build-call-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,OAAO,EAEb,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EACV,gBAAgB,EACjB,MAAM,oBAAoB,CAAA;AAyG3B,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,gBAAgB,GACxB,aAAa,EAAE,CAgBjB"}
+{"version":3,"file":"build-call-graph.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/build-call-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,OAAO,EAEb,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EACV,gBAAgB,EACjB,MAAM,oBAAoB,CAAA;AAwJ3B,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,gBAAgB,GACxB,aAAa,EAAE,CA0CjB"}

package/dist/domain/connection-detection/call-graph/build-call-graph.js

@@ -1,9 +1,9 @@
 import { Node, SyntaxKind, } from 'ts-morph';
 import { componentIdentity } from './call-graph-types';
-import { findClassInProject, traceCallsInBody } from './trace-calls';
+import { findClassInProject, findFunctionInProject, findMethodLevelComponent, traceCallsInBody, } from './trace-calls';
 import { deduplicateLinks } from './deduplicate-links';
 import { resolveCallExpressionReceiverType } from './type-resolver';
-import { getCalledMethodName, resolveTypeThroughInterface, findMethodInProject, } from './call-graph-shared';
+import { getCalledMethodName, resolveContainerMethod, resolveTypeThroughInterface, findMethodInProject, } from './call-graph-shared';
 function processCallExpression(callExpr, component, methodName, project, componentIndex, rawLinks, uncertainLinks, options) {
     if (!Node.isPropertyAccessExpression(callExpr.getExpression())) {
         return;
@@ -36,8 +36,26 @@ function processCallExpression(callExpr, component, methodName, project, compone
         }
         return;
     }
+    const containerTarget = resolveContainerMethod(project, resolvedTypeName ?? typeName, calledMethodName, componentIndex);
+    if (containerTarget !== undefined) {
+        if (componentIdentity(component) !== componentIdentity(containerTarget)) {
+            rawLinks.push({
+                source: component,
+                target: containerTarget,
+                callSite: currentCallSite,
+            });
+        }
+        return;
+    }
     traceNonComponent(project, componentIndex, component, resolvedTypeName ?? typeName, calledMethodName, currentCallSite, rawLinks, uncertainLinks, uncertain, options);
 }
+function processFunction(funcDecl, component, project, componentIndex, rawLinks, uncertainLinks, options) {
+    const functionName = funcDecl.getNameOrThrow();
+    const callExpressions = funcDecl.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const callExpr of callExpressions) {
+        processCallExpression(callExpr, component, functionName, project, componentIndex, rawLinks, uncertainLinks, options);
+    }
+}
 function processMethod(method, component, project, componentIndex, rawLinks, uncertainLinks, options) {
     const methodName = method.getName();
     const callExpressions = method.getDescendantsOfKind(SyntaxKind.CallExpression);
@@ -50,11 +68,20 @@ export function buildCallGraph(project, components, componentIndex, options) {
     const uncertainLinks = [];
     for (const component of components) {
         const classDecl = findClassInProject(project, component);
-        if (classDecl === undefined) {
+        if (classDecl !== undefined) {
+            for (const method of classDecl.getMethods()) {
+                processMethod(method, component, project, componentIndex, rawLinks, uncertainLinks, options);
+            }
+            continue;
+        }
+        const methodTarget = findMethodLevelComponent(project, component);
+        if (methodTarget !== undefined) {
+            processMethod(methodTarget.method, component, project, componentIndex, rawLinks, uncertainLinks, options);
             continue;
         }
-        for (const method of classDecl.getMethods()) {
-            processMethod(method, component, project, componentIndex, rawLinks, uncertainLinks, options);
+        const funcDecl = findFunctionInProject(project, component);
+        if (funcDecl !== undefined) {
+            processFunction(funcDecl, component, project, componentIndex, rawLinks, uncertainLinks, options);
         }
     }
     return deduplicateLinks(rawLinks, uncertainLinks);

package/dist/domain/connection-detection/call-graph/call-graph-shared.d.ts

@@ -13,5 +13,6 @@ export interface MethodLookup {
 }
 export declare function getCalledMethodName(callExpr: CallExpression): string;
 export declare function resolveTypeThroughInterface(typeName: string, project: Project, componentIndex: ComponentIndex, options: CallGraphOptions): InterfaceResolutionOutcome;
+export declare function resolveContainerMethod(project: Project, typeName: string, calledMethodName: string, componentIndex: ComponentIndex): EnrichedComponent | undefined;
 export declare function findMethodInProject(project: Project, typeName: string, methodName: string): MethodLookup;
 //# sourceMappingURL=call-graph-shared.d.ts.map

package/dist/domain/connection-detection/call-graph/call-graph-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"call-graph-shared.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/call-graph-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAAE,KAAK,iBAAiB,EAAE,KAAK,OAAO,EAC1D,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAG1D,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,iBAAiB,GAAG,SAAS,CAAA;IACxC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAA;IACrC,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAGpE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,gBAAgB,GACxB,0BAA0B,CAwB5B;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,YAAY,CAgBd"}
+{"version":3,"file":"call-graph-shared.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/call-graph-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,iBAAiB,EACtB,KAAK,OAAO,EAGb,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAG1D,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,iBAAiB,GAAG,SAAS,CAAA;IACxC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAA;IACrC,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAGpE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,gBAAgB,GACxB,0BAA0B,CAwB5B;AAqBD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,cAAc,GAC7B,iBAAiB,GAAG,SAAS,CAa/B;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,YAAY,CAYd"}

package/dist/domain/connection-detection/call-graph/call-graph-shared.js

@@ -1,4 +1,4 @@
-import { SyntaxKind } from 'ts-morph';
+import { SyntaxKind, } from 'ts-morph';
 import { resolveInterface } from '../interface-resolution/resolve-interface';
 export function getCalledMethodName(callExpr) {
     const expression = callExpr.getExpression();
@@ -27,20 +27,40 @@ export function resolveTypeThroughInterface(typeName, project, componentIndex, o
         uncertain: interfaceResult.typeDefinedInSource ? interfaceResult.reason : undefined,
     };
 }
-export function findMethodInProject(project, typeName, methodName) {
+function findClassByNameInProject(project, typeName) {
     for (const sourceFile of project.getSourceFiles()) {
         for (const classDecl of sourceFile.getClasses()) {
-            if (classDecl.getName() !== typeName) {
-                continue;
+            if (classDecl.getType().getSymbol()?.getName() === typeName) {
+                return {
+                    classDecl,
+                    sourceFile,
+                };
             }
-            return {
-                method: classDecl.getMethod(methodName),
-                classFound: true,
-            };
         }
     }
+    return undefined;
+}
+export function resolveContainerMethod(project, typeName, calledMethodName, componentIndex) {
+    const lookup = findClassByNameInProject(project, typeName);
+    if (lookup === undefined) {
+        return undefined;
+    }
+    const method = lookup.classDecl.getMethod(calledMethodName);
+    if (method === undefined) {
+        return undefined;
+    }
+    return componentIndex.getComponentByLocation(lookup.sourceFile.getFilePath(), method.getStartLineNumber());
+}
+export function findMethodInProject(project, typeName, methodName) {
+    const lookup = findClassByNameInProject(project, typeName);
+    if (lookup === undefined) {
+        return {
+            method: undefined,
+            classFound: false,
+        };
+    }
     return {
-        method: undefined,
-        classFound: false,
+        method: lookup.classDecl.getMethod(methodName),
+        classFound: true,
     };
 }

package/dist/domain/connection-detection/call-graph/trace-calls.d.ts

@@ -1,7 +1,13 @@
-import { type ClassDeclaration, type Project, type MethodDeclaration } from 'ts-morph';
+import { type ClassDeclaration, type FunctionDeclaration, type MethodDeclaration, type Project } from 'ts-morph';
 import type { ComponentIndex } from '../component-index';
 import type { EnrichedComponent } from '../../value-extraction/enrich-components';
 import type { CallGraphOptions, CallSite, RawLink, UncertainRawLink } from './call-graph-types';
 export declare function traceCallsInBody(body: MethodDeclaration, project: Project, componentIndex: ComponentIndex, sourceComponent: EnrichedComponent, originCallSite: CallSite, visited: Set<string>, results: RawLink[], uncertainResults: UncertainRawLink[], options: CallGraphOptions): void;
 export declare function findClassInProject(project: Project, component: EnrichedComponent): ClassDeclaration | undefined;
+export interface MethodLevelTarget {
+    classDecl: ClassDeclaration;
+    method: MethodDeclaration;
+}
+export declare function findMethodLevelComponent(project: Project, component: EnrichedComponent): MethodLevelTarget | undefined;
+export declare function findFunctionInProject(project: Project, component: EnrichedComponent): FunctionDeclaration | undefined;
 //# sourceMappingURL=trace-calls.d.ts.map

package/dist/domain/connection-detection/call-graph/trace-calls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-calls.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/trace-calls.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAAE,KAAK,OAAO,EAAE,KAAK,iBAAiB,EAC5D,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EACV,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB,EACtD,MAAM,oBAAoB,CAAA;AAS3B,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,iBAAiB,EAClC,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,EACpB,OAAO,EAAE,OAAO,EAAE,EAClB,gBAAgB,EAAE,gBAAgB,EAAE,EACpC,OAAO,EAAE,gBAAgB,GACxB,IAAI,CAiEN;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,iBAAiB,GAC3B,gBAAgB,GAAG,SAAS,CAM9B"}
+{"version":3,"file":"trace-calls.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/trace-calls.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,OAAO,EAEb,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EACV,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB,EACtD,MAAM,oBAAoB,CAAA;AA8H3B,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,iBAAiB,EAClC,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,EACpB,OAAO,EAAE,OAAO,EAAE,EAClB,gBAAgB,EAAE,gBAAgB,EAAE,EACpC,OAAO,EAAE,gBAAgB,GACxB,IAAI,CAWN;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,iBAAiB,GAC3B,gBAAgB,GAAG,SAAS,CAM9B;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,gBAAgB,CAAA;IAC3B,MAAM,EAAE,iBAAiB,CAAA;CAC1B;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,iBAAiB,GAC3B,iBAAiB,GAAG,SAAS,CAiB/B;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,iBAAiB,GAC3B,mBAAmB,GAAG,SAAS,CAMjC"}

package/dist/domain/connection-detection/call-graph/trace-calls.js

@@ -1,47 +1,82 @@
-import { SyntaxKind } from 'ts-morph';
+import { SyntaxKind, } from 'ts-morph';
 import { componentIdentity } from './call-graph-types';
 import { resolveCallExpressionReceiverType } from './type-resolver';
-import { getCalledMethodName, resolveTypeThroughInterface, findMethodInProject, } from './call-graph-shared';
-export function traceCallsInBody(body, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options) {
-    const callExpressions = body.getDescendantsOfKind(SyntaxKind.CallExpression);
-    for (const callExpr of callExpressions) {
-        const sourceFile = callExpr.getSourceFile();
-        const typeResult = resolveCallExpressionReceiverType(callExpr, sourceFile, { strict: options.strict, });
-        if (!typeResult.resolved) {
-            continue;
-        }
-        const typeName = typeResult.typeName;
-        const calledMethodName = getCalledMethodName(callExpr);
-        const { component: targetComponent, resolvedTypeName, uncertain, } = resolveTypeThroughInterface(typeName, project, componentIndex, options);
-        if (targetComponent !== undefined) {
-            if (componentIdentity(sourceComponent) !== componentIdentity(targetComponent)) {
-                results.push({
-                    source: sourceComponent,
-                    target: targetComponent,
-                    callSite: originCallSite,
-                });
-            }
-            continue;
-        }
-        const traceTypeName = resolvedTypeName ?? typeName;
-        const visitKey = `${traceTypeName}.${calledMethodName}`;
-        if (visited.has(visitKey)) {
-            continue;
-        }
-        visited.add(visitKey);
-        const { method: resolvedMethod, classFound } = findMethodInProject(project, traceTypeName, calledMethodName);
-        if (resolvedMethod !== undefined) {
-            traceCallsInBody(resolvedMethod, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options);
-        }
-        else if (!classFound && uncertain !== undefined) {
-            uncertainResults.push({
-                source: sourceComponent,
-                reason: uncertain,
-                callSite: originCallSite,
+import { getCalledMethodName, resolveContainerMethod, resolveTypeThroughInterface, findMethodInProject, } from './call-graph-shared';
+function resolveComponentTarget(typeName, calledMethodName, ctx) {
+    const { component: directMatch, resolvedTypeName, uncertain, } = resolveTypeThroughInterface(typeName, ctx.project, ctx.componentIndex, ctx.options);
+    if (directMatch !== undefined) {
+        return {
+            target: directMatch,
+            resolvedTypeName: undefined,
+            uncertain: undefined,
+        };
+    }
+    const containerTarget = resolveContainerMethod(ctx.project, resolvedTypeName ?? typeName, calledMethodName, ctx.componentIndex);
+    return {
+        target: containerTarget,
+        resolvedTypeName,
+        uncertain,
+    };
+}
+function traceCallExpression(callExpr, ctx) {
+    const sourceFile = callExpr.getSourceFile();
+    const typeResult = resolveCallExpressionReceiverType(callExpr, sourceFile, { strict: ctx.options.strict, });
+    if (!typeResult.resolved) {
+        return;
+    }
+    const typeName = typeResult.typeName;
+    const calledMethodName = getCalledMethodName(callExpr);
+    const outcome = resolveComponentTarget(typeName, calledMethodName, ctx);
+    if (outcome.target !== undefined) {
+        if (componentIdentity(ctx.sourceComponent) !== componentIdentity(outcome.target)) {
+            ctx.results.push({
+                source: ctx.sourceComponent,
+                target: outcome.target,
+                callSite: ctx.originCallSite,
             });
         }
+        return;
+    }
+    traceIntoNonComponent(typeName, calledMethodName, outcome, ctx);
+}
+function traceIntoNonComponent(typeName, calledMethodName, outcome, ctx) {
+    const traceTypeName = outcome.resolvedTypeName ?? typeName;
+    const visitKey = `${traceTypeName}.${calledMethodName}`;
+    if (ctx.visited.has(visitKey)) {
+        return;
+    }
+    ctx.visited.add(visitKey);
+    const { method: resolvedMethod, classFound } = findMethodInProject(ctx.project, traceTypeName, calledMethodName);
+    if (resolvedMethod !== undefined) {
+        traceBody(resolvedMethod, ctx);
+        return;
+    }
+    if (!classFound && outcome.uncertain !== undefined) {
+        ctx.uncertainResults.push({
+            source: ctx.sourceComponent,
+            reason: outcome.uncertain,
+            callSite: ctx.originCallSite,
+        });
+    }
+}
+function traceBody(body, ctx) {
+    const callExpressions = body.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const callExpr of callExpressions) {
+        traceCallExpression(callExpr, ctx);
     }
 }
+export function traceCallsInBody(body, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options) {
+    traceBody(body, {
+        project,
+        componentIndex,
+        sourceComponent,
+        originCallSite,
+        visited,
+        results,
+        uncertainResults,
+        options,
+    });
+}
 export function findClassInProject(project, component) {
     const sourceFile = project.getSourceFile(component.location.file);
     if (sourceFile === undefined) {
@@ -49,3 +84,28 @@ export function findClassInProject(project, component) {
     }
     return sourceFile.getClasses().find((c) => c.getStartLineNumber() === component.location.line);
 }
+export function findMethodLevelComponent(project, component) {
+    const sourceFile = project.getSourceFile(component.location.file);
+    if (sourceFile === undefined) {
+        return undefined;
+    }
+    for (const classDecl of sourceFile.getClasses()) {
+        const method = classDecl
+            .getMethods()
+            .find((m) => m.getStartLineNumber() === component.location.line);
+        if (method !== undefined) {
+            return {
+                classDecl,
+                method,
+            };
+        }
+    }
+    return undefined;
+}
+export function findFunctionInProject(project, component) {
+    const sourceFile = project.getSourceFile(component.location.file);
+    if (sourceFile === undefined) {
+        return undefined;
+    }
+    return sourceFile.getFunctions().find((f) => f.getStartLineNumber() === component.location.line);
+}

package/dist/domain/connection-detection/detect-connections.js

@@ -15,7 +15,7 @@ export function detectConnections(project, components, options, globMatcher) {
     const componentIndex = new ComponentIndex(components);
     const sourceFilePaths = computeFilteredFilePaths(project, options.moduleGlobs, globMatcher);
     const setupMs = performance.now() - setupStart;
-    const strict = !options.allowIncomplete;
+    const strict = options.allowIncomplete !== true;
     const callGraphStart = performance.now();
     const syncLinks = buildCallGraph(project, components, componentIndex, {
         strict,

package/dist/domain/value-extraction/enrich-components.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enrich-components.d.ts","sourceRoot":"","sources":["../../../src/domain/value-extraction/enrich-components.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAC2B,OAAO,EAC7C,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EACV,wBAAwB,EAUzB,MAAM,6CAA6C,CAAA;AACpD,OAAO,KAAK,EACV,cAAc,EAAE,WAAW,EAC5B,MAAM,mCAAmC,CAAA;AAY1C,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAA;AAEzD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACvC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,cAAc,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,iBAAiB,EAAE,CAAA;IAC/B,QAAQ,EAAE,iBAAiB,EAAE,CAAA;CAC9B;AA8RD,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,cAAc,EAAE,EACjC,MAAM,EAAE,wBAAwB,EAChC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,GAChB,gBAAgB,CAclB"}
+{"version":3,"file":"enrich-components.d.ts","sourceRoot":"","sources":["../../../src/domain/value-extraction/enrich-components.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAC2B,OAAO,EAC7C,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EACV,wBAAwB,EAKzB,MAAM,6CAA6C,CAAA;AACpD,OAAO,KAAK,EACV,cAAc,EAAE,WAAW,EAC5B,MAAM,mCAAmC,CAAA;AAa1C,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAA;AAEzD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACvC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,cAAc,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,iBAAiB,EAAE,CAAA;IAC/B,QAAQ,EAAE,iBAAiB,EAAE,CAAA;CAC9B;AAmRD,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,cAAc,EAAE,EACjC,MAAM,EAAE,wBAAwB,EAChC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,GAChB,gBAAgB,CAclB"}

package/dist/domain/value-extraction/enrich-components.js

@@ -2,18 +2,12 @@ import { posix } from 'node:path';
 import { evaluateLiteralRule, evaluateFromClassNameRule, evaluateFromFilePathRule, evaluateFromPropertyRule, evaluateFromMethodNameRule, } from './evaluate-extraction-rule';
 import { evaluateFromGenericArgRule } from './evaluate-extraction-rule-generic';
 import { ExtractionError } from '../../platform/domain/ast-literals/literal-detection';
+import { applyTransforms } from '../../platform/domain/string-transforms/transforms';
 function findMatchingModule(filePath, modules, globMatcher, configDir) {
     const normalized = filePath.replaceAll(/\\+/g, '/');
     const pathToMatch = posix.relative(configDir.replaceAll(/\\+/g, '/'), normalized);
     return modules.find((m) => globMatcher(pathToMatch, m.path));
 }
-function isDetectionRule(rule) {
-    /* istanbul ignore if -- @preserve: unreachable with typed ResolvedExtractionConfig; defensive guard */
-    if (typeof rule !== 'object' || rule === null) {
-        return false;
-    }
-    return 'find' in rule && 'where' in rule;
-}
 function getBuiltInRule(module, componentType) {
     const ruleMap = {
         api: module.api,
@@ -25,10 +19,10 @@ function getBuiltInRule(module, componentType) {
         ui: module.ui,
     };
     const rule = ruleMap[componentType];
-    if (isDetectionRule(rule)) {
-        return rule;
+    if (rule === undefined || !('find' in rule)) {
+        return undefined;
     }
-    return undefined;
+    return rule;
 }
 function findDetectionRule(module, componentType) {
     const builtInTypes = [
@@ -37,6 +31,7 @@ function findDetectionRule(module, componentType) {
         'domainOp',
         'event',
         'eventHandler',
+        'eventPublisher',
         'ui',
     ];
     if (builtInTypes.includes(componentType)) {
@@ -44,24 +39,6 @@ function findDetectionRule(module, componentType) {
     }
     return module.customTypes?.[componentType];
 }
-function isLiteralRule(rule) {
-    return 'literal' in rule;
-}
-function isFromClassNameRule(rule) {
-    return 'fromClassName' in rule;
-}
-function isFromFilePathRule(rule) {
-    return 'fromFilePath' in rule;
-}
-function isFromPropertyRule(rule) {
-    return 'fromProperty' in rule;
-}
-function isFromMethodNameRule(rule) {
-    return 'fromMethodName' in rule;
-}
-function isFromGenericArgRule(rule) {
-    return 'fromGenericArg' in rule;
-}
 function findClassAtLine(project, draft) {
     const sourceFile = project.getSourceFile(draft.location.file);
     if (sourceFile === undefined) {
@@ -106,30 +83,45 @@ function findContainingClass(project, draft) {
     throw new ExtractionError(`No containing class found for method at line ${methodLine}`, draft.location.file, draft.location.line);
 }
 function evaluateClassRule(rule, classDecl) {
-    if (isFromClassNameRule(rule)) {
+    if ('fromClassName' in rule) {
         return evaluateFromClassNameRule(rule, classDecl);
     }
     /* istanbul ignore next -- @preserve: only fromProperty reaches here; defensive guard */
-    if (!isFromPropertyRule(rule)) {
+    if (!('fromProperty' in rule)) {
         throw new ExtractionError('Unsupported extraction rule type for class-based component', classDecl.getSourceFile().getFilePath(), classDecl.getStartLineNumber());
     }
     return evaluateFromPropertyRule(rule, classDecl);
 }
 function evaluateRule(rule, draft, project) {
-    if (isLiteralRule(rule)) {
+    if ('literal' in rule) {
         return evaluateLiteralRule(rule);
     }
-    if (isFromFilePathRule(rule)) {
+    if ('fromFilePath' in rule) {
         return evaluateFromFilePathRule(rule, draft.location.file);
     }
-    if (isFromMethodNameRule(rule)) {
+    if ('fromMethodName' in rule) {
         const methodDecl = findMethodAtLine(project, draft);
         return evaluateFromMethodNameRule(rule, methodDecl);
     }
-    if (isFromGenericArgRule(rule)) {
+    if ('fromGenericArg' in rule) {
         const classDecl = findContainingClass(project, draft);
         return evaluateFromGenericArgRule(rule, classDecl);
     }
+    if ('fromParameterType' in rule) {
+        const methodDecl = findMethodAtLine(project, draft);
+        const params = methodDecl.getParameters();
+        const position = rule.fromParameterType.position;
+        const param = params[position];
+        if (param === undefined) {
+            throw new ExtractionError(`Parameter position ${position} out of bounds. Method has ${params.length} parameter(s)`, draft.location.file, draft.location.line);
+        }
+        const typeName = param.getTypeNode()?.getText() ?? 'unknown';
+        const transform = rule.fromParameterType.transform;
+        if (transform === undefined) {
+            return { value: typeName };
+        }
+        return { value: applyTransforms(typeName, transform) };
+    }
     const classDecl = findClassAtLine(project, draft);
     return evaluateClassRule(rule, classDecl);
 }

package/dist/platform/domain/ast-literals/literal-detection.d.ts

@@ -19,6 +19,9 @@ export type LiteralResult = {
 } | {
     kind: 'boolean';
     value: boolean;
+} | {
+    kind: 'string[]';
+    value: string[];
 };
 export declare function extractLiteralValue(expression: Expression | undefined, file: string, line: number): LiteralResult;
 //# sourceMappingURL=literal-detection.d.ts.map

package/dist/platform/domain/ast-literals/literal-detection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"literal-detection.d.ts","sourceRoot":"","sources":["../../../../src/platform/domain/ast-literals/literal-detection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG1C,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,QAAQ,EAAE;QACjB,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;gBAEW,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAQxD;AAED,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAY1E;AAED,MAAM,MAAM,aAAa,GACrB;IACA,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;CACd,GACC;IACA,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;CACd,GACC;IACA,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAmDH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,aAAa,CAWf"}
+{"version":3,"file":"literal-detection.d.ts","sourceRoot":"","sources":["../../../../src/platform/domain/ast-literals/literal-detection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG1C,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,QAAQ,EAAE;QACjB,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;gBAEW,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAQxD;AAED,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAa1E;AAUD,MAAM,MAAM,aAAa,GACrB;IACA,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;CACd,GACC;IACA,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;CACd,GACC;IACA,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;CACf,GACC;IACA,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AA0EH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,aAAa,CAWf"}

package/dist/platform/domain/ast-literals/literal-detection.js

@@ -24,7 +24,15 @@ export function isLiteralValue(expression) {
     return (kind === SyntaxKind.StringLiteral ||
         kind === SyntaxKind.NumericLiteral ||
         kind === SyntaxKind.TrueKeyword ||
-        kind === SyntaxKind.FalseKeyword);
+        kind === SyntaxKind.FalseKeyword ||
+        isStringArrayLiteral(expression));
+}
+function isStringArrayLiteral(expression) {
+    if (expression.getKind() !== SyntaxKind.ArrayLiteralExpression) {
+        return false;
+    }
+    const elements = expression.asKindOrThrow(SyntaxKind.ArrayLiteralExpression).getElements();
+    return elements.every((e) => e.getKind() === SyntaxKind.StringLiteral);
 }
 function extractString(expression) {
     return expression.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
@@ -32,6 +40,18 @@ function extractString(expression) {
 function extractNumber(expression) {
     return Number(expression.getText());
 }
+function extractStringArray(expression) {
+    const arrayLiteral = expression.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+    const elements = arrayLiteral.getElements();
+    const values = [];
+    for (const element of elements) {
+        if (element.getKind() !== SyntaxKind.StringLiteral) {
+            return undefined;
+        }
+        values.push(element.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue());
+    }
+    return values;
+}
 function buildExtractionResult(expression) {
     const syntaxKind = expression.getKind();
     switch (syntaxKind) {
@@ -55,6 +75,16 @@ function buildExtractionResult(expression) {
                 kind: 'boolean',
                 value: false,
             };
+        case SyntaxKind.ArrayLiteralExpression: {
+            const values = extractStringArray(expression);
+            if (values === undefined) {
+                return undefined;
+            }
+            return {
+                kind: 'string[]',
+                value: values,
+            };
+        }
         default:
             return undefined;
     }
@@ -63,7 +93,7 @@ function throwMissingInitializer(file, line) {
     throw new ExtractionError('No initializer found', file, line);
 }
 function throwNonLiteralValue(expression, file, line) {
-    throw new ExtractionError(`Non-literal value detected (${expression.getKindName()}): ${expression.getText()}. Only inline literals (strings, numbers, booleans) are supported`, file, line);
+    throw new ExtractionError(`Non-literal value detected (${expression.getKindName()}): ${expression.getText()}. Only inline literals (strings, numbers, booleans, string arrays) are supported`, file, line);
 }
 export function extractLiteralValue(expression, file, line) {
     if (expression === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@living-architecture/riviere-extract-ts",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "publishConfig": {
     "access": "public"