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

package/dist/builder/scanner/composition/read-composition.js

@@ -0,0 +1,302 @@
+import { CssSelector } from '@angular/compiler';
+import { SUBJECT_MARKER_ATTR } from '../../../shared/composition.js';
+import { VOID_ELEMENTS } from '../../../shared/void-elements.js';
+import { matchHostString } from '../../manifest/host-parser.js';
+import { describeShowcaseIssue, describeShowcaseOrigin } from '../showcase-diagnostics.js';
+import { composeTemplate } from './compose-template.js';
+import { resolveShowcaseImports } from './declarables.js';
+import { matchDeclarables } from './match-declarables.js';
+/** How a directive's text `content` goes into a template to render as written: no tag, no interpolation, no block. */
+const TEXT_ENTITIES = { '&': '&amp;', '<': '&lt;', '{': '&#123;', '}': '&#125;', '@': '&#64;' };
+/** The one variant the styleguide renders a showcase without variants as. */
+const IMPLICIT_VARIANT = { name: 'Default' };
+/**
+ * The context of one scan: the library's declarables, and the lookup of a showcase's `imports` with the scan's
+ * compiler options.
+ *
+ * `readDeclarables` runs once, for the first showcase that composes, so that a library without compositions pays
+ * nothing for them on any scan. Its declarables come without those whose selector Angular cannot parse, each named
+ * once in a notice, so that one of them cannot fail every composition. When it throws, that is one diagnostic, and no
+ * showcase of the scan has a composition.
+ */
+export function createCompositionContext(readDeclarables, compilerOptions, reporters) {
+    let read;
+    return {
+        declarables: () => {
+            read ??= { declarables: indexDeclarables(readDeclarables, reporters) };
+            return read.declarables;
+        },
+        resolveImports: (imports, containingFile) => resolveShowcaseImports(imports, containingFile, compilerOptions)
+    };
+}
+function indexDeclarables(readDeclarables, { report, notify }) {
+    let declarables;
+    try {
+        declarables = readDeclarables();
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        report(`ng-prism could not read the library's components, directives and pipes (${reason}), so no variant renders a template or a host template.`);
+        return undefined;
+    }
+    return declarables.filter((declarable) => {
+        const problem = selectorProblem(declarable);
+        if (problem) {
+            notify(`${declarable.name} from "${declarable.from}" has the selector "${declarable.selector}", which Angular cannot parse (${problem}); no composition imports it.`);
+        }
+        return !problem;
+    });
+}
+/**
+ * Read the compositions of a showcase. A variant is composed when it has a `template` or a host template, its own
+ * `host` or else the showcase's; a showcase without variants is one variant. A directive's `template` without a host
+ * template renders inside the element of its string or object host, if it has one. Each composed variant gets its
+ * template from {@link composeTemplate}, checked with Angular's parser against the library and the showcase's
+ * `imports`, and variants with the same template and the same unbound inputs share a case.
+ *
+ * Each problem is reported against the field it comes from, with the showcase's file, line and variant, and leaves
+ * that variant out: it renders as it would without `template` and `host`. Only what Angular may still accept is a
+ * notice: an import ng-prism cannot read, an element or a pipe nothing declares while there is one, a library class
+ * that matches only by standard attributes, and one that is not standalone, which only its NgModule can bring in. A
+ * subject that is not standalone has no composition at all.
+ *
+ * Mutates `config`: a composed variant loses the HTML `content` of a component inside a host template, and the
+ * inputs that the template sets on the subject, each with a diagnostic.
+ *
+ * `undefined` when no variant is composed. Also when `@angular/compiler` throws, which is one diagnostic for the
+ * showcase, so that the build goes on, and when the library's declarables could not be read.
+ */
+export function readComposition(subject, context, reporters) {
+    const { className, config, configNode } = subject;
+    const sharedHost = isHostTemplate(config.host) ? config.host : undefined;
+    const elementHost = subject.isDirective && !sharedHost ? readElementHost(config.host) : undefined;
+    const declared = config.variants ?? [];
+    const variants = declared.length > 0 ? declared : [IMPLICIT_VARIANT];
+    // Without a template, a variant keeps rendering in a string or object host as it did before.
+    const hosts = variants.map((variant) => variant.host ?? sharedHost ?? (variant.template !== undefined ? elementHost : undefined));
+    const firstComposed = variants.findIndex((variant, index) => variant.template !== undefined || hosts[index] !== undefined);
+    if (firstComposed < 0)
+        return undefined;
+    const at = (path, text) => describeShowcaseIssue(className, configNode, path, text);
+    // Where a variant's composition is written: the variant, its template and the host template it renders in.
+    const pathsOf = (variant, index) => {
+        const path = declared.length > 0 ? ['variants', subject.sources?.variants?.[index] ?? index] : ['host'];
+        const hostPath = variant.host ? [...path, 'host'] : ['host'];
+        return { path, hostPath, templatePath: [...path, 'template'] };
+    };
+    if (!subject.standalone) {
+        const { hostPath, templatePath } = pathsOf(variants[firstComposed], firstComposed);
+        reporters.report(at(variants[firstComposed].template !== undefined ? templatePath : hostPath, `${className} is not standalone, which the wrapper that renders a composition needs; no variant of this showcase renders a template or a host template`));
+        return undefined;
+    }
+    const declarables = context.declarables();
+    if (!declarables)
+        return undefined;
+    // Messages and mutations wait for the end, so that a compiler failure leaves nothing behind but its own diagnostic.
+    const pending = [];
+    const report = (message) => pending.push(() => reporters.report(message));
+    const notify = (message) => pending.push(() => reporters.notify(message));
+    // Where the compiler is at, for the diagnostic when it throws.
+    let current = ['imports'];
+    try {
+        const hostImport = elementHost && 'import' in elementHost && hosts.includes(elementHost) ? elementHost.import : undefined;
+        const { resolved, unresolved } = readImports(subject, hostImport, declarables, context, (path, text) => notify(at(path, text)));
+        const inputNames = new Map(subject.inputs.map((input) => [input.alias ?? input.name, input.name]));
+        const cases = [];
+        const caseIndex = new Map();
+        const imports = new Map();
+        const skipped = new Set();
+        const notStandalone = new Set();
+        const variantCases = variants.map((variant, index) => {
+            const host = hosts[index];
+            if (variant.template === undefined && host === undefined)
+                return -1;
+            if (host && 'problem' in host) {
+                report(at(['host'], host.problem));
+                return -1;
+            }
+            const { path, hostPath, templatePath } = pathsOf(variant, index);
+            const { content, dropsContent } = subjectContent(variant, subject.isDirective);
+            current = variant.template !== undefined ? templatePath : hostPath;
+            const composed = composeTemplate({ selector: subject.selector, isDirective: subject.isDirective, inputNames, hostTemplate: host?.template, content });
+            if (!composed.ok) {
+                report(at(composed.at === 'host' ? hostPath : variant.template !== undefined ? templatePath : [...path, 'content'], composed.problem));
+                return -1;
+            }
+            const match = matchDeclarables(composed.nodes, declarables, resolved);
+            // Before the problems, which one of them may explain: the element it declares is unknown without its NgModule.
+            match.notStandalone.forEach((name) => notStandalone.add(name));
+            // A message names the field that writes what it is about: the template when it does, else the host template.
+            const fieldOf = (written) => variant.template !== undefined && (!host || written(variant.template)) ? templatePath : hostPath;
+            const undeclared = [
+                ...match.unknownElements.map((element) => ({ where: fieldOf((t) => writesElement(t, element)), text: `<${element}> matches no imported component` })),
+                ...match.unknownPipes.map((pipe) => ({ where: fieldOf((t) => writesPipe(t, pipe)), text: `pipe "${pipe}" matches no imported pipe` }))
+            ];
+            const problems = match.ambiguous.map(({ element, classes }) => at(fieldOf((t) => writesElement(t, element)), `<${element}> matches ${andList(classes)}, and Angular allows one component per element (NG0300)`));
+            // An import ng-prism cannot read may declare what nothing else does, so Angular decides.
+            if (unresolved.length > 0) {
+                for (const { where, text } of undeclared)
+                    notify(at(where, `${text}; an import ng-prism cannot read may declare it, so Angular checks it`));
+            }
+            else {
+                problems.unshift(...undeclared.map(({ where, text }) => at(where, text)));
+            }
+            problems.forEach(report);
+            if (problems.length > 0)
+                return -1;
+            // The wrapper imports the subject anyway, by the path of its entry point.
+            for (const { name, from, selector } of match.imports) {
+                if (name !== className || selector !== subject.selector)
+                    imports.set(`${from} ${name}`, { name, from });
+            }
+            for (const { element, className: skippedClass } of match.skipped) {
+                if (skippedClass !== className)
+                    skipped.add(`${skippedClass} on <${element}>`);
+            }
+            if (dropsContent) {
+                report(at([...path, 'content'], 'HTML content cannot be projected into a host template; use template'));
+                pending.push(() => delete variant.content);
+            }
+            const owned = new Set(composed.ownedInputs);
+            const unbound = subject.inputs.flatMap(({ name, defaultUnreadable }) => {
+                if (owned.has(name))
+                    return [{ name, reason: 'template' }];
+                return defaultUnreadable && variant.inputs?.[name] === undefined ? [{ name, reason: 'default' }] : [];
+            });
+            for (const name of composed.ownedInputs) {
+                if (!variant.inputs || !(name in variant.inputs))
+                    continue;
+                report(at([...path, 'inputs', name], 'set by the template on the subject; the variant value was dropped'));
+                pending.push(() => delete variant.inputs?.[name]);
+            }
+            // Variants that set an input with an unreadable default and variants that leave it to the subject need a case each.
+            const key = JSON.stringify([composed.template, unbound]);
+            let caseAt = caseIndex.get(key);
+            if (caseAt === undefined) {
+                caseAt = cases.push({ template: composed.template, unbound, paths: [] }) - 1;
+                caseIndex.set(key, caseAt);
+            }
+            cases[caseAt].paths.push(path);
+            return caseAt;
+        });
+        if (notStandalone.size > 0) {
+            const [verb, pronoun, modules] = notStandalone.size === 1 ? ['is', 'it', 'the NgModule that declares'] : ['are', 'them', 'the NgModules that declare'];
+            notify(at(['imports'], `${andList([...notStandalone])} ${verb} not standalone, so a composition cannot import ${pronoun}; add ${modules} ${pronoun} here`));
+        }
+        if (skipped.size > 0) {
+            const [verb, pronoun] = skipped.size === 1 ? ['matches', 'it'] : ['match', 'them'];
+            notify(at(['imports'], `${[...skipped].join(', ')} ${verb} only by standard attributes and ${skipped.size === 1 ? 'is' : 'are'} not imported; add ${pronoun} here to apply ${pronoun}`));
+        }
+        pending.forEach((flush) => flush());
+        if (cases.length === 0)
+            return undefined;
+        for (const entry of unresolved)
+            imports.set(`${entry.from} ${entry.name}`, entry);
+        return {
+            variantCases,
+            cases: cases.map(({ template, unbound, paths }) => ({ template, unbound, origin: describeShowcaseOrigin(configNode, paths) })),
+            imports: [...imports.values()]
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        reporters.report(at(current, `@angular/compiler failed on it (${reason}); no variant of this showcase renders a template or a host template`));
+        return undefined;
+    }
+}
+/**
+ * The showcase's `imports`, and the class of an object host a variant template renders in, looked up: a class of the
+ * library as it is indexed, anything else through {@link CompositionContext.resolveImports}. What ng-prism can read is
+ * matched like a library class, the rest is imported as written, with a notice. That includes an import whose
+ * selector Angular cannot parse.
+ */
+function readImports({ config, filePath, sources }, hostImport, declarables, context, notice) {
+    const listed = (config.imports ?? []).map((entry, index) => ({
+        entry,
+        path: ['imports', sources?.imports?.[index] ?? index]
+    }));
+    if (hostImport)
+        listed.push({ entry: hostImport, path: ['host', 'import'] });
+    const isEntry = (entry) => (declarable) => declarable.name === entry.name && declarable.from === entry.from;
+    const fromLibrary = listed.flatMap(({ entry }) => declarables.filter(isEntry(entry)));
+    const elsewhere = listed.filter(({ entry }) => !fromLibrary.some(isEntry(entry))).map(({ entry }) => entry);
+    const looked = elsewhere.length > 0 ? context.resolveImports(elsewhere, filePath).resolved : [];
+    const resolved = [...fromLibrary, ...looked.filter((declarable) => !selectorProblem(declarable))];
+    const unresolved = listed.filter(({ entry }) => !resolved.some(isEntry(entry)));
+    for (const { entry, path } of unresolved) {
+        notice(path, `"${entry.name}" from "${entry.from}" is not a component, directive or pipe ng-prism can read; it is imported as written and Angular checks the template`);
+    }
+    return { resolved, unresolved: unresolved.map(({ entry }) => entry) };
+}
+/**
+ * A directive's string or object host as the host template of a variant template: the one element the host names,
+ * marked as the subject, with the static inputs of an object host as attributes and its class to import. The text a
+ * string host holds is left out, as the template replaces it. `undefined` for no host or an empty string.
+ */
+function readElementHost(host) {
+    const consequence = 'so the variants render without their template';
+    if (typeof host === 'string') {
+        if (host.trim() === '')
+            return undefined;
+        const parsed = matchHostString(host);
+        return parsed
+            ? { template: markedElement(parsed.tag, parsed.attrs) }
+            : { problem: `${JSON.stringify(host)} is not one element ("<tag attrs>" or "<tag>text</tag>") for a variant template to render in, ${consequence}` };
+    }
+    if (typeof host !== 'object' || host === null)
+        return undefined;
+    const { selector, import: hostImport, inputs } = host;
+    if (typeof selector !== 'string' || selector === '' || !hostImport?.name || !hostImport.from) {
+        return { problem: `an object host needs a selector and an import { name, from } for a variant template to render in, ${consequence}` };
+    }
+    const attributes = Object.entries(inputs ?? {}).map(([name, value]) => `${name}="${String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;')}"`);
+    return { template: markedElement(selector, attributes.join(' ')), import: { name: hostImport.name, from: hostImport.from } };
+}
+function markedElement(tag, attributes) {
+    const opening = `<${tag}${attributes ? ` ${attributes}` : ''} ${SUBJECT_MARKER_ATTR}`;
+    return VOID_ELEMENTS.has(tag.toLowerCase()) ? `${opening} />` : `${opening}></${tag}>`;
+}
+/**
+ * What a composed variant puts into its subject: its template, or the text `content` of a directive, escaped. A
+ * component's `content` is HTML, which cannot go into a host template, the only way such a variant is composed.
+ */
+function subjectContent(variant, isDirective) {
+    if (variant.template !== undefined)
+        return { content: variant.template, dropsContent: false };
+    if (variant.content === undefined)
+        return { dropsContent: false };
+    if (!isDirective)
+        return { dropsContent: true };
+    return { content: typeof variant.content === 'string' && variant.content !== '' ? escapeText(variant.content) : undefined, dropsContent: false };
+}
+function escapeText(text) {
+    return text.replace(/[&<{}@]/g, (char) => TEXT_ENTITIES[char]);
+}
+/** Why Angular cannot parse the selector of a declarable, `undefined` when it can or there is none. */
+function selectorProblem({ selector }) {
+    if (selector === undefined)
+        return undefined;
+    try {
+        CssSelector.parse(selector);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+function isHostTemplate(host) {
+    return typeof host === 'object' && host !== null && typeof host.template === 'string';
+}
+function writesElement(template, element) {
+    return new RegExp(`<${escapeRegExp(element)}[\\s/>]`, 'i').test(template);
+}
+function writesPipe(template, pipe) {
+    return new RegExp(`\\|\\s*${escapeRegExp(pipe)}(?![\\w$])`).test(template);
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** `A and B`, `A, B and C`. */
+function andList(items) {
+    return items.length < 2 ? items.join('') : `${items.slice(0, -1).join(', ')} and ${items.at(-1)}`;
+}

package/dist/builder/scanner/composition/template-elements.d.ts

@@ -0,0 +1,12 @@
+import { BindingType, CssSelector, TmplAstElement, type TmplAstTemplate } from '@angular/compiler';
+/**
+ * What a directive matcher sees of an element or an `<ng-template>`, built the way Angular builds it: tag, static
+ * attributes and classes, bound inputs and outputs. A template that a structural directive creates (`*libIf`) is an
+ * `ng-template` with the attributes of its microsyntax.
+ */
+export declare function elementSelector(node: TmplAstElement | TmplAstTemplate): CssSelector;
+/** `[name]` and `[(name)]`; attribute, class, style and animation bindings set no input. */
+export declare function isInputBinding(type: BindingType): boolean;
+/** The parser names an element in a namespace `:svg:rect`; selectors match the local name. */
+export declare function localName(name: string): string;
+//# sourceMappingURL=template-elements.d.ts.map

package/dist/builder/scanner/composition/template-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-elements.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/composition/template-elements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEnG;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,eAAe,GAAG,WAAW,CAyBnF;AAED,4FAA4F;AAC5F,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C"}

package/dist/builder/scanner/composition/template-elements.js

@@ -0,0 +1,41 @@
+import { BindingType, CssSelector, TmplAstElement } from '@angular/compiler';
+/**
+ * What a directive matcher sees of an element or an `<ng-template>`, built the way Angular builds it: tag, static
+ * attributes and classes, bound inputs and outputs. A template that a structural directive creates (`*libIf`) is an
+ * `ng-template` with the attributes of its microsyntax.
+ */
+export function elementSelector(node) {
+    const selector = new CssSelector();
+    const isElement = node instanceof TmplAstElement;
+    selector.setElement(isElement ? localName(node.name) : 'ng-template');
+    if (!isElement && node.tagName !== 'ng-template') {
+        for (const attribute of node.templateAttrs)
+            selector.addAttribute(attribute.name, '');
+        return selector;
+    }
+    for (const attribute of node.attributes) {
+        selector.addAttribute(attribute.name, attribute.value);
+        if (attribute.name.toLowerCase() === 'class') {
+            for (const className of attribute.value.trim().split(/\s+/)) {
+                if (className)
+                    selector.addClassName(className);
+            }
+        }
+    }
+    for (const bound of node.inputs) {
+        if (isInputBinding(bound.type))
+            selector.addAttribute(bound.name, '');
+    }
+    for (const output of node.outputs) {
+        selector.addAttribute(output.name, '');
+    }
+    return selector;
+}
+/** `[name]` and `[(name)]`; attribute, class, style and animation bindings set no input. */
+export function isInputBinding(type) {
+    return type === BindingType.Property || type === BindingType.TwoWay;
+}
+/** The parser names an element in a namespace `:svg:rect`; selectors match the local name. */
+export function localName(name) {
+    return name.replace(/^:[^:]+:/, '');
+}

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

@@ -3,6 +3,10 @@ export type { CreateScannerOptions, Scanner, ScanResult } from './scanner.js';
 export { resolveEntryPointExports } from './entry-point.scanner.js';
 export type { EntryPointInput, MultiEntryResult, ResolvedEntryPoint } from './entry-point.scanner.js';
 export { scanComponents } from './component.scanner.js';
+export { scanServices } from './service.scanner.js';
+export type { ScanServicesOptions } from './service.scanner.js';
+export { scanPipes } from './pipe.scanner.js';
+export type { ScanPipesOptions } from './pipe.scanner.js';
 export { extractInputs, extractOutputs } from './input.extractor.js';
 export { generateManifest } from './manifest.generator.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,YAAY,EAAE,oBAAoB,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACtG,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,YAAY,EAAE,oBAAoB,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACtG,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/builder/scanner/index.js

@@ -2,5 +2,7 @@
 export { createScanner } from './scanner.js';
 export { resolveEntryPointExports } from './entry-point.scanner.js';
 export { scanComponents } from './component.scanner.js';
+export { scanServices } from './service.scanner.js';
+export { scanPipes } from './pipe.scanner.js';
 export { extractInputs, extractOutputs } from './input.extractor.js';
 export { generateManifest } from './manifest.generator.js';

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

@@ -1,14 +1,43 @@
 import ts from 'typescript';
 import type { InputMeta, OutputMeta } from '../../plugin/plugin.types.js';
+import { type ClassHierarchy } from './class-hierarchy.js';
 /**
  * Extract all @Input(), input() and model() signal metadata from a class
  * declaration and the base classes Angular inherits inputs from. An input the
  * subclass redeclares wins over the one in its base class.
  */
-export declare function extractInputs(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker, hierarchy?: import("./class-hierarchy.js").ClassHierarchy): InputMeta[];
+export declare function extractInputs(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker, hierarchy?: ClassHierarchy): InputMeta[];
+/**
+ * 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 declare function findInputDeclaration(hierarchy: ClassHierarchy, name: string): {
+    member: ts.PropertyDeclaration;
+    owner: ts.ClassDeclaration;
+} | undefined;
+/** The declaration Angular takes an output from, as {@link findInputDeclaration} for an input. */
+export declare function findOutputDeclaration(hierarchy: ClassHierarchy, name: string): {
+    member: ts.PropertyDeclaration;
+    owner: ts.ClassDeclaration;
+} | undefined;
+/** Whether an input is a `model()` or `model.required()`, for which Angular adds a change output. */
+export declare function isModelInput(member: ts.PropertyDeclaration): boolean;
 /**
  * Extract all @Output() and output() signal metadata from a class declaration
  * and the base classes Angular inherits outputs from.
  */
-export declare function extractOutputs(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker, hierarchy?: import("./class-hierarchy.js").ClassHierarchy): OutputMeta[];
+export declare function extractOutputs(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker, hierarchy?: ClassHierarchy): OutputMeta[];
+/**
+ * Whether a declared type, or the expression a type is inferred from,
+ * 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.
+ */
+export declare function usesTypeParameters(node: ts.Node | undefined, owner: ts.ClassDeclaration, checker: ts.TypeChecker): boolean;
+/**
+ * The type of a property declared in a generic base class, as the subclass
+ * sees it: `items = input.required<T[]>()` in `Field<T>` is an
+ * `InputSignal<Country[]>` on `Picker extends Field<Country>`.
+ */
+export declare function getInstantiatedType(name: string, subclass: ts.ClassDeclaration, checker: ts.TypeChecker): ts.Type | undefined;
 //# sourceMappingURL=input.extractor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"input.extractor.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/input.extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAI1E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,SAAS,gDAAwC,GAAG,SAAS,EAAE,CAuCrJ;AAwFD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,SAAS,gDAAwC,GAAG,UAAU,EAAE,CA4BvJ"}
+{"version":3,"file":"input.extractor.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/input.extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1E,OAAO,EAAE,KAAK,cAAc,EAAqB,MAAM,sBAAsB,CAAC;AAE9E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,SAAS,iBAAwC,GAAG,SAAS,EAAE,CAsCrJ;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,EAAE,CAAC,mBAAmB,CAAC;IAAC,KAAK,EAAE,EAAE,CAAC,gBAAgB,CAAA;CAAE,GAAG,SAAS,CAExJ;AAED,kGAAkG;AAClG,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,EAAE,CAAC,mBAAmB,CAAC;IAAC,KAAK,EAAE,EAAE,CAAC,gBAAgB,CAAA;CAAE,GAAG,SAAS,CAEzJ;AAED,qGAAqG;AACrG,wBAAgB,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC,mBAAmB,GAAG,OAAO,CAKpE;AAoHD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,SAAS,iBAAwC,GAAG,UAAU,EAAE,CA4BvJ;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,OAAO,CAgB1H;AAuBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,EAAE,CAAC,IAAI,GAAG,SAAS,CAI7H"}

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { evaluateExpression, 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.
@@ -59,7 +94,7 @@ function readInput(member, name, checker, owner, subclass) {
     if (inputDecorator) {
         const required = isDecoratorInputRequired(inputDecorator);
         const alias = readAlias(getDecoratorArgument(inputDecorator), name, checker);
-        const defaultValue = readInitialValue(member, 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);
@@ -70,7 +105,7 @@ function readInput(member, name, checker, owner, subclass) {
             rawType,
             required,
             ...(values && { values }),
-            ...(defaultValue !== undefined && { defaultValue }),
+            ...defaultFields(initial),
             ...(doc && { doc })
         };
     }
@@ -80,7 +115,7 @@ function readInput(member, name, checker, owner, subclass) {
     const required = isSignalInputRequired(signalCall);
     // `input(initial, options)`, but `input.required(options)`.
     const alias = readAlias(signalCall.arguments[required ? 0 : 1], name, checker);
-    const defaultValue = readInitialValue(member, 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.
@@ -93,7 +128,7 @@ function readInput(member, name, checker, owner, subclass) {
         rawType,
         required,
         ...(values && { values }),
-        ...(defaultValue !== undefined && { defaultValue }),
+        ...defaultFields(initial),
         ...(doc && { doc })
     };
 }
@@ -141,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;
@@ -174,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"}