@ankhorage/paradox 0.0.9 → 0.1.0

package/dist/analyze/semantic/docBlocks.js

@@ -0,0 +1,102 @@
+import { defaultTagRegistry } from './tagRegistry.js';
+import { relativeToRoot } from './utils.js';
+const DOC_BLOCK_REGEX = /\/\*\*\*[\s\S]*?\*\//g;
+/***
+ * Collects all Paradox doc blocks from a source file.
+ */
+export function collectDocBlocks(sourceFile, options) {
+    const { program } = options;
+    const tagRegistry = options.tagRegistry ?? defaultTagRegistry;
+    const text = sourceFile.getFullText();
+    const sourcePath = relativeToRoot(program.root, sourceFile.getFilePath());
+    const blocks = [];
+    for (const match of text.matchAll(DOC_BLOCK_REGEX)) {
+        const [raw = ''] = match;
+        const start = match.index;
+        const end = start + raw.length;
+        const { line, column } = sourceFile.getLineAndColumnAtPos(start);
+        const parsed = parseDocBlock(raw, tagRegistry);
+        const id = `${sourcePath}:${line}:${column}`;
+        blocks.push({
+            id,
+            sourcePath,
+            start,
+            end,
+            line,
+            column,
+            raw,
+            description: parsed.description,
+            params: parsed.params,
+            returns: parsed.returns,
+            tags: parsed.tags,
+        });
+    }
+    return blocks;
+}
+/***
+ * Extracts registered tags from a doc block.
+ */
+function collectTags(raw, tagRegistry = defaultTagRegistry) {
+    const tags = [];
+    const lines = normalizeDocBlock(raw);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('@'))
+            continue;
+        const [tagName, ...rest] = trimmed.slice(1).split(/\s+/);
+        if (!tagName || !tagRegistry.has(tagName))
+            continue;
+        const value = rest.join(' ').trim();
+        tags.push({
+            name: tagName,
+            value: value.length > 0 ? value : null,
+        });
+    }
+    return tags;
+}
+function parseDocBlock(raw, tagRegistry) {
+    const lines = normalizeDocBlock(raw);
+    const tags = collectTags(raw, tagRegistry);
+    const params = {};
+    let returns = null;
+    const description = lines
+        .filter((line) => {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('@'))
+            return true;
+        const [tagName, ...rest] = trimmed.slice(1).split(/\s+/);
+        if (!tagName)
+            return false;
+        if (tagName === 'param') {
+            const [name, ...descParts] = rest;
+            if (name) {
+                params[name] = descParts.join(' ').trim();
+            }
+            return false;
+        }
+        if (tagName === 'returns' || tagName === 'return') {
+            const returnBody = rest.join(' ').trim();
+            returns = returnBody.length > 0 ? returnBody : null;
+            return false;
+        }
+        if (tagRegistry.has(tagName)) {
+            return false;
+        }
+        return true;
+    })
+        .join('\n')
+        .trim();
+    return {
+        description: description.length > 0 ? description : null,
+        tags,
+        params,
+        returns,
+    };
+}
+function normalizeDocBlock(raw) {
+    return raw
+        .replace(/^\/\*\*\*/, '')
+        .replace(/\*\/$/, '')
+        .split('\n')
+        .map((line) => line.replace(/^\s*\*\s?/, '').trimEnd());
+}

package/dist/analyze/semantic/exports.d.ts

@@ -0,0 +1,29 @@
+import type { Node, Symbol as MorphSymbol, Type } from 'ts-morph';
+import type { AnalyzedExport, AnalyzedProgram, AnalyzedProps, AnalyzedTypeMember, ResolvedTypeReference } from './model.js';
+/***
+ * Collects exported declarations from configured entrypoints.
+ */
+export declare function collectExports(program: AnalyzedProgram): AnalyzedExport[];
+/***
+ * Returns a human-readable signature for callable exports.
+ */
+export declare function getExportSignature(_program: AnalyzedProgram, analyzedExport: Pick<AnalyzedExport, 'node'>): string | undefined;
+/***
+ * Resolves a named type reference from a node or symbol.
+ */
+export declare function resolveTypeReference(program: AnalyzedProgram, typeNodeOrSymbol: Node | Type | MorphSymbol): ResolvedTypeReference | null;
+/***
+ * Collects nested type members for interfaces and type literals.
+ */
+export declare function collectTypeMembers(program: AnalyzedProgram, reference: ResolvedTypeReference, options?: {
+    inheritedFrom?: string;
+    depth?: number;
+}): AnalyzedTypeMember[];
+/***
+ * Extracts props metadata for a callable export.
+ */
+export declare function collectPropsForExport(program: AnalyzedProgram, analyzedExport: Pick<AnalyzedExport, 'name' | 'node'>): AnalyzedProps | undefined;
+/***
+ * Collects related types referenced by an export.
+ */
+export declare function collectRelatedTypes(analyzedExport: Pick<AnalyzedExport, 'name' | 'signature' | 'props' | 'typeMembers'>): string[];

