@yalehwang/archguard 0.1.23 → 0.1.31

package/dist/mermaid/generator.js

@@ -1,17 +1,19 @@
+import path from 'path';
+import { globalEntityTypeRegistry } from '../core/entity-type-registry.js';
 import { CommentGenerator } from './comment-generator.js';
 import { groupEntitiesByPackage } from './generator-grouping.js';
 import { validateGeneratorInput } from './generator-validation.js';
-const ENTITY_CLASSDEF_STYLES = {
-    classNode: 'fill:#f6f8fa,stroke:#d0d7de,color:#24292f',
-    interface: 'fill:#ddf4ff,stroke:#54aeff,color:#0969da',
-    enum: 'fill:#fff8c5,stroke:#d4a72c,color:#633c01',
-    struct: 'fill:#f6f8fa,stroke:#d0d7de,color:#24292f',
-    trait: 'fill:#ddf4ff,stroke:#54aeff,color:#0969da',
-    abstract_class: 'fill:#fdf4ff,stroke:#d2a8ff,color:#8250df',
-    function: 'fill:#f6f8fa,stroke:#d0d7de,color:#57606a',
-};
-function entityTypeToClassDef(type) {
-    return type === 'class' ? 'classNode' : type;
+import { ENTITY_CLASSDEF_STYLES, normalizeEntityName, escapeId, generateRelationLine as _generateRelationLine, isNoisyTarget, generateClassDefinition as _generateClassDefinition, } from './generator-formatting.js';
+function entityTypeToClassDef(type, registry = globalEntityTypeRegistry) {
+    if (type === 'class')
+        return 'classNode';
+    if (type in ENTITY_CLASSDEF_STYLES)
+        return type;
+    const custom = registry.get(type);
+    if (custom?.mermaidShape && custom.mermaidShape !== 'default') {
+        return custom.mermaidShape === 'component' ? 'interface' : 'classNode';
+    }
+    return 'classNode';
 }
 export class ValidatedMermaidGenerator {
     archJson;
@@ -36,14 +38,6 @@ export class ValidatedMermaidGenerator {
     }
     generate() {
         validateGeneratorInput(this.archJson, this.verbose);
-        const lines = ['classDiagram'];
-        if (this.diagramConfig && this.diagramConfig.annotations?.enableComments !== false) {
-            const comments = this.commentGenerator.generateAll(this.diagramConfig);
-            if (comments) {
-                lines.push(comments);
-                lines.push('');
-            }
-        }
         let diagramCode;
         switch (this.options.level) {
             case 'package':
@@ -57,7 +51,16 @@ export class ValidatedMermaidGenerator {
                 diagramCode = this.generateClassLevel();
                 break;
         }
-        const diagramLines = diagramCode.split('\n').slice(1);
+        const diagramLines = diagramCode.split('\n');
+        const header = diagramLines.shift() || 'classDiagram';
+        const lines = [header];
+        if (this.diagramConfig && this.diagramConfig.annotations?.enableComments !== false) {
+            const comments = this.commentGenerator.generateAll(this.diagramConfig);
+            if (comments) {
+                lines.push(comments);
+                lines.push('');
+            }
+        }
         lines.push(...diagramLines);
         if (this.diagramConfig && this.diagramConfig.annotations?.enableVisibleTitle) {
             const visibleTitle = this.commentGenerator.generateVisibleTitle(this.diagramConfig);
@@ -67,7 +70,7 @@ export class ValidatedMermaidGenerator {
                     lines.push(visibleTitle);
                 }
                 else {
-                    const insertIndex = lines.findIndex((line) => !line.startsWith('%%') && line !== 'classDiagram');
+                    const insertIndex = lines.findIndex((line) => !line.startsWith('%%') && line !== header);
                     if (insertIndex !== -1) {
                         lines.splice(insertIndex, 0, visibleTitle);
                     }
@@ -78,6 +81,9 @@ export class ValidatedMermaidGenerator {
         return this.postProcess(code);
     }
     generatePackageLevel() {
+        if (this.getArchitecturalLayers()) {
+            return this.generateLayeredPackageLevel();
+        }
         const lines = ['classDiagram'];
         const packageGroups = groupEntitiesByPackage(this.archJson, this.options.grouping);
         for (const group of packageGroups) {
@@ -85,18 +91,105 @@ export class ValidatedMermaidGenerator {
             for (const entityId of group.entities) {
                 const entity = this.archJson.entities.find((e) => e.id === entityId);
                 if (entity) {
-                    entityLines.push(`    class ${this.escapeId(this.normalizeEntityName(entity.name))}`);
+                    entityLines.push(`    class ${escapeId(normalizeEntityName(entity.name))}`);
                 }
             }
             if (entityLines.length === 0)
                 continue;
-            lines.push(`  namespace ${this.escapeId(group.name)} {`);
+            lines.push(`  namespace ${escapeId(group.name)} {`);
             lines.push(...entityLines);
             lines.push('  }');
         }
         lines.push(...this.generateRelations(packageGroups));
         return lines.join('\n');
     }
+    getArchitecturalLayers() {
+        const layers = this.archJson.extensions?.projectSemantics?.architecturalLayers;
+        return layers && Object.keys(layers).length > 0 ? layers : undefined;
+    }
+    normalizePackagePath(filePath) {
+        const normalizedFile = filePath.replace(/\\/g, '/');
+        const workspaceRoot = this.archJson.workspaceRoot?.replace(/\\/g, '/');
+        if (workspaceRoot && path.isAbsolute(filePath)) {
+            return path.posix.dirname(path.posix.relative(workspaceRoot, normalizedFile));
+        }
+        return path.posix.dirname(normalizedFile);
+    }
+    findMatchingLayer(packageName, layers) {
+        const normalizedPackage = packageName.replace(/\\/g, '/');
+        const candidates = Object.entries(layers)
+            .map(([key, label]) => ({ key: key.replace(/\\/g, '/'), label }))
+            .filter(({ key }) => normalizedPackage === key || normalizedPackage.startsWith(`${key}/`))
+            .sort((left, right) => right.key.length - left.key.length);
+        return candidates[0] ?? null;
+    }
+    generateLayeredPackageLevel() {
+        const architecturalLayers = this.getArchitecturalLayers();
+        if (!architecturalLayers) {
+            return this.generatePackageLevel();
+        }
+        const direction = this.options.grouping.layout?.direction ?? 'TB';
+        const lines = [`flowchart ${direction}`];
+        const entityPackageIndex = new Map();
+        const packageNames = [];
+        const seenPackages = new Set();
+        for (const entity of this.archJson.entities) {
+            const sourceFile = entity.sourceLocation?.file;
+            if (!sourceFile)
+                continue;
+            const packageName = this.normalizePackagePath(sourceFile);
+            if (!packageName || packageName === '.')
+                continue;
+            entityPackageIndex.set(entity.id, packageName);
+            entityPackageIndex.set(entity.name, packageName);
+            if (!seenPackages.has(packageName)) {
+                seenPackages.add(packageName);
+                packageNames.push(packageName);
+            }
+        }
+        const groupedPackages = new Map();
+        const unmatchedPackages = [];
+        for (const packageName of packageNames) {
+            const layerMatch = this.findMatchingLayer(packageName, architecturalLayers);
+            if (!layerMatch) {
+                unmatchedPackages.push(packageName);
+                continue;
+            }
+            if (!groupedPackages.has(layerMatch.label)) {
+                groupedPackages.set(layerMatch.label, []);
+            }
+            groupedPackages.get(layerMatch.label)?.push(packageName);
+        }
+        const nodeIdForPackage = (packageName) => escapeId(`pkg_${packageName}`);
+        for (const [label, layerPackages] of groupedPackages.entries()) {
+            if (layerPackages.length === 0)
+                continue;
+            lines.push(`  subgraph ${escapeId(`layer_${label}`)}["${label}"]`);
+            for (const packageName of layerPackages) {
+                lines.push(`    ${nodeIdForPackage(packageName)}["${packageName}"]`);
+            }
+            lines.push('  end');
+        }
+        for (const packageName of unmatchedPackages) {
+            lines.push(`  ${nodeIdForPackage(packageName)}["${packageName}"]`);
+        }
+        const relationEdges = new Set();
+        for (const relation of this.archJson.relations) {
+            const sourcePackage = entityPackageIndex.get(relation.source) ??
+                entityPackageIndex.get(normalizeEntityName(relation.source));
+            const targetPackage = entityPackageIndex.get(relation.target) ??
+                entityPackageIndex.get(normalizeEntityName(relation.target));
+            if (!sourcePackage || !targetPackage || sourcePackage === targetPackage) {
+                continue;
+            }
+            const edge = `  ${nodeIdForPackage(sourcePackage)} --> ${nodeIdForPackage(targetPackage)}`;
+            if (!relationEdges.has(edge)) {
+                relationEdges.add(edge);
+                lines.push(edge);
+            }
+        }
+        return lines.join('\n');
+    }
     generateClassLevel() {
         const lines = ['classDiagram'];
         for (const [name, style] of Object.entries(ENTITY_CLASSDEF_STYLES)) {
@@ -107,40 +200,57 @@ export class ValidatedMermaidGenerator {
         const visibleEntities = this.archJson.entities.filter((e) => e.type !== 'function');
         const knownEntityNames = new Set(visibleEntities.map((e) => e.name));
         const knownEntityIds = new Set(visibleEntities.map((e) => e.id));
+        const modulePrefixIndex = this.buildModulePrefixIndex(knownEntityIds);
         if (packageGroups.length > 0 && packageGroups[0]?.name !== 'Default') {
             for (const group of packageGroups) {
                 const entityLines = [];
                 for (const entityId of group.entities) {
                     const entity = visibleEntities.find((e) => e.id === entityId);
                     if (entity) {
-                        entityLines.push(...this.generateClassDefinition(entity, 2, true));
+                        entityLines.push(..._generateClassDefinition(entity, 2, this.options));
                     }
                 }
                 if (entityLines.length === 0)
                     continue;
-                lines.push(`  namespace ${this.escapeId(group.name)} {`);
+                lines.push(`  namespace ${escapeId(group.name)} {`);
                 lines.push(...entityLines);
                 lines.push('  }');
             }
             for (const relation of this.archJson.relations) {
-                if ((knownEntityNames.has(relation.source) || knownEntityIds.has(relation.source)) &&
-                    (knownEntityIds.has(relation.target) ||
-                        knownEntityNames.has(relation.target) ||
-                        !this.isNoisyTarget(relation.target))) {
-                    lines.push(`  ${this.generateRelationLine(relation)}`);
+                const sourceKnownDirect = knownEntityNames.has(relation.source) || knownEntityIds.has(relation.source);
+                const sourceKnownViaPrefix = !sourceKnownDirect && modulePrefixIndex.has(relation.source);
+                const sourceKnown = sourceKnownDirect || sourceKnownViaPrefix;
+                const targetOk = knownEntityIds.has(relation.target) ||
+                    knownEntityNames.has(relation.target) ||
+                    sourceKnownViaPrefix ||
+                    !isNoisyTarget(relation.target);
+                if (sourceKnown && targetOk) {
+                    {
+                        const _line = _generateRelationLine(relation, this.entityIdToName);
+                        if (_line !== null)
+                            lines.push(`  ${_line}`);
+                    }
                 }
             }
         }
         else {
             for (const entity of visibleEntities) {
-                lines.push(...this.generateClassDefinition(entity, 1, true));
+                lines.push(..._generateClassDefinition(entity, 1, this.options));
             }
             for (const relation of this.archJson.relations) {
-                if ((knownEntityNames.has(relation.source) || knownEntityIds.has(relation.source)) &&
-                    (knownEntityIds.has(relation.target) ||
-                        knownEntityNames.has(relation.target) ||
-                        !this.isNoisyTarget(relation.target))) {
-                    lines.push(`  ${this.generateRelationLine(relation)}`);
+                const sourceKnownDirect = knownEntityNames.has(relation.source) || knownEntityIds.has(relation.source);
+                const sourceKnownViaPrefix = !sourceKnownDirect && modulePrefixIndex.has(relation.source);
+                const sourceKnown = sourceKnownDirect || sourceKnownViaPrefix;
+                const targetOk = knownEntityIds.has(relation.target) ||
+                    knownEntityNames.has(relation.target) ||
+                    sourceKnownViaPrefix ||
+                    !isNoisyTarget(relation.target);
+                if (sourceKnown && targetOk) {
+                    {
+                        const _line = _generateRelationLine(relation, this.entityIdToName);
+                        if (_line !== null)
+                            lines.push(`  ${_line}`);
+                    }
                 }
             }
         }
@@ -148,7 +258,7 @@ export class ValidatedMermaidGenerator {
         lines.push('  %% Node type annotations');
         const seenAnnotationsClass = new Set();
         for (const entity of visibleEntities) {
-            const normalizedId = this.escapeId(this.normalizeEntityName(entity.name));
+            const normalizedId = escapeId(normalizeEntityName(entity.name));
             if (seenAnnotationsClass.has(normalizedId))
                 continue;
             seenAnnotationsClass.add(normalizedId);
@@ -172,32 +282,37 @@ export class ValidatedMermaidGenerator {
                 for (const entityId of group.entities) {
                     const entity = visibleEntities.find((e) => e.id === entityId);
                     if (entity) {
-                        entityLines.push(...this.generateClassDefinition(entity, 2, true));
+                        entityLines.push(..._generateClassDefinition(entity, 2, this.options));
                     }
                 }
                 if (entityLines.length === 0)
                     continue;
-                lines.push(`  namespace ${this.escapeId(group.name)} {`);
+                lines.push(`  namespace ${escapeId(group.name)} {`);
                 lines.push(...entityLines);
                 lines.push('  }');
             }
         }
         else {
             for (const entity of visibleEntities) {
-                lines.push(...this.generateClassDefinition(entity, 1, true));
+                lines.push(..._generateClassDefinition(entity, 1, this.options));
             }
         }
+        const modulePrefixIndexMethod = this.buildModulePrefixIndex(knownEntityIds);
         for (const relation of this.archJson.relations) {
-            if ((knownEntityNames.has(relation.source) || knownEntityIds.has(relation.source)) &&
-                !this.isNoisyTarget(relation.target)) {
-                lines.push(`  ${this.generateRelationLine(relation)}`);
+            const sourceKnownDirect = knownEntityNames.has(relation.source) || knownEntityIds.has(relation.source);
+            const sourceKnownViaPrefix = !sourceKnownDirect && modulePrefixIndexMethod.has(relation.source);
+            const sourceKnown = sourceKnownDirect || sourceKnownViaPrefix;
+            if (sourceKnown && (sourceKnownViaPrefix || !isNoisyTarget(relation.target))) {
+                const _line = _generateRelationLine(relation, this.entityIdToName);
+                if (_line !== null)
+                    lines.push(`  ${_line}`);
             }
         }
         lines.push('');
         lines.push('  %% Node type annotations');
         const seenAnnotationsMethod = new Set();
         for (const entity of visibleEntities) {
-            const normalizedId = this.escapeId(this.normalizeEntityName(entity.name));
+            const normalizedId = escapeId(normalizeEntityName(entity.name));
             if (seenAnnotationsMethod.has(normalizedId))
                 continue;
             seenAnnotationsMethod.add(normalizedId);
@@ -205,119 +320,38 @@ export class ValidatedMermaidGenerator {
         }
         return lines.join('\n');
     }
-    generateClassDefinition(entity, indent, detailed = false) {
-        const lines = [];
-        const padding = '  '.repeat(indent);
-        const className = this.escapeId(this.normalizeEntityName(entity.name));
-        const classType = 'class';
-        lines.push(`${padding}${classType} ${className} {`);
-        const members = entity.members || [];
-        for (const member of members) {
-            if (!this.shouldIncludeMember(member)) {
-                continue;
-            }
-            const memberLine = this.generateMemberLine(member, detailed);
-            lines.push(`${padding}  ${memberLine}`);
-        }
-        lines.push(`${padding}}`);
-        return lines;
-    }
-    generateMemberLine(member, detailed) {
-        const visibility = this.getVisibilitySymbol(member.visibility);
-        const staticModifier = member.isStatic ? 'static ' : '';
-        const abstractModifier = member.isAbstract ? 'abstract ' : '';
-        if (member.type === 'property') {
-            const readonly = member.isReadonly ? 'readonly ' : '';
-            const optional = member.isOptional ? '?' : '';
-            const type = member.fieldType ? `: ${this.sanitizeType(member.fieldType)}` : '';
-            return `${visibility}${staticModifier}${abstractModifier}${readonly}${member.name}${optional}${type}`;
-        }
-        else if (member.type === 'method' || member.type === 'constructor') {
-            const async = member.isAsync ? 'async ' : '';
-            const returnType = member.returnType ? `: ${this.sanitizeType(member.returnType)}` : '';
-            const params = member.parameters
-                ?.map((p) => {
-                const optional = p.isOptional ? '?' : '';
-                const paramType = p.type ? `: ${this.sanitizeType(p.type)}` : '';
-                return `${p.name}${optional}${paramType}`;
-            })
-                .join(', ') || '';
-            return `${visibility}${staticModifier}${abstractModifier}${async}${member.name}(${params})${returnType}`;
-        }
-        else {
-            return `${visibility}${member.name}`;
-        }
-    }
-    normalizeEntityName(name) {
-        if (name.startsWith('import(')) {
-            const match = name.match(/^import\([^)]+\)\.\s*([\w.]+)/);
-            if (match) {
-                return match[2];
-            }
-        }
-        if (name.startsWith('import___')) {
-            const parts = name.split('___');
-            if (parts.length > 0) {
-                const lastPart = parts[parts.length - 1];
-                if (lastPart && lastPart.length > 0) {
-                    return lastPart;
-                }
-            }
-        }
-        const scopedMatch = name.match(/(?:\.ts|\.js)\.([A-Za-z_$][A-Za-z0-9_$]*)$/);
-        if (scopedMatch) {
-            return scopedMatch[1];
-        }
-        if (name.startsWith('{') || name.includes('=>')) {
-            return '[Type]';
-        }
-        return name;
-    }
     get entityIdToName() {
         if (!this._entityIdToName) {
             this._entityIdToName = new Map(this.archJson.entities.map((e) => [e.id, e.name]));
         }
         return this._entityIdToName;
     }
-    generateRelationLine(relation) {
-        const resolve = (id) => {
-            const simpleName = this.entityIdToName.get(id);
-            return this.escapeId(this.normalizeEntityName(simpleName ?? id));
-        };
-        const source = resolve(relation.source);
-        const target = resolve(relation.target);
-        switch (relation.type) {
-            case 'inheritance':
-                return `${target} <|-- ${source}`;
-            case 'implementation':
-                return `${target} <|.. ${source}`;
-            case 'composition':
-                return `${source} *-- ${target}`;
-            case 'aggregation':
-                return `${source} o-- ${target}`;
-            case 'dependency':
-            default:
-                return `${source} --> ${target}`;
+    buildModulePrefixIndex(entityIds) {
+        const index = new Map();
+        for (const entityId of entityIds) {
+            const lastDot = entityId.lastIndexOf('.');
+            if (lastDot > 0) {
+                const moduleId = entityId.substring(0, lastDot);
+                if (!index.has(moduleId)) {
+                    index.set(moduleId, entityId);
+                }
+            }
         }
-    }
-    isNoisyTarget(target) {
-        return (target.startsWith('{') ||
-            target.startsWith('"') ||
-            target.startsWith("'") ||
-            target.startsWith('(') ||
-            target.includes('=>') ||
-            /^\d/.test(target) ||
-            /^[A-Z]$/.test(target) ||
-            /^[a-z]\w*\./.test(target));
+        return index;
     }
     generateRelations(_packageGroups) {
         const lines = [];
         const knownEntityNames = new Set(this.archJson.entities.map((e) => e.name));
         const knownEntityIds = new Set(this.archJson.entities.map((e) => e.id));
+        const modulePrefixIndex = this.buildModulePrefixIndex(knownEntityIds);
         for (const relation of this.archJson.relations) {
-            if ((knownEntityNames.has(relation.source) || knownEntityIds.has(relation.source)) &&
-                !this.isNoisyTarget(relation.target)) {
-                lines.push(`  ${this.generateRelationLine(relation)}`);
+            const sourceKnownDirect = knownEntityNames.has(relation.source) || knownEntityIds.has(relation.source);
+            const sourceKnownViaPrefix = !sourceKnownDirect && modulePrefixIndex.has(relation.source);
+            const sourceKnown = sourceKnownDirect || sourceKnownViaPrefix;
+            if (sourceKnown && (sourceKnownViaPrefix || !isNoisyTarget(relation.target))) {
+                const _line = _generateRelationLine(relation, this.entityIdToName);
+                if (_line !== null)
+                    lines.push(`  ${_line}`);
             }
         }
         return lines;
@@ -338,83 +372,6 @@ export class ValidatedMermaidGenerator {
             reasoning: pkg.reasoning,
         }));
     }
-    shouldIncludeMember(member) {
-        if (member.visibility === 'private' && !this.options.includePrivate) {
-            return false;
-        }
-        if (member.visibility === 'protected' && !this.options.includeProtected) {
-            return false;
-        }
-        return true;
-    }
-    getVisibilitySymbol(visibility) {
-        switch (visibility) {
-            case 'public':
-                return '+';
-            case 'private':
-                return '-';
-            case 'protected':
-                return '#';
-            default:
-                return '+';
-        }
-    }
-    escapeId(id) {
-        if (!id)
-            return 'Unknown';
-        let escaped = id;
-        escaped = escaped.replace(/<[^>]*>$/g, '');
-        return escaped.replace(/[^a-zA-Z0-9_]/g, '_');
-    }
-    sanitizeType(type) {
-        if (!type)
-            return 'any';
-        type = this.normalizeTypeName(type);
-        let simplified = type;
-        let prevLength;
-        do {
-            prevLength = simplified.length;
-            simplified = simplified.replace(/\{[^{}]*\}/g, 'object');
-        } while (simplified.length !== prevLength && simplified.includes('{'));
-        const advancedTypePattern = /^(Partial|Required|Readonly|Pick|Omit|Record|Exclude|Extract|ReturnType|Parameters|DeepPartial)<.+>$/;
-        if (advancedTypePattern.test(simplified)) {
-            return 'any';
-        }
-        simplified = simplified.replace(/\([^)]*\)\s*=>\s*/g, 'Function');
-        while (simplified.includes('Promise<')) {
-            simplified = simplified.replace(/(\w+)<([^<>]*)>/g, '$1');
-            simplified = simplified.replace(/\bPromise\b/g, 'any');
-        }
-        if (simplified.includes('|')) {
-            return 'any';
-        }
-        if (simplified.includes('&')) {
-            return 'object';
-        }
-        let prevLength2;
-        do {
-            prevLength2 = simplified.length;
-            simplified = simplified.replace(/Array<[^>]+>/g, 'Array');
-        } while (simplified.length !== prevLength2);
-        simplified = simplified.replace(/\w+\[\]/g, 'Array');
-        simplified = simplified.replace(/Array+/g, 'Array');
-        while (simplified.match(/\w+</)) {
-            simplified = simplified.replace(/(\w+)<([^<>]*)>/g, '$1');
-        }
-        simplified = simplified.replace(/\bz\.infer\b/g, 'any');
-        simplified = simplified.replace(/\s+/g, ' ').trim();
-        if (simplified.length > 50 || simplified === '') {
-            return 'any';
-        }
-        return simplified;
-    }
-    normalizeTypeName(type) {
-        const importPattern = /import\([^)]+\)\.\s*([\w.]+)/g;
-        type = type.replace(importPattern, '$1');
-        const importPathPattern = /import___[^_]+___([\w]+)/g;
-        type = type.replace(importPathPattern, '$1');
-        return type;
-    }
     generateClassDiagrams(maxNodesPerDiagram) {
         const visibleEntities = this.archJson.entities.filter((e) => e.type !== 'function');
         const packageGroups = groupEntitiesByPackage(this.archJson, this.options.grouping);
@@ -441,23 +398,31 @@ export class ValidatedMermaidGenerator {
                 lines.push(`  classDef ${name} ${style}`);
             }
             lines.push('');
-            lines.push(`  namespace ${this.escapeId(group.name)} {`);
+            lines.push(`  namespace ${escapeId(group.name)} {`);
             for (const entity of groupEntities) {
-                lines.push(...this.generateClassDefinition(entity, 2, true));
+                lines.push(..._generateClassDefinition(entity, 2, this.options));
             }
             lines.push('  }');
+            const modulePrefixIndexGroup = this.buildModulePrefixIndex(knownEntityIds);
             for (const relation of this.archJson.relations) {
-                const sourceInGroup = groupEntityIdSet.has(relation.source) || groupEntityNames.has(relation.source);
+                const sourceInGroupDirect = groupEntityIdSet.has(relation.source) || groupEntityNames.has(relation.source);
+                const sourceViaPrefix = !sourceInGroupDirect && modulePrefixIndexGroup.has(relation.source);
+                const sourceInGroup = sourceInGroupDirect || sourceViaPrefix;
                 const targetKnown = knownEntityIds.has(relation.target) || knownEntityNames.has(relation.target);
-                if (sourceInGroup && (targetKnown || !this.isNoisyTarget(relation.target))) {
-                    lines.push(`  ${this.generateRelationLine(relation)}`);
+                const targetOk = targetKnown || sourceViaPrefix || !isNoisyTarget(relation.target);
+                if (sourceInGroup && targetOk) {
+                    {
+                        const _line = _generateRelationLine(relation, this.entityIdToName);
+                        if (_line !== null)
+                            lines.push(`  ${_line}`);
+                    }
                 }
             }
             lines.push('');
             lines.push('  %% Node type annotations');
             const seenAnnotations = new Set();
             for (const entity of groupEntities) {
-                const normalizedId = this.escapeId(this.normalizeEntityName(entity.name));
+                const normalizedId = escapeId(normalizeEntityName(entity.name));
                 if (seenAnnotations.has(normalizedId))
                     continue;
                 seenAnnotations.add(normalizedId);