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

package/dist/builder/scanner/input.extractor.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { evaluateStatic, findDecorator, getDecoratorArgument, getJsDocComment } from './ast-utils.js';
+import { evaluateExpression, evaluateStatic, findDecorator, getDecoratorArgument, getJsDocComment, UNEVALUABLE } from './ast-utils.js';
 import { getClassHierarchy } from './class-hierarchy.js';
 /**
  * Extract all @Input(), input() and model() signal metadata from a class
@@ -28,11 +28,9 @@ export function extractInputs(classDecl, checker, hierarchy = getClassHierarchy(
             }
             const initializedBy = reinitialized.get(name);
             if (initializedBy) {
-                const defaultValue = readInitialValue(initializedBy, checker);
-                if (defaultValue === undefined)
-                    delete input.defaultValue;
-                else
-                    input.defaultValue = defaultValue;
+                delete input.defaultValue;
+                delete input.defaultUnreadable;
+                Object.assign(input, defaultFields(readInitialValue(initializedBy, checker)));
             }
             seen.add(name);
             inputs.push(input);
@@ -40,16 +38,53 @@ export function extractInputs(classDecl, checker, hierarchy = getClassHierarchy(
     }
     return inputs;
 }
+/**
+ * The declaration Angular takes an input from: the member of that name in the
+ * nearest class that defines metadata and declares it an input, the one
+ * {@link extractInputs} reads.
+ */
+export function findInputDeclaration(hierarchy, name) {
+    return findDeclaration(hierarchy, name, (member) => !isStatic(member) && (!!findDecorator(member, 'Input') || !!getInputSignalCall(member)));
+}
+/** The declaration Angular takes an output from, as {@link findInputDeclaration} for an input. */
+export function findOutputDeclaration(hierarchy, name) {
+    return findDeclaration(hierarchy, name, (member) => !!findDecorator(member, 'Output') || isOutputSignal(member));
+}
+/** Whether an input is a `model()` or `model.required()`, for which Angular adds a change output. */
+export function isModelInput(member) {
+    const call = getInputSignalCall(member);
+    const callee = call && (ts.isPropertyAccessExpression(call.expression) ? call.expression.expression : call.expression);
+    return !!callee && ts.isIdentifier(callee) && callee.text === 'model';
+}
+function findDeclaration(hierarchy, name, declares) {
+    for (const { classDecl: owner, definesMetadata } of hierarchy.classes) {
+        if (!definesMetadata)
+            continue;
+        const member = owner.members.find((m) => ts.isPropertyDeclaration(m) && ts.isIdentifier(m.name) && m.name.text === name && declares(m));
+        if (member)
+            return { member, owner };
+    }
+    return undefined;
+}
 function isStatic(member) {
     return !!ts.getModifiers(member)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
 }
-/** What a field starts out with: its initializer, or for `input()` and `model()` the value passed to them. */
+/**
+ * What a field starts out with: its initializer, or for `input()` and `model()` the value passed to them. `undefined`
+ * when there is none, {@link UNEVALUABLE} when there is one the scan cannot read.
+ */
 function readInitialValue(member, checker) {
     const signalCall = getInputSignalCall(member);
     if (!signalCall)
         return member.initializer ? evaluateDefault(member.initializer, checker) : undefined;
     return !isSignalInputRequired(signalCall) && signalCall.arguments.length > 0 ? evaluateDefault(signalCall.arguments[0], checker) : undefined;
 }
