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

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

@@ -0,0 +1,54 @@
+import ts from 'typescript';
+import type { ShowcaseImport } from '../../../decorator/showcase.types.js';
+/** A component, directive or pipe that a template can use, and the module specifier a consumer imports it from. */
+export interface Declarable {
+    /** The name it is exported under. */
+    name: string;
+    from: string;
+    kind: 'component' | 'directive' | 'pipe';
+    /** Of a component or directive, as written in its metadata: a list of selectors is one string. */
+    selector?: string;
+    /** Of a pipe: the name a template calls it by. */
+    pipeName?: string;
+    /** `false` for a class an NgModule declares, which only that module can bring into a template. */
+    standalone: boolean;
+}
+/** What {@link readDeclarable} finds in a class: a {@link Declarable} before it is given a name and a module. */
+export type DeclarableShape = Pick<Declarable, 'kind' | 'selector' | 'pipeName' | 'standalone'>;
+/**
+ * Index every component, directive and pipe the library's entry points export
+ * by its selector or name, with or without `@Showcase`, so that a template can
+ * be matched against them. A class from a dependency that an entry point
+ * re-exports is read from its `.d.ts`. A class without a selector (or a pipe
+ * without a name) cannot be used in a template and is left out, as is
+ * everything that is not a component, directive or pipe.
+ *
+ * A class exported more than once keeps its first entry, as in
+ * `buildExportIndex`: callers put the secondary entry points before the
+ * primary one.
+ */
+export declare function buildDeclarableIndex(entries: ReadonlyArray<{
+    exports: ts.Symbol[];
+    importPath: string;
+}>, checker: ts.TypeChecker): Declarable[];
+/**
+ * Look up each `{ name, from }` of a showcase's `imports` without a program: the module is resolved the way a bundler
+ * does it, with the `paths` and the other options given, and the class is read from the file it lands in, following
+ * `export … from` up to five modules on. An entry that cannot be found, is not exported, or is not a component,
+ * directive or pipe (an NgModule or a service, say) comes back unresolved. A selector that only a checker could
+ * evaluate is not read.
+ */
+export declare function resolveShowcaseImports(imports: readonly ShowcaseImport[], containingFile: string, compilerOptions: ts.CompilerOptions): {
+    resolved: Declarable[];
+    unresolved: ShowcaseImport[];
+};
+/**
+ * What a class declares for templates: from `@Component`, `@Directive` or `@Pipe` in source, from the `ɵcmp`, `ɵdir`
+ * or `ɵpipe` that the compiler left in a `.d.ts`. `undefined` for a class that is neither, or has no selector or name.
+ * The `checker` evaluates a selector given as a constant; without one only a literal is read.
+ *
+ * A class is standalone unless it says otherwise, as in Angular since 19: with `standalone: false` in its decorator,
+ * or `false` as the `IsStandalone` type argument in a `.d.ts`.
+ */
+export declare function readDeclarable(classDecl: ts.ClassDeclaration, checker?: ts.TypeChecker): DeclarableShape | undefined;
+//# sourceMappingURL=declarables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"declarables.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/composition/declarables.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAI3E,mHAAmH;AACnH,MAAM,WAAW,UAAU;IACvB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,MAAM,CAAC;IACzC,kGAAkG;IAClG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kGAAkG;IAClG,UAAU,EAAE,OAAO,CAAC;CACvB;AAED,iHAAiH;AACjH,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,CAAC,CAAC;AAgChG;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,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,UAAU,EAAE,CAoBhJ;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAClC,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,EAAE,CAAC,eAAe,GACpC;IAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;IAAC,UAAU,EAAE,cAAc,EAAE,CAAA;CAAE,CAgB1D;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,WAAW,GAAG,eAAe,GAAG,SAAS,CA4BpH"}

package/dist/builder/scanner/composition/declarables.js

