@living-architecture/riviere-cli 0.8.7 → 0.8.8

package/dist/bin.js

@@ -5388,20 +5388,20 @@ var require_dependencies = __commonJS({
         const deps = propertyDeps[prop];
         if (deps.length === 0)
           continue;
-        const hasProperty2 = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
+        const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
         cxt.setParams({
           property: prop,
           depsCount: deps.length,
           deps: deps.join(", ")
         });
         if (it.allErrors) {
-          gen.if(hasProperty2, () => {
+          gen.if(hasProperty, () => {
             for (const depProp of deps) {
               (0, code_1.checkReportMissingProp)(cxt, depProp);
             }
           });
         } else {
-          gen.if((0, codegen_1._)`${hasProperty2} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
+          gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
           (0, code_1.reportMissingProp)(cxt, missing);
           gen.else();
         }
@@ -25289,21 +25289,9 @@ var COMPONENT_TYPES = [
   "domainOp",
   "event",
   "eventHandler",
+  "eventPublisher",
   "ui"
 ];
-var FIND_TARGETS = ["classes", "methods", "functions"];
-function hasProperty(obj, key) {
-  return key in obj;
-}
-function isDetectionRule(rule) {
-  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);
-}
 function extractComponents(project, sourceFilePaths, config2, globMatcher, configDir) {
   return sourceFilePaths.flatMap((filePath) => extractFromFile(project, filePath, config2, globMatcher, configDir));
 }
@@ -25343,7 +25331,7 @@ function extractWithRule(sourceFile, filePath, domain2, 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);
@@ -25565,6 +25553,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 void 0;
+    }
+    values.push(element.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue());
+  }
+  return values;
+}
 function buildExtractionResult(expression) {
   const syntaxKind = expression.getKind();
   switch (syntaxKind) {
@@ -25588,6 +25588,16 @@ function buildExtractionResult(expression) {
         kind: "boolean",
         value: false
       };
+    case SyntaxKind.ArrayLiteralExpression: {
+      const values = extractStringArray(expression);
+      if (values === void 0) {
+        return void 0;
+      }
+      return {
+        kind: "string[]",
+        value: values
+      };
+    }
     default:
       return void 0;
   }
@@ -25596,7 +25606,7 @@ function throwMissingInitializer(file2, line) {
   throw new ExtractionError("No initializer found", file2, line);
 }
 function throwNonLiteralValue(expression, file2, line) {
-  throw new ExtractionError(`Non-literal value detected (${expression.getKindName()}): ${expression.getText()}. Only inline literals (strings, numbers, booleans) are supported`, file2, line);
+  throw new ExtractionError(`Non-literal value detected (${expression.getKindName()}): ${expression.getText()}. Only inline literals (strings, numbers, booleans, string arrays) are supported`, file2, line);
 }
 function extractLiteralValue(expression, file2, line) {
   if (expression === void 0) {
@@ -27608,64 +27618,120 @@ function resolveTypeThroughInterface(typeName, project, componentIndex, options)
     uncertain: interfaceResult.typeDefinedInSource ? interfaceResult.reason : void 0
   };
 }
-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 void 0;
+}
+function resolveContainerMethod(project, typeName, calledMethodName, componentIndex) {
+  const lookup = findClassByNameInProject(project, typeName);
+  if (lookup === void 0) {
+    return void 0;
+  }
+  const method = lookup.classDecl.getMethod(calledMethodName);
+  if (method === void 0) {
+    return void 0;
+  }
+  return componentIndex.getComponentByLocation(lookup.sourceFile.getFilePath(), method.getStartLineNumber());
+}
+function findMethodInProject(project, typeName, methodName) {
+  const lookup = findClassByNameInProject(project, typeName);
+  if (lookup === void 0) {
+    return {
+      method: void 0,
+      classFound: false
+    };
+  }
   return {
-    method: void 0,
-    classFound: false
+    method: lookup.classDecl.getMethod(methodName),
+    classFound: true
   };
 }
 
 // ../riviere-extract-ts/dist/domain/connection-detection/call-graph/trace-calls.js
-function traceCallsInBody(body, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options) {
-  const callExpressions = body.getDescendantsOfKind(SyntaxKind5.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 !== void 0) {
-      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 !== void 0) {
-      traceCallsInBody(resolvedMethod, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options);
-    } else if (!classFound && uncertain !== void 0) {
-      uncertainResults.push({
-        source: sourceComponent,
-        reason: uncertain,
-        callSite: originCallSite
+function resolveComponentTarget(typeName, calledMethodName, ctx) {
+  const { component: directMatch, resolvedTypeName, uncertain } = resolveTypeThroughInterface(typeName, ctx.project, ctx.componentIndex, ctx.options);
+  if (directMatch !== void 0) {
+    return {
+      target: directMatch,
+      resolvedTypeName: void 0,
+      uncertain: void 0
+    };
+  }
+  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 !== void 0) {
+    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 !== void 0) {
+    traceBody(resolvedMethod, ctx);
+    return;
+  }
+  if (!classFound && outcome.uncertain !== void 0) {
+    ctx.uncertainResults.push({
+      source: ctx.sourceComponent,
+      reason: outcome.uncertain,
+      callSite: ctx.originCallSite
+    });
+  }
+}
+function traceBody(body, ctx) {
+  const callExpressions = body.getDescendantsOfKind(SyntaxKind5.CallExpression);
+  for (const callExpr of callExpressions) {
+    traceCallExpression(callExpr, ctx);
   }
 }
+function traceCallsInBody(body, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options) {
+  traceBody(body, {
+    project,
+    componentIndex,
+    sourceComponent,
+    originCallSite,
+    visited,
+    results,
+    uncertainResults,
+    options
+  });
+}
 function findClassInProject(project, component) {
   const sourceFile = project.getSourceFile(component.location.file);
   if (sourceFile === void 0) {
@@ -27673,6 +27739,29 @@ function findClassInProject(project, component) {
   }
   return sourceFile.getClasses().find((c) => c.getStartLineNumber() === component.location.line);
 }
+function findMethodLevelComponent(project, component) {
+  const sourceFile = project.getSourceFile(component.location.file);
+  if (sourceFile === void 0) {
+    return void 0;
+  }
+  for (const classDecl of sourceFile.getClasses()) {
+    const method = classDecl.getMethods().find((m) => m.getStartLineNumber() === component.location.line);
+    if (method !== void 0) {
+      return {
+        classDecl,
+        method
+      };
+    }
+  }
+  return void 0;
+}
+function findFunctionInProject(project, component) {
+  const sourceFile = project.getSourceFile(component.location.file);
+  if (sourceFile === void 0) {
+    return void 0;
+  }
+  return sourceFile.getFunctions().find((f) => f.getStartLineNumber() === component.location.line);
+}
 
 // ../riviere-extract-ts/dist/domain/connection-detection/call-graph/deduplicate-links.js
 function linkKey(source, target, type) {
@@ -27761,8 +27850,26 @@ function processCallExpression(callExpr, component, methodName, project, compone
     }
     return;
   }
+  const containerTarget = resolveContainerMethod(project, resolvedTypeName ?? typeName, calledMethodName, componentIndex);
+  if (containerTarget !== void 0) {
+    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(SyntaxKind6.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(SyntaxKind6.CallExpression);
@@ -27775,11 +27882,20 @@ function buildCallGraph(project, components, componentIndex, options) {
   const uncertainLinks = [];
   for (const component of components) {
     const classDecl = findClassInProject(project, component);
-    if (classDecl === void 0) {
+    if (classDecl !== void 0) {
+      for (const method of classDecl.getMethods()) {
+        processMethod(method, component, project, componentIndex, rawLinks, uncertainLinks, options);
+      }
+      continue;
+    }
+    const methodTarget = findMethodLevelComponent(project, component);
+    if (methodTarget !== void 0) {
+      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 !== void 0) {
+      processFunction(funcDecl, component, project, componentIndex, rawLinks, uncertainLinks, options);
     }
   }
   return deduplicateLinks(rawLinks, uncertainLinks);
@@ -27808,6 +27924,15 @@ 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 === void 0) {
     return [];
@@ -27960,7 +28085,7 @@ 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,
@@ -27990,12 +28115,6 @@ function findMatchingModule2(filePath, modules, globMatcher, configDir) {
   const pathToMatch = posix2.relative(configDir.replaceAll(/\\+/g, "/"), normalized);
   return modules.find((m) => globMatcher(pathToMatch, m.path));
 }
-function isDetectionRule2(rule) {
-  if (typeof rule !== "object" || rule === null) {
-    return false;
-  }
-  return "find" in rule && "where" in rule;
-}
 function getBuiltInRule(module, componentType) {
   const ruleMap = {
     api: module.api,
@@ -28007,10 +28126,10 @@ function getBuiltInRule(module, componentType) {
     ui: module.ui
   };
   const rule = ruleMap[componentType];
-  if (isDetectionRule2(rule)) {
-    return rule;
+  if (rule === void 0 || !("find" in rule)) {
+    return void 0;
   }
-  return void 0;
+  return rule;
 }
 function findDetectionRule(module, componentType) {
   const builtInTypes = [
@@ -28019,6 +28138,7 @@ function findDetectionRule(module, componentType) {
     "domainOp",
     "event",
     "eventHandler",
+    "eventPublisher",
     "ui"
   ];
   if (builtInTypes.includes(componentType)) {
@@ -28026,24 +28146,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 === void 0) {
@@ -28084,29 +28186,44 @@ 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);
   }
-  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 classDecl2 = findContainingClass(project, draft);
     return evaluateFromGenericArgRule(rule, classDecl2);
   }
+  if ("fromParameterType" in rule) {
+    const methodDecl = findMethodAtLine(project, draft);
+    const params = methodDecl.getParameters();
+    const position = rule.fromParameterType.position;
+    const param = params[position];
+    if (param === void 0) {
+      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 transform2 = rule.fromParameterType.transform;
+    if (transform2 === void 0) {
+      return { value: typeName };
+    }
+    return { value: applyTransforms(typeName, transform2) };
+  }
   const classDecl = findClassAtLine(project, draft);
   return evaluateClassRule(rule, classDecl);
 }
@@ -29610,7 +29727,7 @@ function parsePackageJson(pkg) {
 }
 function loadPackageJson() {
   if (true) {
-    return { version: "0.8.6" };
+    return { version: "0.8.7" };
   }
   const require2 = createRequire2(import.meta.url);
   return parsePackageJson(require2("../../package.json"));
@@ -29659,7 +29776,6 @@ program.parseAsync().catch((error48) => {
 /* istanbul ignore next -- @preserve: unreachable with valid Predicate type */
 /* istanbul ignore next -- @preserve: Anonymous declarations have undefined names; predicate correctly returns false */
 /* istanbul ignore next -- @preserve: Methods in object literals have non-class parents; predicate correctly returns false */
-/* istanbul ignore if -- @preserve: unreachable with typed ResolvedExtractionConfig; defensive guard */
 /* istanbul ignore else -- @preserve: false branch is unreachable; FindTarget is exhaustive */
 /* istanbul ignore next -- @preserve: unreachable with valid FindTarget type; defensive fallback */
 /* v8 ignore next -- @preserve: getExtends() !== undefined guarantees getBaseClass() returns a value */

package/dist/index.js

@@ -5387,20 +5387,20 @@ var require_dependencies = __commonJS({
         const deps = propertyDeps[prop];
         if (deps.length === 0)
           continue;
-        const hasProperty2 = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
+        const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
         cxt.setParams({
           property: prop,
           depsCount: deps.length,
           deps: deps.join(", ")
         });
         if (it.allErrors) {
-          gen.if(hasProperty2, () => {
+          gen.if(hasProperty, () => {
             for (const depProp of deps) {
               (0, code_1.checkReportMissingProp)(cxt, depProp);
             }
           });
         } else {
-          gen.if((0, codegen_1._)`${hasProperty2} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
+          gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
           (0, code_1.reportMissingProp)(cxt, missing);
           gen.else();
         }
@@ -25315,21 +25315,9 @@ var COMPONENT_TYPES = [
   "domainOp",
   "event",
   "eventHandler",
+  "eventPublisher",
   "ui"
 ];
-var FIND_TARGETS = ["classes", "methods", "functions"];
-function hasProperty(obj, key) {
-  return key in obj;
-}
-function isDetectionRule(rule) {
-  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);
-}
 function extractComponents(project, sourceFilePaths, config2, globMatcher, configDir) {
   return sourceFilePaths.flatMap((filePath) => extractFromFile(project, filePath, config2, globMatcher, configDir));
 }
@@ -25369,7 +25357,7 @@ function extractWithRule(sourceFile, filePath, domain2, 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);
@@ -25591,6 +25579,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 void 0;
+    }
+    values.push(element.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue());
+  }
+  return values;
+}
 function buildExtractionResult(expression) {
   const syntaxKind = expression.getKind();
   switch (syntaxKind) {
@@ -25614,6 +25614,16 @@ function buildExtractionResult(expression) {
         kind: "boolean",
         value: false
       };
+    case SyntaxKind.ArrayLiteralExpression: {
+      const values = extractStringArray(expression);
+      if (values === void 0) {
+        return void 0;
+      }
+      return {
+        kind: "string[]",
+        value: values
+      };
+    }
     default:
       return void 0;
   }
@@ -25622,7 +25632,7 @@ function throwMissingInitializer(file2, line) {
   throw new ExtractionError("No initializer found", file2, line);
 }
 function throwNonLiteralValue(expression, file2, line) {
-  throw new ExtractionError(`Non-literal value detected (${expression.getKindName()}): ${expression.getText()}. Only inline literals (strings, numbers, booleans) are supported`, file2, line);
+  throw new ExtractionError(`Non-literal value detected (${expression.getKindName()}): ${expression.getText()}. Only inline literals (strings, numbers, booleans, string arrays) are supported`, file2, line);
 }
 function extractLiteralValue(expression, file2, line) {
   if (expression === void 0) {
@@ -27634,64 +27644,120 @@ function resolveTypeThroughInterface(typeName, project, componentIndex, options)
     uncertain: interfaceResult.typeDefinedInSource ? interfaceResult.reason : void 0
   };
 }
-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 void 0;
+}
+function resolveContainerMethod(project, typeName, calledMethodName, componentIndex) {
+  const lookup = findClassByNameInProject(project, typeName);
+  if (lookup === void 0) {
+    return void 0;
+  }
+  const method = lookup.classDecl.getMethod(calledMethodName);
+  if (method === void 0) {
+    return void 0;
+  }
+  return componentIndex.getComponentByLocation(lookup.sourceFile.getFilePath(), method.getStartLineNumber());
+}
+function findMethodInProject(project, typeName, methodName) {
+  const lookup = findClassByNameInProject(project, typeName);
+  if (lookup === void 0) {
+    return {
+      method: void 0,
+      classFound: false
+    };
+  }
   return {
-    method: void 0,
-    classFound: false
+    method: lookup.classDecl.getMethod(methodName),
+    classFound: true
   };
 }
 
 // ../riviere-extract-ts/dist/domain/connection-detection/call-graph/trace-calls.js
-function traceCallsInBody(body, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options) {
-  const callExpressions = body.getDescendantsOfKind(SyntaxKind5.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 !== void 0) {
-      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 !== void 0) {
-      traceCallsInBody(resolvedMethod, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options);
-    } else if (!classFound && uncertain !== void 0) {
-      uncertainResults.push({
-        source: sourceComponent,
-        reason: uncertain,
-        callSite: originCallSite
+function resolveComponentTarget(typeName, calledMethodName, ctx) {
+  const { component: directMatch, resolvedTypeName, uncertain } = resolveTypeThroughInterface(typeName, ctx.project, ctx.componentIndex, ctx.options);
+  if (directMatch !== void 0) {
+    return {
+      target: directMatch,
+      resolvedTypeName: void 0,
+      uncertain: void 0
+    };
+  }
+  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 !== void 0) {
+    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 !== void 0) {
+    traceBody(resolvedMethod, ctx);
+    return;
+  }
+  if (!classFound && outcome.uncertain !== void 0) {
+    ctx.uncertainResults.push({
+      source: ctx.sourceComponent,
+      reason: outcome.uncertain,
+      callSite: ctx.originCallSite
+    });
+  }
+}
+function traceBody(body, ctx) {
+  const callExpressions = body.getDescendantsOfKind(SyntaxKind5.CallExpression);
+  for (const callExpr of callExpressions) {
+    traceCallExpression(callExpr, ctx);
   }
 }
+function traceCallsInBody(body, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options) {
+  traceBody(body, {
+    project,
+    componentIndex,
+    sourceComponent,
+    originCallSite,
+    visited,
+    results,
+    uncertainResults,
+    options
+  });
+}
 function findClassInProject(project, component) {
   const sourceFile = project.getSourceFile(component.location.file);
   if (sourceFile === void 0) {
@@ -27699,6 +27765,29 @@ function findClassInProject(project, component) {
   }
   return sourceFile.getClasses().find((c) => c.getStartLineNumber() === component.location.line);
 }
+function findMethodLevelComponent(project, component) {
+  const sourceFile = project.getSourceFile(component.location.file);
+  if (sourceFile === void 0) {
+    return void 0;
+  }
+  for (const classDecl of sourceFile.getClasses()) {
+    const method = classDecl.getMethods().find((m) => m.getStartLineNumber() === component.location.line);
+    if (method !== void 0) {
+      return {
+        classDecl,
+        method
+      };
+    }
+  }
+  return void 0;
+}
+function findFunctionInProject(project, component) {
+  const sourceFile = project.getSourceFile(component.location.file);
+  if (sourceFile === void 0) {
+    return void 0;
+  }
+  return sourceFile.getFunctions().find((f) => f.getStartLineNumber() === component.location.line);
+}
 
 // ../riviere-extract-ts/dist/domain/connection-detection/call-graph/deduplicate-links.js
 function linkKey(source, target, type) {
@@ -27787,8 +27876,26 @@ function processCallExpression(callExpr, component, methodName, project, compone
     }
     return;
   }
+  const containerTarget = resolveContainerMethod(project, resolvedTypeName ?? typeName, calledMethodName, componentIndex);
+  if (containerTarget !== void 0) {
+    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(SyntaxKind6.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(SyntaxKind6.CallExpression);
@@ -27801,11 +27908,20 @@ function buildCallGraph(project, components, componentIndex, options) {
   const uncertainLinks = [];
   for (const component of components) {
     const classDecl = findClassInProject(project, component);
-    if (classDecl === void 0) {
+    if (classDecl !== void 0) {
+      for (const method of classDecl.getMethods()) {
+        processMethod(method, component, project, componentIndex, rawLinks, uncertainLinks, options);
+      }
+      continue;
+    }
+    const methodTarget = findMethodLevelComponent(project, component);
+    if (methodTarget !== void 0) {
+      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 !== void 0) {
+      processFunction(funcDecl, component, project, componentIndex, rawLinks, uncertainLinks, options);
     }
   }
   return deduplicateLinks(rawLinks, uncertainLinks);
@@ -27834,6 +27950,15 @@ 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 === void 0) {
     return [];
@@ -27986,7 +28111,7 @@ 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,
@@ -28016,12 +28141,6 @@ function findMatchingModule2(filePath, modules, globMatcher, configDir) {
   const pathToMatch = posix2.relative(configDir.replaceAll(/\\+/g, "/"), normalized);
   return modules.find((m) => globMatcher(pathToMatch, m.path));
 }
-function isDetectionRule2(rule) {
-  if (typeof rule !== "object" || rule === null) {
-    return false;
-  }
-  return "find" in rule && "where" in rule;
-}
 function getBuiltInRule(module, componentType) {
   const ruleMap = {
     api: module.api,
@@ -28033,10 +28152,10 @@ function getBuiltInRule(module, componentType) {
     ui: module.ui
   };
   const rule = ruleMap[componentType];
-  if (isDetectionRule2(rule)) {
-    return rule;
+  if (rule === void 0 || !("find" in rule)) {
+    return void 0;
   }
-  return void 0;
+  return rule;
 }
 function findDetectionRule(module, componentType) {
   const builtInTypes = [
@@ -28045,6 +28164,7 @@ function findDetectionRule(module, componentType) {
     "domainOp",
     "event",
     "eventHandler",
+    "eventPublisher",
     "ui"
   ];
   if (builtInTypes.includes(componentType)) {
@@ -28052,24 +28172,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 === void 0) {
@@ -28110,29 +28212,44 @@ 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);
   }
-  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 classDecl2 = findContainingClass(project, draft);
     return evaluateFromGenericArgRule(rule, classDecl2);
   }
+  if ("fromParameterType" in rule) {
+    const methodDecl = findMethodAtLine(project, draft);
+    const params = methodDecl.getParameters();
+    const position = rule.fromParameterType.position;
+    const param = params[position];
+    if (param === void 0) {
+      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 transform2 = rule.fromParameterType.transform;
+    if (transform2 === void 0) {
+      return { value: typeName };
+    }
+    return { value: applyTransforms(typeName, transform2) };
+  }
   const classDecl = findClassAtLine(project, draft);
   return evaluateClassRule(rule, classDecl);
 }
@@ -29686,7 +29803,6 @@ export {
 /* istanbul ignore next -- @preserve: unreachable with valid Predicate type */
 /* istanbul ignore next -- @preserve: Anonymous declarations have undefined names; predicate correctly returns false */
 /* istanbul ignore next -- @preserve: Methods in object literals have non-class parents; predicate correctly returns false */
-/* istanbul ignore if -- @preserve: unreachable with typed ResolvedExtractionConfig; defensive guard */
 /* istanbul ignore else -- @preserve: false branch is unreachable; FindTarget is exhaustive */
 /* istanbul ignore next -- @preserve: unreachable with valid FindTarget type; defensive fallback */
 /* v8 ignore next -- @preserve: getExtends() !== undefined guarantees getBaseClass() returns a value */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@living-architecture/riviere-cli",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "publishConfig": {
     "access": "public"
   },
@@ -34,7 +34,7 @@
     "yaml": "^2.7.0",
     "@living-architecture/riviere-builder": "0.6.3",
     "@living-architecture/riviere-extract-config": "0.4.3",
-    "@living-architecture/riviere-extract-ts": "0.2.6",
+    "@living-architecture/riviere-extract-ts": "0.2.7",
     "@living-architecture/riviere-query": "0.5.3",
     "@living-architecture/riviere-schema": "0.5.3"
   }