@tstdl/base 0.93.125 → 0.93.126

package/injector/graph.js

@@ -0,0 +1,631 @@
+import { toArray } from '../utils/array/array.js';
+import { isArray, isDefined, isFunction } from '../utils/type-guards.js';
+import { Injector } from './injector.js';
+import { afterResolve } from './interfaces.js';
+import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider } from './provider.js';
+import { getTokenName } from './token.js';
+/**
+ * Extracts the dependency graph structure from an injector and optional resolution accesses.
+ * @param injector The injector to analyze.
+ * @param options Options for graph extraction.
+ * @returns A structured representation of the dependency graph.
+ */
+export function getDependencyGraph(injector, options = {}) {
+    const { highlightCycles = true, includeTokens, excludeTokens, maxDepth, excludeLoggers = true } = options;
+    const capturedAccesses = options.accesses ?? injector.accesses;
+    const state = {
+        nextId: 0,
+        tokenToId: new Map(),
+        tokenToInjector: new Map(),
+        injectorNames: new Map(),
+        processedTokens: new Set(),
+        edges: new Map(),
+        metadata: new Map(),
+        dynamicResolutions: new Map(), // injectorId -> ownerToken -> tokens
+        cycleEdges: new Set(),
+    };
+    const getTokenId = (token) => {
+        if (!state.tokenToId.has(token)) {
+            state.tokenToId.set(token, `n${state.nextId++}`);
+        }
+        return state.tokenToId.get(token);
+    };
+    const getEffectiveTokenName = (token) => (typeof token == 'function' && (token.name != '')) ? token.name : getTokenName(token);
+    const recordMetadata = (token, registration) => {
+        if (state.metadata.has(token)) {
+            return;
+        }
+        const allRegistrations = toArray(registration);
+        const lifecycles = new Set();
+        const types = new Set();
+        let hasAfterResolve = false;
+        for (const registrationEntry of allRegistrations) {
+            lifecycles.add(registrationEntry.options.lifecycle ?? 'transient');
+            hasAfterResolve = hasAfterResolve || isDefined(registrationEntry.options.afterResolve);
+            if (isClassProvider(registrationEntry.provider)) {
+                types.add('class');
+                hasAfterResolve = hasAfterResolve || isProviderWithInitializer(registrationEntry.provider) || isFunction(registrationEntry.provider.useClass.prototype[afterResolve]);
+            }
+            else if (isValueProvider(registrationEntry.provider)) {
+                types.add('value');
+            }
+            else if (isTokenProvider(registrationEntry.provider)) {
+                types.add('token');
+                hasAfterResolve = hasAfterResolve || isProviderWithInitializer(registrationEntry.provider);
+            }
+            else if (isFactoryProvider(registrationEntry.provider)) {
+                types.add('factory');
+                hasAfterResolve = hasAfterResolve || isProviderWithInitializer(registrationEntry.provider);
+            }
+        }
+        state.metadata.set(token, {
+            lifecycle: Array.from(lifecycles).join('|'),
+            type: Array.from(types).join('|') || 'unknown',
+            hasAfterResolve,
+        });
+    };
+    const addEdge = (from, to, label, color, style, penwidth) => {
+        const key = `${getTokenId(from)}->${getTokenId(to)}:${label}:${style}:${color}`;
+        if (!state.edges.has(key)) {
+            state.edges.set(key, { from, to, label, color, style, penwidth, isCycle: false });
+        }
+    };
+    // 1. Initial traversal for registrations
+    const traverse = (injector) => {
+        if (injector == null) {
+            return;
+        }
+        traverse(injector.parent);
+        const injectorName = (injector.name != '') ? injector.name : (injector.parent == null ? 'RootInjector' : `Injector ${injector.id}`);
+        state.injectorNames.set(injector.id, injectorName);
+        const registrations = new Map(injector.getRegistrations());
+        if (injector.parent == null) {
+            for (const [token, globalRegistration] of Injector.getGlobalRegistrations()) {
+                if (!registrations.has(token)) {
+                    registrations.set(token, (isArray(globalRegistration) ? globalRegistration.map((r) => ({ ...r, injector, resolutions: new Map() })) : { ...globalRegistration, injector, resolutions: new Map() }));
+                }
+            }
+        }
+        for (const [token, registration] of registrations) {
+            state.processedTokens.add(token);
+            if (!state.tokenToInjector.has(token)) {
+                state.tokenToInjector.set(token, injector.id);
+                recordMetadata(token, registration);
+            }
+            for (const entry of toArray(registration)) {
+                const target = isTokenProvider(entry.provider) ? (entry.provider.useToken ?? entry.provider.useTokenProvider?.()) : undefined;
+                if (isDefined(target)) {
+                    addEdge(token, target, 'alias', '#7f8c8d', 'dashed');
+                }
+            }
+        }
+    };
+    traverse(injector);
+    // 2. Process accesses for edges and cycles
+    for (const access of capturedAccesses) {
+        const nodes = access.chain.nodes;
+        const chainTokens = new Map();
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            if (node.type == 'ellipsis') {
+                continue;
+            }
+            const owner = node.injector.ownerToken;
+            if (isDefined(owner) && !state.processedTokens.has(owner)) {
+                state.processedTokens.add(owner);
+                let current = node.injector;
+                while (current && !current.getRegistrations().has(owner)) {
+                    current = current.parent;
+                }
+                const ownerInjectorId = current?.id ?? node.injector.id;
+                state.tokenToInjector.set(owner, ownerInjectorId);
+                if (!state.injectorNames.has(ownerInjectorId)) {
+                    state.injectorNames.set(ownerInjectorId, current?.name || `Injector ${ownerInjectorId}`);
+                }
+            }
+            if (highlightCycles && chainTokens.has(node.token)) {
+                for (let j = chainTokens.get(node.token); j < i; j++) {
+                    const node1 = nodes[j];
+                    const node2 = nodes[j + 1];
+                    if (node1.type != 'ellipsis' && node2.type != 'ellipsis') {
+                        state.cycleEdges.add(`${getTokenId(node1.token)}->${getTokenId(node2.token)}`);
+                    }
+                }
+            }
+            chainTokens.set(node.token, i);
+            if (!state.processedTokens.has(node.token)) {
+                state.processedTokens.add(node.token);
+                state.tokenToInjector.set(node.token, node.resolvedBy?.id ?? node.injector.id);
+                state.injectorNames.set(node.injector.id, node.injector.name);
+                if (node.resolvedBy) {
+                    state.injectorNames.set(node.resolvedBy.id, node.resolvedBy.name);
+                }
+                if (node.registration) {
+                    recordMetadata(node.token, node.registration);
+                }
+            }
+            if (i == 0 && isDefined(owner) && owner != node.token) {
+                addEdge(owner, node.token, 'dynamic resolve', '#9b59b6', 'dotted');
+                const registrationInjectorId = node.resolvedBy?.id ?? node.injector.id;
+                if (!state.dynamicResolutions.has(registrationInjectorId)) {
+                    state.dynamicResolutions.set(registrationInjectorId, new Map());
+                }
+                const map = state.dynamicResolutions.get(registrationInjectorId);
+                if (!map.has(owner)) {
+                    map.set(owner, new Set());
+                }
+                map.get(owner).add(node.token);
+            }
+            if (i > 0 && nodes[i - 1].type != 'ellipsis') {
+                const previous = nodes[i - 1];
+                let label;
+                switch (node.type) {
+                    case 'parameter':
+                        label = `constructor[${node.index}]`;
+                        break;
+                    case 'property':
+                        label = `property[${String(node.property)}]`;
+                        break;
+                    case 'inject':
+                        label = 'inject()';
+                        break;
+                    case 'token':
+                        label = 'token';
+                        break;
+                    default:
+                        throw new Error(`Unknown chain node type ${node.type}`);
+                }
+                if (node.forwardRef) {
+                    label += ' (forwardRef)';
+                }
+                if (node.optional) {
+                    label += ' (optional)';
+                }
+                if (node.multi) {
+                    label += ' (multi)';
+                }
+                if (isDefined(node.argument)) {
+                    const s = JSON.stringify(node.argument);
+                    label += `\narg: ${s.length > 20 ? `${s.substring(0, 17)}...` : s}`;
+                }
+                if (node.isCached) {
+                    label += '\n(cached)';
+                }
+                if (node.resolvedBy && node.resolvedBy.id != node.injector.id) {
+                    label += `\nvia ${node.injector.name}`;
+                }
+                addEdge(previous.token, node.token, label, node.forwardRef ? '#e67e22' : undefined, node.isCached ? (node.optional ? 'dashed,bold' : 'bold') : (node.optional ? 'dashed' : undefined));
+            }
+        }
+    }
+    // 3. Cycle Marking
+    for (const edge of state.edges.values()) {
+        if (state.cycleEdges.has(`${getTokenId(edge.from)}->${getTokenId(edge.to)}`)) {
+            edge.isCycle = true;
+        }
+    }
+    // 4. Filtering
+    const includeSet = includeTokens ? new Set(includeTokens) : undefined;
+    const excludeSet = excludeTokens ? new Set(excludeTokens) : undefined;
+    const isExcludedToken = (token) => excludeLoggers && ['Logger', 'LogManager', 'Injector'].includes(getEffectiveTokenName(token));
+    const reachable = new Map();
+    const collect = (token, depth) => {
+        if ((reachable.has(token) && reachable.get(token) <= depth) || excludeSet?.has(token) || isExcludedToken(token) || (isDefined(maxDepth) && depth > maxDepth)) {
+            return;
+        }
+        reachable.set(token, depth);
+        for (const edge of state.edges.values()) {
+            if (edge.from == token) {
+                collect(edge.to, depth + 1);
+            }
+        }
+    };
+    if (includeSet) {
+        for (const token of includeSet) {
+            collect(token, 0);
+        }
+    }
+    else if (capturedAccesses.length > 0) {
+        const touched = new Set();
+        for (const access of capturedAccesses) {
+            for (const node of access.chain.nodes) {
+                if (node.type != 'ellipsis') {
+                    touched.add(node.token);
+                }
+            }
+        }
+        for (const token of touched) {
+            collect(token, 0);
+        }
+    }
+    else {
+        for (const token of state.processedTokens) {
+            if (!excludeSet?.has(token) && !isExcludedToken(token)) {
+                collect(token, 0);
+            }
+        }
+    }
+    const nodes = new Map();
+    for (const token of state.processedTokens) {
+        if (reachable.has(token)) {
+            nodes.set(token, {
+                token,
+                name: getEffectiveTokenName(token),
+                injectorId: state.tokenToInjector.get(token) ?? 0,
+                metadata: state.metadata.get(token),
+            });
+        }
+    }
+    const edges = Array.from(state.edges.values()).filter((edge) => reachable.has(edge.from) && reachable.has(edge.to));
+    return {
+        nodes,
+        edges,
+        injectorNames: state.injectorNames,
+        dynamicResolutions: state.dynamicResolutions,
+    };
+}
+/**
+ * Renders a dependency graph structure into a Graphviz DOT representation.
+ * @param graph The dependency graph to render.
+ * @param options Rendering options.
+ * @returns A string in DOT format.
+ */
+export function renderDependencyGraphToDot(graph, options = {}) {
+    const { groupByInjector = true, showLegend = true, showMetadata = true, rankdir = 'LR', fontname = 'Helvetica', fontsize = 11, bgcolor, nodesep, ranksep } = options;
+    const nextIdState = { nextId: 0 };
+    const tokenToId = new Map();
+    const getTokenId = (token) => {
+        if (!tokenToId.has(token)) {
+            tokenToId.set(token, `n${nextIdState.nextId++}`);
+        }
+        return tokenToId.get(token);
+    };
+    const lines = ['strict digraph G {'];
+    if (bgcolor) {
+        lines.push(`  bgcolor=${JSON.stringify(bgcolor)};`);
+    }
+    if (nodesep) {
+        lines.push(`  nodesep=${nodesep};`);
+    }
+    if (ranksep) {
+        lines.push(`  ranksep=${ranksep};`);
+    }
+    lines.push(`  node [shape=box, fontname=${JSON.stringify(fontname)}, style=filled, fillcolor="#f9f9f9", fontsize=${fontsize}];`);
+    lines.push(`  edge [fontname=${JSON.stringify(fontname)}, fontsize=${fontsize - 1}];`);
+    lines.push(`  rankdir=${rankdir}; compound=true;`);
+    for (const edge of graph.edges) {
+        const color = edge.isCycle ? '#e74c3c' : edge.color;
+        const penwidth = edge.isCycle ? 2.0 : edge.penwidth;
+        const attributes = [
+            `label=${JSON.stringify(edge.label)}`,
+            color && `color=${JSON.stringify(color)}, fontcolor=${JSON.stringify(color)}`,
+            edge.style && `style=${JSON.stringify(edge.style)}`,
+            penwidth && `penwidth=${penwidth}`,
+        ].filter(Boolean).join(', ');
+        lines.push(`  ${getTokenId(edge.from)} -> ${getTokenId(edge.to)} [${attributes}];`);
+    }
+    const renderNode = (node) => {
+        const metadata = node.metadata;
+        const lifecycle = metadata.lifecycle;
+        const first = lifecycle.split('|')[0];
+        const colors = { singleton: '#d1e7dd', injector: '#fff3cd', resolution: '#cfe2ff', transient: '#f8d7da' };
+        const shapes = { singleton: 'doubleoctagon', injector: 'component', resolution: 'ellipse', transient: 'box' };
+        const name = node.name + (metadata.hasAfterResolve ? ' *' : '');
+        const label = showMetadata ? `${name}\n[${lifecycle}, ${metadata.type}]` : name;
+        const fillcolor = colors[first] ?? '#f9f9f9';
+        const shape = shapes[first] ?? 'box';
+        return `    ${getTokenId(node.token)} [label=${JSON.stringify(label)}, fillcolor=${JSON.stringify(fillcolor)}, shape=${JSON.stringify(shape)}];`;
+    };
+    const injectors = groupByInjector ? Array.from(graph.injectorNames.keys()) : [0];
+    for (const injectorId of injectors) {
+        if (groupByInjector) {
+            lines.push(`  subgraph cluster_${injectorId} {`);
+            lines.push(`    label = ${JSON.stringify(graph.injectorNames.get(injectorId) ?? `Injector ${injectorId}`)}; style = dotted; fontname = ${JSON.stringify(`${fontname}-Bold`)}; fontsize = ${fontsize + 1};`);
+        }
+        const injectorTokens = Array.from(graph.nodes.values()).filter((node) => !groupByInjector || node.injectorId == injectorId);
+        const dynamic = graph.dynamicResolutions.get(injectorId);
+        const inDynamic = new Set();
+        if (dynamic) {
+            for (const [owner, tokens] of dynamic) {
+                if (!graph.nodes.has(owner)) {
+                    continue;
+                }
+                const subNodes = Array.from(tokens).filter((token) => graph.nodes.has(token) && (!groupByInjector || graph.nodes.get(token).injectorId == injectorId)).map((token) => graph.nodes.get(token));
+                if (subNodes.length == 0) {
+                    continue;
+                }
+                lines.push(`    subgraph cluster_${injectorId}_${getTokenId(owner)} { label = ${JSON.stringify(`Dynamic Resolutions of ${graph.nodes.get(owner).name}`)}; style = dashed; color = "#9b59b6"; fontname = ${JSON.stringify(fontname)}; fontsize = ${fontsize};`);
+                for (const node of subNodes) {
+                    lines.push(renderNode(node));
+                    inDynamic.add(node.token);
+                }
+                lines.push('    }');
+            }
+        }
+        for (const node of injectorTokens) {
+            if (!inDynamic.has(node.token)) {
+                lines.push(renderNode(node));
+            }
+        }
+        if (groupByInjector) {
+            lines.push('  }');
+        }
+    }
+    if (showLegend) {
+        const legendFontSize = fontsize - 1;
+        lines.push(`  subgraph cluster_legend { label = "Legend"; style = solid; color = gray; fontname = ${JSON.stringify(`${fontname}-Bold`)}; fontsize = ${fontsize + 1};`);
+        lines.push('    // Column 1: Scoping');
+        lines.push('    node [fixedsize=true, width=1.6, height=0.4];');
+        lines.push(`    l_singleton [label="Singleton", fillcolor="#d1e7dd", shape=doubleoctagon, fontsize=${legendFontSize}];`);
+        lines.push(`    l_injector [label="Injector Scoped", fillcolor="#fff3cd", shape=component, fontsize=${legendFontSize}];`);
+        lines.push(`    l_resolution [label="Resolution Scoped", fillcolor="#cfe2ff", shape=ellipse, fontsize=${legendFontSize}];`);
+        lines.push(`    l_transient [label="Transient", fillcolor="#f8d7da", shape=box, fontsize=${legendFontSize}];`);
+        lines.push('    // Column 2 & 3: Dependency Types (Part 1)');
+        lines.push('    node [shape=point, width=0.05, height=0.05, label=""];');
+        lines.push('    l_circular_from; l_cached_from; l_optional_from; l_cross_from;');
+        lines.push('    node [shape=plaintext, width=1.6, height=0.4];');
+        lines.push(`    l_circular_to [label="Circular Dependency", fontsize=${legendFontSize}];`);
+        lines.push(`    l_cached_to [label="Cached Resolution", fontsize=${legendFontSize}];`);
+        lines.push(`    l_optional_to [label="Optional Dependency", fontsize=${legendFontSize}];`);
+        lines.push(`    l_cross_to [label="Cross-Injector", fontsize=${legendFontSize}];`);
+        lines.push('    // Column 4 & 5: Dependency Types (Part 2)');
+        lines.push('    node [shape=point, width=0.05, height=0.05, label=""];');
+        lines.push('    l_alias_from; l_forward_from; l_dynamic_from; l_spacer_from;');
+        lines.push('    node [shape=plaintext, width=1.6, height=0.4];');
+        lines.push(`    l_alias_to [label="Alias", fontsize=${legendFontSize}];`);
+        lines.push(`    l_forward_to [label="Forward Reference", fontsize=${legendFontSize}];`);
+        lines.push(`    l_dynamic_to [label="Dynamic Resolve", fontsize=${legendFontSize}];`);
+        lines.push('    l_spacer_to [label="", style=invis];');
+        lines.push('    // Column Ranks (Vertical Stacking)');
+        lines.push('    { rank=same; l_singleton l_injector l_resolution l_transient }');
+        lines.push('    { rank=same; l_circular_from l_cached_from l_optional_from l_cross_from }');
+        lines.push('    { rank=same; l_circular_to l_cached_to l_optional_to l_cross_to }');
+        lines.push('    { rank=same; l_alias_from l_forward_from l_dynamic_from l_spacer_from }');
+        lines.push('    { rank=same; l_alias_to l_forward_to l_dynamic_to l_spacer_to }');
+        lines.push('    // Horizontal Row Alignment & Arrows');
+        lines.push('    l_singleton -> l_circular_from [style=invis, minlen=1];');
+        lines.push('    l_circular_from -> l_circular_to [color="#e74c3c", penwidth=2, minlen=1];');
+        lines.push('    l_circular_to -> l_alias_from [style=invis, minlen=1];');
+        lines.push('    l_alias_from -> l_alias_to [color="#7f8c8d", style=dashed, minlen=1];');
+        lines.push('    l_injector -> l_cached_from [style=invis, minlen=1];');
+        lines.push('    l_cached_from -> l_cached_to [style=bold, minlen=1];');
+        lines.push('    l_cached_to -> l_forward_from [style=invis, minlen=1];');
+        lines.push('    l_forward_from -> l_forward_to [color="#e67e22", minlen=1];');
+        lines.push('    l_resolution -> l_optional_from [style=invis, minlen=1];');
+        lines.push('    l_optional_from -> l_optional_to [style=dashed, minlen=1];');
+        lines.push('    l_optional_to -> l_dynamic_from [style=invis, minlen=1];');
+        lines.push('    l_dynamic_from -> l_dynamic_to [color="#9b59b6", style=dotted, minlen=1];');
+        lines.push('    l_transient -> l_cross_from [style=invis, minlen=1];');
+        lines.push('    l_cross_from -> l_cross_to [minlen=1];');
+        lines.push('    l_cross_to -> l_spacer_from [style=invis, minlen=1];');
+        lines.push('    l_spacer_from -> l_spacer_to [style=invis, minlen=1];');
+        lines.push('    // Vertical Reinforcement');
+        lines.push('    l_singleton -> l_injector -> l_resolution -> l_transient [style=invis];');
+        lines.push('    l_circular_from -> l_cached_from -> l_optional_from -> l_cross_from [style=invis];');
+        lines.push('    l_circular_to -> l_cached_to -> l_optional_to -> l_cross_to [style=invis];');
+        lines.push('    l_alias_from -> l_forward_from -> l_dynamic_from -> l_spacer_from [style=invis];');
+    }
+    return lines.join('\n');
+}
+/**
+ * Renders a dependency graph structure into a D2 representation.
+ * @param graph The dependency graph to render.
+ * @param options Rendering options.
+ * @returns A string in D2 format.
+ */
+export function renderDependencyGraphToD2(graph, options = {}) {
+    const { groupByInjector = true, showLegend = true, showMetadata = true, rankdir = 'LR', bgcolor } = options;
+    const nextIdState = { nextId: 0 };
+    const tokenToId = new Map();
+    const getTokenId = (token) => {
+        if (!tokenToId.has(token)) {
+            tokenToId.set(token, `n${nextIdState.nextId++}`);
+        }
+        return tokenToId.get(token);
+    };
+    const getTokenPath = (token) => {
+        const node = graph.nodes.get(token);
+        const id = getTokenId(token);
+        if (!node || !groupByInjector) {
+            return id;
+        }
+        const injectorName = graph.injectorNames.get(node.injectorId) ?? `Injector ${node.injectorId}`;
+        let path = `${JSON.stringify(injectorName)}.${id}`;
+        const dynamic = graph.dynamicResolutions.get(node.injectorId);
+        if (dynamic) {
+            for (const [owner, tokens] of dynamic) {
+                if (tokens.has(token) && graph.nodes.has(owner)) {
+                    const ownerName = graph.nodes.get(owner).name;
+                    path = `${JSON.stringify(injectorName)}.${JSON.stringify(`Dynamic Resolutions of ${ownerName}`)}.${id}`;
+                    break;
+                }
+            }
+        }
+        return path;
+    };
+    const lines = [];
+    if (rankdir == 'LR') {
+        lines.push('direction: right');
+    }
+    else if (rankdir == 'TB') {
+        lines.push('direction: down');
+    }
+    else if (rankdir == 'BT') {
+        lines.push('direction: up');
+    }
+    else if (rankdir == 'RL') {
+        lines.push('direction: left');
+    }
+    if (bgcolor) {
+        lines.push(`style: {\n  fill: ${JSON.stringify(bgcolor)}\n}`);
+    }
+    lines.push('classes: {');
+    lines.push('  singleton: {');
+    lines.push('    shape: hexagon');
+    lines.push('    style: { fill: "#d1e7dd" }');
+    lines.push('  }');
+    lines.push('  injector_scoped: {');
+    lines.push('    shape: package');
+    lines.push('    style: { fill: "#fff3cd" }');
+    lines.push('  }');
+    lines.push('  resolution_scoped: {');
+    lines.push('    shape: oval');
+    lines.push('    style: { fill: "#cfe2ff" }');
+    lines.push('  }');
+    lines.push('  transient: {');
+    lines.push('    shape: rectangle');
+    lines.push('    style: { fill: "#f8d7da" }');
+    lines.push('  }');
+    lines.push('}');
+    const renderNode = (node, indent) => {
+        const nodeLines = [];
+        const metadata = node.metadata;
+        const lifecycle = metadata.lifecycle;
+        const first = lifecycle.split('|')[0];
+        const classMap = { singleton: 'singleton', injector: 'injector_scoped', resolution: 'resolution_scoped', transient: 'transient' };
+        const className = classMap[first] ?? 'transient';
+        const name = node.name + (metadata.hasAfterResolve ? ' *' : '');
+        const label = showMetadata ? `${name}\n[${lifecycle}, ${metadata.type}]` : name;
+        nodeLines.push(`${indent}${getTokenId(node.token)}: ${JSON.stringify(label)} {`);
+        nodeLines.push(`${indent}  class: ${className}`);
+        nodeLines.push(`${indent}}`);
+        return nodeLines;
+    };
+    for (const edge of graph.edges) {
+        const color = edge.isCycle ? '#e74c3c' : edge.color;
+        let penwidth = edge.isCycle ? 2.0 : edge.penwidth;
+        if (edge.style?.includes('bold')) {
+            penwidth = (penwidth ?? 1) + 2;
+        }
+        const from = getTokenPath(edge.from);
+        const to = getTokenPath(edge.to);
+        let edgeLine = `${from} -> ${to}`;
+        if (edge.label || color || edge.style || penwidth) {
+            const label = edge.label?.split('\n')[0];
+            const tooltip = edge.label;
+            edgeLine += `: ${JSON.stringify(label)} {`;
+            lines.push(edgeLine);
+            if (tooltip && tooltip !== label) {
+                lines.push(`  tooltip: ${JSON.stringify(tooltip)}`);
+            }
+            if (color) {
+                lines.push(`  style.stroke: ${JSON.stringify(color)}`);
+                lines.push(`  style.font-color: ${JSON.stringify(color)}`);
+            }
+            if (edge.style?.includes('dashed')) {
+                lines.push('  style.stroke-dash: 5');
+            }
+            else if (edge.style?.includes('dotted')) {
+                lines.push('  style.stroke-dash: 2');
+            }
+            if (penwidth) {
+                lines.push(`  style.stroke-width: ${penwidth}`);
+            }
+            lines.push('}');
+        }
+        else {
+            lines.push(edgeLine);
+        }
+    }
+    const injectors = groupByInjector ? Array.from(graph.injectorNames.keys()) : [0];
+    for (const injectorId of injectors) {
+        let indent = '';
+        if (groupByInjector) {
+            const name = graph.injectorNames.get(injectorId) ?? `Injector ${injectorId}`;
+            lines.push(`${JSON.stringify(name)}: {`);
+            lines.push('  style: {');
+            lines.push('    stroke-dash: 5');
+            lines.push('    border-radius: 10');
+            lines.push('  }');
+            indent = '  ';
+        }
+        const injectorTokens = Array.from(graph.nodes.values()).filter((node) => !groupByInjector || node.injectorId == injectorId);
+        const dynamic = graph.dynamicResolutions.get(injectorId);
+        const inDynamic = new Set();
+        if (dynamic) {
+            for (const [owner, tokens] of dynamic) {
+                if (!graph.nodes.has(owner)) {
+                    continue;
+                }
+                const subNodes = Array.from(tokens).filter((token) => graph.nodes.has(token) && (!groupByInjector || graph.nodes.get(token).injectorId == injectorId)).map((token) => graph.nodes.get(token));
+                if (subNodes.length == 0) {
+                    continue;
+                }
+                const ownerName = graph.nodes.get(owner).name;
+                lines.push(`${indent}${JSON.stringify(`Dynamic Resolutions of ${ownerName}`)}: {`);
+                lines.push(`${indent}  style: {`);
+                lines.push(`${indent}    stroke: "#9b59b6"`);
+                lines.push(`${indent}    stroke-dash: 5`);
+                lines.push(`${indent}    border-radius: 10`);
+                lines.push(`${indent}  }`);
+                for (const node of subNodes) {
+                    lines.push(...renderNode(node, `${indent}  `));
+                    inDynamic.add(node.token);
+                }
+                lines.push(`${indent}}`);
+            }
+        }
+        for (const node of injectorTokens) {
+            if (!inDynamic.has(node.token)) {
+                lines.push(...renderNode(node, indent));
+            }
+        }
+        if (groupByInjector) {
+            lines.push('}');
+        }
+    }
+    if (showLegend) {
+        lines.push('Legend: {');
+        lines.push('  shape: package');
+        lines.push('  near: top-right');
+        lines.push('  grid-columns: 2');
+        lines.push('  style: {');
+        lines.push('    stroke-dash: 0');
+        lines.push('    border-radius: 10');
+        lines.push('  }');
+        lines.push('  Singleton: { class: singleton }');
+        lines.push('  Injector Scoped: { class: injector_scoped }');
+        lines.push('  Resolution Scoped: { class: resolution_scoped }');
+        lines.push('  Transient: { class: transient }');
+        lines.push('}');
+    }
+    return lines.join('\n');
+}
+/**
+ * Generates a Graphviz DOT representation of the dependency injection graph.
+ * @param injector The injector to analyze.
+ * @param options Options for graph generation.
+ * @returns A string in DOT format.
+ */
+export function generateDependencyGraph(injector, options = {}) {
+    const graph = getDependencyGraph(injector, options);
+    return renderDependencyGraphToDot(graph, options);
+}
+/**
+ * Generates a D2 representation of the dependency injection graph.
+ * @param injector The injector to analyze.
+ * @param options Options for graph generation.
+ * @returns A string in D2 format.
+ */
+export function generateDependencyGraphD2(injector, options = {}) {
+    const graph = getDependencyGraph(injector, options);
+    return renderDependencyGraphToD2(graph, options);
+}
+/**
+ * Generates a Graphviz DOT representation of the application's dependency injection graph.
+ * @param application The application to analyze.
+ * @param options Options for graph generation.
+ * @returns A string in DOT format.
+ */
+export function generateApplicationDependencyGraph(application, options = {}) {
+    return generateDependencyGraph(application.injector, options);
+}
+/**
+ * Generates a D2 representation of the application's dependency injection graph.
+ * @param application The application to analyze.
+ * @param options Options for graph generation.
+ * @returns A string in D2 format.
+ */
+export function generateApplicationDependencyGraphD2(application, options = {}) {
+    return generateDependencyGraphD2(application.injector, options);
+}

package/injector/index.d.ts

@@ -4,6 +4,8 @@
  * @module Injector
  */
 export * from './decorators.js';
+export * from './forward-ref.js';
+export * from './graph.js';
 export * from './inject.js';
 export * from './injector.js';
 export * from './interfaces.js';

package/injector/index.js

@@ -4,6 +4,8 @@
  * @module Injector
  */
 export * from './decorators.js';
+export * from './forward-ref.js';
+export * from './graph.js';
 export * from './inject.js';
 export * from './injector.js';
 export * from './interfaces.js';