+/** How {@link InputMeta} carries what {@link readInitialValue} found: a value, or that there is one that could not be read. */
+function defaultFields(initial) {
+    if (initial === UNEVALUABLE)
+        return { defaultUnreadable: true };
+    return initial === undefined ? {} : { defaultValue: initial };
+}
 /**
  * `owner` declares the member. `subclass` is the showcased class when that is
  * a different one, which decides what the type parameters of `owner` stand for.
@@ -58,17 +93,19 @@ function readInput(member, name, checker, owner, subclass) {
     const inputDecorator = findDecorator(member, 'Input');
     if (inputDecorator) {
         const required = isDecoratorInputRequired(inputDecorator);
-        const defaultValue = readInitialValue(member, checker);
+        const alias = readAlias(getDecoratorArgument(inputDecorator), name, checker);
+        const initial = readInitialValue(member, checker);
         const doc = getJsDocComment(member, checker);
         const instantiated = subclass && usesTypeParameters(member.type ?? member.initializer, owner, checker) ? getInstantiatedType(name, subclass, checker) : undefined;
         const { type, values, rawType } = instantiated ? mapType(instantiated, checker) : resolveDecoratorInputType(member, checker);
         return {
             name,
+            ...(alias && { alias }),
             type,
             rawType,
             required,
             ...(values && { values }),
-            ...(defaultValue !== undefined && { defaultValue }),
+            ...defaultFields(initial),
             ...(doc && { doc })
         };
     }
@@ -76,7 +113,9 @@ function readInput(member, name, checker, owner, subclass) {
     if (!signalCall)
         return undefined;
     const required = isSignalInputRequired(signalCall);
-    const defaultValue = readInitialValue(member, checker);
+    // `input(initial, options)`, but `input.required(options)`.
+    const alias = readAlias(signalCall.arguments[required ? 0 : 1], name, checker);
+    const initial = readInitialValue(member, checker);
     const doc = getJsDocComment(member, checker);
     const declaredType = signalCall.typeArguments?.[0] ?? signalCall.arguments[0];
     // A signal is a getter function, so its call signature returns the value type.
@@ -84,14 +123,26 @@ function readInput(member, name, checker, owner, subclass) {
     const { type, values, rawType } = instantiated ? mapType(instantiated, checker) : resolveSignalInputType(signalCall, checker);
     return {
         name,
+        ...(alias && { alias }),
         type,
         rawType,
         required,
         ...(values && { values }),
-        ...(defaultValue !== undefined && { defaultValue }),
+        ...defaultFields(initial),
         ...(doc && { doc })
     };
 }
+/**
+ * The `alias` of an input or output, from a decorator argument (`'x'` or
+ * `{ alias: 'x' }`) or the options of `input()`, `model()` and `output()`.
+ * It counts when the builder can evaluate it statically to a string (a literal
+ * or a constant) that differs from the member name.
+ */
+function readAlias(arg, name, checker) {
+    const value = arg ? evaluateExpression(arg, checker) : undefined;
+    const alias = typeof value === 'object' && value !== null ? value['alias'] : value;
+    return typeof alias === 'string' && alias !== name ? alias : undefined;
+}
 /**
  * Extract all @Output() and output() signal metadata from a class declaration
  * and the base classes Angular inherits outputs from.
@@ -108,11 +159,14 @@ export function extractOutputs(classDecl, checker, hierarchy = getClassHierarchy
             const name = member.name && ts.isIdentifier(member.name) ? member.name.text : undefined;
             if (!name || seen.has(name))
                 continue;
-            if (!findDecorator(member, 'Output') && !isOutputSignal(member))
+            const outputDecorator = findDecorator(member, 'Output');
+            if (!outputDecorator && !isOutputSignal(member))
                 continue;
             const doc = getJsDocComment(member, checker);
+            const options = outputDecorator ? getDecoratorArgument(outputDecorator) : member.initializer.arguments[0];
+            const alias = readAlias(options, name, checker);
             seen.add(name);
-            outputs.push({ name, ...(doc && { doc }) });
+            outputs.push({ name, ...(alias && { alias }), ...(doc && { doc }) });
         }
     }
     return outputs;
@@ -122,7 +176,7 @@ export function extractOutputs(classDecl, checker, hierarchy = getClassHierarchy
  * mentions a type parameter of the class that declares it. Only then does the
  * subclass change the type; otherwise the source text stays, alias names included.
  */
