@ng-prism/core 22.2.1 → 22.4.0

package/dist/builder/scanner/ast-utils.js

@@ -1,14 +1,69 @@
 import ts from 'typescript';
+/**
+ * What {@link evaluateStatic} returns for a root it cannot evaluate. A symbol,
+ * so that it stays distinct from an `undefined` written on purpose.
+ */
+export const UNEVALUABLE = Symbol('ng-prism.unevaluable');
+const ignore = () => undefined;
+const ARITHMETIC = {
+    [ts.SyntaxKind.PlusToken]: (left, right) => left + right,
+    [ts.SyntaxKind.MinusToken]: (left, right) => left - right,
+    [ts.SyntaxKind.AsteriskToken]: (left, right) => left * right,
+    [ts.SyntaxKind.SlashToken]: (left, right) => left / right,
+    [ts.SyntaxKind.PercentToken]: (left, right) => left % right,
+    [ts.SyntaxKind.AsteriskAsteriskToken]: (left, right) => left ** right
+};
+/** Symbols that name a declaration of their own, as opposed to a property inside a constant's value. */
+const DECLARATION_SYMBOLS = ts.SymbolFlags.Variable | ts.SymbolFlags.EnumMember | ts.SymbolFlags.Function | ts.SymbolFlags.Class | ts.SymbolFlags.Method;
 /**
  * Statically evaluate an AST expression node.
- * Returns `undefined` for non-evaluable expressions (variables, function calls, spread).
+ *
+ * Inside an object or array literal, whatever cannot be evaluated costs only
+ * that property or element: it is reported and left out, never the container
+ * around it. Only the root itself can come back as {@link UNEVALUABLE}.
+ */
+export function evaluateStatic(node, options = {}) {
+    return evaluateMember(node, [], { report: options.report ?? ignore, checker: options.checker, resolving: new Set(), resolved: new Map(), trace: {} });
+}
+/**
+ * {@link evaluateStatic} for callers that read a few known fields and have no
+ * use for diagnostics, such as `@Component` metadata: what cannot be evaluated
+ * is left out silently, and an unevaluable root becomes `undefined`.
+ */
+export function evaluateExpression(node, checker) {
+    const value = evaluateStatic(node, { checker });
+    return value === UNEVALUABLE ? undefined : value;
+}
+function evaluateMember(node, path, context) {
+    return guard(node, path, context, () => evaluateNode(node, path, context));
+}
+/** Runs `evaluate` for the member `node` and, if it fails, reports it with the cause the trace picked up on the way. */
+function guard(node, path, context, evaluate) {
+    const { trace } = context;
+    const outer = trace.cause;
+    trace.cause = undefined;
+    const value = evaluate();
+    if (value === UNEVALUABLE) {
+        context.report({ path, node, reason: isRuntimeValue(node) ? 'runtime-value' : 'unsupported', cause: trace.cause });
+    }
+    trace.cause = outer;
+    return value;
+}
+/** For operands and keys: what fails inside them is the failure of the member around them, not a drop of its own. */
+function silent(context) {
+    return { ...context, report: ignore };
+}
+/**
+ * Reports only what an array or object literal drops. An operand that fails
+ * makes the whole expression around it {@link UNEVALUABLE}, so the member
+ * holding it reports `limit * 2`, not just `limit`.
  */
