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

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/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.

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;AAG1F,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,CA0DpE"}
+{"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,11 @@
 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,
@@ -34,44 +39,73 @@ export function createScanner(options) {
     const sourceFiles = createSourceFileCache(compilerOptions);
     let previousProgram;
     return {
-        scan() {
+        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();
+            // 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 components = scanComponents(exports, checker, diagnostics, notices);
-                for (const c of components) {
+                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;
-                    if (primary)
-                        fromPrimary.add(c);
+                if (primary) {
+                    for (const item of [...components, ...services, ...pipes])
+                        fromPrimary.add(item);
                 }
                 allComponents.push(...components);
+                allServices.push(...services);
+                allPipes.push(...pipes);
             }
-            // 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. The primary
-            // entry point comes last and re-exporting its secondaries is normal there.
-            const seen = new Set();
-            const unique = [];
-            for (const c of allComponents) {
-                const key = `${c.filePath}::${c.className}`;
-                if (seen.has(key)) {
-                    if (fromPrimary.has(c))
-                        continue;
-                    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;
-                }
-                seen.add(key);
-                unique.push(c);
-            }
-            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"}

package/dist/builder/scanner/service/angular-decorators.js

@@ -0,0 +1,154 @@
+import ts from 'typescript';
+import { evaluateExpression, evaluateStatic, findDecorator, getDecoratorArgument, UNEVALUABLE } from '../ast-utils.js';
+const ANGULAR_CORE = '@angular/core';
+/**
+ * `@Showcase` fields that only a component can use. A class that carries
+ * one of them next to `@Injectable` or `@Pipe` is a component with that
+ * decorator, not a service or a pipe: showing it as one would drop the field.
+ */
+const COMPONENT_ONLY_FIELDS = ['variants', 'states', 'providers', 'bg', 'canvasLayout', 'host', 'renderPage'];
+/** The values of `providedIn` that make Angular provide a service without anyone listing it. */
+const AUTO_PROVIDED_IN = ['root', 'platform', 'any'];
+/**
+ * {@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 function findAngularCoreDecorator(classDecl, name, checker) {
+    const decorator = findDecorator(classDecl, name);
+    return decorator && isImportedFromAngularCore(decorator, name, checker) ? 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 function classifyShowcaseClass(classDecl, showcaseArg, checker) {
+    // Compared by name, as everywhere else in the scanner.
+    if (findDecorator(classDecl, 'Component') || findDecorator(classDecl, 'Directive'))
+        return { kind: 'component' };
+    const pipe = findAngularCoreDecorator(classDecl, 'Pipe', checker);
+    if (pipe) {
+        const fields = readComponentOnlyFields(showcaseArg, checker);
+        if (fields.length === 0)
+            return { kind: 'pipe', decorator: pipe };
+        return readPipeOptions(pipe, checker).standalone
+            ? { kind: 'legacy-component', fields, source: 'pipe' }
+            : { kind: 'legacy-component', fields, source: 'pipe', standalone: false };
+    }
+    const decorator = findAngularCoreDecorator(classDecl, 'Service', checker) ?? findAngularCoreDecorator(classDecl, 'Injectable', checker);
+    if (!decorator)
+        return { kind: 'component' };
+    const fields = readComponentOnlyFields(showcaseArg, checker);
+    return fields.length > 0 ? { kind: 'legacy-component', fields, source: 'injectable' } : { kind: 'service', decorator };
+}
+/**
+ * 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 function readProvision(decorator, checker) {
+    const isService = decoratorName(decorator) === 'Service';
+    const arg = getDecoratorArgument(decorator);
+    if (!arg)
+        return isService ? 'auto' : 'manual';
+    let unreadable = false;
+    const raw = evaluateStatic(arg, {
+        checker,
+        report: (issue) => {
+            // A `factory` is a runtime value and always dropped, which leaves the provision alone.
+            if (isService && issue.path[0] === 'autoProvided')
+                unreadable = true;
+        }
+    });
+    if (raw === UNEVALUABLE || typeof raw !== 'object' || raw === null)
+        return 'manual';
+    const options = raw;
+    if (isService)
+        return unreadable || options['autoProvided'] === false ? 'manual' : 'auto';
+    return AUTO_PROVIDED_IN.includes(options['providedIn']) ? 'auto' : 'manual';
+}
+/**
+ * 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 function readPipeOptions(decorator, checker) {
+    const arg = getDecoratorArgument(decorator);
+    let unreadable = false;
+    const raw = arg
+        ? evaluateStatic(arg, {
+            checker,
+            report: (issue) => {
+                // The whole argument or a spread that fails could have carried `pure` along, so it counts for it too.
+                if (issue.path.length === 0 || issue.path[0] === 'pure')
+                    unreadable = true;
+            }
+        })
+        : {};
+    const options = typeof raw === 'object' && raw !== null ? raw : {};
+    const result = { standalone: options['standalone'] !== false };
+    if (typeof options['name'] === 'string')
+        result.name = options['name'];
+    if (typeof options['pure'] === 'boolean')
+        result.pure = options['pure'];
+    else if (!unreadable && options['pure'] === undefined)
+        result.pure = true;
+    return result;
+}
+function isImportedFromAngularCore(decorator, name, checker) {
+    const expr = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
+    if (!ts.isIdentifier(expr))
+        return false;
+    return (checker.getSymbolAtLocation(expr)?.declarations?.some((decl) => {
+        if (!ts.isImportSpecifier(decl))
+            return false;
+        const importDeclaration = decl.parent.parent.parent;
+        // `import { Injectable as Service }` is Angular's Injectable, not its Service.
+        return (ts.isStringLiteral(importDeclaration.moduleSpecifier) &&
+            importDeclaration.moduleSpecifier.text === ANGULAR_CORE &&
+            (decl.propertyName ?? decl.name).text === name);
+    }) ?? false);
+}
+function decoratorName(decorator) {
+    const expr = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
+    return ts.isIdentifier(expr) ? expr.text : undefined;
+}
+function readComponentOnlyFields(showcaseArg, checker) {
+    if (!showcaseArg)
+        return [];
+    const declared = new Set();
+    if (ts.isObjectLiteralExpression(showcaseArg)) {
+        for (const prop of showcaseArg.properties) {
+            if (prop.name && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)))
+                declared.add(prop.name.text);
+        }
+    }
+    const evaluated = evaluateExpression(showcaseArg, checker);
+    if (typeof evaluated === 'object' && evaluated !== null) {
+        for (const key of Object.keys(evaluated))
+            declared.add(key);
+    }
+    return COMPONENT_ONLY_FIELDS.filter((field) => declared.has(field));
+}

package/dist/builder/scanner/service/doc-tags.d.ts

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+import type { ApiDocTags } from '../../../plugin/service.types.js';
+/** The comment text of a node without its tags, as written: line breaks and markdown stay. */
+export declare function readDescription(node: ts.Node): string | undefined;
+/** The tags of a node. `@version` and tags without a place in {@link ApiDocTags} are not read. */
+export declare function readDocTags(node: ts.Node): ApiDocTags;
+/** Whether a node has a doc block of its own, tags only or not. */
+export declare function isDocumented(node: ts.Node): boolean;
+/** Whether a node carries an `@internal` tag. */
+export declare function isInternal(node: ts.Node): boolean;
+/** The `@param` descriptions of a function-like node, by parameter name. */
+export declare function readParamDescriptions(node: ts.Node): Map<string, string>;
+//# sourceMappingURL=doc-tags.d.ts.map

package/dist/builder/scanner/service/doc-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-tags.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/service/doc-tags.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAgCnE,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,GAAG,SAAS,CAEjE;AAED,kGAAkG;AAClG,wBAAgB,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,UAAU,CA6BrD;AAED,mEAAmE;AACnE,wBAAgB,YAAY,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAEnD;AAED,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAEjD;AAED,4EAA4E;AAC5E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAaxE"}

package/dist/builder/scanner/service/doc-tags.js

@@ -0,0 +1,97 @@
+import ts from 'typescript';
+/**
+ * The block that documents a node: the last `/** *\/` above it, as long as it
+ * sits right on top of the node and says something. Line comments in between,
+ * such as `// eslint-disable-next-line`, keep it attached. TypeScript also
+ * attaches a block that floats a few lines above, such as a section banner,
+ * and one that is only a ruler (`/** ===== *\/`); neither describes the node.
+ */
+function readDocBlock(node) {
+    const blocks = node.jsDoc;
+    const block = blocks?.[blocks.length - 1];
+    if (!block)
+        return undefined;
+    const sourceFile = node.getSourceFile();
+    // The first line is the rest of the block's last line, the last one the indentation of the node.
+    const linesBetween = sourceFile.text.slice(block.end, node.getStart(sourceFile)).split('\n').slice(1, -1);
+    if (linesBetween.some((line) => !/^\s*\/\//.test(line)))
+        return undefined;
+    const stripped = block.getText(sourceFile).replace(/[/*\s]/g, '');
+    if (stripped.length === 0 || /^[*=\-_#~]+$/.test(stripped))
+        return undefined;
+    return block;
+}
+function commentText(comment) {
+    return ts.getTextOfJSDocComment(comment)?.trim() || undefined;
+}
+/** The comment text of a node without its tags, as written: line breaks and markdown stay. */
+export function readDescription(node) {
+    return commentText(readDocBlock(node)?.comment);
+}
+/** The tags of a node. `@version` and tags without a place in {@link ApiDocTags} are not read. */
+export function readDocTags(node) {
+    const result = {};
+    for (const tag of readDocBlock(node)?.tags ?? []) {
+        const comment = commentText(tag.comment);
+        switch (tag.tagName.text) {
+            case 'deprecated':
+                result.deprecated = comment ?? true;
+                break;
+            case 'since':
+                if (comment)
+                    result.since = comment;
+                break;
+            case 'default':
+                if (comment)
+                    result.default = comment;
+                break;
+            case 'see': {
+                const reference = readSeeReference(tag);
+                if (reference)
+                    result.see = [...(result.see ?? []), reference];
+                break;
+            }
+            case 'example':
+                if (comment)
+                    result.example = [...(result.example ?? []), comment];
+                break;
+        }
+    }
+    return result;
+}
+/** Whether a node has a doc block of its own, tags only or not. */
+export function isDocumented(node) {
+    return readDocBlock(node) !== undefined;
+}
+/** Whether a node carries an `@internal` tag. */
+export function isInternal(node) {
+    return readDocBlock(node)?.tags?.some((tag) => tag.tagName.text === 'internal') ?? false;
+}
+/** The `@param` descriptions of a function-like node, by parameter name. */
+export function readParamDescriptions(node) {
+    const result = new Map();
+    for (const tag of readDocBlock(node)?.tags ?? []) {
+        if (!ts.isJSDocParameterTag(tag) || !ts.isIdentifier(tag.name))
+            continue;
+        // `@param name - text` is the TSDoc spelling; the dash is not part of the text.
+        const description = commentText(tag.comment)?.replace(/^-\s+/, '');
+        if (description)
+            result.set(tag.name.text, description);
+    }
+    return result;
+}
+/**
+ * What a `@see` points at: the target of a `{@link}`, a name, or a URL. The
+ * parser reads a URL as a name followed by `://…` and leaves a stray `*` of the
+ * next line behind, so the tag is read from the source instead of from its parts.
+ */
+function readSeeReference(tag) {
+    const body = tag
+        .getSourceFile()
+        .text.slice(tag.tagName.end, tag.end)
+        .split('\n')
+        .map((line) => line.replace(/^\s*\*?\s*/, ''))
+        .join(' ')
+        .trim();
+    return /^\{@link(?:code|plain)?\s+([^\s}|]+)/.exec(body)?.[1] ?? (body.split(/\s+/)[0] || undefined);
+}

package/dist/builder/scanner/service/export-index.d.ts

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+/** Where a symbol can be imported from: the resolved symbol of an export, and the `importPath` of the entry point that exports it. */
+export type ExportIndex = ReadonlyMap<ts.Symbol, string>;
+/**
+ * Index everything the library's entry points export by its resolved symbol,
+ * so that a reference found anywhere in the source can be traced to the entry
+ * point a consumer imports it from. A re-export (`export { x } from`) is an
+ * alias and is followed to the declaration, which is what a reference resolves
+ * to as well.
+ *
+ * A symbol exported more than once keeps the first entry: callers put the
+ * secondary entry points before the primary one, as the component dedupe does.
+ */
+export declare function buildExportIndex(entries: ReadonlyArray<{
+    exports: ts.Symbol[];
+    importPath: string;
+}>, checker: ts.TypeChecker): ExportIndex;
+//# sourceMappingURL=export-index.d.ts.map

package/dist/builder/scanner/service/export-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-index.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/service/export-index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,sIAAsI;AACtI,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC;IAAE,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,WAAW,CAY3I"}

package/dist/builder/scanner/service/export-index.js

@@ -0,0 +1,22 @@
+import ts from 'typescript';
+/**
+ * Index everything the library's entry points export by its resolved symbol,
+ * so that a reference found anywhere in the source can be traced to the entry
+ * point a consumer imports it from. A re-export (`export { x } from`) is an
+ * alias and is followed to the declaration, which is what a reference resolves
+ * to as well.
+ *
+ * A symbol exported more than once keeps the first entry: callers put the
+ * secondary entry points before the primary one, as the component dedupe does.
+ */
+export function buildExportIndex(entries, checker) {
+    const index = new Map();
+    for (const { exports, importPath } of entries) {
+        for (const sym of exports) {
+            const resolved = sym.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
+            if (!index.has(resolved))
+                index.set(resolved, importPath);
+        }
+    }
+    return index;
+}