-function usesTypeParameters(node, owner, checker) {
+export function usesTypeParameters(node, owner, checker) {
     const parameters = owner.typeParameters;
     if (!node || !parameters?.length)
         return false;
@@ -155,19 +209,21 @@ function typeMentions(type, isOwnParameter, checker, visited = new Set()) {
  * sees it: `items = input.required<T[]>()` in `Field<T>` is an
  * `InputSignal<Country[]>` on `Picker extends Field<Country>`.
  */
-function getInstantiatedType(name, subclass, checker) {
+export function getInstantiatedType(name, subclass, checker) {
     const property = checker.getPropertyOfType(checker.getTypeAtLocation(subclass), name);
     return property && checker.getTypeOfSymbolAtLocation(property, subclass);
 }
 /**
  * A default is all or nothing. The renderer applies it to the component, so
  * the part of `{ ...shared, size: 'm' }` that can be read would overwrite the
- * whole default the component actually declares.
+ * whole default the component actually declares: it is {@link UNEVALUABLE}
+ * instead, so that a default the scan could not read stays apart from one that
+ * is `undefined`.
  */
 function evaluateDefault(node, checker) {
     let complete = true;
     const value = evaluateStatic(node, { checker, report: () => (complete = false) });
-    return complete ? value : undefined;
+    return complete ? value : UNEVALUABLE;
 }
 function getInputSignalCall(member) {
     const init = member.initializer;

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

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+import type { ScannedPipe } from '../../plugin/pipe.types.js';
+import type { ExportIndex } from './api/export-index.js';
+import { type ShowcasedClass } from './component.scanner.js';
+export interface ScanPipesOptions {
+    /** Built from every entry point of the library, since a setup function or a type is often exported by another one than the pipe. */
+    exportIndex: ExportIndex;
+    /** Shared with {@link scanComponents} and {@link scanServices}, and across entry points, so that a pipe exported from several of them does not repeat its warnings. */
+    diagnostics: string[];
+    notices: Set<string>;
+}
+/**
+ * Read the pipes among the showcased classes of an entry point: classes with
+ * `@Pipe` from `@angular/core`, unless they declare fields only a component
+ * can use. Components are left to {@link scanComponents}, services to
+ * {@link scanServices}.
+ *
+ * A pipe the styleguide cannot call from a template is reported and dropped:
+ * one declared with `standalone: false`, and one whose `name` the source does
+ * not give as a constant. A `pure` that cannot be read is left out instead,
+ * since the pipe is still worth showing.
+ *
+ * Nothing is run and the class is never imported: the pipe is read from the
+ * source, its API from the declarations, its `setup` from the array literal
+ * the arrow function returns. A pipe whose API cannot be read is left out with
+ * a notice, so that it does not take the whole scan down.
+ */
+export declare function scanPipes(showcased: ShowcasedClass[], checker: ts.TypeChecker, { exportIndex, diagnostics, notices }: ScanPipesOptions): ScannedPipe[];
+//# sourceMappingURL=pipe.scanner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/pipe.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAA0C,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAIrG,MAAM,WAAW,gBAAgB;IAC7B,oIAAoI;IACpI,WAAW,EAAE,WAAW,CAAC;IACzB,uKAAuK;IACvK,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACxB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,cAAc,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE,gBAAgB,GAAG,WAAW,EAAE,CAiDtJ"}

package/dist/builder/scanner/pipe.scanner.js

@@ -0,0 +1,65 @@
+import { readPipeOptions } from './api/angular-decorators.js';
+import { extractPipeApi } from './api/pipe-api.extractor.js';
+import { readSetupRefs } from './api/setup.reader.js';
+import { createReporters, extractShowcaseConfig } from './component.scanner.js';
+import { pickServiceFields } from './service.scanner.js';
+import { describePipeNameUnreadable, describePipeNotStandalone, describeUnreadableApi } from './showcase-diagnostics.js';
+/**
+ * Read the pipes among the showcased classes of an entry point: classes with
+ * `@Pipe` from `@angular/core`, unless they declare fields only a component
+ * can use. Components are left to {@link scanComponents}, services to
+ * {@link scanServices}.
+ *
+ * A pipe the styleguide cannot call from a template is reported and dropped:
+ * one declared with `standalone: false`, and one whose `name` the source does
+ * not give as a constant. A `pure` that cannot be read is left out instead,
+ * since the pipe is still worth showing.
+ *
+ * Nothing is run and the class is never imported: the pipe is read from the
+ * source, its API from the declarations, its `setup` from the array literal
+ * the arrow function returns. A pipe whose API cannot be read is left out with
+ * a notice, so that it does not take the whole scan down.
+ */
+export function scanPipes(showcased, checker, { exportIndex, diagnostics, notices }) {
+    const pipes = [];
+    const { report, notify } = createReporters(diagnostics, notices);
+    for (const { symbol, classDecl, decorator, argument, kind: classKind } of showcased) {
+        if (classKind.kind !== 'pipe')
+            continue;
+        const className = classDecl.name?.text ?? 'Anonymous';
+        const showcaseConfig = extractShowcaseConfig(decorator, className, report, checker);
+        if (!showcaseConfig || !argument)
+            continue;
+        const options = readPipeOptions(classKind.decorator, checker);
+        if (!options.standalone) {
+            report(describePipeNotStandalone(className, classKind.decorator));
+            continue;
+        }
+        if (options.name === undefined) {
+            report(describePipeNameUnreadable(className, classKind.decorator));
+            continue;
+        }
+        let api;
+        try {
+            api = extractPipeApi(classDecl, readSetupRefs(argument, className, checker, exportIndex, report), checker, exportIndex);
+        }
+        catch (error) {
+            notify(describeUnreadableApi(className, error, 'pipe'));
+            continue;
+        }
+        const pipe = {
+            className,
+            filePath: classDecl.getSourceFile().fileName,
+            showcaseConfig: pickServiceFields(showcaseConfig),
+            pipeName: options.name,
+            api
+        };
+        const importPath = exportIndex.get(symbol);
+        if (options.pure !== undefined)
+            pipe.pure = options.pure;
+        if (importPath !== undefined)
+            pipe.importPath = importPath;
+        pipes.push(pipe);
+    }
+    return pipes;
+}

package/dist/builder/scanner/pseudo-states.d.ts

@@ -1,4 +1,5 @@
 import { type ForcedPseudoStates } from '../../shared/pseudo-state.type.js';
+export declare function describeValue(value: unknown): string;
 /**
  * `Variant.pseudo` as the scanner evaluated it, with everything it cannot use
  * reported and dropped: a value that is no object, an unknown state, and a

package/dist/builder/scanner/pseudo-states.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pseudo-states.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/pseudo-states.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAsD,MAAM,mCAAmC,CAAC;AAehI;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,kBAAkB,GAAG,SAAS,CAmBjI"}
+{"version":3,"file":"pseudo-states.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/pseudo-states.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAsD,MAAM,mCAAmC,CAAC;AAUhI,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGpD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,kBAAkB,GAAG,SAAS,CAmBjI"}

package/dist/builder/scanner/pseudo-states.js

@@ -5,7 +5,7 @@ function isPseudoState(value) {
 function isSelector(value) {
     return typeof value === 'string' && value.trim() !== '';
 }
-function describeValue(value) {
+export function describeValue(value) {
     if (typeof value === 'string' || (typeof value === 'object' && value !== null))
         return JSON.stringify(value) ?? String(value);
     return String(value);

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

@@ -1,18 +1,42 @@
 import ts from 'typescript';
+import type { ScannedPipe } from '../../plugin/pipe.types.js';
 import type { ScannedComponent } from '../../plugin/plugin.types.js';
+import type { ScannedService } from '../../plugin/service.types.js';
 import { type EntryPointInput } from './entry-point.scanner.js';
 export interface CreateScannerOptions {
     entryPoints: ReadonlyArray<EntryPointInput>;
     compilerOptions?: ts.CompilerOptions;
 }
+/**
+ * What the scan reads beyond the components, each `true` when not given. The
+ * build reads only what a plugin in the config uses: services and pipes are
+ * then only counted, and components come without `api`.
+ */
+export interface ScanOptions {
+    /** {@link ScannedComponent.api}, read for a plugin with `componentApi`. */
+    componentApi?: boolean;
+    /** Services, read for a plugin with a view panel that applies to them. */
+    services?: boolean;
+    /** Pipes, read for a plugin with a view panel that applies to them. */
+    pipes?: boolean;
+}
 export interface ScanResult {
     components: ScannedComponent[];
+    /** Empty when {@link ScanOptions.services} is `false`. */
+    services: ScannedService[];
+    /** Empty when {@link ScanOptions.pipes} is `false`. */
+    pipes: ScannedPipe[];
+    /** The showcased services and pipes the options left unread, counted once each however many entry points export them. */
+    unread: {
+        services: number;
+        pipes: number;
+    };
     /** One message per @Showcase value the scan had to drop, already printed as a warning. */
     diagnostics: string[];
 }
 export interface Scanner {
     /** Scan all entry points. Reuses TypeScript program state from previous scans. */
-    scan(): ScanResult;
+    scan(options?: ScanOptions): ScanResult;
 }
 /**
  * Create a stateful multi-entry scanner that retains the previous ts.Program between scans.
@@ -20,8 +44,8 @@ export interface Scanner {
  * transitive type graph (Angular framework typings, etc.) is parsed once and shared via
  * the program's `TypeChecker`, instead of N programs that each load Material/CDK/RxJS.
  *
- * TypeScript reuses parsed SourceFile objects from the old program on rebuild, making
- * incremental scans fast.
+ * On rebuild, the source-file cache hands TypeScript the already parsed SourceFile of
+ * every unchanged file, so only the changed files are parsed again.
  */
 export declare function createScanner(options: CreateScannerOptions): Scanner;
 //# sourceMappingURL=scanner.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,KAAK,eAAe,EAA4B,MAAM,0BAA0B,CAAC;AAE1F,MAAM,WAAW,oBAAoB;IACjC,WAAW,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAC5C,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC;CACxC;AAED,MAAM,WAAW,UAAU;IACvB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,0FAA0F;IAC1F,WAAW,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,OAAO;IACpB,kFAAkF;IAClF,IAAI,IAAI,UAAU,CAAC;CACtB;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAiDpE"}
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAKpE,OAAO,EAAE,KAAK,eAAe,EAA4B,MAAM,0BAA0B,CAAC;AAK1F,MAAM,WAAW,oBAAoB;IACjC,WAAW,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAC5C,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC;CACxC;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACvB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,uDAAuD;IACvD,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,yHAAyH;IACzH,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,0FAA0F;IAC1F,WAAW,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,OAAO;IACpB,kFAAkF;IAClF,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;CAC3C;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CA4DpE"}

package/dist/builder/scanner/scanner.js

@@ -1,6 +1,12 @@
 import ts from 'typescript';
-import { scanComponents } from './component.scanner.js';
+import { buildExportIndex } from './api/export-index.js';
+import { createReporters, findShowcasedClasses, scanComponents } from './component.scanner.js';
+import { buildDeclarableIndex } from './composition/declarables.js';
+import { createCompositionContext } from './composition/read-composition.js';
 import { resolveEntryPointExports } from './entry-point.scanner.js';
+import { scanPipes } from './pipe.scanner.js';
+import { scanServices } from './service.scanner.js';
+import { createSourceFileCache } from './source-file-cache.js';
 const DEFAULT_COMPILER_OPTIONS = {
     target: ts.ScriptTarget.ES2022,
     module: ts.ModuleKind.ES2022,
@@ -22,46 +28,84 @@ const DEFAULT_COMPILER_OPTIONS = {
  * transitive type graph (Angular framework typings, etc.) is parsed once and shared via
  * the program's `TypeChecker`, instead of N programs that each load Material/CDK/RxJS.
  *
- * TypeScript reuses parsed SourceFile objects from the old program on rebuild, making
- * incremental scans fast.
+ * On rebuild, the source-file cache hands TypeScript the already parsed SourceFile of
+ * every unchanged file, so only the changed files are parsed again.
  */
 export function createScanner(options) {
     const compilerOptions = {
         ...DEFAULT_COMPILER_OPTIONS,
         ...options.compilerOptions
     };
+    const sourceFiles = createSourceFileCache(compilerOptions);
     let previousProgram;
     return {
-        scan() {
-            const { program, entries } = resolveEntryPointExports(options.entryPoints, compilerOptions, previousProgram);
+        scan({ componentApi = true, services: readServices = true, pipes: readPipes = true } = {}) {
+            const { program, entries } = resolveEntryPointExports(options.entryPoints, compilerOptions, previousProgram, sourceFiles.host);
             previousProgram = program;
+            sourceFiles.prune(program);
             const checker = program.getTypeChecker();
             const allComponents = [];
+            const allServices = [];
+            const allPipes = [];
+            const unreadServices = new Set();
+            const unreadPipes = new Set();
             const diagnostics = [];
             const notices = new Set();
-            for (const { exports, importPath } of entries) {
-                const components = scanComponents(exports, checker, diagnostics, notices);
+            // A setup function or a type is often exported by another entry point than the component, service or pipe that names it.
+            const exportIndex = buildExportIndex(entries, checker);
+            const context = { exportIndex, diagnostics, notices };
+            // A showcase's templates use what any entry point exports, not only its own. Read for the first one that composes.
+            const composition = createCompositionContext(() => buildDeclarableIndex(entries, checker), compilerOptions, createReporters(diagnostics, notices));
+            const fromPrimary = new Set();
+            for (const { exports, importPath, primary } of entries) {
+                const showcased = findShowcasedClasses(exports, checker);
+                const components = scanComponents(showcased, checker, { ...context, api: componentApi, composition });
+                const services = readServices ? scanServices(showcased, checker, context) : [];
+                const pipes = readPipes ? scanPipes(showcased, checker, context) : [];
+                for (const { classDecl, kind } of showcased) {
+                    if (!readServices && kind.kind === 'service')
+                        unreadServices.add(classDecl);
+                    if (!readPipes && kind.kind === 'pipe')
+                        unreadPipes.add(classDecl);
+                }
                 for (const c of components)
                     c.importPath = importPath;
-                allComponents.push(...components);
-            }
-            // Dedupe by (filePath, className): if a component class is re-exported from
-            // multiple entry points (e.g. atoms/button + barrel index.ts), we keep the first
-            // occurrence. The duplicate would otherwise produce duplicate imports in the
-            // generated manifest and a runtime collision in the Prism shell.
-            const seen = new Set();
-            const unique = [];
-            for (const c of allComponents) {
-                const key = `${c.filePath}::${c.className}`;
-                if (seen.has(key)) {
-                    console.warn(`⚠ ng-prism: ${c.className} is exported by multiple entry points; ` +
-                        `keeping the first occurrence (importPath: ${unique.find((u) => u.className === c.className && u.filePath === c.filePath)?.importPath}).`);
-                    continue;
+                if (primary) {
+                    for (const item of [...components, ...services, ...pipes])
+                        fromPrimary.add(item);
                 }
-                seen.add(key);
-                unique.push(c);
+                allComponents.push(...components);
+                allServices.push(...services);
+                allPipes.push(...pipes);
             }
-            return { components: unique, diagnostics };
+            return {
+                components: dedupe(allComponents, fromPrimary),
+                services: dedupe(allServices, fromPrimary),
+                pipes: dedupe(allPipes, fromPrimary),
+                unread: { services: unreadServices.size, pipes: unreadPipes.size },
+                diagnostics
+            };
         }
     };
 }
+/**
+ * Dedupe by (filePath, className): if a class is re-exported from multiple
+ * entry points (e.g. atoms/button + barrel index.ts), we keep the first
+ * occurrence. The duplicate would otherwise produce duplicate imports in the
+ * generated manifest and a runtime collision in the Prism shell. The primary
+ * entry point comes last and re-exporting its secondaries is normal there.
+ */
+function dedupe(items, fromPrimary) {
+    const first = new Map();
+    for (const item of items) {
+        const key = `${item.filePath}::${item.className}`;
+        const kept = first.get(key);
+        if (!kept) {
+            first.set(key, item);
+        }
+        else if (!fromPrimary.has(item)) {
+            console.warn(`⚠ ng-prism: ${item.className} is exported by multiple entry points; ` + `keeping the first occurrence (importPath: ${kept.importPath}).`);
+        }
+    }
+    return [...first.values()];
+}

package/dist/builder/scanner/service/angular-decorators.d.ts

@@ -0,0 +1,80 @@
+import ts from 'typescript';
+import type { ServiceProvision } from '../../../plugin/service.types.js';
+export type ShowcaseClassKind = {
+    kind: 'component';
+}
+/** `decorator` is the `@Injectable` or `@Service` that makes it one. */
+ | {
+    kind: 'service';
+    decorator: ts.Decorator;
+}
+/** `decorator` is the `@Pipe` that makes it one; whether the pipe is shown is for the pipe scan to decide. */
+ | {
+    kind: 'pipe';
+    decorator: ts.Decorator;
+}
+/**
+ * An `@Injectable`, `@Service` or `@Pipe` that still declares component-only `fields`, so it stays a component for now.
+ * `source` says which decorator would make it a service or a pipe; `standalone: false` only for a pipe declared in an NgModule.
+ */
+ | {
+    kind: 'legacy-component';
+    fields: string[];
+    source: 'injectable' | 'pipe';
+    standalone?: false;
+};
+/** What the `@Pipe` metadata says, as far as the source can be read. */
+export interface PipeOptions {
+    /** Missing when the source does not give it as a string constant: the pipe cannot be shown without its name. */
+    name?: string;
+    /** `true` when the metadata does not say, missing when it says something the scan cannot read. */
+    pure?: boolean;
+    /** Only `false` when the metadata statically says `standalone: false`; Angular's default is `true`. */
+    standalone: boolean;
+}
+/**
+ * {@link findDecorator} for an Angular decorator: it only counts if the
+ * identifier is imported from `@angular/core`. A `@Service` from a
+ * dependency-injection package of another name has nothing to do with Angular's.
+ *
+ * The scanner never imports `Service` itself, since Angular 20 has none: the
+ * decorator is recognised in the source alone.
+ */
+export declare function findAngularCoreDecorator(classDecl: ts.ClassDeclaration, name: 'Injectable' | 'Service' | 'Component' | 'Directive' | 'Pipe', checker: ts.TypeChecker): ts.Decorator | undefined;
+/**
+ * Tell a service or a pipe from a component. They all carry `@Showcase`, and
+ * the only thing that tells them apart is the Angular decorator beside it.
+ *
+ * A class with `@Component` or `@Directive` is a component, whatever else it
+ * carries. Otherwise `@Pipe` makes it a pipe, and `@Service` or `@Injectable`
+ * a service, so that a pipe that is also injectable stays a pipe. Either is
+ * overruled by the `@Showcase` argument declaring a component-only field: such
+ * a class has been shown as a component so far, so it stays one
+ * (`legacy-component`) until 23.0.0, and the scan says why. That check comes
+ * first, before anything is said about the pipe itself.
+ *
+ * `showcaseArg` is read from the literal and from the evaluated value, since a
+ * constant or a spread can bring the field in and a field the evaluator cannot
+ * read is still in the literal.
+ */
+export declare function classifyShowcaseClass(classDecl: ts.ClassDeclaration, showcaseArg: ts.Expression | undefined, checker: ts.TypeChecker): ShowcaseClassKind;
+/**
+ * Whether Angular provides the service on its own (`auto`) or the user has to
+ * list it in a providers array (`manual`).
+ *
+ * `@Service()` is auto-provided unless it says `autoProvided: false`;
+ * `@Injectable` is when `providedIn` is `'root'`, `'platform'` or `'any'`.
+ * Anything else, such as no argument, no `providedIn`, a module class or a value
+ * the scan cannot read, is `manual`, without a warning: a service nobody
+ * provides is a normal thing to document.
+ */
+export declare function readProvision(decorator: ts.Decorator, checker: ts.TypeChecker): ServiceProvision;
+/**
+ * Read `name`, `pure` and `standalone` from the `@Pipe` metadata.
+ *
+ * Nothing that cannot be read is guessed: a `name` or `pure` the source does not
+ * give as a constant is left out, so that the caller can say so, while
+ * `standalone` only counts as `false` when the source says exactly that.
+ */
+export declare function readPipeOptions(decorator: ts.Decorator, checker: ts.TypeChecker): PipeOptions;
+//# sourceMappingURL=angular-decorators.d.ts.map

package/dist/builder/scanner/service/angular-decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-decorators.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/service/angular-decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAezE,MAAM,MAAM,iBAAiB,GACvB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE;AACvB,wEAAwE;GACtE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAA;CAAE;AAC9C,8GAA8G;GAC5G;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAA;CAAE;AAC3C;;;GAGG;GACD;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC;AAExG,wEAAwE;AACxE,MAAM,WAAW,WAAW;IACxB,gHAAgH;IAChH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kGAAkG;IAClG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uGAAuG;IACvG,UAAU,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACpC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAC9B,IAAI,EAAE,YAAY,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,EACnE,OAAO,EAAE,EAAE,CAAC,WAAW,GACxB,EAAE,CAAC,SAAS,GAAG,SAAS,CAI1B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,WAAW,EAAE,EAAE,CAAC,UAAU,GAAG,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,iBAAiB,CAuBxJ;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,gBAAgB,CAsBhG;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,WAAW,CAqB7F"}