@ng-prism/core 22.5.0 → 22.6.0

package/dist/builder/scanner/component.scanner.js

@@ -4,8 +4,9 @@ import { CANVAS_LAYOUTS } from '../../shared/canvas-layout.type.js';
 import { evaluateExpression, evaluateStatic, findDecorator, getDecoratorArgument, UNEVALUABLE } from './ast-utils.js';
 import { getClassHierarchy } from './class-hierarchy.js';
 import { extractInputs, extractOutputs } from './input.extractor.js';
-import { readPseudoStates } from './pseudo-states.js';
+import { describeValue, readPseudoStates } from './pseudo-states.js';
 import { describeDeprecatedProviders, describeUnevaluable, describeUnreadableBase } from './showcase-diagnostics.js';
+import { readShowcaseStates } from './showcase-states.js';
 const COMPONENT_STATUSES = ['stable', 'beta', 'wip', 'deprecated'];
 function isComponentStatus(value) {
     return typeof value === 'string' && COMPONENT_STATUSES.includes(value);
@@ -123,6 +124,8 @@ function extractShowcaseConfig(decorator, className, report, checker) {
         return undefined;
     // Reported once for the whole field below, wherever it came from: the literal, a spread or a constant.
     let providers;
+    // A state the evaluator dropped whole leaves no element behind, so its position is noted to keep the later states where the source has them.
+    const unevaluableStates = new Set();
     const raw = evaluateStatic(arg, {
         checker,
         report: (issue) => {
@@ -130,6 +133,8 @@ function extractShowcaseConfig(decorator, className, report, checker) {
                 providers ??= issue.node;
                 return;
             }
+            if (issue.path[0] === 'states' && issue.path.length === 2 && typeof issue.path[1] === 'number')
+                unevaluableStates.add(issue.path[1]);
             report(describeUnevaluable(className, arg, issue));
         }
     });
@@ -169,6 +174,16 @@ function extractShowcaseConfig(decorator, className, report, checker) {
         config.host = obj['host'];
     if (obj['renderPage'])
         config.renderPage = obj['renderPage'];
+    if (obj['states'] !== undefined) {
+        if (config.renderPage) {
+            report(`${className} declares states together with renderPage; a component page has no Overview to show them in. Skipping states.`);
+        }
+        else {
+            const states = readShowcaseStates(obj['states'], className, report, unevaluableStates);
+            if (states)
+                config.states = states;
+        }
+    }
     if (obj['status'] !== undefined) {
         if (isComponentStatus(obj['status'])) {
             config.status = obj['status'];
@@ -218,6 +233,10 @@ function extractShowcaseConfig(decorator, className, report, checker) {
                 else
                     delete cleaned['pseudo'];
             }
+            if (variant['states'] !== undefined && variant['states'] !== false) {
+                report(`${className} variant "${String(variant['name'])}" declares invalid states ${describeValue(variant['states'])}, expected false. Skipping.`);
+                delete cleaned['states'];
+            }
             return cleaned;
         });
     }

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/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;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"}

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { evaluateStatic, findDecorator, getDecoratorArgument, getJsDocComment } from './ast-utils.js';
+import { evaluateExpression, evaluateStatic, findDecorator, getDecoratorArgument, getJsDocComment } from './ast-utils.js';
 import { getClassHierarchy } from './class-hierarchy.js';
 /**
  * Extract all @Input(), input() and model() signal metadata from a class
@@ -58,12 +58,14 @@ function readInput(member, name, checker, owner, subclass) {
     const inputDecorator = findDecorator(member, 'Input');
     if (inputDecorator) {
         const required = isDecoratorInputRequired(inputDecorator);
+        const alias = readAlias(getDecoratorArgument(inputDecorator), name, checker);
         const defaultValue = readInitialValue(member, checker);
         const doc = getJsDocComment(member, checker);
         const instantiated = subclass && usesTypeParameters(member.type ?? member.initializer, owner, checker) ? getInstantiatedType(name, subclass, checker) : undefined;
         const { type, values, rawType } = instantiated ? mapType(instantiated, checker) : resolveDecoratorInputType(member, checker);
         return {
             name,
+            ...(alias && { alias }),
             type,
             rawType,
             required,
@@ -76,6 +78,8 @@ function readInput(member, name, checker, owner, subclass) {
     if (!signalCall)
         return undefined;
     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 doc = getJsDocComment(member, checker);
     const declaredType = signalCall.typeArguments?.[0] ?? signalCall.arguments[0];
@@ -84,6 +88,7 @@ function readInput(member, name, checker, owner, subclass) {
     const { type, values, rawType } = instantiated ? mapType(instantiated, checker) : resolveSignalInputType(signalCall, checker);
     return {
         name,
+        ...(alias && { alias }),
         type,
         rawType,
         required,
@@ -92,6 +97,17 @@ function readInput(member, name, checker, owner, subclass) {
         ...(doc && { doc })
     };
 }
+/**
+ * The `alias` of an input or output, from a decorator argument (`'x'` or
+ * `{ alias: 'x' }`) or the options of `input()`, `model()` and `output()`.
+ * It counts when the builder can evaluate it statically to a string (a literal
+ * or a constant) that differs from the member name.
+ */
+function readAlias(arg, name, checker) {
+    const value = arg ? evaluateExpression(arg, checker) : undefined;
+    const alias = typeof value === 'object' && value !== null ? value['alias'] : value;
+    return typeof alias === 'string' && alias !== name ? alias : undefined;
+}
 /**
  * Extract all @Output() and output() signal metadata from a class declaration
  * and the base classes Angular inherits outputs from.
@@ -108,11 +124,14 @@ export function extractOutputs(classDecl, checker, hierarchy = getClassHierarchy
             const name = member.name && ts.isIdentifier(member.name) ? member.name.text : undefined;
             if (!name || seen.has(name))
                 continue;
-            if (!findDecorator(member, 'Output') && !isOutputSignal(member))
+            const outputDecorator = findDecorator(member, 'Output');
+            if (!outputDecorator && !isOutputSignal(member))
                 continue;
             const doc = getJsDocComment(member, checker);
+            const options = outputDecorator ? getDecoratorArgument(outputDecorator) : member.initializer.arguments[0];
+            const alias = readAlias(options, name, checker);
             seen.add(name);
-            outputs.push({ name, ...(doc && { doc }) });
+            outputs.push({ name, ...(alias && { alias }), ...(doc && { doc }) });
         }
     }
     return outputs;

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

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

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

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

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

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

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

@@ -20,8 +20,8 @@ export interface Scanner {
  * transitive type graph (Angular framework typings, etc.) is parsed once and shared via
  * the program's `TypeChecker`, instead of N programs that each load Material/CDK/RxJS.
  *
- * TypeScript reuses parsed SourceFile objects from the old program on rebuild, making
- * incremental scans fast.
+ * On rebuild, the source-file cache hands TypeScript the already parsed SourceFile of
+ * every unchanged file, so only the changed files are parsed again.
  */
 export declare function createScanner(options: CreateScannerOptions): Scanner;
 //# sourceMappingURL=scanner.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,KAAK,eAAe,EAA4B,MAAM,0BAA0B,CAAC;AAE1F,MAAM,WAAW,oBAAoB;IACjC,WAAW,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAC5C,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC;CACxC;AAED,MAAM,WAAW,UAAU;IACvB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,0FAA0F;IAC1F,WAAW,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,OAAO;IACpB,kFAAkF;IAClF,IAAI,IAAI,UAAU,CAAC;CACtB;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAiDpE"}
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,KAAK,eAAe,EAA4B,MAAM,0BAA0B,CAAC;AAG1F,MAAM,WAAW,oBAAoB;IACjC,WAAW,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAC5C,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC;CACxC;AAED,MAAM,WAAW,UAAU;IACvB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,0FAA0F;IAC1F,WAAW,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,OAAO;IACpB,kFAAkF;IAClF,IAAI,IAAI,UAAU,CAAC;CACtB;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CA0DpE"}

package/dist/builder/scanner/scanner.js

@@ -1,6 +1,7 @@
 import ts from 'typescript';
 import { scanComponents } from './component.scanner.js';
 import { resolveEntryPointExports } from './entry-point.scanner.js';
+import { createSourceFileCache } from './source-file-cache.js';
 const DEFAULT_COMPILER_OPTIONS = {
     target: ts.ScriptTarget.ES2022,
     module: ts.ModuleKind.ES2022,
@@ -22,38 +23,47 @@ const DEFAULT_COMPILER_OPTIONS = {
  * transitive type graph (Angular framework typings, etc.) is parsed once and shared via
  * the program's `TypeChecker`, instead of N programs that each load Material/CDK/RxJS.
  *
- * TypeScript reuses parsed SourceFile objects from the old program on rebuild, making
- * incremental scans fast.
+ * On rebuild, the source-file cache hands TypeScript the already parsed SourceFile of
+ * every unchanged file, so only the changed files are parsed again.
  */
 export function createScanner(options) {
     const compilerOptions = {
         ...DEFAULT_COMPILER_OPTIONS,
         ...options.compilerOptions
     };
+    const sourceFiles = createSourceFileCache(compilerOptions);
     let previousProgram;
     return {
         scan() {
-            const { program, entries } = resolveEntryPointExports(options.entryPoints, compilerOptions, previousProgram);
+            const { program, entries } = resolveEntryPointExports(options.entryPoints, compilerOptions, previousProgram, sourceFiles.host);
             previousProgram = program;
+            sourceFiles.prune(program);
             const checker = program.getTypeChecker();
             const allComponents = [];
             const diagnostics = [];
             const notices = new Set();
-            for (const { exports, importPath } of entries) {
+            const fromPrimary = new Set();
+            for (const { exports, importPath, primary } of entries) {
                 const components = scanComponents(exports, checker, diagnostics, notices);
-                for (const c of components)
+                for (const c of components) {
                     c.importPath = importPath;
+                    if (primary)
+                        fromPrimary.add(c);
+                }
                 allComponents.push(...components);
             }
             // Dedupe by (filePath, className): if a component class is re-exported from
             // multiple entry points (e.g. atoms/button + barrel index.ts), we keep the first
             // occurrence. The duplicate would otherwise produce duplicate imports in the
-            // generated manifest and a runtime collision in the Prism shell.
+            // generated manifest and a runtime collision in the Prism shell. The primary
+            // entry point comes last and re-exporting its secondaries is normal there.
             const seen = new Set();
             const unique = [];
             for (const c of allComponents) {
                 const key = `${c.filePath}::${c.className}`;
                 if (seen.has(key)) {
+                    if (fromPrimary.has(c))
+                        continue;
                     console.warn(`⚠ ng-prism: ${c.className} is exported by multiple entry points; ` +
                         `keeping the first occurrence (importPath: ${unique.find((u) => u.className === c.className && u.filePath === c.filePath)?.importPath}).`);
                     continue;

package/dist/builder/scanner/showcase-diagnostics.js

@@ -49,14 +49,14 @@ export function describeUnreadableBase(className, base) {
     return (`${className} inherits ${base.inputs.join(', ')} from ${baseName}, which only exists as a declaration (${location(base.classDecl)}); ` +
         `without its source these inputs cannot be read, so they are missing from the manifest and variants cannot set them.`);
 }
-/** A variant is named by its `name` as well as its index, since that is what the styleguide shows. */
+/** A variant or a state is named by its `name` as well as its index, since that is what the styleguide shows. */
 function formatShowcasePath(path, config) {
     const [head, index, ...rest] = path;
-    if (head !== 'variants' || typeof index !== 'number')
+    if ((head !== 'variants' && head !== 'states') || typeof index !== 'number')
         return formatPath(path);
-    const name = variantName(config, index);
-    const variant = name === undefined ? `variants[${index}]` : `variants[${index}] ${JSON.stringify(name)}`;
-    return rest.length === 0 ? variant : `${variant} › ${formatPath(rest)}`;
+    const name = elementName(config, head, index);
+    const element = name === undefined ? `${head}[${index}]` : `${head}[${index}] ${JSON.stringify(name)}`;
+    return rest.length === 0 ? element : `${element} › ${formatPath(rest)}`;
 }
 function formatPath(path) {
     return path
@@ -70,10 +70,10 @@ function formatPath(path) {
         .join('');
 }
 /** Read from the source, because the evaluated array has already lost the elements before the index. */
-function variantName(config, index) {
-    const variants = ts.isObjectLiteralExpression(config) ? findInitializer(config, 'variants') : undefined;
-    const variant = variants && ts.isArrayLiteralExpression(variants) ? variants.elements[index] : undefined;
-    const name = variant && ts.isObjectLiteralExpression(variant) ? findInitializer(variant, 'name') : undefined;
+function elementName(config, key, index) {
+    const elements = ts.isObjectLiteralExpression(config) ? findInitializer(config, key) : undefined;
+    const element = elements && ts.isArrayLiteralExpression(elements) ? elements.elements[index] : undefined;
+    const name = element && ts.isObjectLiteralExpression(element) ? findInitializer(element, 'name') : undefined;
     const value = name && evaluateExpression(name);
     return typeof value === 'string' ? value : undefined;
 }

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

@@ -0,0 +1,17 @@
+import type { ShowcaseState } from '../../decorator/showcase.types.js';
+/**
+ * `ShowcaseConfig.states` as the scanner evaluated it, with everything it
+ * cannot use reported. `undefined` when it is no list, or an empty one.
+ *
+ * Every slot of the list survives, because a state is identified by its
+ * position (the URL, the marker and the discovery manifest use it): an
+ * unusable entry becomes a state without pseudo states, which the styleguide
+ * shows as an empty column, instead of shifting the entries behind it.
+ * A state without a usable name is called `State <position>`.
+ *
+ * `unevaluable` holds the source positions of the entries the evaluator could
+ * not read at all. They are missing from `value`, so an empty slot goes back
+ * in at each of them, without a message of its own.
+ */
+export declare function readShowcaseStates(value: unknown, className: string, report: (message: string) => void, unevaluable?: ReadonlySet<number>): ShowcaseState[] | undefined;
+//# sourceMappingURL=showcase-states.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"showcase-states.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/showcase-states.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAUvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACjC,WAAW,GAAE,WAAW,CAAC,MAAM,CAAa,GAC7C,aAAa,EAAE,GAAG,SAAS,CA4C7B"}

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

@@ -0,0 +1,58 @@
+import { describeValue, readPseudoStates } from './pseudo-states.js';
+function isEmptyObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+/** Stands in for a state the evaluator dropped, which its own diagnostic already explains. */
+const GAP = Symbol('unevaluable state');
+/**
+ * `ShowcaseConfig.states` as the scanner evaluated it, with everything it
+ * cannot use reported. `undefined` when it is no list, or an empty one.
+ *
+ * Every slot of the list survives, because a state is identified by its
+ * position (the URL, the marker and the discovery manifest use it): an
+ * unusable entry becomes a state without pseudo states, which the styleguide
+ * shows as an empty column, instead of shifting the entries behind it.
+ * A state without a usable name is called `State <position>`.
+ *
+ * `unevaluable` holds the source positions of the entries the evaluator could
+ * not read at all. They are missing from `value`, so an empty slot goes back
+ * in at each of them, without a message of its own.
+ */
+export function readShowcaseStates(value, className, report, unevaluable = new Set()) {
+    if (!Array.isArray(value)) {
+        report(`${className} declares invalid states ${describeValue(value)}, expected a list of { name, pseudo }. Skipping.`);
+        return undefined;
+    }
+    const entries = [...value];
+    // Ascending, so that each position is already the one the source gives it once the earlier gaps are back.
+    for (const index of [...unevaluable].sort((a, b) => a - b))
+        entries.splice(index, 0, GAP);
+    if (entries.length === 0)
+        return undefined;
+    const firstIndexOfName = new Map();
+    return entries.map((entry, index) => {
+        const state = typeof entry === 'object' && entry !== null && !Array.isArray(entry) ? entry : undefined;
+        const declaredName = state?.['name'];
+        const hasName = typeof declaredName === 'string' && declaredName.trim() !== '';
+        if (state && !hasName)
+            report(`${className} states[${index}] has no name, expected a non-empty string. Calling it "State ${index + 1}".`);
+        else if (!state && entry !== GAP)
+            report(`${className} states[${index}] is ${describeValue(entry)}, expected { name, pseudo }. Its column stays empty.`);
+        const name = hasName ? declaredName : `State ${index + 1}`;
+        const first = firstIndexOfName.get(name);
+        if (first !== undefined) {
+            report(`${className} state "${name}" repeats the name of states[${first}]; only the first one is used. Its column stays empty.`);
+            return { name, pseudo: {} };
+        }
+        firstIndexOfName.set(name, index);
+        if (!state)
+            return { name, pseudo: {} };
+        const pseudo = state['pseudo'];
+        // `readPseudoStates` reports what it drops, but an empty object has nothing to drop.
+        if (pseudo === undefined || isEmptyObject(pseudo)) {
+            report(`${className} state "${name}" declares no pseudo states. Its column stays empty.`);
+            return { name, pseudo: {} };
+        }
+        return { name, pseudo: readPseudoStates(pseudo, `${className} state "${name}"`, report) ?? {} };
+    });
+}

package/dist/builder/scanner/source-file-cache.d.ts

@@ -0,0 +1,26 @@
+import ts from 'typescript';
+export interface SourceFileCache {
+    /** Pass to `ts.createProgram` together with the previous program. */
+    host: ts.CompilerHost;
+    /** Drop every cached file the given program no longer contains. */
+    prune(program: ts.Program): void;
+}
+/**
+ * A compiler host that hands out the same `SourceFile` for a file that has
+ * not changed since it was last parsed.
+ *
+ * `ts.createProgram(…, oldProgram)` only reuses a file from the old program
+ * when the host returns the identical object. The default host reads and
+ * parses on every call, so without this cache each rebuild re-parses the
+ * whole program, Angular's typings included.
+ *
+ * A file counts as unchanged while its mtime and size are. An edit that keeps
+ * the size and lands within the file system's mtime resolution goes unseen;
+ * APFS and ext4 record nanoseconds, so in practice that does not happen.
+ *
+ * Module resolutions are recomputed on every program. Reusing them would
+ * miss a file created after an import of it had already failed to resolve,
+ * because the importing file itself has not changed.
+ */
+export declare function createSourceFileCache(compilerOptions: ts.CompilerOptions): SourceFileCache;
+//# sourceMappingURL=source-file-cache.d.ts.map

package/dist/builder/scanner/source-file-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-file-cache.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/source-file-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,MAAM,WAAW,eAAe;IAC5B,qEAAqE;IACrE,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC;IACtB,mEAAmE;IACnE,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,GAAG,IAAI,CAAC;CACpC;AAOD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,EAAE,CAAC,eAAe,GAAG,eAAe,CAmC1F"}

package/dist/builder/scanner/source-file-cache.js

@@ -0,0 +1,60 @@
+import { statSync } from 'fs';
+import ts from 'typescript';
+/**
+ * A compiler host that hands out the same `SourceFile` for a file that has
+ * not changed since it was last parsed.
+ *
+ * `ts.createProgram(…, oldProgram)` only reuses a file from the old program
+ * when the host returns the identical object. The default host reads and
+ * parses on every call, so without this cache each rebuild re-parses the
+ * whole program, Angular's typings included.
+ *
+ * A file counts as unchanged while its mtime and size are. An edit that keeps
+ * the size and lands within the file system's mtime resolution goes unseen;
+ * APFS and ext4 record nanoseconds, so in practice that does not happen.
+ *
+ * Module resolutions are recomputed on every program. Reusing them would
+ * miss a file created after an import of it had already failed to resolve,
+ * because the importing file itself has not changed.
+ */
+export function createSourceFileCache(compilerOptions) {
+    const host = ts.createCompilerHost(compilerOptions);
+    const parse = host.getSourceFile.bind(host);
+    const cache = new Map();
+    host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+        const stamp = readStamp(fileName);
+        if (stamp === undefined) {
+            cache.delete(fileName);
+            return undefined;
+        }
+        const cached = cache.get(fileName);
+        if (cached?.stamp === stamp && !shouldCreateNewSourceFile)
+            return cached.sourceFile;
+        const sourceFile = parse(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+        if (sourceFile)
+            cache.set(fileName, { stamp, sourceFile });
+        else
+            cache.delete(fileName);
+        return sourceFile;
+    };
+    host.hasInvalidatedResolutions = () => true;
+    return {
+        host,
+        prune(program) {
+            const live = new Set(program.getSourceFiles().map((sf) => sf.fileName));
+            for (const fileName of cache.keys()) {
+                if (!live.has(fileName))
+                    cache.delete(fileName);
+            }
+        }
+    };
+}
+function readStamp(fileName) {
+    try {
+        const { mtimeMs, size } = statSync(fileName);
+        return `${mtimeMs}:${size}`;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/builder/shared/prism-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prism-pipeline.d.ts","sourceRoot":"","sources":["../../../src/builder/shared/prism-pipeline.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAShE,OAAO,EAAiB,KAAK,OAAO,EAAmB,MAAM,uBAAuB,CAAC;AAErF,MAAM,WAAW,oBAAoB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,mGAAmG;IACnG,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,mGAAmG;IACnG,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,CAExD;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAuFtJ"}
+{"version":3,"file":"prism-pipeline.d.ts","sourceRoot":"","sources":["../../../src/builder/shared/prism-pipeline.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAUhE,OAAO,EAAiB,KAAK,OAAO,EAAmB,MAAM,uBAAuB,CAAC;AAErF,MAAM,WAAW,oBAAoB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,mGAAmG;IACnG,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,mGAAmG;IACnG,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,CAExD;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA2FtJ"}

package/dist/builder/shared/prism-pipeline.js

@@ -3,9 +3,10 @@ import { dirname, join } from 'path';
 import ts from 'typescript';
 import { checkA11yThresholds, DEFAULT_A11Y_REPORT_PATH, readA11yForComponents, readA11yMeta } from '../a11y/a11y-report-reader.js';
 import { loadConfig } from '../config-loader/config-loader.js';
+import { describeDeprecatedOptions } from '../config-loader/deprecated-options.js';
 import { generateRuntimeManifest } from '../manifest/runtime-manifest.generator.js';
 import { runPluginHooks } from '../plugin-runner/plugin-runner.js';
-import { discoverSecondaryEntryPoints } from '../scanner/entry-point-discovery.js';
+import { discoverSecondaryEntryPoints, findPrimaryEntryFile } from '../scanner/entry-point-discovery.js';
 import { createScanner } from '../scanner/scanner.js';
 export function createPipelineState() {
     return { scanner: undefined, lastEntrySetKey: undefined };
@@ -17,6 +18,9 @@ export async function runPrismPipeline(options, context, state) {
         workspaceRoot,
         configFileName: options.configFile
     });
+    for (const notice of describeDeprecatedOptions(config, options.configFile)) {
+        console.warn(`⚠ ng-prism: ${notice}`);
+    }
     context.reportStatus('Scanning components...');
     const { components, diagnostics } = scanEntryPoints(workspaceRoot, options, state);
     if (config.strictShowcase && diagnostics.length > 0) {
@@ -115,6 +119,18 @@ function findLibraryRoot(filePath) {
     }
     return undefined;
 }
+/**
+ * Reads config files, `extends` included, but lists no directories. Only
+ * `paths` and `baseUrl` are taken from the config, so enumerating the files it
+ * includes would only cost time: with no `include`, that is every source file
+ * below the config, on every rebuild.
+ */
+const CONFIG_HOST = {
+    useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: () => []
+};
 function resolveTsconfigPaths(entryPointDir) {
     const configPath = ts.findConfigFile(entryPointDir, ts.sys.fileExists, 'tsconfig.json');
     if (!configPath)
@@ -122,7 +138,7 @@ function resolveTsconfigPaths(entryPointDir) {
     const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
     if (configFile.error)
         return {};
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname(configPath));
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, CONFIG_HOST, dirname(configPath));
     const result = {};
     if (parsed.options.paths)
         result.paths = parsed.options.paths;
@@ -136,18 +152,17 @@ function resolveEntryPoints(workspaceRoot, options) {
     const entryIsDirectory = isDirectory(absoluteEntryPoint);
     const libraryRoot = entryIsDirectory ? absoluteEntryPoint : findLibraryRoot(absoluteEntryPoint);
     const discovered = libraryRoot ? discoverSecondaryEntryPoints(libraryRoot, options.libraryImportPath) : [];
-    // Fallback to a direct file scan when:
-    //  - the entry is a file and no ng-package.json was found above it, OR
-    //  - the entry is a file with an ng-package.json above it but discovery found nothing
-    //    (e.g. primary-only library, root ng-package.json carries `dest`).
-    const entryPoints = discovered.length === 0 && !entryIsDirectory
-        ? [
-            {
-                entryFile: absoluteEntryPoint,
-                importPath: options.libraryImportPath
-            }
-        ]
+    // The primary entry point is scanned after the secondary ones: a file entryPoint is
+    // the primary itself, a directory names it in its ng-package.json. A root
+    // ng-package.json without `dest` is already among the discovered ones.
+    const primaryEntryFile = entryIsDirectory ? findPrimaryEntryFile(absoluteEntryPoint) : absoluteEntryPoint;
+    const entryPoints = primaryEntryFile && !discovered.some((e) => e.entryFile === primaryEntryFile)
+        ? [...discovered, { entryFile: primaryEntryFile, importPath: options.libraryImportPath, primary: true }]
         : discovered;
+    if (entryPoints.length === 0) {
+        console.warn(`⚠ ng-prism: entryPoint "${options.entryPoint}" resolves to no entry file: no ng-package.json with a lib.entryFile ` +
+            `that exists, and no secondary entry points below it. Point entryPoint at the library's barrel file.`);
+    }
     return { entryPoints, compilerOptions };
 }
 function scanEntryPoints(workspaceRoot, options, state) {