@ng-prism/core 21.10.2 → 21.10.3

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

@@ -1 +1 @@
-{"version":3,"file":"component.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/component.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAiBrE;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,EACpB,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,gBAAgB,EAAE,CAyCpB"}
+{"version":3,"file":"component.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/component.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAiBrE;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,EACpB,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,gBAAgB,EAAE,CA8CpB"}

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

@@ -16,6 +16,11 @@ export function scanComponents(exports, checker) {
         const classDecl = resolved.declarations?.find(ts.isClassDeclaration);
         if (!classDecl)
             continue;
+        // Perf: cheap pre-filter — skip the full decorator walk for files that don't
+        // mention Showcase at all. False positives (string-literal containing "@Showcase")
+        // just lose the optimization for that file; correctness is unaffected.
+        if (!classDecl.getSourceFile().text.includes('@Showcase'))
+            continue;
         const showcaseDecorator = findDecorator(classDecl, 'Showcase');
         if (!showcaseDecorator)
             continue;

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

@@ -1,11 +1,22 @@
 import ts from 'typescript';
-export interface EntryPointResult {
-    program: ts.Program;
+export interface EntryPointInput {
+    entryFile: string;
+    importPath: string;
+}
+export interface ResolvedEntryPoint extends EntryPointInput {
     exports: ts.Symbol[];
 }
+export interface MultiEntryResult {
+    program: ts.Program;
+    entries: ResolvedEntryPoint[];
+}
 /**
- * Resolve all exported symbols from an entry-point file (e.g. public-api.ts).
+ * Resolve all exported symbols for one or more entry-point files (e.g. public-api.ts).
+ * A single shared `ts.Program` is created with every entry file as a root name, so the
+ * transitive type graph (Angular framework typings, etc.) is parsed once and reused
+ * across all entries via the shared `TypeChecker`.
+ *
  * Re-exports (`export * from '...'`) are resolved automatically by TypeScript.
  */
-export declare function resolveEntryPointExports(entryPointPath: string, compilerOptions: ts.CompilerOptions, previousProgram?: ts.Program): EntryPointResult;
+export declare function resolveEntryPointExports(entryPoints: ReadonlyArray<EntryPointInput>, compilerOptions: ts.CompilerOptions, previousProgram?: ts.Program): 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,gBAAgB;IAC/B,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IACpB,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,EAAE,CAAC,eAAe,EACnC,eAAe,CAAC,EAAE,EAAE,CAAC,OAAO,GAC3B,gBAAgB,CAqBlB"}
+{"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;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IACpB,OAAO,EAAE,kBAAkB,EAAE,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,aAAa,CAAC,eAAe,CAAC,EAC3C,eAAe,EAAE,EAAE,CAAC,eAAe,EACnC,eAAe,CAAC,EAAE,EAAE,CAAC,OAAO,GAC3B,gBAAgB,CAoClB"}

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

@@ -1,19 +1,32 @@
 import ts from 'typescript';
 /**
- * Resolve all exported symbols from an entry-point file (e.g. public-api.ts).
+ * Resolve all exported symbols for one or more entry-point files (e.g. public-api.ts).
+ * A single shared `ts.Program` is created with every entry file as a root name, so the
+ * transitive type graph (Angular framework typings, etc.) is parsed once and reused
+ * across all entries via the shared `TypeChecker`.
+ *
  * Re-exports (`export * from '...'`) are resolved automatically by TypeScript.
  */
-export function resolveEntryPointExports(entryPointPath, compilerOptions, previousProgram) {
-    const program = ts.createProgram([entryPointPath], compilerOptions, undefined, previousProgram);
+export function resolveEntryPointExports(entryPoints, compilerOptions, previousProgram) {
+    const program = ts.createProgram(entryPoints.map((e) => e.entryFile), compilerOptions, undefined, previousProgram);
     const checker = program.getTypeChecker();
-    const sourceFile = program.getSourceFile(entryPointPath);
-    if (!sourceFile) {
-        throw new Error(`Could not find source file: ${entryPointPath}`);
-    }
-    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
-    if (!moduleSymbol) {
-        return { program, exports: [] };
-    }
-    const exports = checker.getExportsOfModule(moduleSymbol);
-    return { program, exports };
+    const entries = entryPoints.map(({ entryFile, importPath }) => {
+        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: [] };
+            }
+            const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+            const exports = moduleSymbol
+                ? checker.getExportsOfModule(moduleSymbol)
+                : [];
+            return { entryFile, importPath, 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 { program, entries };
 }

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

@@ -1,7 +1,7 @@
 export { createScanner } from './scanner.js';
-export type { CreateScannerOptions, Scanner } from './scanner.js';
+export type { CreateScannerOptions, Scanner, ScanResult } from './scanner.js';
 export { resolveEntryPointExports } from './entry-point.scanner.js';
-export type { EntryPointResult } from './entry-point.scanner.js';
+export type { EntryPointInput, ResolvedEntryPoint, MultiEntryResult, } from './entry-point.scanner.js';
 export { scanComponents } from './component.scanner.js';
 export { extractInputs, extractOutputs } from './input.extractor.js';
 export { generateManifest } from './manifest.generator.js';

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,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,YAAY,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,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,EACV,eAAe,EACf,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAClC,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"}

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

@@ -1,16 +1,25 @@
 import ts from 'typescript';
-import type { PrismManifest } from '../../plugin/plugin.types.js';
+import type { ScannedComponent } from '../../plugin/plugin.types.js';
+import { type EntryPointInput } from './entry-point.scanner.js';
 export interface CreateScannerOptions {
-    entryPoint: string;
+    entryPoints: ReadonlyArray<EntryPointInput>;
     compilerOptions?: ts.CompilerOptions;
 }
+export interface ScanResult {
+    components: ScannedComponent[];
+}
 export interface Scanner {
-    /** Scan the entry point. Reuses TypeScript program state from previous scans. */
-    scan(): PrismManifest;
+    /** Scan all entry points. Reuses TypeScript program state from previous scans. */
+    scan(): ScanResult;
 }
 /**
- * Create a stateful scanner that retains the previous ts.Program between scans.
- * TypeScript reuses parsed SourceFile objects from the old program, making incremental scans fast.
+ * Create a stateful multi-entry scanner that retains the previous ts.Program between scans.
+ * A single shared program is created with every entry-point file as a root name, so the
+ * 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.
  */
 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,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAIlE,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC;CACtC;AAED,MAAM,WAAW,OAAO;IACtB,iFAAiF;IACjF,IAAI,IAAI,aAAa,CAAC;CACvB;AAWD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAmBpE"}
+{"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;AACrE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,0BAA0B,CAAC;AAGlC,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAC5C,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC;CACtC;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,OAAO;IACtB,kFAAkF;IAClF,IAAI,IAAI,UAAU,CAAC;CACpB;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAoDpE"}

package/dist/builder/scanner/scanner.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { resolveEntryPointExports } from './entry-point.scanner.js';
+import { resolveEntryPointExports, } from './entry-point.scanner.js';
 import { scanComponents } from './component.scanner.js';
 const DEFAULT_COMPILER_OPTIONS = {
     target: ts.ScriptTarget.ES2022,
@@ -8,21 +8,58 @@ const DEFAULT_COMPILER_OPTIONS = {
     experimentalDecorators: true,
     strict: true,
     skipLibCheck: true,
+    // Perf: skip auto-loading every @types/* package; library source rarely needs ambient globals.
+    // Users with explicit needs can pass `types: ['node']` via tsconfig.json paths.
+    types: [],
+    // Perf: we never call program.emit(); skip emit-related setup work.
+    noEmit: true,
+    // Perf: complement to skipLibCheck — also skip type-checking lib.*.d.ts files.
+    skipDefaultLibCheck: true,
 };
 /**
- * Create a stateful scanner that retains the previous ts.Program between scans.
- * TypeScript reuses parsed SourceFile objects from the old program, making incremental scans fast.
+ * Create a stateful multi-entry scanner that retains the previous ts.Program between scans.
+ * A single shared program is created with every entry-point file as a root name, so the
+ * 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.
  */
 export function createScanner(options) {
-    const compilerOptions = { ...DEFAULT_COMPILER_OPTIONS, ...options.compilerOptions };
+    const compilerOptions = {
+        ...DEFAULT_COMPILER_OPTIONS,
+        ...options.compilerOptions,
+    };
     let previousProgram;
     return {
         scan() {
-            const { program, exports } = resolveEntryPointExports(options.entryPoint, compilerOptions, previousProgram);
+            const { program, entries } = resolveEntryPointExports(options.entryPoints, compilerOptions, previousProgram);
             previousProgram = program;
             const checker = program.getTypeChecker();
-            const components = scanComponents(exports, checker);
-            return { components };
+            const allComponents = [];
+            for (const { exports, importPath } of entries) {
+                const components = scanComponents(exports, checker);
+                for (const c of components)
+                    c.importPath = importPath;
+                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.
+            const seen = new Set();
+            const unique = [];
+            for (const c of allComponents) {
+                const key = `${c.filePath}::${c.className}`;
+                if (seen.has(key)) {
+                    console.warn(`⚠ ng-prism: ${c.className} is exported by multiple entry points; ` +
+                        `keeping the first occurrence (importPath: ${unique.find((u) => u.className === c.className && u.filePath === c.filePath)?.importPath}).`);
+                    continue;
+                }
+                seen.add(key);
+                unique.push(c);
+            }
+            return { components: unique };
         },
     };
 }

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

@@ -14,7 +14,9 @@ export interface PrismPipelineResult {
     written: boolean;
 }
 export interface PrismPipelineState {
-    scanners: Map<string, Scanner>;
+    scanner: Scanner | undefined;
+    /** Sorted, joined entry-file paths — used to detect when the entry set changed between rebuilds. */
+    lastEntrySetKey: string | undefined;
 }
 export declare function createPipelineState(): PrismPipelineState;
 export declare function runPrismPipeline(options: PrismPipelineOptions, context: BuilderContext, state: PrismPipelineState): Promise<PrismPipelineResult>;

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":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAMhE,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAMpE,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,mGAAmG;IACnG,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,CAExD;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAoD9B"}
+{"version":3,"file":"prism-pipeline.d.ts","sourceRoot":"","sources":["../../../src/builder/shared/prism-pipeline.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAGhE,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAOpE,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,mGAAmG;IACnG,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,oGAAoG;IACpG,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,CAExD;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAoD9B"}

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

@@ -7,7 +7,7 @@ import { loadConfig } from '../config-loader/config-loader.js';
 import { runPluginHooks } from '../plugin-runner/plugin-runner.js';
 import { generateRuntimeManifest } from '../manifest/runtime-manifest.generator.js';
 export function createPipelineState() {
-    return { scanners: new Map() };
+    return { scanner: undefined, lastEntrySetKey: undefined };
 }
 export async function runPrismPipeline(options, context, state) {
     const { workspaceRoot } = context;
@@ -106,36 +106,41 @@ function resolveTsconfigPaths(entryPointDir) {
         result.baseUrl = parsed.options.baseUrl;
     return result;
 }
-function scanEntryPoints(workspaceRoot, options, state) {
+function resolveEntryPoints(workspaceRoot, options) {
     const absoluteEntryPoint = join(workspaceRoot, options.entryPoint);
-    const pathOptions = resolveTsconfigPaths(dirname(absoluteEntryPoint));
+    const compilerOptions = resolveTsconfigPaths(dirname(absoluteEntryPoint));
     const entryIsDirectory = isDirectory(absoluteEntryPoint);
     const libraryRoot = entryIsDirectory
         ? absoluteEntryPoint
         : findLibraryRoot(absoluteEntryPoint);
-    if (!libraryRoot) {
-        return getOrCreateScanner(state, absoluteEntryPoint, pathOptions).scan();
-    }
-    const entryPoints = discoverSecondaryEntryPoints(libraryRoot, options.libraryImportPath);
-    if (entryPoints.length === 0 && !entryIsDirectory) {
-        return getOrCreateScanner(state, absoluteEntryPoint, pathOptions).scan();
-    }
-    const allComponents = [];
-    for (const ep of entryPoints) {
-        const scanner = getOrCreateScanner(state, ep.entryFile, pathOptions);
-        const result = scanner.scan();
-        for (const comp of result.components) {
-            comp.importPath = ep.importPath;
-            allComponents.push(comp);
-        }
-    }
-    return { components: allComponents };
+    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,
+            },
+        ]
+        : discovered;
+    return { entryPoints, compilerOptions };
 }
-function getOrCreateScanner(state, entryFile, compilerOptions) {
-    let scanner = state.scanners.get(entryFile);
-    if (!scanner) {
-        scanner = createScanner({ entryPoint: entryFile, compilerOptions });
-        state.scanners.set(entryFile, scanner);
+function scanEntryPoints(workspaceRoot, options, state) {
+    const { entryPoints, compilerOptions } = resolveEntryPoints(workspaceRoot, options);
+    const newKey = entryPoints
+        .map((e) => e.entryFile)
+        .slice()
+        .sort()
+        .join('|');
+    if (newKey !== state.lastEntrySetKey) {
+        state.scanner = undefined;
+        state.lastEntrySetKey = newKey;
     }
-    return scanner;
+    state.scanner ??= createScanner({ entryPoints, compilerOptions });
+    return state.scanner.scan();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ng-prism/core",
-  "version": "21.10.2",
+  "version": "21.10.3",
   "description": "ng-prism — the Angular-native Storybook alternative. Lightweight component showcase with @Showcase decorator, no story files needed.",
   "keywords": [
     "ng-prism",