package/dist/analyze/semantic/exports.js

@@ -0,0 +1,399 @@
+import { Node as MorphNode, TypeFormatFlags } from 'ts-morph';
+import { isReactComponent } from './isReactComponent.js';
+import { getParadoxComment, parseParadoxComment } from './paradoxComment.js';
+import { isNodeModulePath, isPathInsideRoot, relativeToRoot } from './utils.js';
+/***
+ * Collects exported declarations from configured entrypoints.
+ */
+export function collectExports(program) {
+    const exportsByName = new Map();
+    for (const entrypoint of program.entrypointFilePaths) {
+        const sourceFile = program.project.getSourceFile((file) => file.getFilePath() === entrypoint);
+        if (!sourceFile)
+            continue;
+        const entrypointPath = relativeToRoot(program.root, sourceFile.getFilePath());
+        for (const symbol of sourceFile.getExportSymbols()) {
+            const resolved = resolveExportSymbol(symbol);
+            const declaration = getFirstDeclaration(resolved.getDeclarations());
+            if (!declaration)
+                continue;
+            const name = resolved.getName();
+            const sourcePath = relativeToRoot(program.root, declaration.getSourceFile().getFilePath());
+            const existing = exportsByName.get(name);
+            const exportPaths = existing
+                ? uniqueSorted([...existing.exportPaths, entrypointPath])
+                : [entrypointPath];
+            const kind = existing?.kind ?? detectExportKind(declaration);
+            exportsByName.set(name, {
+                name,
+                sourcePath,
+                exportPaths,
+                kind,
+                signature: existing?.signature,
+                docBlock: existing?.docBlock,
+                tags: existing?.tags ?? [],
+                props: existing?.props,
+                typeMembers: existing?.typeMembers,
+                relatedTypes: existing?.relatedTypes ?? [],
+                node: declaration,
+                symbol: resolved,
+            });
+        }
+    }
+    return [...exportsByName.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+/***
+ * Determines the kind of export for documentation.
+ */
+function detectExportKind(node) {
+    if (isReactComponent(node))
+        return 'component';
+    const name = getDeclarationName(node);
+    if (name && /^use[A-Z]/.test(name))
+        return 'hook';
+    if (MorphNode.isFunctionDeclaration(node))
+        return 'function';
+    if (MorphNode.isClassDeclaration(node))
+        return 'class';
+    if (MorphNode.isInterfaceDeclaration(node))
+        return 'interface';
+    if (MorphNode.isTypeAliasDeclaration(node))
+        return 'type';
+    if (MorphNode.isVariableDeclaration(node))
+        return 'const';
+    return 'unknown';
+}
+/***
+ * Returns a human-readable signature for callable exports.
+ */
+export function getExportSignature(_program, analyzedExport) {
+    const callableNode = getCallableNode(analyzedExport.node);
+    if (!callableNode)
+        return undefined;
+    const callSignatures = callableNode.getType().getCallSignatures();
+    if (callSignatures.length === 0)
+        return undefined;
+    const [callSignature] = callSignatures;
+    const parameters = callSignature.getParameters().map((parameter) => {
+        const declaration = getFirstDeclaration(parameter.getDeclarations());
+        const name = parameter.getName();
+        const isOptional = declaration && MorphNode.isParameterDeclaration(declaration)
+            ? declaration.isOptional()
+            : false;
+        const type = getParameterTypeText(parameter, declaration, callableNode);
+        return `${name}${isOptional ? '?' : ''}: ${type}`;
+    });
+    const returnType = callSignature.getReturnType().getText(callableNode);
+    const returnSuffix = returnType === 'void' ? '' : ` => ${returnType}`;
+    return `(${parameters.join(', ')})${returnSuffix}`;
+}
+/***
+ * Resolves a named type reference from a node or symbol.
+ */
+export function resolveTypeReference(program, typeNodeOrSymbol) {
+    const type = MorphNode.isNode(typeNodeOrSymbol)
+        ? typeNodeOrSymbol.getType()
+        : 'getText' in typeNodeOrSymbol
+            ? typeNodeOrSymbol
+            : typeNodeOrSymbol.getDeclaredType();
+    const symbol = type.getSymbol() ?? ('getDeclarations' in typeNodeOrSymbol ? typeNodeOrSymbol : null);
+    const name = symbol?.getName() ?? null;
+    const declaration = getFirstDeclaration(symbol?.getDeclarations() ?? []);
+    const sourcePath = declaration
+        ? relativeToRoot(program.root, declaration.getSourceFile().getFilePath())
+        : null;
+    return {
+        type,
+        name,
+        sourcePath,
+        symbol: symbol ?? null,
+    };
+}
+/***
+ * Collects nested type members for interfaces and type literals.
+ */
+export function collectTypeMembers(program, reference, options = {}) {
+    const depth = options.depth ?? 0;
+    if (depth > 3)
+        return [];
+    const membersByName = new Map();
+    const ownMembers = collectMembersFromType(program, reference, options.inheritedFrom, depth);
+    for (const member of ownMembers) {
+        membersByName.set(member.name, member);
+    }
+    const baseTypes = reference.type.getBaseTypes();
+    for (const baseType of baseTypes) {
+        const baseReference = resolveTypeReference(program, baseType);
+        if (!baseReference)
+            continue;
+        const baseName = baseReference.name ?? 'BaseType';
+        const baseMembers = collectTypeMembers(program, baseReference, {
+            inheritedFrom: baseName,
+            depth: depth + 1,
+        });
+        for (const member of baseMembers) {
+            if (!membersByName.has(member.name)) {
+                membersByName.set(member.name, member);
+            }
+        }
+    }
+    return [...membersByName.values()];
+}
+/***
+ * Extracts props metadata for a callable export.
+ */
+export function collectPropsForExport(program, analyzedExport) {
+    const callableNode = getCallableNode(analyzedExport.node);
+    if (!callableNode)
+        return undefined;
+    const parameters = callableNode.getParameters();
+    if (parameters.length === 0)
+        return undefined;
+    const [parameter] = parameters;
+    const parameterType = parameter.getType();
+    if (parameterType.isAny())
+        return undefined;
+    const resolved = resolveTypeReference(program, parameterType);
+    if (!resolved)
+        return undefined;
+    const typeName = resolved.name ??
+        parameterType.getText(parameter, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+    const defaultValues = collectDefaultValuesFromBinding(parameter);
+    const members = collectTypeMembers(program, resolved)
+        .filter((member) => member.name.length > 0)
+        .map((member) => ({
+        name: member.name,
+        type: member.type,
+        required: member.required,
+        defaultValue: defaultValues[member.name],
+        description: member.description,
+        inheritedFrom: member.inheritedFrom,
+    }));
+    return {
+        typeName,
+        sourcePath: resolved.sourcePath,
+        members,
+    };
+}
+/***
+ * Collects default values from destructured bindings.
+ */
+function collectDefaultValuesFromBinding(parameter) {
+    const defaults = {};
+    const nameNode = parameter.getNameNode();
+    if (!MorphNode.isObjectBindingPattern(nameNode))
+        return defaults;
+    for (const element of nameNode.getElements()) {
+        const initializer = element.getInitializer();
+        if (!initializer)
+            continue;
+        const name = element.getName();
+        defaults[name] = initializer.getText();
+    }
+    return defaults;
+}
+/***
+ * Collects related types referenced by an export.
+ */
+export function collectRelatedTypes(analyzedExport) {
+    const candidates = [];
+    if (analyzedExport.signature)
+        candidates.push(analyzedExport.signature);
+    if (analyzedExport.props) {
+        candidates.push(analyzedExport.props.typeName);
+        candidates.push(...analyzedExport.props.members.map((member) => member.type));
+    }
+    if (analyzedExport.typeMembers) {
+        candidates.push(...flattenMembers(analyzedExport.typeMembers).map((member) => member.type));
+    }
+    const related = new Set();
+    for (const candidate of candidates) {
+        for (const match of candidate.matchAll(/\b[A-Z][A-Za-z0-9_]*\b/g)) {
+            const [name] = match;
+            if (!IGNORED_RELATED_SYMBOLS.has(name) && name !== analyzedExport.name) {
+                related.add(name);
+            }
+        }
+    }
+    return [...related].sort((left, right) => left.localeCompare(right));
+}
+function collectMembersFromType(program, reference, inheritedFrom, depth) {
+    const declarationMembers = getDeclaredMembers(reference);
+    const declarations = declarationMembers.length > 0 ? declarationMembers : reference.type.getProperties();
+    return declarations.flatMap((property) => {
+        const declaration = getFirstDeclaration(property.getDeclarations());
+        if (!declaration)
+            return [];
+        const propertyType = property.getTypeAtLocation(declaration);
+        const rawComment = getParadoxComment(declaration);
+        const parsed = rawComment
+            ? parseParadoxComment(rawComment)
+            : { description: null, isConfig: false, params: {}, returns: null };
+        const required = !property.isOptional() && !isUndefinedUnion(propertyType);
+        const childReference = shouldExpandType(program, propertyType)
+            ? resolveTypeReference(program, propertyType)
+            : null;
+        const children = childReference
+            ? collectTypeMembers(program, childReference, {
+                inheritedFrom: undefined,
+                depth: depth + 1,
+            })
+            : undefined;
+        const declaredTypeText = getDeclaredTypeText(declaration);
+        const baseTypeText = declaredTypeText ??
+            propertyType.getText(declaration, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+        const typeText = appendUndefinedIfOptional(baseTypeText, required);
+        return [
+            {
+                name: property.getName(),
+                type: typeText,
+                required,
+                description: parsed.description ?? undefined,
+                inheritedFrom,
+                children: children && children.length > 0 ? children : undefined,
+            },
+        ];
+    });
+}
+function getDeclaredTypeText(declaration) {
+    if (MorphNode.isPropertySignature(declaration) || MorphNode.isPropertyDeclaration(declaration)) {
+        const typeNode = declaration.getTypeNode();
+        if (!typeNode)
+            return null;
+        if (MorphNode.isTypeLiteral(typeNode))
+            return null;
+        return typeNode.getText();
+    }
+    return null;
+}
+function getDeclaredMembers(reference) {
+    const declarations = reference.symbol?.getDeclarations() ?? [];
+    const members = [];
+    for (const declaration of declarations) {
+        if (MorphNode.isInterfaceDeclaration(declaration)) {
+            for (const property of declaration.getProperties()) {
+                const symbol = property.getSymbol();
+                if (symbol)
+                    members.push(symbol);
+            }
+            for (const method of declaration.getMethods()) {
+                const symbol = method.getSymbol();
+                if (symbol)
+                    members.push(symbol);
+            }
+        }
+        else if (MorphNode.isTypeAliasDeclaration(declaration)) {
+            const typeNode = declaration.getTypeNode();
+            if (typeNode && MorphNode.isTypeLiteral(typeNode)) {
+                for (const member of typeNode.getMembers()) {
+                    if (MorphNode.isPropertySignature(member) || MorphNode.isMethodSignature(member)) {
+                        const symbol = member.getSymbol();
+                        if (symbol)
+                            members.push(symbol);
+                    }
+                }
+            }
+        }
+    }
+    return members;
+}
+function shouldExpandType(program, type) {
+    if (type.isUnion() || type.isIntersection())
+        return false;
+    if (type.isString() || type.isNumber() || type.isBoolean() || type.isEnum())
+        return false;
+    const symbol = type.getSymbol();
+    const declaration = getFirstDeclaration(symbol?.getDeclarations() ?? []);
+    if (declaration) {
+        const sourceFile = declaration.getSourceFile();
+        const sourcePath = relativeToRoot(program.root, sourceFile.getFilePath());
+        return !sourcePath.includes('node_modules');
+    }
+    if (!type.isObject())
+        return false;
+    const propertyDeclarations = type
+        .getProperties()
+        .flatMap((property) => property.getDeclarations());
+    return propertyDeclarations.some((decl) => {
+        const filePath = decl.getSourceFile().getFilePath();
+        return isPathInsideRoot(program.root, filePath) && !isNodeModulePath(filePath);
+    });
+}
+function flattenMembers(members) {
+    return members.flatMap((member) => [
+        member,
+        ...(member.children ? flattenMembers(member.children) : []),
+    ]);
+}
+function isUndefinedUnion(type) {
+    if (!type.isUnion())
+        return false;
+    return type.getUnionTypes().some((unionType) => unionType.isUndefined());
+}
+function getFirstDeclaration(declarations) {
+    const [declaration = null] = declarations;
+    return declaration;
+}
+function resolveExportSymbol(symbol) {
+    return symbol.getAliasedSymbol() ?? symbol;
+}
+function getDeclarationName(node) {
+    if (MorphNode.isFunctionDeclaration(node))
+        return node.getName() ?? null;
+    if (MorphNode.isVariableDeclaration(node))
+        return node.getName();
+    if (MorphNode.isClassDeclaration(node))
+        return node.getName() ?? null;
+    if (MorphNode.isInterfaceDeclaration(node))
+        return node.getName();
+    if (MorphNode.isTypeAliasDeclaration(node))
+        return node.getName();
+    return null;
+}
+function getParameterTypeText(parameter, declaration, fallbackNode) {
+    return declaration
+        ? parameter.getTypeAtLocation(declaration).getText(declaration)
+        : parameter.getTypeAtLocation(fallbackNode).getText(fallbackNode);
+}
+function appendUndefinedIfOptional(typeText, required) {
+    if (required || typeText.includes('undefined'))
+        return typeText;
+    return `${typeText} | undefined`;
+}
+function getCallableNode(node) {
+    if (MorphNode.isFunctionDeclaration(node))
+        return node;
+    if (MorphNode.isMethodDeclaration(node))
+        return node;
+    if (MorphNode.isMethodSignature(node))
+        return node;
+    if (MorphNode.isArrowFunction(node))
+        return node;
+    if (MorphNode.isFunctionExpression(node))
+        return node;
+    if (MorphNode.isVariableDeclaration(node)) {
+        const initializer = node.getInitializer();
+        if (initializer &&
+            (MorphNode.isArrowFunction(initializer) || MorphNode.isFunctionExpression(initializer))) {
+            return initializer;
+        }
+    }
+    return null;
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+const IGNORED_RELATED_SYMBOLS = new Set([
+    'Array',
+    'Boolean',
+    'Date',
+    'Element',
+    'JSX',
+    'Map',
+    'Number',
+    'Promise',
+    'ReadonlyArray',
+    'Record',
+    'Set',
+    'String',
+]);

package/dist/analyze/semantic/graphs.d.ts

@@ -0,0 +1,13 @@
+import type { AnalyzedExport, AnalyzedProgram, CallEdge, ComponentCompositionEdge, ImportEdge } from './model.js';
+/***
+ * Collects local import relationships between source files.
+ */
+export declare function collectImportGraph(program: AnalyzedProgram): ImportEdge[];
+/***
+ * Collects call relationships between local symbols.
+ */
+export declare function collectCallGraph(program: AnalyzedProgram): CallEdge[];
+/***
+ * Collects component composition edges for React components.
+ */
+export declare function collectComponentCompositionGraph(program: AnalyzedProgram, exports?: AnalyzedExport[]): ComponentCompositionEdge[];

package/dist/analyze/semantic/graphs.js

@@ -0,0 +1,151 @@
+import { Node as MorphNode } from 'ts-morph';
+import { collectExports } from './exports.js';
+import { isNodeModulePath, isPathInsideRoot, relativeToRoot } from './utils.js';
+/***
+ * Collects local import relationships between source files.
+ */
+export function collectImportGraph(program) {
+    const edges = [];
+    for (const sourceFile of program.project.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile())
+            continue;
+        if (!isPathInsideRoot(program.root, sourceFile.getFilePath()))
+            continue;
+        if (isNodeModulePath(sourceFile.getFilePath()))
+            continue;
+        const sourcePath = relativeToRoot(program.root, sourceFile.getFilePath());
+        const moduleDeclarations = [
+            ...sourceFile.getImportDeclarations(),
+            ...sourceFile.getExportDeclarations(),
+        ];
+        for (const declaration of moduleDeclarations) {
+            const dependency = declaration.getModuleSpecifierSourceFile();
+            if (!dependency)
+                continue;
+            const dependencyPath = dependency.getFilePath();
+            if (!isPathInsideRoot(program.root, dependencyPath) || isNodeModulePath(dependencyPath))
+                continue;
+            edges.push({
+                fromPath: sourcePath,
+                toPath: relativeToRoot(program.root, dependencyPath),
+                sourcePath,
+            });
+        }
+    }
+    return uniqueEdges(edges, (edge) => `${edge.fromPath}->${edge.toPath}`);
+}
+/***
+ * Collects call relationships between local symbols.
+ */
+export function collectCallGraph(program) {
+    const edges = [];
+    for (const sourceFile of program.project.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile())
+            continue;
+        if (!isPathInsideRoot(program.root, sourceFile.getFilePath()))
+            continue;
+        if (isNodeModulePath(sourceFile.getFilePath()))
+            continue;
+        const sourcePath = relativeToRoot(program.root, sourceFile.getFilePath());
+        sourceFile.forEachDescendant((node) => {
+            if (!MorphNode.isCallExpression(node))
+                return;
+            const edge = toCallEdge(program, node, sourcePath);
+            if (edge)
+                edges.push(edge);
+        });
+    }
+    return uniqueEdges(edges, (edge) => `${edge.fromSymbol}->${edge.toSymbol}@${edge.sourcePath}:${edge.callExpression}`);
+}
+/***
+ * Collects component composition edges for React components.
+ */
+export function collectComponentCompositionGraph(program, exports = collectExports(program)) {
+    const edges = [];
+    const components = exports.filter((entry) => entry.kind === 'component');
+    for (const component of components) {
+        const componentName = component.name;
+        const { sourcePath } = component;
+        const jsxElements = findJsxElements(component.node);
+        for (const element of jsxElements) {
+            const jsxTagName = element.getTagNameNode().getText();
+            if (!/^[A-Z]/.test(jsxTagName))
+                continue;
+            edges.push({
+                fromComponent: componentName,
+                toComponent: jsxTagName,
+                jsxElement: element.getText(),
+                sourcePath,
+            });
+        }
+    }
+    return uniqueEdges(edges, (edge) => `${edge.fromComponent}->${edge.toComponent}@${edge.sourcePath}:${edge.jsxElement}`);
+}
+function toCallEdge(program, node, sourcePath) {
+    const expression = node.getExpression();
+    const symbol = expression.getSymbol() ?? expression.getType().getSymbol();
+    if (!symbol)
+        return null;
+    const declarations = symbol.getDeclarations();
+    if (declarations.length === 0)
+        return null;
+    const [declaration] = declarations;
+    const declarationPath = declaration.getSourceFile().getFilePath();
+    if (!isPathInsideRoot(program.root, declarationPath) || isNodeModulePath(declarationPath))
+        return null;
+    const fromSymbol = getEnclosingSymbolName(node) ?? sourcePath;
+    const toSymbol = symbol.getName();
+    if (!toSymbol)
+        return null;
+    return {
+        fromSymbol,
+        toSymbol,
+        callExpression: expression.getText(),
+        sourcePath,
+    };
+}
+function findJsxElements(node) {
+    const elements = [];
+    node.forEachDescendant((descendant) => {
+        if (MorphNode.isJsxSelfClosingElement(descendant) ||
+            MorphNode.isJsxOpeningElement(descendant)) {
+            elements.push(descendant);
+        }
+    });
+    return elements;
+}
+function getEnclosingSymbolName(node) {
+    const ancestor = node.getFirstAncestor((candidate) => {
+        return (MorphNode.isFunctionDeclaration(candidate) ||
+            MorphNode.isMethodDeclaration(candidate) ||
+            MorphNode.isFunctionExpression(candidate) ||
+            MorphNode.isArrowFunction(candidate) ||
+            MorphNode.isClassDeclaration(candidate));
+    });
+    if (!ancestor)
+        return null;
+    if (MorphNode.isFunctionDeclaration(ancestor))
+        return ancestor.getName() ?? null;
+    if (MorphNode.isMethodDeclaration(ancestor))
+        return ancestor.getName();
+    if (MorphNode.isClassDeclaration(ancestor))
+        return ancestor.getName() ?? null;
+    if (MorphNode.isArrowFunction(ancestor) || MorphNode.isFunctionExpression(ancestor)) {
+        const parent = ancestor.getParent();
+        if (MorphNode.isVariableDeclaration(parent))
+            return parent.getName();
+        if (MorphNode.isPropertyAssignment(parent))
+            return parent.getName();
+    }
+    return null;
+}
+function uniqueEdges(edges, key) {
+    const seen = new Set();
+    return edges.filter((edge) => {
+        const edgeKey = key(edge);
+        if (seen.has(edgeKey))
+            return false;
+        seen.add(edgeKey);
+        return true;
+    });
+}