@@ -0,0 +1,182 @@
+import ts from 'typescript';
+import { isImportableName } from '../../manifest/manifest-imports.js';
+import { findDecorator, getDecoratorArgument, readDecoratorField } from '../ast-utils.js';
+/** How many modules a lookup follows from the one the import names: `export … from` and a re-exported import each count one. */
+const MAX_REEXPORT_DEPTH = 5;
+const DECORATED = [
+    { decorator: 'Component', kind: 'component' },
+    { decorator: 'Directive', kind: 'directive' },
+    { decorator: 'Pipe', kind: 'pipe' }
+];
+/** The static members that Angular's compiler leaves in a `.d.ts`, each typed `ɵɵ…Declaration<Class, "selector" | "name", …>`. */
+const COMPILED_MEMBERS = new Map([
+    ['ɵcmp', 'component'],
+    ['ɵdir', 'directive'],
+    ['ɵpipe', 'pipe']
+]);
+/** The position of `IsStandalone` among the type arguments of `ɵɵComponentDeclaration`, `ɵɵDirectiveDeclaration` and `ɵɵPipeDeclaration`. */
+const STANDALONE_ARGUMENT = { component: 7, directive: 7, pipe: 2 };
+/** Where the declaration of a class can be read from: TypeScript source and its declaration files. */
+const READABLE_EXTENSIONS = new Set([
+    ts.Extension.Ts,
+    ts.Extension.Tsx,
+    ts.Extension.Dts,
+    ts.Extension.Mts,
+    ts.Extension.Dmts,
+    ts.Extension.Cts,
+    ts.Extension.Dcts
+]);
+/**
+ * Index every component, directive and pipe the library's entry points export
+ * by its selector or name, with or without `@Showcase`, so that a template can
+ * be matched against them. A class from a dependency that an entry point
+ * re-exports is read from its `.d.ts`. A class without a selector (or a pipe
+ * without a name) cannot be used in a template and is left out, as is
+ * everything that is not a component, directive or pipe.
+ *
+ * A class exported more than once keeps its first entry, as in
+ * `buildExportIndex`: callers put the secondary entry points before the
+ * primary one.
+ */
+export function buildDeclarableIndex(entries, checker) {
+    const seen = new Set();
+    const declarables = [];
+    for (const { exports, importPath } of entries) {
+        for (const sym of exports) {
+            const resolved = sym.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
+            if (seen.has(resolved))
+                continue;
+            seen.add(resolved);
+            const classDecl = resolved.declarations?.find(ts.isClassDeclaration);
+            const shape = classDecl && readDeclarable(classDecl, checker);
+            // A default export, or one under a string name, cannot be imported by its name.
+            if (shape && isImportableName(sym.name))
+                declarables.push({ name: sym.name, from: importPath, ...shape });
+        }
+    }
+    return declarables;
+}
+/**
+ * Look up each `{ name, from }` of a showcase's `imports` without a program: the module is resolved the way a bundler
+ * does it, with the `paths` and the other options given, and the class is read from the file it lands in, following
+ * `export … from` up to five modules on. An entry that cannot be found, is not exported, or is not a component,
+ * directive or pipe (an NgModule or a service, say) comes back unresolved. A selector that only a checker could
+ * evaluate is not read.
+ */
+export function resolveShowcaseImports(imports, containingFile, compilerOptions) {
+    const options = { ...compilerOptions, module: ts.ModuleKind.ESNext, moduleResolution: ts.ModuleResolutionKind.Bundler };
+    const files = new Map();
+    const resolved = [];
+    const unresolved = [];
+    for (const entry of imports) {
+        const lookup = { options, files, visited: new Set() };
+        const classDecl = findExportedClass(entry.name, entry.from, containingFile, 0, lookup);
+        const shape = classDecl && readDeclarable(classDecl);
+        if (shape)
+            resolved.push({ name: entry.name, from: entry.from, ...shape });
+        else
+            unresolved.push(entry);
+    }
+    return { resolved, unresolved };
+}
+/**
+ * What a class declares for templates: from `@Component`, `@Directive` or `@Pipe` in source, from the `ɵcmp`, `ɵdir`
+ * or `ɵpipe` that the compiler left in a `.d.ts`. `undefined` for a class that is neither, or has no selector or name.
+ * The `checker` evaluates a selector given as a constant; without one only a literal is read.
+ *
+ * A class is standalone unless it says otherwise, as in Angular since 19: with `standalone: false` in its decorator,
+ * or `false` as the `IsStandalone` type argument in a `.d.ts`.
+ */
+export function readDeclarable(classDecl, checker) {
+    for (const { decorator, kind } of DECORATED) {
+        const found = findDecorator(classDecl, decorator);
+        if (!found)
+            continue;
+        const arg = getDecoratorArgument(found);
+        return shape(kind, arg && readDecoratorField(arg, kind === 'pipe' ? 'name' : 'selector', checker), arg && readDecoratorField(arg, 'standalone', checker) === false);
+    }
+    for (const member of classDecl.members) {
+        const kind = ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) ? COMPILED_MEMBERS.get(member.name.text) : undefined;
+        if (!kind || !ts.isPropertyDeclaration(member) || !member.type || !ts.isTypeReferenceNode(member.type))
+            continue;
+        const literal = member.type.typeArguments?.[1];
+        const isStandalone = member.type.typeArguments?.[STANDALONE_ARGUMENT[kind]];
+        const notStandalone = isStandalone !== undefined && ts.isLiteralTypeNode(isStandalone) && isStandalone.literal.kind === ts.SyntaxKind.FalseKeyword;
+        return shape(kind, literal && ts.isLiteralTypeNode(literal) && ts.isStringLiteral(literal.literal) ? literal.literal.text : undefined, notStandalone);
+    }
+    return undefined;
+}
+function shape(kind, value, notStandalone) {
+    if (typeof value !== 'string' || value === '')
+        return undefined;
+    const standalone = !notStandalone;
+    return kind === 'pipe' ? { kind, pipeName: value, standalone } : { kind, selector: value, standalone };
+}
+function findExportedClass(name, specifier, containingFile, depth, lookup) {
+    if (depth > MAX_REEXPORT_DEPTH)
+        return undefined;
+    const resolved = ts.resolveModuleName(specifier, containingFile, lookup.options, ts.sys).resolvedModule;
+    if (!resolved || !READABLE_EXTENSIONS.has(resolved.extension))
+        return undefined;
+    const sourceFile = readSourceFile(resolved.resolvedFileName, lookup.files);
+    const key = `${resolved.resolvedFileName}\0${name}`;
+    if (!sourceFile || lookup.visited.has(key))
+        return undefined;
+    lookup.visited.add(key);
+    return findExportInFile(name, sourceFile, depth, lookup);
+}
+/**
+ * The class that `sourceFile` exports as `name`. An export of its own wins over what `export *` brings along,
+ * which is looked at only when there is none.
+ */
+function findExportInFile(name, sourceFile, depth, lookup) {
+    const reexportedAll = [];
+    for (const statement of sourceFile.statements) {
+        if (ts.isClassDeclaration(statement) && statement.name?.text === name && ts.getModifiers(statement)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+            return statement;
+        }
+        if (!ts.isExportDeclaration(statement) || statement.isTypeOnly)
+            continue;
+        const specifier = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
+        if (!statement.exportClause) {
+            if (specifier)
+                reexportedAll.push(specifier);
+            continue;
+        }
+        if (!ts.isNamedExports(statement.exportClause))
+            continue;
+        const element = statement.exportClause.elements.find((e) => !e.isTypeOnly && e.name.text === name);
+        if (!element)
+            continue;
+        const exported = (element.propertyName ?? element.name).text;
+        return specifier ? findExportedClass(exported, specifier, sourceFile.fileName, depth + 1, lookup) : findLocalClass(exported, sourceFile, depth, lookup);
+    }
+    for (const specifier of reexportedAll) {
+        const found = findExportedClass(name, specifier, sourceFile.fileName, depth + 1, lookup);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/** The class that `local` names inside `sourceFile`: declared there, or imported from another module, as `export { local }` can re-export either. */
+function findLocalClass(local, sourceFile, depth, lookup) {
+    for (const statement of sourceFile.statements) {
+        if (ts.isClassDeclaration(statement) && statement.name?.text === local)
+            return statement;
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        const element = bindings && ts.isNamedImports(bindings) ? bindings.elements.find((e) => e.name.text === local) : undefined;
+        if (element)
+            return findExportedClass((element.propertyName ?? element.name).text, statement.moduleSpecifier.text, sourceFile.fileName, depth + 1, lookup);
+    }
+    return undefined;
+}
+function readSourceFile(fileName, files) {
+    if (files.has(fileName))
+        return files.get(fileName);
+    const text = ts.sys.readFile(fileName);
+    const sourceFile = text === undefined ? undefined : ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest);
+    files.set(fileName, sourceFile);
+    return sourceFile;
+}

package/dist/builder/scanner/composition/match-declarables.d.ts

@@ -0,0 +1,43 @@
+import { type TmplAstNode } from '@angular/compiler';
+import type { Declarable } from './declarables.js';
+/** What a composed template uses of the declarables it can see, and what it uses that none of them declares. */
+export interface DeclarableMatch {
+    /** Library matches that name something the author wrote, plus every explicit import. Deduplicated by from + name. */
+    imports: Declarable[];
+    /**
+     * Elements neither standard HTML nor matched by an imported component or directive: as in Angular, an element a
+     * directive matches (`<lib-outlet>`) counts as declared. Excludes ng-container, ng-template, ng-content.
+     */
+    unknownElements: string[];
+    /** Pipe names no library or explicit pipe declares. */
+    unknownPipes: string[];
+    /** Elements two or more imported library components match, which Angular rejects with NG0300. */
+    ambiguous: {
+        element: string;
+        classes: string[];
+    }[];
+    /** Library matches left out by the written-name rule, for a notice. */
+    skipped: {
+        element: string;
+        className: string;
+    }[];
+    /** The library classes the template uses that are not standalone, which no wrapper can import: their NgModule has to. */
+    notStandalone: string[];
+}
+/**
+ * Decide what the wrapper of a composed template imports, and find what the template uses that nothing declares.
+ *
+ * A library class is imported when its selector matches an element (or an `<ng-template>`) of the template and the
+ * part that matched names something the author wrote: a custom element, which has a `-` in its name, or an attribute
+ * that is no DOM property of the element. A class does not count. So `<input type="email">` does not pull in a
+ * library directive for `input[type=email]`, which a consumer of the library would not get without importing it
+ * either. A library pipe is imported when the template calls it by name. The `explicit` declarables, the resolved
+ * `imports` of the showcase, are always imported, and they declare elements and pipes like the library does.
+ *
+ * A library class that is not standalone is never imported, and declares nothing: only its NgModule, as an explicit
+ * import, brings it into a template.
+ *
+ * Throws what `@angular/compiler` throws, for a selector it cannot parse, say.
+ */
+export declare function matchDeclarables(nodes: readonly TmplAstNode[], library: readonly Declarable[], explicit: readonly Declarable[]): DeclarableMatch;
+//# sourceMappingURL=match-declarables.d.ts.map

package/dist/builder/scanner/composition/match-declarables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-declarables.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/composition/match-declarables.ts"],"names":[],"mappings":"AAAA,OAAO,EAOH,KAAK,WAAW,EAEnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,gHAAgH;AAChH,MAAM,WAAW,eAAe;IAC5B,qHAAqH;IACrH,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB;;;OAGG;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,uDAAuD;IACvD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,iGAAiG;IACjG,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACpD,uEAAuE;IACvE,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAClD,yHAAyH;IACzH,aAAa,EAAE,MAAM,EAAE,CAAC;CAC3B;AAiBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,EAAE,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE,QAAQ,EAAE,SAAS,UAAU,EAAE,GAAG,eAAe,CA4EhJ"}

package/dist/builder/scanner/composition/match-declarables.js

@@ -0,0 +1,131 @@
+import { CombinedRecursiveAstVisitor, CssSelector, DomElementSchemaRegistry, SelectorMatcher, TmplAstElement } from '@angular/compiler';
+import { elementSelector, localName } from './template-elements.js';
+/** Elements that Angular renders itself, which the DOM schema does not list. */
+const ANGULAR_ELEMENTS = new Set(['ng-container', 'ng-template', 'ng-content']);
+let domSchema;
+/**
+ * Decide what the wrapper of a composed template imports, and find what the template uses that nothing declares.
+ *
+ * A library class is imported when its selector matches an element (or an `<ng-template>`) of the template and the
+ * part that matched names something the author wrote: a custom element, which has a `-` in its name, or an attribute
+ * that is no DOM property of the element. A class does not count. So `<input type="email">` does not pull in a
+ * library directive for `input[type=email]`, which a consumer of the library would not get without importing it
+ * either. A library pipe is imported when the template calls it by name. The `explicit` declarables, the resolved
+ * `imports` of the showcase, are always imported, and they declare elements and pipes like the library does.
+ *
+ * A library class that is not standalone is never imported, and declares nothing: only its NgModule, as an explicit
+ * import, brings it into a template.
+ *
+ * Throws what `@angular/compiler` throws, for a selector it cannot parse, say.
+ */
+export function matchDeclarables(nodes, library, explicit) {
+    const schema = (domSchema ??= new DomElementSchemaRegistry());
+    const walker = new TemplateWalker();
+    const matcher = new SelectorMatcher();
+    const addSelectables = (declarables, isExplicit) => {
+        for (const declarable of declarables) {
+            if (declarable.selector)
+                matcher.addSelectables(CssSelector.parse(declarable.selector), { declarable, explicit: isExplicit });
+        }
+    };
+    for (const node of nodes)
+        walker.visit(node);
+    addSelectables(library, false);
+    addSelectables(explicit, true);
+    const matches = walker.nodes.map((node) => {
+        const tag = node instanceof TmplAstElement ? node.name : 'ng-template';
+        const hits = [];
+        matcher.match(elementSelector(node), (part, hit) => hits.push({ ...hit, written: hit.explicit || namesWritten(part, tag, schema) }));
+        return { node, hits };
+    });
+    const imports = new Map();
+    const add = (declarable) => {
+        if (!imports.has(key(declarable)))
+            imports.set(key(declarable), declarable);
+    };
+    const notStandalone = new Map();
+    const use = (declarable, isExplicit) => {
+        if (isExplicit || declarable.standalone)
+            add(declarable);
+        else
+            notStandalone.set(key(declarable), declarable);
+    };
+    explicit.forEach(add);
+    for (const { hits } of matches) {
+        for (const hit of hits)
+            if (hit.written)
+                use(hit.declarable, hit.explicit);
+    }
+    for (const declarable of library) {
+        if (declarable.pipeName !== undefined && walker.pipes.has(declarable.pipeName))
+            use(declarable, false);
+    }
+    const isImported = (declarable) => imports.has(key(declarable));
+    const unknownElements = new Set();
+    const ambiguous = new Map();
+    const skipped = new Map();
+    for (const { node, hits } of matches) {
+        const element = displayName(node);
+        const libraryHits = hits.filter((hit) => !hit.explicit);
+        const components = new Map(libraryHits.filter((hit) => hit.declarable.kind === 'component' && isImported(hit.declarable)).map((hit) => [key(hit.declarable), hit.declarable.name]));
+        if (components.size > 1) {
+            const classes = [...components.values()].sort();
+            ambiguous.set(`${element} ${classes.join(' ')}`, { element, classes });
+        }
+        for (const { declarable, written } of libraryHits) {
+            if (!written && declarable.standalone && !isImported(declarable))
+                skipped.set(`${element} ${declarable.name}`, { element, className: declarable.name });
+        }
+        if (node instanceof TmplAstElement && !ANGULAR_ELEMENTS.has(element) && !schema.hasElement(node.name, []) && !hits.some((hit) => isImported(hit.declarable))) {
+            unknownElements.add(element);
+        }
+    }
+    const declaredPipes = new Set([...library.filter((declarable) => declarable.standalone), ...explicit].map((declarable) => declarable.pipeName));
+    return {
+        imports: [...imports.values()],
+        unknownElements: [...unknownElements],
+        unknownPipes: [...walker.pipes].filter((pipe) => !declaredPipes.has(pipe)),
+        ambiguous: [...ambiguous.values()],
+        skipped: [...skipped.values()],
+        notStandalone: [...notStandalone.values()].filter((declarable) => !isImported(declarable)).map((declarable) => declarable.name)
+    };
+}
+/** Every element and `<ng-template>` of a template, also those in control flow blocks, and every pipe its expressions call. */
+class TemplateWalker extends CombinedRecursiveAstVisitor {
+    nodes = [];
+    /** Pipe names, in the order of their first use. */
+    pipes = new Set();
+    visitElement(element) {
+        this.nodes.push(element);
+        super.visitElement(element);
+    }
+    visitTemplate(template) {
+        this.nodes.push(template);
+        super.visitTemplate(template);
+    }
+    visitPipe(pipe, context) {
+        this.pipes.add(pipe.name);
+        return super.visitPipe(pipe, context);
+    }
+}
+/**
+ * Whether the part of a selector that matched names something the author wrote: a custom element, or an attribute
+ * that is no DOM property of `tag` (`libInput`, but neither `type` nor `tabindex`). Classes do not count.
+ */
+function namesWritten(part, tag, schema) {
+    if (part.element?.includes('-'))
+        return true;
+    return part.attrs.some((name, i) => i % 2 === 0 && !schema.hasProperty(tag, schema.getMappedPropName(camelCase(name)), []));
+}
+/** `aria-label` → `ariaLabel`, the way Angular maps an attribute to a property. */
+function camelCase(name) {
+    return name.replace(/-+([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+}
+/** The element as the author wrote it; a template that `*libIf` creates is named after its element. */
+function displayName(node) {
+    return localName(node instanceof TmplAstElement ? node.name : (node.tagName ?? 'ng-template'));
+}
+/** Class names have no spaces, so this tells apart every name and module pair. */
+function key({ name, from }) {
+    return `${name} ${from}`;
+}

package/dist/builder/scanner/composition/read-composition.d.ts

@@ -0,0 +1,77 @@
+import type ts from 'typescript';
+import type { ShowcaseConfig, ShowcaseImport } from '../../../decorator/showcase.types.js';
+import type { ComponentComposition, InputMeta } from '../../../plugin/plugin.types.js';
+import { type Declarable } from './declarables.js';
+type Report = (message: string) => void;
+/** What the compositions of every showcase in one scan are read against. */
+export interface CompositionContext {
+    /**
+     * The components, directives and pipes the library's entry points export, read when a showcase first asks for
+     * them; `undefined` when they could not be read.
+     */
+    declarables(): readonly Declarable[] | undefined;
+    /** Look up the `imports` of a showcase written in `containingFile`. */
+    resolveImports(imports: readonly ShowcaseImport[], containingFile: string): {
+        resolved: Declarable[];
+        unresolved: ShowcaseImport[];
+    };
+}
+/** The showcased component or directive, as the scan read it. */
+export interface CompositionSubject {
+    className: string;
+    filePath: string;
+    selector: string;
+    isDirective: boolean;
+    /** A wrapper can only import a standalone subject. */
+    standalone: boolean;
+    inputs: InputMeta[];
+    config: ShowcaseConfig;
+    /** The argument of `@Showcase`, which the messages point into. */
+    configNode: ts.Expression;
+    /**
+     * Where each entry of `config.variants` and `config.imports` is written in `configNode`, which differs from its
+     * position in the list after the scan dropped an entry before it. Without it, the position in the list.
+     */
+    sources?: {
+        variants?: readonly number[];
+        imports?: readonly number[];
+    };
+}
+/**
+ * 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 declare function createCompositionContext(readDeclarables: () => readonly Declarable[], compilerOptions: ts.CompilerOptions, reporters: {
+    report: Report;
+    notify: Report;
+}): CompositionContext;
+/**
+ * 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 declare function readComposition(subject: CompositionSubject, context: CompositionContext, reporters: {
+    report: Report;
+    notify: Report;
+}): ComponentComposition | undefined;
+export {};
+//# sourceMappingURL=read-composition.d.ts.map

package/dist/builder/scanner/composition/read-composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-composition.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/composition/read-composition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAA+B,cAAc,EAAE,cAAc,EAAW,MAAM,sCAAsC,CAAC;AACjI,OAAO,KAAK,EAAE,oBAAoB,EAAmB,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAOxG,OAAO,EAAE,KAAK,UAAU,EAA0B,MAAM,kBAAkB,CAAC;AAG3E,KAAK,MAAM,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAExC,4EAA4E;AAC5E,MAAM,WAAW,kBAAkB;IAC/B;;;OAGG;IACH,WAAW,IAAI,SAAS,UAAU,EAAE,GAAG,SAAS,CAAC;IACjD,uEAAuE;IACvE,cAAc,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,EAAE,cAAc,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;QAAC,UAAU,EAAE,cAAc,EAAE,CAAA;KAAE,CAAC;CACxI;AAED,iEAAiE;AACjE,MAAM,WAAW,kBAAkB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,sDAAsD;IACtD,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,MAAM,EAAE,cAAc,CAAC;IACvB,kEAAkE;IAClE,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC;CAC3E;AAWD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACpC,eAAe,EAAE,MAAM,SAAS,UAAU,EAAE,EAC5C,eAAe,EAAE,EAAE,CAAC,eAAe,EACnC,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC9C,kBAAkB,CAUpB;AA0BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC3B,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC9C,oBAAoB,GAAG,SAAS,CA0KlC"}