-export function evaluateExpression(node) {
+function evaluateNode(node, path, context) {
     if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
         return node.text;
     }
     if (ts.isNumericLiteral(node)) {
-        return Number(node.text);
+        return finite(Number(node.text));
     }
     if (node.kind === ts.SyntaxKind.TrueKeyword)
         return true;
@@ -16,45 +71,292 @@ export function evaluateExpression(node) {
         return false;
     if (node.kind === ts.SyntaxKind.NullKeyword)
         return null;
-    if (node.kind === ts.SyntaxKind.UndefinedKeyword)
-        return undefined;
-    if (ts.isParenthesizedExpression(node)) {
-        return evaluateExpression(node.expression);
+    if (ts.isIdentifier(node)) {
+        // In expression position `undefined` parses as an identifier, not a keyword.
+        if (node.text === 'undefined')
+            return undefined;
+        return evaluateReference(context.checker?.getSymbolAtLocation(node), node, path, context);
     }
-    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
-        const operand = evaluateExpression(node.operand);
-        if (typeof operand === 'number')
-            return -operand;
-        return undefined;
+    // Types only: the value is the expression inside.
+    if (ts.isParenthesizedExpression(node) ||
+        ts.isAsExpression(node) ||
+        ts.isSatisfiesExpression(node) ||
+        ts.isNonNullExpression(node) ||
+        ts.isTypeAssertionExpression(node)) {
+        return evaluateNode(node.expression, path, context);
+    }
+    if (ts.isPrefixUnaryExpression(node)) {
+        return evaluatePrefixUnary(node, context);
+    }
+    if (ts.isBinaryExpression(node)) {
+        return evaluateBinary(node, context);
+    }
+    if (ts.isTemplateExpression(node)) {
+        return evaluateTemplate(node, context);
+    }
+    if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+        return evaluateAccess(node, path, context);
     }
     if (ts.isArrayLiteralExpression(node)) {
-        const result = [];
-        for (const element of node.elements) {
-            if (ts.isSpreadElement(element))
-                return undefined;
-            result.push(evaluateExpression(element));
-        }
-        return result;
+        return evaluateArray(node, path, context);
     }
     if (ts.isObjectLiteralExpression(node)) {
-        const result = {};
-        for (const prop of node.properties) {
-            if (ts.isSpreadAssignment(prop))
-                return undefined;
-            if (!ts.isPropertyAssignment(prop))
-                return undefined;
-            const key = ts.isIdentifier(prop.name)
-                ? prop.name.text
-                : ts.isStringLiteral(prop.name)
-                    ? prop.name.text
-                    : undefined;
-            if (key === undefined)
-                return undefined;
-            result[key] = evaluateExpression(prop.initializer);
+        return evaluateObject(node, path, context);
+    }
+    return UNEVALUABLE;
+}
+/**
+ * The value of the declaration a reference points to: the initializer of a
+ * `const`, or the value of an enum member. Imports are followed to their
+ * source, and what the initializer drops is reported where it is written.
+ */
+function evaluateReference(symbol, reference, path, context) {
+    const { checker } = context;
+    if (!symbol || !checker)
+        return UNEVALUABLE;
+    const target = resolveAlias(symbol, checker);
+    const declaration = target.valueDeclaration;
+    if (target.flags & (ts.SymbolFlags.Function | ts.SymbolFlags.Class | ts.SymbolFlags.Method)) {
+        return fail(reference, 'runtime-value', context);
+    }
+    if (declaration && ts.isEnumMember(declaration)) {
+        // Asked of the member, not of `Size.Medium`: for an access the checker only answers for const enums.
+        return checker.getConstantValue(declaration) ?? UNEVALUABLE;
+    }
+    if (!declaration || !ts.isVariableDeclaration(declaration) || !ts.isIdentifier(declaration.name))
+        return UNEVALUABLE;
+    // Before let and var: an ambient `declare var Math` is a declaration without a value, not a variable the user chose.
+    if (!declaration.initializer)
+        return fail(reference, 'no-value', context);
+    const scope = ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.BlockScoped;
+    if (scope === ts.NodeFlags.Let)
+        return fail(reference, 'let', context);
+    if (scope === 0)
+        return fail(reference, 'var', context);
+    if (scope !== ts.NodeFlags.Const)
+        return UNEVALUABLE;
+    const resolved = context.resolved.get(declaration) ?? resolveConstant(declaration, declaration.initializer, context);
+    if (!resolved)
+        return fail(reference, 'cycle', context);
+    for (const issue of resolved.issues)
+        context.report({ ...issue, path: [...path, ...issue.path] });
+    if (resolved.value === UNEVALUABLE) {
+        context.trace.cause ??= resolved.cause;
+        return UNEVALUABLE;
+    }
+    // A copy per reference, so that two of them never share an object a plugin could change through either.
+    return structuredClone(resolved.value);
+}
+/**
+ * Folds a constant once per evaluation, recording its issues relative to the
+ * constant itself. `undefined` while the same constant is still being folded
+ * further up, which is a cycle.
+ */
+function resolveConstant(declaration, initializer, context) {
+    if (context.resolving.has(declaration))
+        return undefined;
+    const issues = [];
+    const trace = {};
+    context.resolving.add(declaration);
+    try {
+        const value = evaluateNode(initializer, [], { ...context, report: (issue) => issues.push(issue), trace });
+        const resolved = { value, issues, cause: trace.cause };
+        context.resolved.set(declaration, resolved);
+        return resolved;
+    }
+    finally {
+        context.resolving.delete(declaration);
+    }
+}
+function resolveAlias(symbol, checker) {
+    return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+function fail(reference, kind, context) {
+    context.trace.cause ??= { node: reference, kind };
+    return UNEVALUABLE;
+}
+/**
+ * `tokens.MAX_FILES` and `Size.Medium` name a declaration of their own.
+ * `TOKENS.size.m` and `SIZES[1]` read a property from a constant's value.
+ */
+function evaluateAccess(node, path, context) {
+    const { checker } = context;
+    const symbol = checker?.getSymbolAtLocation(node);
+    if (symbol && checker && resolveAlias(symbol, checker).flags & DECLARATION_SYMBOLS) {
+        return evaluateReference(symbol, node, path, context);
+    }
+    const dropped = [];
+    const object = evaluateNode(node.expression, [], { ...context, report: (issue) => dropped.push(issue) });
+    const key = ts.isPropertyAccessExpression(node) ? node.name.text : evaluateNode(node.argumentExpression, [], silent(context));
+    if (typeof object !== 'object' || object === null || (typeof key !== 'string' && typeof key !== 'number'))
+        return UNEVALUABLE;
+    const lost = dropped.find((issue) => touches(issue.path, key, Array.isArray(object)));
+    if (lost) {
+        context.trace.cause ??= lost.cause;
+        return UNEVALUABLE;
+    }
+    return Object.hasOwn(object, key) ? object[key] : UNEVALUABLE;
+}
+/**
+ * Whether a part dropped from an object or array could change what `[key]`
+ * reads from it: the part itself, something a spread might have supplied, or,
+ * in an array, an element whose removal moved the later ones up.
+ */
+function touches(dropped, key, array) {
+    if (dropped.length === 0)
+        return true;
+    const [head] = dropped;
+    if (!array)
+        return String(head) === String(key);
+    const index = Number(key);
+    const moved = dropped.length === 1 && (key === 'length' || (typeof head === 'number' && head < index));
+    return head === index || moved;
+}
+function evaluatePrefixUnary(node, context) {
+    const operand = evaluateNode(node.operand, [], silent(context));
+    switch (node.operator) {
+        case ts.SyntaxKind.MinusToken:
+            return typeof operand === 'number' ? -operand : UNEVALUABLE;
+        case ts.SyntaxKind.PlusToken:
+            return typeof operand === 'number' ? operand : UNEVALUABLE;
+        case ts.SyntaxKind.ExclamationToken:
+            return operand === UNEVALUABLE ? UNEVALUABLE : !operand;
+        default:
+            return UNEVALUABLE;
+    }
+}
+/**
+ * Arithmetic on numbers, and `+` as concatenation once either side is a
+ * string. Anything JavaScript would coerce beyond that, such as an object to
+ * `[object Object]`, is not what anybody meant to put into a showcase.
+ */
+function evaluateBinary(node, context) {
+    const operator = node.operatorToken.kind;
+    const left = evaluateNode(node.left, [], silent(context));
+    const right = evaluateNode(node.right, [], silent(context));
+    if (operator === ts.SyntaxKind.PlusToken && (typeof left === 'string' || typeof right === 'string')) {
+        return isPrimitive(left) && isPrimitive(right) ? String(left) + String(right) : UNEVALUABLE;
+    }
+    const apply = ARITHMETIC[operator];
+    return apply && typeof left === 'number' && typeof right === 'number' ? finite(apply(left, right)) : UNEVALUABLE;
+}
+function evaluateTemplate(node, context) {
+    let text = node.head.text;
+    for (const span of node.templateSpans) {
+        const value = evaluateNode(span.expression, [], silent(context));
+        if (!isPrimitive(value))
+            return UNEVALUABLE;
+        text += String(value) + span.literal.text;
+    }
+    return text;
+}
+function isPrimitive(value) {
+    return value === null || value === undefined || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** `Infinity` and `NaN` would reach the manifest as `null`. */
+function finite(value) {
+    return Number.isFinite(value) ? value : UNEVALUABLE;
+}
+function evaluateArray(node, path, context) {
+    const result = [];
+    node.elements.forEach((element, index) => {
+        const elementPath = [...path, index];
+        if (ts.isOmittedExpression(element)) {
+            // A hole is a position, not a value that went missing.
+            result.push(undefined);
+            return;
+        }
+        if (ts.isSpreadElement(element)) {
+            const spread = guard(element, elementPath, context, () => {
+                const value = evaluateNode(element.expression, elementPath, context);
+                return Array.isArray(value) ? value : UNEVALUABLE;
+            });
+            if (Array.isArray(spread))
+                result.push(...spread);
+            return;
+        }
+        const value = evaluateMember(element, elementPath, context);
+        if (value !== UNEVALUABLE)
+            result.push(value);
+    });
+    return result;
+}
+function evaluateObject(node, path, context) {
+    const result = {};
+    for (const prop of node.properties) {
+        if (ts.isSpreadAssignment(prop)) {
+            const spread = guard(prop, path, context, () => {
+                const value = evaluateNode(prop.expression, path, context);
+                return isRecord(value) ? value : UNEVALUABLE;
+            });
+            if (isRecord(spread)) {
+                for (const [key, value] of Object.entries(spread))
+                    setOwn(result, key, value);
+            }
+            continue;
         }
-        return result;
+        if (ts.isShorthandPropertyAssignment(prop)) {
+            const keyPath = [...path, prop.name.text];
+            const value = guard(prop, keyPath, context, () => evaluateReference(context.checker?.getShorthandAssignmentValueSymbol(prop), prop.name, keyPath, context));
+            assign(result, prop.name.text, value);
+            continue;
+        }
+        const key = propertyKey(prop, path, context);
+        if (key === undefined)
+            continue;
+        if (key === '__proto__' && !ts.isComputedPropertyName(prop.name)) {
+            // In a literal, `__proto__: x` sets the prototype instead of creating a property.
+            context.report({ path: [...path, key], node: prop, reason: 'unsupported' });
+            continue;
+        }
+        if (!ts.isPropertyAssignment(prop)) {
+            // Methods and accessors: functions, whatever their syntax.
+            context.report({ path: [...path, key], node: prop, reason: 'runtime-value' });
+            assign(result, key, UNEVALUABLE);
+            continue;
+        }
+        assign(result, key, evaluateMember(prop.initializer, [...path, key], context));
     }
-    return undefined;
+    return result;
+}
+/** The key of `prop`, or `undefined` once it is reported as unreadable, with the reason if a reference is to blame. */
+function propertyKey(prop, path, context) {
+    const key = guard(prop, path, context, () => {
+        const { name } = prop;
+        if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+            return name.text;
+        if (ts.isNumericLiteral(name))
+            return String(Number(name.text));
+        if (!ts.isComputedPropertyName(name))
+            return UNEVALUABLE;
+        const value = evaluateNode(name.expression, [], silent(context));
+        return typeof value === 'string' || typeof value === 'number' ? String(value) : UNEVALUABLE;
+    });
+    return typeof key === 'string' ? key : undefined;
+}
+/**
+ * Sets `key`, or removes it when its value could not be evaluated: the source
+ * overrides whatever an earlier spread put there, so keeping that would show
+ * a value the source replaces.
+ */
+function assign(target, key, value) {
+    if (value === UNEVALUABLE) {
+        Reflect.deleteProperty(target, key);
+        return;
+    }
+    setOwn(target, key, value);
+}
+/** An own property even for `__proto__`, which plain assignment would turn into the prototype. */
+function setOwn(target, key, value) {
+    Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+}
+function isRuntimeValue(node) {
+    if (ts.isParenthesizedExpression(node))
+        return isRuntimeValue(node.expression);
+    return ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isClassExpression(node) || ts.isNewExpression(node);
 }
 /**
  * Find a decorator by name on a class or property declaration.
@@ -90,9 +392,7 @@ export function getDecoratorArgument(decorator) {
  * Get the JSDoc comment for a node.
  */
 export function getJsDocComment(node, checker) {
-    const symbol = checker.getSymbolAtLocation(ts.isClassDeclaration(node) || ts.isPropertyDeclaration(node)
-        ? (node.name ?? node)
-        : node);
+    const symbol = checker.getSymbolAtLocation(ts.isClassDeclaration(node) || ts.isPropertyDeclaration(node) ? (node.name ?? node) : node);
     if (!symbol)
         return undefined;
     const doc = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();

package/dist/builder/scanner/class-hierarchy.d.ts

@@ -0,0 +1,33 @@
+import ts from 'typescript';
+export interface HierarchyClass {
+    classDecl: ts.ClassDeclaration;
+    /**
+     * Whether Angular takes inputs and outputs from it: the class itself, or a
+     * base class with @Directive() or @Component(). Angular passes over an
+     * undecorated base class, although its fields are still initialized.
+     */
+    definesMetadata: boolean;
+}
+export interface UnreadableBase {
+    classDecl: ts.ClassDeclaration;
+    /** Public names of the inputs it declares. */
+    inputs: string[];
+}
+export interface ClassHierarchy {
+    /** The class itself, then each base class with source, nearest first. */
+    classes: HierarchyClass[];
+    /**
+     * Base classes that only exist as a declaration and declare inputs:
+     * typically a .d.ts shipped by an npm package, or a `declare class`.
+     * Without the initializer there is no `input()` call, required flag or
+     * default left to read.
+     */
+    unreadable: UnreadableBase[];
+}
+/**
+ * Follow `extends` from a class up to the root of its hierarchy. A mixin
+ * (`extends withX(Base)`) ends the walk: what the call returns has no class
+ * declaration to read members from.
+ */
+export declare function getClassHierarchy(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker): ClassHierarchy;
+//# sourceMappingURL=class-hierarchy.d.ts.map

package/dist/builder/scanner/class-hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-hierarchy.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/class-hierarchy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAS5B,MAAM,WAAW,cAAc;IAC3B,SAAS,EAAE,EAAE,CAAC,gBAAgB,CAAC;IAC/B;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC3B,SAAS,EAAE,EAAE,CAAC,gBAAgB,CAAC;IAC/B,8CAA8C;IAC9C,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC3B,yEAAyE;IACzE,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B;;;;;OAKG;IACH,UAAU,EAAE,cAAc,EAAE,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,cAAc,CAmBzG"}

package/dist/builder/scanner/class-hierarchy.js

@@ -0,0 +1,87 @@
+import ts from 'typescript';
+import { findDecorator } from './ast-utils.js';
+/** The types Angular gives a signal input, which is all a `declare class` written by hand shows of one. */
+const INPUT_SIGNAL_TYPES = new Set(['InputSignal', 'InputSignalWithTransform', 'ModelSignal']);
+/** The static fields the Angular compiler writes a class's directive definition into. */
+const DEFINITION_FIELDS = new Set(['ɵdir', 'ɵcmp']);
+/**
+ * Follow `extends` from a class up to the root of its hierarchy. A mixin
+ * (`extends withX(Base)`) ends the walk: what the call returns has no class
+ * declaration to read members from.
+ */
+export function getClassHierarchy(classDecl, checker) {
+    const classes = [];
+    const unreadable = [];
+    const visited = new Set();
+    for (let current = classDecl; current && !visited.has(current); current = getBaseClass(current, checker)) {
+        visited.add(current);
+        if (!isDeclarationOnly(current)) {
+            classes.push({ classDecl: current, definesMetadata: current === classDecl || isAngularClass(current) });
+            continue;
+        }
+        const inputs = getDeclaredInputs(current, checker);
+        if (inputs.length > 0)
+            unreadable.push({ classDecl: current, inputs });
+    }
+    return { classes, unreadable };
+}
+function isAngularClass(classDecl) {
+    return !!(findDecorator(classDecl, 'Directive') ?? findDecorator(classDecl, 'Component'));
+}
+function getBaseClass(classDecl, checker) {
+    const clause = classDecl.heritageClauses?.find((c) => c.token === ts.SyntaxKind.ExtendsKeyword);
+    let expression = clause?.types[0]?.expression;
+    while (expression && ts.isParenthesizedExpression(expression))
+        expression = expression.expression;
+    if (!expression || !(ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression)))
+        return undefined;
+    let symbol = checker.getSymbolAtLocation(expression);
+    if (symbol && symbol.flags & ts.SymbolFlags.Alias)
+        symbol = checker.getAliasedSymbol(symbol);
+    return symbol?.declarations?.find(ts.isClassDeclaration);
+}
+/** A class in a .d.ts, a `declare class`, or one inside `declare module` or `declare namespace`. */
+function isDeclarationOnly(classDecl) {
+    if (classDecl.getSourceFile().isDeclarationFile)
+        return true;
+    for (let node = classDecl; !ts.isSourceFile(node); node = node.parent) {
+        if ((ts.isClassDeclaration(node) || ts.isModuleDeclaration(node)) && ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.DeclareKeyword)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * The input map the Angular compiler writes into `ɵdir`/`ɵcmp` is complete,
+ * decorator inputs and aliases included. It writes one for every decorated
+ * class, so a compiled class without it is one Angular does not inherit from.
+ * A `declare class` written by hand has no map at all; there the properties
+ * typed as signal inputs are all there is to go by.
+ */
+function getDeclaredInputs(classDecl, checker) {
+    const definition = classDecl.members.find((member) => ts.isPropertyDeclaration(member) && DEFINITION_FIELDS.has(getPropertyNameText(member.name) ?? ''));
+    if (definition) {
+        const inputMap = definition.type && ts.isTypeReferenceNode(definition.type) ? definition.type.typeArguments?.[3] : undefined;
+        return inputMap && ts.isTypeLiteralNode(inputMap) ? inputMap.members.flatMap((entry) => getPublicInputName(entry) ?? []) : [];
+    }
+    if (classDecl.getSourceFile().isDeclarationFile)
+        return [];
+    return classDecl.members.flatMap((member) => {
+        const name = ts.isPropertyDeclaration(member) ? getPropertyNameText(member.name) : undefined;
+        // Through the checker, so an import type or an alias of InputSignal counts too.
+        return name && INPUT_SIGNAL_TYPES.has(checker.getTypeAtLocation(member).symbol?.name ?? '') ? [name] : [];
+    });
+}
+/** `{ alias: 'x'; required: … }` since Angular 16, a plain `'x'` before; a `null` alias means the property name. */
+function getPublicInputName(entry) {
+    if (!ts.isPropertySignature(entry))
+        return undefined;
+    const alias = entry.type && ts.isTypeLiteralNode(entry.type) ? entry.type.members.find((m) => getPropertyNameText(m.name) === 'alias') : undefined;
+    const aliasType = alias && ts.isPropertySignature(alias) ? alias.type : entry.type;
+    if (aliasType && ts.isLiteralTypeNode(aliasType) && ts.isStringLiteral(aliasType.literal))
+        return aliasType.literal.text;
+    return getPropertyNameText(entry.name);
+}
+function getPropertyNameText(name) {
+    return name && (ts.isIdentifier(name) || ts.isStringLiteral(name)) ? name.text : undefined;
+}

package/dist/builder/scanner/component.scanner.d.ts

@@ -2,6 +2,12 @@ import ts from 'typescript';
 import type { ScannedComponent } from '../../plugin/plugin.types.js';
 /**
  * Scan exported symbols for Angular components annotated with @Showcase.
+ *
+ * Every @Showcase value the scan has to drop is printed and collected in
+ * `diagnostics`, once: sharing the array across entry points keeps a
+ * component exported from several of them from repeating its warnings.
+ * `notices` does the same for warnings about what a component inherits,
+ * which are not diagnostics.
  */
-export declare function scanComponents(exports: ts.Symbol[], checker: ts.TypeChecker): ScannedComponent[];
+export declare function scanComponents(exports: ts.Symbol[], checker: ts.TypeChecker, diagnostics?: string[], notices?: Set<string>): ScannedComponent[];
 //# sourceMappingURL=component.scanner.d.ts.map

package/dist/builder/scanner/component.scanner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/component.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAmErE;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,EACpB,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,gBAAgB,EAAE,CA8CpB"}
+{"version":3,"file":"component.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/component.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAgDrE;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,WAAW,GAAE,MAAM,EAAO,EAAE,OAAO,cAAoB,GAAG,gBAAgB,EAAE,CAsEzJ"}