@webda/content-mapper 0.0.0-stage → 4.0.0-beta.4

package/lib/module-discovery.js

@@ -0,0 +1,662 @@
+/**
+ * Webda object discovery on the TypeScript 7 API.
+ *
+ * The first half of `@webda/compiler`'s module generator: find every model,
+ * modda, bean and deployer in a project, work out which section it belongs to,
+ * and compute the `Import` string recorded in `webda.module.json`.
+ *
+ * Schema generation is deliberately not here. It runs through `@webda/schema`,
+ * which still builds its own language service, and that is a separate port. The
+ * point of splitting is that everything in this file can be checked against the
+ * committed `webda.module.json` byte for byte, which is stronger evidence than
+ * a passing test.
+ *
+ * Classification follows `module.ts`: the base-type chain is walked and each
+ * link is attributed to the npm package that declares it, so `Model` from
+ * `@webda/models` is distinguished from any local class of the same name.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import * as is from "typescript/unstable/ast/is";
+import { classPropertiesInTs6Order } from "./property-order.js";
+/** Cache of directory to owning package name. */
+const packageNameCache = new Map();
+/**
+ * Name of the npm package that owns a file.
+ *
+ * Walks up to the nearest `package.json`, matching `getPackageFromType`.
+ * @param fileName - file to attribute
+ * @returns the package name, when one is found
+ */
+export function packageOf(fileName) {
+    let folder = dirname(fileName);
+    while (folder.length > 2) {
+        if (packageNameCache.has(folder))
+            return packageNameCache.get(folder);
+        const manifest = join(folder, "package.json");
+        if (existsSync(manifest)) {
+            let name;
+            try {
+                name = JSON.parse(readFileSync(manifest, "utf8")).name;
+            }
+            catch {
+                name = undefined;
+            }
+            packageNameCache.set(folder, name);
+            return name;
+        }
+        const parent = dirname(folder);
+        if (parent === folder)
+            break;
+        folder = parent;
+    }
+    return undefined;
+}
+/**
+ * The declared type of a class, and every type it derives from.
+ *
+ * Each base is re-resolved through its symbol: `getBaseTypes()` returns
+ * instantiated references whose own bases are empty, so a generic link
+ * otherwise terminates the walk.
+ * @param ctx - analysis context
+ * @param cls - the class declaration
+ * @returns the type chain, nearest first
+ */
+export function classTree(ctx, cls) {
+    const symbol = cls.name ? ctx.checker.getSymbolAtLocation(cls.name) : undefined;
+    const declared = symbol ? ctx.checker.getDeclaredTypeOfSymbol(symbol) : undefined;
+    if (!declared)
+        return [];
+    const chain = [];
+    const seen = new Set();
+    let current = declared;
+    while (current && chain.length < 64) {
+        chain.push(current);
+        const currentSymbol = current.getSymbol?.() ?? current.symbol;
+        const name = currentSymbol?.name;
+        if (name) {
+            // Keyed by declaration, not name: `class User extends User` (a local
+            // model extending `@webda/core`'s) is ordinary, and a name-only guard
+            // stops the walk before it reaches Model.
+            const declaration = currentSymbol.valueDeclaration ?? currentSymbol.declarations?.[0];
+            const owner = declaration?.resolve(ctx.project);
+            const file = owner?.getSourceFile?.()?.fileName ?? owner?._sourceFile?.fileName ?? "";
+            const key = `${name}@${file}`;
+            if (seen.has(key))
+                break;
+            seen.add(key);
+        }
+        const resolved = currentSymbol ? (ctx.checker.getDeclaredTypeOfSymbol(currentSymbol) ?? current) : current;
+        current = (resolved.getBaseTypes?.() ?? current.getBaseTypes?.() ?? [])[0];
+    }
+    return chain;
+}
+/**
+ * Whether a type chain contains a given class from a given package.
+ * @param ctx - analysis context
+ * @param chain - the type chain
+ * @param packageName - owning npm package
+ * @param symbolName - class name
+ * @returns true on a match
+ */
+export function chainExtends(ctx, chain, packageName, symbolName) {
+    for (const type of chain) {
+        const symbol = type.getSymbol?.() ?? type.symbol;
+        if (symbol?.name !== symbolName)
+            continue;
+        const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+        const node = declaration?.resolve(ctx.project);
+        const owner = node?.getSourceFile?.() ?? node?._sourceFile;
+        if (owner?.fileName && packageOf(owner.fileName) === packageName)
+            return true;
+    }
+    return false;
+}
+/**
+ * JSDoc tags on a node, by name.
+ * @param ctx - analysis context
+ * @param sf - containing file
+ * @param node - the node
+ * @returns tag name to value
+ */
+function tagsOf(ctx, sf, node) {
+    const tags = {};
+    for (const match of ctx.triviaOf(sf, node).matchAll(/@(Webda[A-Za-z]*)\s*([^\s*]*)/g)) {
+        tags[match[1]] = match[2] ?? "";
+    }
+    return tags;
+}
+/**
+ * Output path for a source file, without extension.
+ *
+ * Mirrors `ts.getOutputFileNames` for the common `rootDir`/`outDir` layout.
+ * @param fileName - the source file
+ * @param options - discovery options
+ * @returns path relative to the application root
+ */
+export function outputTarget(fileName, options) {
+    const fromRoot = relative(options.rootDir, fileName);
+    return relative(options.appPath, join(options.outDir, fromRoot)).replace(/\.tsx?$/, "");
+}
+/**
+ * The name a class is exported under, if any.
+ *
+ * Mirrors `getExportedName`: a `default` modifier records `"default"` rather
+ * than the class name, and a class with no export modifier may still be
+ * re-exported by a later `export { X }` — `webda.module.json` records the alias
+ * in both cases, so the `Import` string is wrong without this.
+ * @param ctx - analysis context
+ * @param sf - containing file
+ * @param cls - the class declaration
+ * @returns the exported name, or undefined when not exported
+ */
+export function exportedName(ctx, sf, cls) {
+    const className = cls.name?.text;
+    if (!className)
+        return undefined;
+    const modifiers = cls.modifiers ?? [];
+    // 95 === ExportKeyword, 90 === DefaultKeyword
+    const hasExport = modifiers.some((modifier) => /^export$/.test(ctx.textOf(sf, modifier)));
+    if (hasExport) {
+        return modifiers.some((modifier) => /^default$/.test(ctx.textOf(sf, modifier))) ? "default" : className;
+    }
+    for (const statement of sf.statements) {
+        if (!is.isExportDeclaration(statement))
+            continue;
+        for (const element of statement.exportClause?.elements ?? []) {
+            const local = element.propertyName?.text ?? element.name?.text;
+            if (local === className)
+                return element.name?.text ?? className;
+        }
+    }
+    return undefined;
+}
+/**
+ * Discover every Webda object in the project.
+ * @param ctx - analysis context
+ * @param options - discovery options
+ * @returns discovered objects, ordered by section then name
+ */
+export function discoverWebdaObjects(ctx, options) {
+    const found = [];
+    for (const sf of ctx.sourceFiles) {
+        if (sf.fileName.endsWith(".spec.ts"))
+            continue;
+        for (const statement of sf.statements) {
+            if (!is.isClassDeclaration(statement))
+                continue;
+            const cls = statement;
+            if (!cls.name)
+                continue;
+            const chain = classTree(ctx, cls);
+            if (!chain.length)
+                continue;
+            const tags = tagsOf(ctx, sf, cls);
+            // Opt-out marker used by test fixtures and deliberately unregistered
+            // classes; without it they surface as extra module entries.
+            if (tags.WebdaIgnore !== undefined)
+                continue;
+            let section;
+            if (chainExtends(ctx, chain, "@webda/models", "Model")) {
+                section = "models";
+            }
+            else if (tags.WebdaModda !== undefined) {
+                if (!chainExtends(ctx, chain, "@webda/core", "Service"))
+                    continue;
+                section = "moddas";
+            }
+            else if (tags.WebdaDeployer !== undefined) {
+                if (!chainExtends(ctx, chain, "@webda/core", "AbstractDeployer"))
+                    continue;
+                section = "deployers";
+            }
+            else if (chainExtends(ctx, chain, "@webda/core", "Service")) {
+                // Beans are Services carrying the @Bean decorator.
+                const decorated = cls.modifiers?.some((modifier) => modifier.kind === 171 && /(^|\W)Bean(\W|$)/.test(ctx.textOf(sf, modifier)));
+                if (!decorated)
+                    continue;
+                section = "beans";
+            }
+            else {
+                continue;
+            }
+            const exportName = exportedName(ctx, sf, cls);
+            if (!exportName)
+                continue;
+            const tagName = tags[`Webda${section.slice(0, 1).toUpperCase()}${section.slice(1, section.length - 1)}`] || undefined;
+            const bare = tagName && tagName.length ? tagName : cls.name.text;
+            const name = bare.includes("/") ? bare : options.namespace ? `${options.namespace}/${bare}` : bare;
+            found.push({
+                name,
+                exportName,
+                section,
+                importTarget: `${outputTarget(sf.fileName, options)}:${exportName}`,
+                fileName: sf.fileName,
+                className: cls.name.text,
+                baseNames: chain
+                    .slice(1)
+                    .map((type) => (type.getSymbol?.() ?? type.symbol)?.name)
+                    .filter(Boolean),
+                primaryKey: primaryKeyOfChain(ctx, sf, cls, chain),
+                primaryKeySeparator: primaryKeySeparatorOfChain(ctx, sf, cls, chain)
+            });
+        }
+    }
+    found.sort((a, b) => a.section.localeCompare(b.section) || a.name.localeCompare(b.name));
+    if (options.keepDuplicates)
+        return found;
+    // Two classes can resolve to the same namespaced name; `generateWebdaModule`
+    // reports it as an error. Keep the first in sorted order so the result does
+    // not depend on program file ordering.
+    const unique = [];
+    const claimed = new Set();
+    for (const object of found) {
+        const key = `${object.section}:${object.name}`;
+        if (claimed.has(key))
+            continue;
+        claimed.add(key);
+        unique.push(object);
+    }
+    return unique;
+}
+/**
+ * Primary key attributes declared on a model.
+ *
+ * Recognises the two forms `@webda/core` uses: a `readonly ["uuid"]` type
+ * annotation and an `= ["uuid"] as const` initialiser, both keyed by the
+ * `WEBDA_PRIMARY_KEY` symbol.
+ * @param ctx - analysis context
+ * @param sf - containing file
+ * @param cls - the class declaration
+ * @returns key attribute names
+ */
+function primaryKeyOf(ctx, sf, cls) {
+    for (const member of cls.members ?? []) {
+        const name = member.name;
+        if (!name)
+            continue;
+        const nameText = ctx.textOf(sf, name);
+        if (!/WEBDA_PRIMARY_KEY/.test(nameText) || /WEBDA_PRIMARY_KEY_SEPARATOR/.test(nameText))
+            continue;
+        const text = ctx.textOf(sf, member);
+        const keys = [...text.matchAll(/["']([A-Za-z_$][\w$]*)["']/g)].map(match => match[1]);
+        if (keys.length)
+            return keys;
+    }
+    return [];
+}
+/**
+ * Primary key separator declared on the class itself
+ * @param ctx - analysis context
+ * @param sf - file declaring the class
+ * @param cls - the class declaration
+ * @returns the separator, or undefined when the class declares none
+ */
+function primaryKeySeparatorOf(ctx, sf, cls) {
+    for (const member of cls.members ?? []) {
+        const name = member.name;
+        if (!name || !/WEBDA_PRIMARY_KEY_SEPARATOR/.test(ctx.textOf(sf, name)))
+            continue;
+        const match = /=\s*["']([^"']+)["']/.exec(ctx.textOf(sf, member));
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
+/**
+ * Walk a class and its ancestors, nearest first, returning the first value the extractor finds.
+ * @param ctx - analysis context
+ * @param sf - file declaring the class
+ * @param cls - the class declaration
+ * @param chain - the class's type chain, nearest first
+ * @param extract - reads a value off one class declaration
+ * @param empty - result when no class in the chain has a value
+ * @returns the first value found, or `empty`
+ */
+function inheritedFromChain(ctx, sf, cls, chain, extract, empty) {
+    const own = extract(ctx, sf, cls);
+    if (own !== undefined && own.length !== 0)
+        return own;
+    for (const type of chain.slice(1)) {
+        const symbol = type.getSymbol?.() ?? type.symbol;
+        const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+        const node = declaration?.resolve(ctx.project);
+        if (!node)
+            continue;
+        const owner = node.getSourceFile?.() ?? node._sourceFile;
+        if (!owner)
+            continue;
+        const inherited = extract(ctx, owner, node);
+        if (inherited !== undefined && inherited.length !== 0)
+            return inherited;
+    }
+    return empty;
+}
+/**
+ * Primary key for a class, inherited when it declares none.
+ *
+ * `UuidModel` declares `["uuid"]` and every subclass inherits it, including
+ * across package boundaries — a sample-app model inherits from `@webda/models`.
+ * Looking only at the class's own members reports an empty key for all of them.
+ * @param ctx - analysis context
+ * @param sf - file declaring the class
+ * @param cls - the class declaration
+ * @param chain - the class's type chain, nearest first
+ * @returns key attribute names
+ */
+function primaryKeyOfChain(ctx, sf, cls, chain) {
+    return inheritedFromChain(ctx, sf, cls, chain, primaryKeyOf, []);
+}
+/**
+ * Primary key separator for a class, inherited when it declares none.
+ * @param ctx - analysis context
+ * @param sf - file declaring the class
+ * @param cls - the class declaration
+ * @param chain - the class's type chain, nearest first
+ * @returns the separator, or undefined when no class in the chain declares one
+ */
+function primaryKeySeparatorOfChain(ctx, sf, cls, chain) {
+    return inheritedFromChain(ctx, sf, cls, chain, primaryKeySeparatorOf, undefined);
+}
+const packageRootCache = new Map();
+/**
+ * Directory of the npm package that owns a file: the nearest folder with a
+ * `package.json`.
+ * @param fileName - file to attribute
+ * @returns the package directory, when one is found
+ */
+export function packageRootOf(fileName) {
+    let folder = dirname(fileName);
+    const visited = [];
+    let root;
+    while (folder.length > 2) {
+        if (packageRootCache.has(folder)) {
+            root = packageRootCache.get(folder);
+            break;
+        }
+        visited.push(folder);
+        if (existsSync(join(folder, "package.json"))) {
+            root = folder;
+            break;
+        }
+        const parent = dirname(folder);
+        if (parent === folder)
+            break;
+        folder = parent;
+    }
+    for (const folder of visited)
+        packageRootCache.set(folder, root);
+    return root;
+}
+/** `Import` target → model name, per dependency package directory. */
+const dependencyModelsCache = new Map();
+/**
+ * Models a dependency package declares in its `webda.module.json`, keyed by
+ * their `Import` target.
+ * @param root - the dependency's package directory
+ * @returns import target → namespaced model name
+ */
+function dependencyModels(root) {
+    let models = dependencyModelsCache.get(root);
+    if (models)
+        return models;
+    models = new Map();
+    try {
+        const module = JSON.parse(readFileSync(join(root, "webda.module.json"), "utf8"));
+        for (const [name, entry] of Object.entries(module.models ?? {})) {
+            if (typeof entry?.Import === "string")
+                models.set(entry.Import, name);
+        }
+    }
+    catch {
+        // No module, or not readable: the package declares no models
+    }
+    dependencyModelsCache.set(root, models);
+    return models;
+}
+/**
+ * Name of a model declared by a dependency package, as its own
+ * `webda.module.json` records it.
+ *
+ * The class is matched on its `Import` target: the declaring file relative to
+ * the package, without extension, then `:` and the export name. A source file
+ * (`src/x.ts`) also matches its compiled counterpart (`lib/x`).
+ * @param fileName - file declaring the class
+ * @param className - exported name of the class
+ * @param appPath - the project being compiled, whose own module is skipped
+ * @returns the namespaced model name, when the dependency declares one
+ */
+export function dependencyModelName(fileName, className, appPath) {
+    const root = packageRootOf(fileName);
+    if (!root || root === appPath)
+        return undefined;
+    const models = dependencyModels(root);
+    if (!models.size)
+        return undefined;
+    const path = relative(root, fileName)
+        .replace(/\\/g, "/")
+        .replace(/(\.d)?\.[cm]?[jt]sx?$/, "");
+    const paths = path.startsWith("src/") ? [path, `lib/${path.substring(4)}`] : [path];
+    for (const candidate of paths) {
+        const name = models.get(`${candidate}:${className}`);
+        if (name)
+            return name;
+    }
+    // A default export is recorded as `:default`; only trust it when it is the
+    // file's only one.
+    const defaults = paths.flatMap(candidate => {
+        const name = models.get(`${candidate}:default`);
+        return name ? [name] : [];
+    });
+    return defaults.length === 1 && defaults[0].split("/").pop() === className ? defaults[0] : undefined;
+}
+/**
+ * Build the structural half of each model's `webda.module.json` entry.
+ *
+ * Ancestors and subclasses are resolved among the discovered models, so they
+ * carry namespaced names rather than raw class names.
+ * @param objects - discovered objects
+ * @param plural - pluralisation function, supplied by the host
+ * @returns metadata per model name
+ */
+export function buildModelMetadata(objects, plural) {
+    const models = objects.filter(object => object.section === "models");
+    const byClassName = new Map();
+    for (const model of models)
+        byClassName.set(model.className, model);
+    const result = {};
+    for (const model of models) {
+        const ancestors = [];
+        for (const base of model.baseNames) {
+            const ancestor = byClassName.get(base);
+            // Bases outside the discovered set — `Model` itself, or a class from a
+            // dependency — are not module entries and are not recorded.
+            if (ancestor && ancestor.name !== model.name)
+                ancestors.push(ancestor.name);
+        }
+        result[model.name] = {
+            Identifier: model.name,
+            Plural: plural(model.name.split("/").pop() ?? model.name),
+            Ancestors: ancestors,
+            Subclasses: [],
+            PrimaryKey: model.primaryKey,
+            ...(model.primaryKeySeparator ? { PrimaryKeySeparator: model.primaryKeySeparator } : {})
+        };
+    }
+    // Subclasses are the inverse of the immediate ancestor relation.
+    for (const model of models) {
+        const immediate = model.baseNames.map(base => byClassName.get(base)).find(Boolean);
+        if (immediate && immediate.name !== model.name) {
+            result[immediate.name]?.Subclasses.push(model.name);
+        }
+    }
+    for (const entry of Object.values(result))
+        entry.Subclasses.sort();
+    return result;
+}
+/**
+ * Reflect a model's attributes, as `webda.module.json` records them.
+ *
+ * The recorded type is the *written* text rather than a resolved type: an
+ * inline object literal appears verbatim, comments and all. Generic types are
+ * the exception — their arguments are resolved through the checker so a type
+ * parameter is reported as its constraint.
+ *
+ * Properties keyed by a symbol, carrying `@ignore`, or marked not-enumerable
+ * are excluded, matching the original.
+ * @param ctx - analysis context
+ * @param sf - file declaring the class
+ * @param cls - the class declaration
+ * @returns attribute name to reflected type
+ */
+export function reflectAttributes(ctx, sf, cls) {
+    const reflection = {};
+    // Properties of the *type*, so inherited attributes are included — `uuid`
+    // comes from UuidModel and is recorded on every subclass. In TypeScript 6
+    // order, which is the key order of the committed artefact.
+    for (const property of classPropertiesInTs6Order(ctx, cls)) {
+        const name = property.name;
+        // Symbol-keyed slots surface as `__@WEBDA_STORAGE@123`. Ordinary
+        // double-underscore attributes such as `__password` are real and recorded.
+        if (typeof name !== "string" || name.startsWith("__@"))
+            continue;
+        const declaration = property.valueDeclaration ?? property.declarations?.[0];
+        const member = declaration?.resolve(ctx.project);
+        if (!member || !is.isPropertyDeclaration(member))
+            continue;
+        const owner = member.getSourceFile?.() ?? member._sourceFile ?? sf;
+        const nameNode = member.name;
+        if (nameNode && is.isComputedPropertyName(nameNode))
+            continue;
+        if (/@ignore\b/.test(ctx.triviaOf(owner, member)))
+            continue;
+        if (member.modifiers?.some((modifier) => /NotEnumerable/.test(ctx.textOf(owner, modifier))))
+            continue;
+        const typeNode = member.type;
+        if (!typeNode) {
+            reflection[name] = { type: "any" };
+            continue;
+        }
+        const typeArguments = typeNode.typeArguments;
+        if (is.isTypeReferenceNode(typeNode) && typeArguments?.length) {
+            reflection[name] = {
+                type: ctx.textOf(owner, typeNode.typeName),
+                typeParameters: typeArguments.map((argument) => {
+                    const type = ctx.checker.getTypeAtLocation(argument);
+                    return ctx.checker.typeToString(constraintOf(ctx, type) ?? type);
+                })
+            };
+            continue;
+        }
+        const text = ctx.textOf(owner, typeNode);
+        reflection[name] = text.endsWith("[]") ? { type: "Array", typeParameters: [text.slice(0, -2)] } : { type: text };
+    }
+    return reflection;
+}
+/**
+ * Constraint of a type parameter, or undefined for anything else.
+ *
+ * `getConstraintOfTypeParameter` throws when the type is not a parameter or has
+ * no constraint, rather than returning undefined, so it has to be guarded.
+ * @param ctx - analysis context
+ * @param type - the type to inspect
+ * @returns the constraint, when there is one
+ */
+function constraintOf(ctx, type) {
+    if (!type?.isTypeParameter?.())
+        return undefined;
+    try {
+        return ctx.checker.getConstraintOfTypeParameter?.(type);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** `ModelLink*` type names and the link kind each records. */
+const LINK_KINDS = {
+    ModelLink: "LINK",
+    ModelLinksMap: "LINKS_MAP",
+    ModelLinksArray: "LINKS_ARRAY",
+    ModelLinksSimpleArray: "LINKS_SIMPLE_ARRAY"
+};
+/**
+ * Build a model's `Relations` entry.
+ *
+ * Relation kinds are recognised by the written type name — `ModelParent`,
+ * `ModelRelated`, the `ModelLink*` family — and the referenced model is
+ * resolved to its namespaced identifier so the graph is expressed in module
+ * terms rather than class names.
+ * @param ctx - analysis context
+ * @param sf - file declaring the class
+ * @param cls - the class declaration
+ * @param resolveModelId - maps a class name to its namespaced identifier
+ * @returns the relations, omitting empty groups
+ */
+export function buildRelations(ctx, sf, cls, resolveModelId) {
+    const relations = {};
+    for (const property of classPropertiesInTs6Order(ctx, cls)) {
+        const attribute = property.name;
+        if (typeof attribute !== "string" || attribute.startsWith("__@"))
+            continue;
+        const declaration = property.valueDeclaration ?? property.declarations?.[0];
+        const member = declaration?.resolve(ctx.project);
+        if (!member || !is.isPropertyDeclaration(member))
+            continue;
+        const owner = member.getSourceFile?.() ?? member._sourceFile ?? sf;
+        const typeNode = member.type;
+        if (!typeNode || !is.isTypeReferenceNode(typeNode))
+            continue;
+        const typeName = ctx.textOf(owner, typeNode.typeName);
+        const typeArguments = typeNode.typeArguments ?? [];
+        if (!typeArguments.length)
+            continue;
+        const targetName = symbolNameOfTypeNode(ctx, typeArguments[0]);
+        const model = targetName ? resolveModelId(targetName) : undefined;
+        // `ModelLink<T>` on a generic base has no resolvable target. The relation
+        // still exists and is recorded, simply without a `model` — dropping it
+        // loses the link entirely.
+        if (typeName === "ModelParent") {
+            if (!model)
+                continue;
+            relations.parent = { attribute, model };
+        }
+        else if (typeName === "ModelRelated") {
+            if (!model)
+                continue;
+            relations.queries ??= [];
+            relations.queries.push({
+                attribute,
+                model,
+                targetAttribute: ctx.textOf(owner, typeArguments[1]).replace(/"/g, "")
+            });
+        }
+        else if (LINK_KINDS[typeName]) {
+            relations.links ??= [];
+            relations.links.push({
+                attribute,
+                ...(model ? { model } : {}),
+                type: LINK_KINDS[typeName]
+            });
+        }
+    }
+    return relations;
+}
+/**
+ * Class name a type node refers to.
+ * @param ctx - analysis context
+ * @param typeNode - the type node
+ * @returns the referenced symbol's name
+ */
+function symbolNameOfTypeNode(ctx, typeNode) {
+    const type = ctx.checker.getTypeFromTypeNode(typeNode);
+    const symbol = type?.getSymbol?.() ?? type?.symbol;
+    const name = symbol?.name;
+    if (name !== "default")
+        return name;
+    // `export default class Contact` has the symbol name "default"; the class
+    // name is what the module graph is keyed by.
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    const node = declaration?.resolve(ctx.project);
+    return node?.name?.text ?? name;
+}
+//# sourceMappingURL=module-discovery.js.map