@saptools/service-flow 0.1.60 → 0.1.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saptools/service-flow",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/output/mermaid-output.ts

@@ -1,16 +1,21 @@
 import type { TraceResult } from '../types.js';
-function safe(value: string): string {
-  return value.replace(/[^\w-]/g, '_').slice(0, 60);
-}
 function label(trace: TraceResult, idOrLabel: string): string {
   const node = trace.nodes.find((item) => item.id === idOrLabel || item.label === idOrLabel);
   return String(node?.label ?? idOrLabel);
 }
 export function renderMermaid(trace: TraceResult): string {
+  const ids = new Map<string, string>();
+  const nodeId = (value: string): string => {
+    const existing = ids.get(value);
+    if (existing) return existing;
+    const id = `n${ids.size}`;
+    ids.set(value, id);
+    return id;
+  };
   const lines = ['flowchart TD'];
   for (const e of trace.edges)
     lines.push(
-      `  ${safe(e.from)}["${label(trace, e.from)}"] -->|${e.type}| ${safe(e.to)}["${label(trace, e.to)}"]`
+      `  ${nodeId(e.from)}["${label(trace, e.from)}"] -->|${e.type}| ${nodeId(e.to)}["${label(trace, e.to)}"]`
     );
   return `${lines.join('\n')}\n`;
 }

package/src/parsers/symbol-parser.ts

@@ -242,7 +242,17 @@ export async function parseExecutableSymbols(
       if (localName) addSymbol('method', localName, node, parentClass);
     } else if (ts.isPropertyDeclaration(node) && parentClass && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
       const localName = nameOf(node.name);
-      if (localName) addSymbol('method', localName, node.initializer, parentClass, undefined, { source: 'class_property_function', memberKind: ts.isArrowFunction(node.initializer) ? 'arrow_function_property' : 'function_expression_property' });
+      if (localName) {
+        const flags = ts.getCombinedModifierFlags(node);
+        const staticPublicExported = exportedClasses.has(parentClass) && (flags & ts.ModifierFlags.Static) !== 0 && (flags & ts.ModifierFlags.Private) === 0 && (flags & ts.ModifierFlags.Protected) === 0;
+        const isArrow = ts.isArrowFunction(node.initializer);
+        const memberKind = isArrow
+          ? (staticPublicExported ? 'static_arrow_function' : 'arrow_function_property')
+          : (staticPublicExported ? 'static_function_expression' : 'function_expression_property');
+        addSymbol('method', localName, node.initializer, parentClass, staticPublicExported ? `${parentClass}.${localName}` : undefined, staticPublicExported
+          ? { source: 'exported_class_member', exportedClass: parentClass, memberKind }
+          : { source: 'class_property_function', memberKind });
+      }
     } else if (ts.isFunctionDeclaration(node) && node.name) addSymbol('function', node.name.text, node, undefined, exported(node) ? node.name.text : undefined);
     else if (ts.isVariableStatement(node)) {
       for (const d of node.declarationList.declarations) {