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

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/entry-point-discovery.d.ts

@@ -3,4 +3,9 @@ export interface DiscoveredEntryPoint {
     importPath: string;
 }
 export declare function discoverSecondaryEntryPoints(libraryRoot: string, baseImportPath: string): DiscoveredEntryPoint[];
+/**
+ * The primary entry file of the library at `libraryRoot`: `lib.entryFile` of its
+ * own `ng-package.json`, or `undefined` when there is no such file.
+ */
+export declare function findPrimaryEntryFile(libraryRoot: string): string | undefined;
 //# sourceMappingURL=entry-point-discovery.d.ts.map

package/dist/builder/scanner/entry-point-discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point-discovery.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/entry-point-discovery.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAKhH"}
+{"version":3,"file":"entry-point-discovery.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/entry-point-discovery.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAKhH;AAKD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAS5E"}

package/dist/builder/scanner/entry-point-discovery.js

@@ -5,6 +5,20 @@ export function discoverSecondaryEntryPoints(libraryRoot, baseImportPath) {
     findNgPackageJsons(libraryRoot, libraryRoot, baseImportPath, entryPoints);
     return entryPoints;
 }
+/** ng-packagr's default for `lib.entryFile`. */
+const NG_PACKAGR_DEFAULT_ENTRY_FILE = 'src/public_api.ts';
+/**
+ * The primary entry file of the library at `libraryRoot`: `lib.entryFile` of its
+ * own `ng-package.json`, or `undefined` when there is no such file.
+ */
+export function findPrimaryEntryFile(libraryRoot) {
+    const ngPackagePath = join(libraryRoot, 'ng-package.json');
+    if (!existsSync(ngPackagePath))
+        return undefined;
+    const ngPackage = JSON.parse(readFileSync(ngPackagePath, 'utf-8'));
+    const entryFilePath = join(libraryRoot, ngPackage.lib?.entryFile ?? NG_PACKAGR_DEFAULT_ENTRY_FILE);
+    return existsSync(entryFilePath) ? entryFilePath : undefined;
+}
 function findNgPackageJsons(dir, libraryRoot, baseImportPath, result) {
     const isLibraryRoot = dir === libraryRoot;
     const ngPackagePath = join(dir, 'ng-package.json');

package/dist/builder/scanner/entry-point.scanner.d.ts

@@ -2,6 +2,8 @@ import ts from 'typescript';
 export interface EntryPointInput {
     entryFile: string;
     importPath: string;
+    /** The library's primary entry point. A component it re-exports from a secondary one keeps that one, silently. */
+    primary?: boolean;
 }
 export interface ResolvedEntryPoint extends EntryPointInput {
     exports: ts.Symbol[];
@@ -18,5 +20,5 @@ export interface MultiEntryResult {
  *
  * Re-exports (`export * from '...'`) are resolved automatically by TypeScript.
  */
-export declare function resolveEntryPointExports(entryPoints: ReadonlyArray<EntryPointInput>, compilerOptions: ts.CompilerOptions, previousProgram?: ts.Program): MultiEntryResult;
+export declare function resolveEntryPointExports(entryPoints: ReadonlyArray<EntryPointInput>, compilerOptions: ts.CompilerOptions, previousProgram?: ts.Program, host?: ts.CompilerHost): MultiEntryResult;
 //# sourceMappingURL=entry-point.scanner.d.ts.map

package/dist/builder/scanner/entry-point.scanner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/entry-point.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,MAAM,WAAW,eAAe;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACvD,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IACpB,OAAO,EAAE,kBAAkB,EAAE,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACpC,WAAW,EAAE,aAAa,CAAC,eAAe,CAAC,EAC3C,eAAe,EAAE,EAAE,CAAC,eAAe,EACnC,eAAe,CAAC,EAAE,EAAE,CAAC,OAAO,GAC7B,gBAAgB,CA4BlB"}
+{"version":3,"file":"entry-point.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/entry-point.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,MAAM,WAAW,eAAe;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,kHAAkH;IAClH,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACvD,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IACpB,OAAO,EAAE,kBAAkB,EAAE,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACpC,WAAW,EAAE,aAAa,CAAC,eAAe,CAAC,EAC3C,eAAe,EAAE,EAAE,CAAC,eAAe,EACnC,eAAe,CAAC,EAAE,EAAE,CAAC,OAAO,EAC5B,IAAI,CAAC,EAAE,EAAE,CAAC,YAAY,GACvB,gBAAgB,CA8BlB"}

package/dist/builder/scanner/entry-point.scanner.js

@@ -7,23 +7,24 @@ import ts from 'typescript';
  *
  * Re-exports (`export * from '...'`) are resolved automatically by TypeScript.
  */
-export function resolveEntryPointExports(entryPoints, compilerOptions, previousProgram) {
-    const program = ts.createProgram(entryPoints.map((e) => e.entryFile), compilerOptions, undefined, previousProgram);
+export function resolveEntryPointExports(entryPoints, compilerOptions, previousProgram, host) {
+    const program = ts.createProgram(entryPoints.map((e) => e.entryFile), compilerOptions, host, previousProgram);
     const checker = program.getTypeChecker();
-    const entries = entryPoints.map(({ entryFile, importPath }) => {
+    const entries = entryPoints.map((entryPoint) => {
+        const { entryFile } = entryPoint;
         try {
             const sourceFile = program.getSourceFile(entryFile);
             if (!sourceFile) {
                 console.warn(`⚠ ng-prism: source file not found for entry point ${entryFile}, skipping.`);
-                return { entryFile, importPath, exports: [] };
+                return { ...entryPoint, exports: [] };
             }
             const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
             const exports = moduleSymbol ? checker.getExportsOfModule(moduleSymbol) : [];
-            return { entryFile, importPath, exports };
+            return { ...entryPoint, exports };
         }
         catch (err) {
             console.error(`⚠ ng-prism: failed to resolve exports for ${entryFile}: ${err instanceof Error ? err.message : String(err)}`);
-            return { entryFile, importPath, exports: [] };
+            return { ...entryPoint, exports: [] };
         }
     });
     return { program, entries };

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;AAsED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,SAAS,gDAAwC,GAAG,UAAU,EAAE,CAuBvJ"}
+{"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"}