@ng-prism/core 22.5.0 → 22.7.0-beta.0

package/dist/builder/scanner/api/type-collector.js

@@ -0,0 +1,211 @@
+import ts from 'typescript';
+import { isInternal, readDescription, readDocTags } from './doc-tags.js';
+import { collapseWhitespace, extractMembers, extractObjectTypeMembers, readTypeText } from './member.extractor.js';
+/**
+ * Collects the types the API of a service, pipe or component reaches. A type
+ * is documented when it is an interface, class, type alias or enum, a scanned
+ * entry point exports it, and it is not tagged `@internal`. Anything else,
+ * `Signal` or `Provider` or a type the library keeps to itself, stays text
+ * without a link.
+ *
+ * Each type is documented once, under the id it got when it was first
+ * reached: its name, or `${name}@${importPath}` when a type of that name was
+ * reached before. That also ends a type that refers to itself.
+ */
+export function createTypeCollector(checker, exportIndex) {
+    /** Every symbol met so far: what it was reached as, or `null` when it is not documented. */
+    const reached = new Map();
+    const ids = new Set();
+    const queue = [];
+    const docs = [];
+    function collect(typeNode, type, reachedFrom, path) {
+        const links = [];
+        const visit = (symbol) => {
+            const target = reach(symbol, reachedFrom, path);
+            if (target && !links.includes(target.id))
+                links.push(target.id);
+        };
+        if (typeNode)
+            forEachReferenceInNode(typeNode, checker, visit);
+        else
+            forEachReferenceInType(type, checker, visit, new Set());
+        const text = readTypeText(checker, typeNode, type);
+        return links.length > 0 ? { text, links } : { text };
+    }
+    function reach(symbol, reachedFrom, path) {
+        const target = resolveSymbol(symbol, checker);
+        const known = reached.get(target);
+        if (known !== undefined)
+            return known ?? undefined;
+        const declaration = target.declarations?.find(isDocumentedKind);
+        const importPath = exportIndex.get(target);
+        if (!declaration || importPath === undefined || isInternal(declaration)) {
+            reached.set(target, null);
+            return undefined;
+        }
+        const id = ids.has(target.name) ? `${target.name}@${importPath}` : target.name;
+        const entry = { id, symbol: target, declaration, importPath, reachedFrom, path: path ?? target.name };
+        ids.add(id);
+        reached.set(target, entry);
+        queue.push(entry);
+        return entry;
+    }
+    function within(owner) {
+        return {
+            ref(typeNode, type, reachedFrom, site) {
+                switch (site?.kind) {
+                    case 'property':
+                        return collect(typeNode, type, `via ${owner}.${site.name}`, `${owner}.${site.name}`);
+                    case 'parameter':
+                        return collect(typeNode, type, `parameter of ${owner}.${site.method}()`, site.name);
+                    case 'return':
+                        return collect(typeNode, type, `returned by ${owner}.${site.method}()`, `${owner}.${site.method}()`);
+                    default:
+                        return collect(typeNode, type, `via ${owner}`, owner);
+                }
+            }
+        };
+    }
+    function describe({ id, symbol, declaration, importPath, reachedFrom, path }) {
+        const doc = { id, name: symbol.name, kind: kindOf(declaration), importPath, tags: readDocTags(declaration) };
+        const description = readDescription(declaration);
+        const members = within(path);
+        if (description)
+            doc.description = description;
+        if (ts.isClassDeclaration(declaration)) {
+            assignMembers(doc, extractMembers(declaration, checker, members));
+        }
+        else if (ts.isInterfaceDeclaration(declaration)) {
+            assignMembers(doc, extractObjectTypeMembers(checker.getDeclaredTypeOfSymbol(symbol), checker, members));
+        }
+        else if (ts.isEnumDeclaration(declaration)) {
+            doc.members = declaration.members.filter((member) => !isInternal(member)).map((member) => describeEnumMember(member, checker));
+        }
+        else if (isLiteralUnion(declaration.type)) {
+            doc.union = declaration.type.types.map((member) => member.getText());
+        }
+        else if (ts.isTypeLiteralNode(declaration.type)) {
+            assignMembers(doc, extractObjectTypeMembers(checker.getDeclaredTypeOfSymbol(symbol), checker, members));
+        }
+        else {
+            // The text has no links of its own, but the types it names are reached all the same.
+            doc.text = collect(declaration.type, checker.getDeclaredTypeOfSymbol(symbol), `via ${path}`, path).text;
+        }
+        doc.reachedFrom = reachedFrom;
+        return doc;
+    }
+    return {
+        ref: (typeNode, type, reachedFrom, site) => collect(typeNode, type, reachedFrom, site && pathOf(site)),
+        within,
+        drain() {
+            // Describing a type reaches the types of its members, which join the queue behind it.
+            while (docs.length < queue.length)
+                docs.push(describe(queue[docs.length]));
+            return [...docs];
+        }
+    };
+}
+/** The value a type at the top level is the type of: a property, a parameter by its name, or `show()` for a return value. */
+function pathOf(site) {
+    return site.kind === 'return' ? `${site.method}()` : site.name;
+}
+/**
+ * The declaration a reference ends at: an import followed to its source, the
+ * export symbol of a declaration exported from its own file, an enum for one
+ * of its members. That is the symbol the export index holds.
+ */
+function resolveSymbol(symbol, checker) {
+    let target = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    if (target.flags & ts.SymbolFlags.EnumMember && target.valueDeclaration && ts.isEnumDeclaration(target.valueDeclaration.parent)) {
+        target = checker.getSymbolAtLocation(target.valueDeclaration.parent.name) ?? target;
+    }
+    return checker.getExportSymbolOfSymbol(target);
+}
+function isDocumentedKind(declaration) {
+    return ts.isInterfaceDeclaration(declaration) || ts.isClassDeclaration(declaration) || ts.isTypeAliasDeclaration(declaration) || ts.isEnumDeclaration(declaration);
+}
+function kindOf(declaration) {
+    if (ts.isInterfaceDeclaration(declaration))
+        return 'interface';
+    if (ts.isClassDeclaration(declaration))
+        return 'class';
+    if (ts.isEnumDeclaration(declaration))
+        return 'enum';
+    return 'type';
+}
+/** `'top-left' | 'top-right'`, `1 | 2` or `true | null`: a union of literals only. */
+function isLiteralUnion(node) {
+    return ts.isUnionTypeNode(node) && node.types.every(ts.isLiteralTypeNode);
+}
+function assignMembers(doc, { properties, methods }) {
+    if (properties.length > 0)
+        doc.properties = properties;
+    if (methods.length > 0)
+        doc.methods = methods;
+}
+/** The initializer as written, or the value TypeScript counts up to without one. */
+function describeEnumMember(member, checker) {
+    const result = {
+        name: ts.isIdentifier(member.name) || ts.isStringLiteral(member.name) ? member.name.text : member.name.getText()
+    };
+    const value = member.initializer ? collapseWhitespace(member.initializer.getText()) : checker.getConstantValue(member)?.toString();
+    const description = readDescription(member);
+    if (value !== undefined)
+        result.value = value;
+    if (description)
+        result.description = description;
+    return result;
+}
+/** Every type reference in an annotation: in type arguments, arrays, unions and object literal types too. */
+function forEachReferenceInNode(node, checker, visit) {
+    if (ts.isTypeReferenceNode(node)) {
+        const symbol = checker.getSymbolAtLocation(ts.isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
+        if (symbol)
+            visit(symbol);
+    }
+    ts.forEachChild(node, (child) => forEachReferenceInNode(child, checker, visit));
+}
+/**
+ * Every named type in a type without annotation, as `typeToString` prints it:
+ * an alias or a class or interface with their type arguments, the parts of a
+ * union or intersection, and the members of an object literal or function type.
+ */
+function forEachReferenceInType(type, checker, visit, seen) {
+    if (seen.has(type))
+        return;
+    seen.add(type);
+    const walk = (inner) => forEachReferenceInType(inner, checker, visit, seen);
+    if (type.aliasSymbol) {
+        visit(type.aliasSymbol);
+        type.aliasTypeArguments?.forEach(walk);
+        return;
+    }
+    // An enum, or one of its members.
+    if (type.flags & ts.TypeFlags.EnumLiteral && type.symbol) {
+        visit(type.symbol);
+        return;
+    }
+    if (type.isUnionOrIntersection()) {
+        type.types.forEach(walk);
+        return;
+    }
+    if (!(type.flags & ts.TypeFlags.Object))
+        return;
+    const { objectFlags } = type;
+    if (objectFlags & (ts.ObjectFlags.Class | ts.ObjectFlags.Interface | ts.ObjectFlags.Reference)) {
+        if (type.symbol)
+            visit(type.symbol);
+        if (objectFlags & ts.ObjectFlags.Reference)
+            checker.getTypeArguments(type).forEach(walk);
+        return;
+    }
+    if (objectFlags & ts.ObjectFlags.Anonymous) {
+        for (const property of type.getProperties())
+            walk(checker.getTypeOfSymbol(property));
+        for (const signature of type.getCallSignatures()) {
+            for (const parameter of signature.getParameters())
+                walk(checker.getTypeOfSymbol(parameter));
+            walk(signature.getReturnType());
+        }
+    }
+}

package/dist/builder/scanner/ast-utils.d.ts

@@ -57,6 +57,14 @@ export declare function findDecorator(node: ts.ClassDeclaration | ts.PropertyDec
  * Returns undefined if the decorator is not a call or has no arguments.
  */
 export declare function getDecoratorArgument(decorator: ts.Decorator): ts.Expression | undefined;
+/**
+ * One field of `@Component`/`@Directive`/`@Pipe` metadata, read from its own
+ * property where the literal has one, so that `imports`, `providers` and the
+ * rest are not resolved only to be thrown away. A spread or a shorthand could
+ * supply the field from elsewhere, so then the whole argument is evaluated.
+ * Without a `checker`, only what the literal itself says can be read.
+ */
+export declare function readDecoratorField(arg: ts.Expression, key: string, checker?: ts.TypeChecker): unknown;
 /**
  * Get the JSDoc comment for a node.
  */

package/dist/builder/scanner/ast-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast-utils.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/ast-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,OAAO,MAAuC,CAAC;AAEzE,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AAE5D,sFAAsF;AACtF,MAAM,WAAW,mBAAmB;IAChC,kFAAkF;IAClF,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd;;;;;OAKG;IACH,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,GAAG,eAAe,CAAC;CAChE;AAED,MAAM,WAAW,gBAAgB;IAC7B,sGAAsG;IACtG,IAAI,EAAE,cAAc,CAAC;IACrB,sEAAsE;IACtE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd,2GAA2G;IAC3G,MAAM,EAAE,aAAa,GAAG,eAAe,CAAC;IACxC,qFAAqF;IACrF,KAAK,CAAC,EAAE,mBAAmB,CAAC;CAC/B;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAEpE,MAAM,WAAW,eAAe;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,gGAAgG;IAChG,OAAO,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC;CAC5B;AAmCD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAE1F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,WAAW,GAAG,OAAO,CAIzF;AAoYD;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,GAAG,EAAE,CAAC,mBAAmB,EAAE,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,SAAS,GAAG,SAAS,CAgBxH;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,GAAG,EAAE,CAAC,UAAU,GAAG,SAAS,CAOvF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,MAAM,GAAG,SAAS,CAQ1F"}
+{"version":3,"file":"ast-utils.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/ast-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,OAAO,MAAuC,CAAC;AAEzE,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AAE5D,sFAAsF;AACtF,MAAM,WAAW,mBAAmB;IAChC,kFAAkF;IAClF,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd;;;;;OAKG;IACH,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,GAAG,eAAe,CAAC;CAChE;AAED,MAAM,WAAW,gBAAgB;IAC7B,sGAAsG;IACtG,IAAI,EAAE,cAAc,CAAC;IACrB,sEAAsE;IACtE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd,2GAA2G;IAC3G,MAAM,EAAE,aAAa,GAAG,eAAe,CAAC;IACxC,qFAAqF;IACrF,KAAK,CAAC,EAAE,mBAAmB,CAAC;CAC/B;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAEpE,MAAM,WAAW,eAAe;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,gGAAgG;IAChG,OAAO,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC;CAC5B;AAmCD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAE1F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,WAAW,GAAG,OAAO,CAIzF;AAoYD;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,gBAAgB,GAAG,EAAE,CAAC,mBAAmB,EAAE,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,SAAS,GAAG,SAAS,CAgBxH;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,GAAG,EAAE,CAAC,UAAU,GAAG,SAAS,CAOvF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,WAAW,GAAG,OAAO,CAWrG;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,MAAM,GAAG,SAAS,CAQ1F"}

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

@@ -388,6 +388,24 @@ export function getDecoratorArgument(decorator) {
     }
     return undefined;
 }
+/**
+ * One field of `@Component`/`@Directive`/`@Pipe` metadata, read from its own
+ * property where the literal has one, so that `imports`, `providers` and the
+ * rest are not resolved only to be thrown away. A spread or a shorthand could
+ * supply the field from elsewhere, so then the whole argument is evaluated.
+ * Without a `checker`, only what the literal itself says can be read.
+ */
+export function readDecoratorField(arg, key, checker) {
+    if (ts.isObjectLiteralExpression(arg) && !arg.properties.some(ts.isSpreadAssignment)) {
+        const prop = arg.properties.find((p) => p.name !== undefined && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === key);
+        if (!prop)
+            return undefined;
+        if (ts.isPropertyAssignment(prop))
+            return evaluateExpression(prop.initializer, checker);
+    }
+    const raw = evaluateExpression(arg, checker);
+    return typeof raw === 'object' && raw !== null ? raw[key] : undefined;
+}
 /**
  * Get the JSDoc comment for a node.
  */
@@ -395,6 +413,24 @@ export function getJsDocComment(node, checker) {
     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();
+    const doc = joinDocParts(symbol.getDocumentationComment(checker)).trim();
     return doc || undefined;
 }
+/**
+ * Joins the parts of a comment like `ts.displayPartsToString`, except that a
+ * link keeps the separator between its target and its text. TypeScript drops
+ * it, and `{@link Item | the item}` would read `{@link Itemthe item}`. It only
+ * splits a link into a `linkName` and a `linkText` when the target resolves to a
+ * symbol. Any other target comes as one `linkText` that still ends in the blank
+ * before the closing brace, which is trimmed here.
+ */
+function joinDocParts(parts) {
+    return parts
+        .map((part, index) => {
+        if (part.kind !== 'linkText')
+            return part.text;
+        const text = parts[index + 1]?.kind === 'link' ? part.text.trimEnd() : part.text;
+        return parts[index - 1]?.kind === 'linkName' ? ` | ${text}` : text;
+    })
+        .join('');
+}

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

@@ -25,9 +25,11 @@ export interface ClassHierarchy {
     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.
+ * The class, then each base class it extends, nearest first, the ones that
+ * only exist as a declaration included. A mixin (`extends withX(Base)`) ends
+ * the chain: what the call returns has no class declaration to read members from.
  */
+export declare function getClassChain(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker): ts.ClassDeclaration[];
+/** The classes of {@link getClassChain} that have source, and the declaration-only ones among them that declare inputs. */
 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

@@ -1 +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"}
+{"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,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,EAAE,CAAC,gBAAgB,EAAE,CAQ5G;AAED,2HAA2H;AAC3H,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,cAAc,CAgBzG"}

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

@@ -5,16 +5,22 @@ const INPUT_SIGNAL_TYPES = new Set(['InputSignal', 'InputSignalWithTransform', '
 /** 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.
+ * The class, then each base class it extends, nearest first, the ones that
+ * only exist as a declaration included. A mixin (`extends withX(Base)`) ends
+ * the chain: what the call returns has no class declaration to read members from.
  */
+export function getClassChain(classDecl, checker) {
+    const chain = [];
+    for (let current = classDecl; current && !chain.includes(current); current = getBaseClass(current, checker)) {
+        chain.push(current);
+    }
+    return chain;
+}
+/** The classes of {@link getClassChain} that have source, and the declaration-only ones among them that declare inputs. */
 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);
+    for (const current of getClassChain(classDecl, checker)) {
         if (!isDeclarationOnly(current)) {
             classes.push({ classDecl: current, definesMetadata: current === classDecl || isAngularClass(current) });
             continue;

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

@@ -1,13 +1,67 @@
 import ts from 'typescript';
+import type { ShowcaseConfig } from '../../decorator/showcase.types.js';
 import type { ScannedComponent } from '../../plugin/plugin.types.js';
+import { type ShowcaseClassKind } from './api/angular-decorators.js';
+import type { ExportIndex } from './api/export-index.js';
+import { type CompositionContext } from './composition/read-composition.js';
+type Report = (message: string) => void;
 /**
- * Scan exported symbols for Angular components annotated with @Showcase.
+ * The two ways a scan warns, each printing a message once however often it is
+ * raised: `report` for a dropped value, which is also collected in
+ * `diagnostics` and fails the build under `strictShowcase`, and `notify` for
+ * anything else worth saying.
+ */
+export declare function createReporters(diagnostics: string[], notices: Set<string>): {
+    report: Report;
+    notify: Report;
+};
+export interface ScanComponentsOptions {
+    /**
+     * Shared across entry points, and with {@link scanServices} and {@link scanPipes}, so that a class exported from
+     * several of them does not repeat its warnings.
+     */
+    diagnostics?: string[];
+    notices?: Set<string>;
+    /**
+     * Tells the API of a component which of the types it names a consumer can import; without one the API has their
+     * text, but no links and no `types`.
+     */
+    exportIndex?: ExportIndex;
+    /** Whether to read {@link ScannedComponent.api}: only a plugin with `componentApi` reads it, so the build leaves it out without one. */
+    api?: boolean;
+    /** What {@link ScannedComponent.composition} is read against; without it, no composition is read. */
+    composition?: CompositionContext;
+}
+/**
+ * Read the Angular components among the showcased classes of an entry point.
+ * A class with `@Injectable` or `@Service` is a service and one with `@Pipe` a
+ * pipe, each left to its own scan, unless it declares fields only a component
+ * can use.
  *
  * 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.
+ * `diagnostics`, once. `notices` does the same for warnings about what a
+ * component inherits, which are not diagnostics.
+ */
+export declare function scanComponents(showcased: ShowcasedClass[], checker: ts.TypeChecker, options?: ScanComponentsOptions): ScannedComponent[];
+/** An exported class with `@Showcase`, and which scan it belongs to. */
+export interface ShowcasedClass {
+    symbol: ts.Symbol;
+    classDecl: ts.ClassDeclaration;
+    decorator: ts.Decorator;
+    argument: ts.Expression | undefined;
+    kind: ShowcaseClassKind;
+}
+/**
+ * The classes with `@Showcase` among the exports of an entry point, each
+ * classified once: the component, the service and the pipe scan each keep
+ * the classes of their own kind.
+ */
+export declare function findShowcasedClasses(exports: ts.Symbol[], checker: ts.TypeChecker): ShowcasedClass[];
+/**
+ * `setup` is read for services and pipes only, so a component's is never
+ * part of the config: the issue the evaluator raises for its function is
+ * swallowed here, and {@link scanComponents} says what is wrong with it instead.
  */
-export declare function scanComponents(exports: ts.Symbol[], checker: ts.TypeChecker, diagnostics?: string[], notices?: Set<string>): ScannedComponent[];
+export declare function extractShowcaseConfig(decorator: ts.Decorator, className: string, report: Report, checker: ts.TypeChecker): ShowcaseConfig | undefined;
+export {};
 //# 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;AAE5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAiDrE;;;;;;;;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"}
+{"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,EAAgD,cAAc,EAAkB,MAAM,mCAAmC,CAAC;AACtI,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAIrE,OAAO,EAAyB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAE5F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIzD,OAAO,EAAE,KAAK,kBAAkB,EAAmB,MAAM,mCAAmC,CAAC;AA6E7F,KAAK,MAAM,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAExC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAa/G;AAED,MAAM,WAAW,qBAAqB;IAClC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,wIAAwI;IACxI,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,qGAAqG;IACrG,WAAW,CAAC,EAAE,kBAAkB,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,cAAc,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,OAAO,GAAE,qBAA0B,GAAG,gBAAgB,EAAE,CA+H5I;AAED,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC3B,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC;IAClB,SAAS,EAAE,EAAE,CAAC,gBAAgB,CAAC;IAC/B,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC;IACxB,QAAQ,EAAE,EAAE,CAAC,UAAU,GAAG,SAAS,CAAC;IACpC,IAAI,EAAE,iBAAiB,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,cAAc,EAAE,CAMpG;AA2BD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,cAAc,GAAG,SAAS,CAErJ"}