@nx/angular-rspack-compiler 23.2.0-beta.1 → 23.2.0-beta.11

package/README.md

@@ -7,9 +7,9 @@
 
 <div style="text-align: center;">
 
-[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)](<>)
 [![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
-[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)](<>)
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 [![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
 [![Nx Sandboxing](https://staging.nx.app/workspaces/62d013ea0852fe0a2df74438/sandbox-badge.svg)](https://nx.dev/docs/features/ci-features/sandboxing)

package/dist/compilation/build-and-analyze.d.ts

@@ -1,4 +1,16 @@
 import { JavaScriptTransformer } from '@angular/build/private';
 import { AngularCompilation } from '../models';
-export declare function buildAndAnalyze(angularCompilation: AngularCompilation, typescriptFileCache: Map<string, string | Uint8Array>, javascriptTransformer: JavaScriptTransformer): Promise<void>;
+import { type TransformedSource } from '../utils/source-file-cache';
+/**
+ * Emits the affected files of the Angular compilation into the given file
+ * cache as raw, untransformed text. The Rspack loaders in `@nx/angular-rspack`
+ * run the JavaScript transformer on entries on demand and replace them in
+ * place, so only files the bundler actually requests pay the transformation
+ * cost, matching the on-demand transformation in `@angular/build`'s esbuild
+ * compiler plugin.
+ *
+ * @param javascriptTransformer Unused. Kept for signature compatibility; the
+ * transformer now runs in the loaders.
+ */
+export declare function buildAndAnalyze(angularCompilation: AngularCompilation, typescriptFileCache: Map<string, string | TransformedSource>, javascriptTransformer: JavaScriptTransformer): Promise<void>;
 //# sourceMappingURL=build-and-analyze.d.ts.map

package/dist/compilation/build-and-analyze.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-and-analyze.d.ts","sourceRoot":"","sources":["../../src/compilation/build-and-analyze.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAK/C,wBAAsB,eAAe,CACnC,kBAAkB,EAAE,kBAAkB,EACtC,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,EACrD,qBAAqB,EAAE,qBAAqB,iBA8B7C"}
+{"version":3,"file":"build-and-analyze.d.ts","sourceRoot":"","sources":["../../src/compilation/build-and-analyze.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,kBAAkB,EAAE,kBAAkB,EACtC,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAAC,EAC5D,qBAAqB,EAAE,qBAAqB,iBAgB7C"}

package/dist/compilation/build-and-analyze.js

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildAndAnalyze = buildAndAnalyze;
-const path_1 = require("path");
 const assert_supported_versions_1 = require("../utils/assert-supported-versions");
-const JS_TS_FILE_PATTERN = /\.[cm]?[jt]sx?$/;
+const source_file_cache_1 = require("../utils/source-file-cache");
+/**
+ * Emits the affected files of the Angular compilation into the given file
+ * cache as raw, untransformed text. The Rspack loaders in `@nx/angular-rspack`
+ * run the JavaScript transformer on entries on demand and replace them in
+ * place, so only files the bundler actually requests pay the transformation
+ * cost, matching the on-demand transformation in `@angular/build`'s esbuild
+ * compiler plugin.
+ *
+ * @param javascriptTransformer Unused. Kept for signature compatibility; the
+ * transformer now runs in the loaders.
+ */
 async function buildAndAnalyze(angularCompilation, typescriptFileCache, javascriptTransformer) {
     (0, assert_supported_versions_1.assertSupportedAngularRspackCompilerVersions)();
     for (const { filename, contents, } of await angularCompilation.emitAffectedFiles()) {
-        const normalizedFilename = (0, path_1.normalize)(filename.replace(/^[A-Z]:/, ''));
-        // Skip JavaScript transformation for non-JS/TS files (JSON, CSS, etc.)
-        // Let Rspack handle these through its native module rules
-        if (!JS_TS_FILE_PATTERN.test(normalizedFilename)) {
-            const text = typeof contents === 'string'
-                ? contents
-                : Buffer.from(contents).toString();
-            typescriptFileCache.set(normalizedFilename, text);
-            continue;
-        }
-        await javascriptTransformer
-            .transformData(normalizedFilename, contents, true, false)
-            .then((contents) => {
-            typescriptFileCache.set(normalizedFilename, Buffer.from(contents).toString());
-        });
+        const text = typeof contents === 'string'
+            ? contents
+            : Buffer.from(contents).toString();
+        // Setting the raw emit also evicts any stale transformed entry.
+        typescriptFileCache.set((0, source_file_cache_1.toTypeScriptFileCacheKey)(filename), text);
     }
 }

package/dist/compilation/setup-compilation.d.ts

@@ -8,6 +8,14 @@ export interface StylesheetTransformResult {
         path: string;
         text: string;
     }>;
+    /** Bundle metadata listing the files that went into the stylesheet. */
+    metafile?: {
+        outputs: Record<string, {
+            inputs: Record<string, {
+                bytesInOutput: number;
+            }>;
+        }>;
+    };
 }
 export interface SetupCompilationOptions {
     root: string;
@@ -19,12 +27,28 @@ export interface SetupCompilationOptions {
     hasServer?: boolean;
     includePaths?: string[];
     sass?: Sass;
+    watch?: boolean;
+    sourceMap?: boolean;
+    preserveSymlinks?: boolean;
+    customConditions?: string[];
 }
 export declare const DEFAULT_NG_COMPILER_OPTIONS: ts.CompilerOptions;
+/**
+ * Reads the project's TypeScript configuration with the Angular compiler
+ * defaults applied and creates (or reuses) the shared component stylesheet
+ * bundler. TypeScript sourcemaps are emitted inline and only when
+ * `options.sourceMap` is enabled. Targets below ES2022 are raised (see
+ * `applyEs2022TargetDefaults`), unsupported `module` values are set to
+ * ES2022, and partial compilation mode is forced to full, each with a
+ * warning in the returned `setupWarnings`. Combining `isolatedModules` with
+ * `emitDecoratorMetadata` is also warned about, without forcing either
+ * option.
+ */
 export declare function setupCompilation(config: Pick<RsbuildConfig, 'mode' | 'source'>, options: SetupCompilationOptions): Promise<{
     rootNames: readonly string[];
     compilerOptions: ts.CompilerOptions;
     componentStylesheetBundler: ComponentStylesheetBundler;
+    setupWarnings: string[];
 }>;
 /**
  * Dispose the shared component stylesheet bundler and reset the singleton.

package/dist/compilation/setup-compilation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup-compilation.d.ts","sourceRoot":"","sources":["../../src/compilation/setup-compilation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAG5E,OAAO,EACL,0BAA0B,EAI3B,MAAM,wBAAwB,CAAC;AAKhC,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IACzC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED,eAAO,MAAM,2BAA2B,EAAE,EAAE,CAAC,eAc5C,CAAC;AAKF,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,QAAQ,CAAC,EAC9C,OAAO,EAAE,uBAAuB;;;;GAyEjC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iCAAiC,IAAI,OAAO,CAAC,IAAI,CAAC,CAMvE;AAED,wBAAgB,cAAc,CAC5B,0BAA0B,EAAE,0BAA0B,YAG5C,MAAM,kBACE,MAAM,mBACL,MAAM,KACtB,OAAO,CAAC,yBAAyB,CAAC,CAmCtC"}
+{"version":3,"file":"setup-compilation.d.ts","sourceRoot":"","sources":["../../src/compilation/setup-compilation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAI5E,OAAO,EACL,0BAA0B,EAK3B,MAAM,wBAAwB,CAAC;AAIhC,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD,uEAAuE;IACvE,QAAQ,CAAC,EAAE;QACT,OAAO,EAAE,MAAM,CACb,MAAM,EACN;YAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;gBAAE,aAAa,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,CACtD,CAAC;KACH,CAAC;CACH;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IACzC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,eAAO,MAAM,2BAA2B,EAAE,EAAE,CAAC,eAa5C,CAAC;AAKF;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,QAAQ,CAAC,EAC9C,OAAO,EAAE,uBAAuB;;;;;GAsIjC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iCAAiC,IAAI,OAAO,CAAC,IAAI,CAAC,CAMvE;AAED,wBAAgB,cAAc,CAC5B,0BAA0B,EAAE,0BAA0B,YAG5C,MAAM,kBACE,MAAM,mBACL,MAAM,KACtB,OAAO,CAAC,yBAAyB,CAAC,CAmCtC"}

package/dist/compilation/setup-compilation.js

@@ -4,16 +4,17 @@ exports.DEFAULT_NG_COMPILER_OPTIONS = void 0;
 exports.setupCompilation = setupCompilation;
 exports.disposeComponentStylesheetBundler = disposeComponentStylesheetBundler;
 exports.styleTransform = styleTransform;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
 const utils_1 = require("../utils");
+const typescript_compiler_options_1 = require("../utils/typescript-compiler-options");
 const assert_supported_versions_1 = require("../utils/assert-supported-versions");
 const private_1 = require("@angular/build/private");
 const targets_from_browsers_1 = require("../utils/targets-from-browsers");
-const private_2 = require("@angular/build/private");
 const node_module_1 = require("node:module");
 exports.DEFAULT_NG_COMPILER_OPTIONS = {
     suppressOutputPathCheck: true,
     outDir: undefined,
-    sourceMap: true,
     declaration: false,
     declarationMap: false,
     allowEmptyCodegenFiles: false,
@@ -26,20 +27,75 @@ exports.DEFAULT_NG_COMPILER_OPTIONS = {
     supportJitMode: false,
 };
 let COMPONENT_STYLESHEET_BUNDLER = undefined;
+/**
+ * Reads the project's TypeScript configuration with the Angular compiler
+ * defaults applied and creates (or reuses) the shared component stylesheet
+ * bundler. TypeScript sourcemaps are emitted inline and only when
+ * `options.sourceMap` is enabled. Targets below ES2022 are raised (see
+ * `applyEs2022TargetDefaults`), unsupported `module` values are set to
+ * ES2022, and partial compilation mode is forced to full, each with a
+ * warning in the returned `setupWarnings`. Combining `isolatedModules` with
+ * `emitDecoratorMetadata` is also warned about, without forcing either
+ * option.
+ */
 async function setupCompilation(config, options) {
     (0, assert_supported_versions_1.assertSupportedAngularRspackCompilerVersions)();
     const { readConfiguration } = await (0, utils_1.loadCompilerCli)();
     const { options: tsCompilerOptions, rootNames } = readConfiguration(config.source?.tsconfigPath ?? options.tsConfig, {
         ...exports.DEFAULT_NG_COMPILER_OPTIONS,
+        // Sourcemaps must be inline to survive the loader chain, and emitting
+        // them forgoes Angular's fast raw-TS emit path, so only emit them when
+        // script sourcemaps are requested.
+        inlineSources: !!options.sourceMap,
+        inlineSourceMap: !!options.sourceMap,
+        sourceMap: undefined,
+        // Composite emit is unsupported and conflicts with the incremental
+        // state handling; force it off.
+        composite: false,
+        // The bundler resolves symlinks based on this option alone; the
+        // program must resolve the same way, so the tsconfig value is ignored.
+        preserveSymlinks: options.preserveSymlinks,
         ...(options.useTsProjectReferences
             ? {
                 sourceMap: false,
+                inlineSourceMap: false,
                 inlineSources: false,
                 isolatedModules: true,
             }
             : {}),
     });
     const compilerOptions = tsCompilerOptions;
+    const setupWarnings = [];
+    const hasExplicitUseDefineForClassFields = compilerOptions.useDefineForClassFields !== undefined;
+    if ((0, typescript_compiler_options_1.applyEs2022TargetDefaults)(compilerOptions)) {
+        setupWarnings.push(hasExplicitUseDefineForClassFields
+            ? "TypeScript compiler option 'target' is set to 'ES2022'."
+            : "TypeScript compiler options 'target' and 'useDefineForClassFields' are set to 'ES2022' and 'false' respectively.");
+    }
+    // Partial compilation output requires the Angular linker, which the JS
+    // transformer skips for application code; it would ship unlinked and fail
+    // at runtime.
+    if (compilerOptions.compilationMode === 'partial') {
+        setupWarnings.push('Angular partial compilation mode is not supported when building applications. Full compilation mode will be used instead.');
+        compilerOptions.compilationMode = 'full';
+    }
+    if (compilerOptions.module === undefined ||
+        compilerOptions.module < ts.ModuleKind.ES2015) {
+        compilerOptions.module = ts.ModuleKind.ES2022;
+        setupWarnings.push("TypeScript compiler options 'module' values 'CommonJS', 'UMD', 'System' and 'AMD' are not supported. The 'module' option will be set to 'ES2022' instead.");
+    }
+    if (compilerOptions.isolatedModules &&
+        compilerOptions.emitDecoratorMetadata) {
+        setupWarnings.push("TypeScript compiler option 'isolatedModules' may prevent the 'emitDecoratorMetadata' option from emitting all metadata. " +
+            "The 'emitDecoratorMetadata' option is not required by Angular and can be removed if not explicitly required by the project.");
+    }
+    // With bundler-style resolution the program resolves package exports with
+    // these conditions; keep them in step with the bundler's custom
+    // conditions so both resolve the same files.
+    if (compilerOptions.moduleResolution === ts.ModuleResolutionKind.Bundler ||
+        compilerOptions.module === ts.ModuleKind.Preserve) {
+        compilerOptions.customConditions = options.customConditions;
+    }
     const searchDirectories = await (0, private_1.generateSearchDirectories)([options.root]);
     const postcssConfiguration = await (0, private_1.loadPostcssConfiguration)(searchDirectories);
     // Skip tailwind configuration if postcss is customized
@@ -69,18 +125,19 @@ async function setupCompilation(config, options) {
             media: `media/${config.mode === 'production' ? '[name]-[hash]' : '[name]'}`,
         },
         sourcemap: false,
-        target: (0, targets_from_browsers_1.transformSupportedBrowsersToTargets)((0, private_2.getSupportedBrowsers)(options.root, {
+        target: (0, targets_from_browsers_1.transformSupportedBrowsersToTargets)((0, private_1.getSupportedBrowsers)(options.root, {
             warn: (message) => console.warn(message),
         })),
         includePaths: options.includePaths,
         sass: options.sass,
         postcssConfiguration,
         tailwindConfiguration,
-    }, options.inlineStyleLanguage, false));
+    }, options.inlineStyleLanguage, !!options.watch));
     return {
         rootNames,
         compilerOptions,
         componentStylesheetBundler: COMPONENT_STYLESHEET_BUNDLER,
+        setupWarnings,
     };
 }
 /**
@@ -117,10 +174,10 @@ function styleTransform(componentStylesheetBundler) {
                     console.error('Failed to compile styles. Continuing execution ignoring failing stylesheet...', error.text);
                 }
             }
-            // Return both contents and outputFiles
             return {
                 contents: stylesheetResult.contents,
                 outputFiles: stylesheetResult.outputFiles,
+                metafile: stylesheetResult.metafile,
             };
         }
         catch (e) {

package/dist/compilation/setup-with-angular-compilation.d.ts

@@ -1,11 +1,25 @@
 import type { RsbuildConfig } from '@rsbuild/core';
 import { AngularCompilation, SourceFileCache } from '../models';
 import { SetupCompilationOptions } from './setup-compilation';
+/**
+ * The files bundled into a component stylesheet, keyed by the stylesheet
+ * they were bundled from. Used to attribute package licenses.
+ */
+export interface StylesheetMetafileInputs {
+    source: string;
+    inputs: Record<string, {
+        bytesInOutput: number;
+    }>;
+}
 export declare function setupCompilationWithAngularCompilation(config: Pick<RsbuildConfig, 'source'>, options: SetupCompilationOptions, sourceFileCache?: SourceFileCache, angularCompilation?: AngularCompilation, modifiedFiles?: Set<string>): Promise<{
     angularCompilation: AngularCompilation;
     collectedStylesheetAssets: {
         path: string;
         text: string;
     }[];
+    collectedStylesheetMetafileInputs: StylesheetMetafileInputs[];
+    useTypeScriptTranspilation: boolean;
+    resourceDependencies: Map<string, readonly string[]>;
+    setupWarnings: string[];
 }>;
 //# sourceMappingURL=setup-with-angular-compilation.d.ts.map

package/dist/compilation/setup-with-angular-compilation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup-with-angular-compilation.d.ts","sourceRoot":"","sources":["../../src/compilation/setup-with-angular-compilation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAEL,kBAAkB,EAClB,eAAe,EAChB,MAAM,WAAW,CAAC;AACnB,OAAO,EAGL,uBAAuB,EAExB,MAAM,qBAAqB,CAAC;AAE7B,wBAAsB,sCAAsC,CAC1D,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,EACrC,OAAO,EAAE,uBAAuB,EAChC,eAAe,CAAC,EAAE,eAAe,EACjC,kBAAkB,CAAC,EAAE,kBAAkB,EACvC,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;;;cAkBoB,MAAM;cAAQ,MAAM;;GA2CpE"}
+{"version":3,"file":"setup-with-angular-compilation.d.ts","sourceRoot":"","sources":["../../src/compilation/setup-with-angular-compilation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAEL,kBAAkB,EAClB,eAAe,EAEhB,MAAM,WAAW,CAAC;AACnB,OAAO,EAGL,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAE7B;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnD;AAED,wBAAsB,sCAAsC,CAC1D,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,EACrC,OAAO,EAAE,uBAAuB,EAChC,eAAe,CAAC,EAAE,eAAe,EACjC,kBAAkB,CAAC,EAAE,kBAAkB,EACvC,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;;;cA0DoB,MAAM;cAAQ,MAAM;;;;;;GA+GpE"}

package/dist/compilation/setup-with-angular-compilation.js

@@ -1,11 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupCompilationWithAngularCompilation = setupCompilationWithAngularCompilation;
+const node_path_1 = require("node:path");
 const models_1 = require("../models");
 const setup_compilation_1 = require("./setup-compilation");
 async function setupCompilationWithAngularCompilation(config, options, sourceFileCache, angularCompilation, modifiedFiles) {
-    const { rootNames, compilerOptions, componentStylesheetBundler } = await (0, setup_compilation_1.setupCompilation)(config, options);
-    angularCompilation ?? (angularCompilation = await (0, models_1.createAngularCompilation)(!options.aot, !options.hasServer, false));
+    const { rootNames, compilerOptions, componentStylesheetBundler, setupWarnings, } = await (0, setup_compilation_1.setupCompilation)(config, options);
+    // Persist the TypeScript incremental state to the cache directory when one
+    // is available so later cold builds resume from it.
+    if (sourceFileCache?.persistentCachePath &&
+        compilerOptions.incremental !== false) {
+        compilerOptions.incremental = true;
+        compilerOptions.tsBuildInfoFile = (0, node_path_1.join)(sourceFileCache.persistentCachePath, '.tsbuildinfo');
+    }
+    else {
+        compilerOptions.incremental = false;
+    }
+    // Mirrors @angular/build's NG_BUILD_PARALLEL_TS switch: anything but
+    // 0/false runs the Angular compilation in a worker thread, so type
+    // checking overlaps with the bundling work.
+    const parallelTs = process.env['NG_BUILD_PARALLEL_TS'];
+    let createdAngularCompilation = false;
+    if (!angularCompilation) {
+        try {
+            angularCompilation = await (0, models_1.createAngularCompilation)(!options.aot, !options.hasServer, parallelTs !== '0' && parallelTs?.toLowerCase() !== 'false');
+        }
+        catch (error) {
+            attachSetupWarnings(error, setupWarnings);
+            throw error;
+        }
+        createdAngularCompilation = true;
+    }
+    // Drop the bundler's cached results for changed files so dependent
+    // stylesheets get rebuilt; there's nothing to invalidate on the first build.
+    if (modifiedFiles) {
+        componentStylesheetBundler.invalidate(modifiedFiles);
+    }
     modifiedFiles ?? (modifiedFiles = new Set(rootNames));
     const fileReplacements = options.fileReplacements.reduce((r, f) => {
         r[f.replace] = f.with;
@@ -13,34 +43,100 @@ async function setupCompilationWithAngularCompilation(config, options, sourceFil
     }, {});
     // Store collected stylesheet output files
     const collectedStylesheetAssets = [];
+    const collectedStylesheetMetafileInputs = [];
     // Create a wrapper around styleTransform to collect outputFiles
     const transformFn = (0, setup_compilation_1.styleTransform)(componentStylesheetBundler);
-    const wrappedTransformStylesheet = async (styles, containingFile, stylesheetFile) => {
+    const wrappedTransformStylesheet = async (styles, containingFile, stylesheetFile, order, className) => {
         const result = await transformFn(styles, containingFile, stylesheetFile);
         // Collect outputFiles if present
         if (result.outputFiles && result.outputFiles.length > 0) {
             collectedStylesheetAssets.push(...result.outputFiles);
         }
+        if (result.metafile) {
+            // Inline styles share the containing file; disambiguate with the
+            // class name and order so entries stay unique per stylesheet.
+            let source = stylesheetFile ?? containingFile;
+            if (!stylesheetFile) {
+                source += `?class=${className}&order=${order}`;
+            }
+            const inputs = {};
+            for (const output of Object.values(result.metafile.outputs)) {
+                Object.assign(inputs, output.inputs);
+            }
+            collectedStylesheetMetafileInputs.push({ source, inputs });
+        }
         // Return just the contents string as expected by Angular compilation
         return result.contents;
     };
-    // Initialization errors are intentionally not caught here: callers must
-    // surface them as build errors instead of continuing with a compilation
-    // that was never initialized.
-    const { referencedFiles } = await angularCompilation.initialize(config.source?.tsconfigPath ?? options.tsConfig, {
-        sourceFileCache,
-        fileReplacements,
-        modifiedFiles,
-        transformStylesheet: wrappedTransformStylesheet,
-        processWebWorker(workerFile) {
-            return workerFile;
-        },
-    }, () => compilerOptions);
+    // Initialization errors are rethrown for callers to surface as build
+    // errors instead of continuing with a compilation that was never
+    // initialized.
+    let initializationResult;
+    try {
+        initializationResult = await angularCompilation.initialize(config.source?.tsconfigPath ?? options.tsConfig, {
+            sourceFileCache,
+            fileReplacements,
+            modifiedFiles,
+            transformStylesheet: wrappedTransformStylesheet,
+            processWebWorker(workerFile) {
+                return workerFile;
+            },
+        }, () => compilerOptions);
+    }
+    catch (error) {
+        // A worker-based compilation spawns its worker thread on construction;
+        // close one created here or every failing setup would leak a worker.
+        // A caller-provided compilation stays alive for the caller to reuse.
+        if (createdAngularCompilation) {
+            try {
+                await angularCompilation.close?.();
+            }
+            catch {
+                // The initialization error is the one worth surfacing.
+            }
+        }
+        attachSetupWarnings(error, setupWarnings);
+        throw error;
+    }
+    const { compilerOptions: initializedCompilerOptions, referencedFiles, componentResourcesDependencies, } = initializationResult;
     if (sourceFileCache) {
         sourceFileCache.referencedFiles = referencedFiles;
     }
+    // The compiler already tracks each source file's template and stylesheet
+    // dependencies; re-key them like the emit cache so loaders can register
+    // watch dependencies without re-parsing sources. JIT compilations do not
+    // report them, and neither does @angular/build 20 in any mode, so both fall
+    // back to the URL resolvers.
+    let resourceDependencies;
+    if (componentResourcesDependencies) {
+        resourceDependencies = new Map();
+        for (const [file, dependencies] of componentResourcesDependencies) {
+            resourceDependencies.set((0, models_1.toTypeScriptFileCacheKey)(file), dependencies);
+        }
+    }
+    // Only the AOT emit branches between TypeScript transpilation and raw
+    // Angular-transformed TypeScript, on this exact expression over the
+    // program's options (JIT always transpiles). The loaders classify the
+    // emitted cache entries with this flag, so it must never diverge from the
+    // emit's gate. The worker-based initialize reports only four options; the
+    // three the gate reads are among them, and any other option would be
+    // undefined here.
+    const useTypeScriptTranspilation = !initializedCompilerOptions?.isolatedModules ||
+        !!initializedCompilerOptions?.sourceMap ||
+        !!initializedCompilerOptions?.inlineSourceMap;
     return {
         angularCompilation,
         collectedStylesheetAssets,
+        collectedStylesheetMetafileInputs,
+        useTypeScriptTranspilation,
+        resourceDependencies,
+        setupWarnings,
     };
 }
+// Callers report initialization failures as build errors; hand them the
+// setup warnings so they are not lost with the failed build.
+function attachSetupWarnings(error, setupWarnings) {
+    if (error && typeof error === 'object') {
+        error.setupWarnings = setupWarnings;
+    }
+}

package/dist/models/index.d.ts

@@ -1,5 +1,6 @@
-import { JavaScriptTransformer, SourceFileCache, AngularCompilation, createAngularCompilation } from '@angular/build/private';
-export { JavaScriptTransformer, SourceFileCache, AngularCompilation, createAngularCompilation, };
+import { JavaScriptTransformer, AngularCompilation, createAngularCompilation } from '@angular/build/private';
+export { JavaScriptTransformer, AngularCompilation, createAngularCompilation };
+export { SourceFileCache, toTypeScriptFileCacheKey, type BabelFileCacheEntry, type TransformedSource, } from '../utils/source-file-cache';
 export * from './inline-style-language';
 export * from './file-replacement';
 export * from './style-preprocessor-options';

package/dist/models/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,wBAAwB,GACzB,CAAC;AAEF,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAE7C,oBAAY,eAAe;IACzB,IAAI,IAAI;IACR,MAAM,IAAS;IACf,SAAS,IAAS;IAClB,QAAQ,IAAS;IACjB,GAAG,IAAgC;CACpC;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IACpC,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,KAAK,CAAC;CAChB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,CAAC;AAC/E,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,GACvB,MAAM,4BAA4B,CAAC;AAEpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAE7C,oBAAY,eAAe;IACzB,IAAI,IAAI;IACR,MAAM,IAAS;IACf,SAAS,IAAS;IAClB,QAAQ,IAAS;IACjB,GAAG,IAAgC;CACpC;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IACpC,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,KAAK,CAAC;CAChB"}

package/dist/models/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagnosticModes = exports.createAngularCompilation = exports.SourceFileCache = exports.JavaScriptTransformer = void 0;
+exports.DiagnosticModes = exports.toTypeScriptFileCacheKey = exports.SourceFileCache = exports.createAngularCompilation = exports.JavaScriptTransformer = void 0;
 const tslib_1 = require("tslib");
 const private_1 = require("@angular/build/private");
 Object.defineProperty(exports, "JavaScriptTransformer", { enumerable: true, get: function () { return private_1.JavaScriptTransformer; } });
-Object.defineProperty(exports, "SourceFileCache", { enumerable: true, get: function () { return private_1.SourceFileCache; } });
 Object.defineProperty(exports, "createAngularCompilation", { enumerable: true, get: function () { return private_1.createAngularCompilation; } });
+var source_file_cache_1 = require("../utils/source-file-cache");
+Object.defineProperty(exports, "SourceFileCache", { enumerable: true, get: function () { return source_file_cache_1.SourceFileCache; } });
+Object.defineProperty(exports, "toTypeScriptFileCacheKey", { enumerable: true, get: function () { return source_file_cache_1.toTypeScriptFileCacheKey; } });
 tslib_1.__exportStar(require("./inline-style-language"), exports);
 tslib_1.__exportStar(require("./file-replacement"), exports);
 tslib_1.__exportStar(require("./style-preprocessor-options"), exports);

package/dist/utils/component-resolvers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-resolvers.d.ts","sourceRoot":"","sources":["../../src/utils/component-resolvers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAYH,qBAAa,iBAAiB;IAK5B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA0C;IAEzE,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CA6B1C;CACF;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,YASxC;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,YAO3C;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAG9B;IAEJ,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAa1C;CACF"}
+{"version":3,"file":"component-resolvers.d.ts","sourceRoot":"","sources":["../../src/utils/component-resolvers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAWH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA0C;IAEzE,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAoB1C;CACF;AAgFD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAGnD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEtD;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAG9B;IAEJ,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAa1C;CACF"}

package/dist/utils/component-resolvers.js

@@ -27,29 +27,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateUrlsResolver = exports.StyleUrlsResolver = void 0;
 exports.getStyleUrls = getStyleUrls;
 exports.getTemplateUrls = getTemplateUrls;
+const tslib_1 = require("tslib");
 const node_path_1 = require("node:path");
-const ts_morph_1 = require("ts-morph");
+const ts = tslib_1.__importStar(require("typescript"));
 const path_1 = require("path");
-const utils_1 = require("./utils");
 class StyleUrlsResolver {
     constructor() {
-        // These resolvers may be called multiple times during the same
-        // compilation for the same files. Caching is required because these
-        // resolvers use synchronous system calls to the filesystem, which can
-        // degrade performance when running compilations for multiple files.
         this.styleUrlsCache = new Map();
     }
     resolve(code, id) {
-        // Given the code is the following:
-        // @Component({
-        //   styleUrls: [
-        //     './app.component.scss'
-        //   ]
-        // })
-        // The `matchedStyleUrls` would result in: `styleUrls: [\n    './app.component.scss'\n  ]`.
-        const matchedStyleUrls = getStyleUrls(code)
-            // for type narrowing
-            .filter((v) => v !== undefined);
+        const matchedStyleUrls = getStyleUrls(code);
         const entry = this.styleUrlsCache.get(id);
         // We're using `matchedStyleUrls` as a key because the code may be changing continuously,
         // resulting in the resolver being called multiple times. While the code changes, the
@@ -67,19 +54,69 @@ class StyleUrlsResolver {
     }
 }
 exports.StyleUrlsResolver = StyleUrlsResolver;
+let lastScan;
+// These resolvers run only when the Angular compilation did not report the
+// component's resource dependencies, so they follow @angular/build's JIT
+// resource transformer: a resource becomes a module only when its URL is a
+// plain string literal, and anything else names no file to watch. Empty is
+// skipped for all three properties because it resolves to the component's own
+// directory rather than a file; Angular skips it for `templateUrl` and
+// `styleUrls` entries but not for `styleUrl`.
+function collectUrl(urls, node) {
+    if (ts.isStringLiteralLike(node) && node.text) {
+        urls.push(node.text);
+    }
+}
+// Both resolvers run back to back on the same source in the rspack loader, so
+// the last scan is memoized to parse each file once instead of twice.
+function scanComponentResources(code) {
+    if (lastScan !== undefined && lastScan.code === code) {
+        return lastScan.resources;
+    }
+    const sourceFile = ts.createSourceFile('cmp.ts', code, ts.ScriptTarget.Latest, 
+    // parent pointers are unused: every value below is read off the node itself
+    false, ts.ScriptKind.TS);
+    const styleUrl = [];
+    const styleUrls = [];
+    const templateUrl = [];
+    // Every property assignment in the file is considered, not just the ones in a
+    // @Component decorator: Angular identifies that decorator by resolving its
+    // symbol to @angular/core, which needs a type checker this parse has no
+    // program for.
+    const visit = (node) => {
+        if (ts.isPropertyAssignment(node) &&
+            // identifier and quoted keys name the same property, computed ones are
+            // dropped, matching how Angular reflects @Component metadata
+            (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name))) {
+            const name = node.name.text;
+            if (name === 'styleUrl') {
+                collectUrl(styleUrl, node.initializer);
+            }
+            else if (name === 'templateUrl') {
+                collectUrl(templateUrl, node.initializer);
+            }
+            else if (name === 'styleUrls' &&
+                ts.isArrayLiteralExpression(node.initializer)) {
+                for (const element of node.initializer.elements) {
+                    collectUrl(styleUrls, element);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    const resources = { styleUrl, styleUrls, templateUrl };
+    lastScan = { code, resources };
+    return resources;
+}
+// the explicit return types keep the memoized `readonly string[]` arrays from
+// being handed to callers unspread
 function getStyleUrls(code) {
-    const project = new ts_morph_1.Project({ useInMemoryFileSystem: true });
-    const sourceFile = project.createSourceFile('cmp.ts', code);
-    const properties = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
-    const styleUrl = (0, utils_1.getTextByProperty)('styleUrl', properties);
-    const styleUrls = (0, utils_1.getAllTextByProperty)('styleUrls', properties);
+    const { styleUrl, styleUrls } = scanComponentResources(code);
     return [...styleUrls, ...styleUrl];
 }
 function getTemplateUrls(code) {
-    const project = new ts_morph_1.Project({ useInMemoryFileSystem: true });
-    const sourceFile = project.createSourceFile('cmp.ts', code);
-    const properties = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
-    return (0, utils_1.getTextByProperty)('templateUrl', properties);
+    return [...scanComponentResources(code).templateUrl];
 }
 class TemplateUrlsResolver {
     constructor() {

package/dist/utils/index.d.ts

@@ -1,5 +1,7 @@
 export * from './regex-filters';
 export * from './component-resolvers';
+export * from './javascript-transformer-cache';
 export * from './load-compiler-cli';
+export * from './typescript-compiler-options';
 export { maxWorkers } from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/utils/index.js

@@ -4,6 +4,8 @@ exports.maxWorkers = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./regex-filters"), exports);
 tslib_1.__exportStar(require("./component-resolvers"), exports);
+tslib_1.__exportStar(require("./javascript-transformer-cache"), exports);
 tslib_1.__exportStar(require("./load-compiler-cli"), exports);
+tslib_1.__exportStar(require("./typescript-compiler-options"), exports);
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "maxWorkers", { enumerable: true, get: function () { return utils_1.maxWorkers; } });

package/dist/utils/javascript-transformer-cache.d.ts

@@ -0,0 +1,18 @@
+import type { Cache } from '@angular/build/private';
+export interface JavascriptTransformerCache {
+    cache: Cache<Uint8Array>;
+    close(): Promise<void>;
+}
+/**
+ * Creates the persistent store the esbuild application builder uses for
+ * `JavaScriptTransformer` results, so Angular package linking is only paid
+ * on the first build with a given cache directory.
+ *
+ * The LMDB-backed store is not part of `@angular/build`'s exported API and
+ * its exports map blocks subpath imports, so it is loaded from the resolved
+ * package location. Returns `undefined` when it cannot be loaded (older
+ * `@angular/build` versions, platforms without lmdb prebuilds), in which
+ * case the transformer runs uncached.
+ */
+export declare function createJavascriptTransformerCache(persistentCachePath: string): JavascriptTransformerCache | undefined;
+//# sourceMappingURL=javascript-transformer-cache.d.ts.map

package/dist/utils/javascript-transformer-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-transformer-cache.d.ts","sourceRoot":"","sources":["../../src/utils/javascript-transformer-cache.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAEpD,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC9C,mBAAmB,EAAE,MAAM,GAC1B,0BAA0B,GAAG,SAAS,CAmBxC"}

package/dist/utils/javascript-transformer-cache.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJavascriptTransformerCache = createJavascriptTransformerCache;
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+/**
+ * Creates the persistent store the esbuild application builder uses for
+ * `JavaScriptTransformer` results, so Angular package linking is only paid
+ * on the first build with a given cache directory.
+ *
+ * The LMDB-backed store is not part of `@angular/build`'s exported API and
+ * its exports map blocks subpath imports, so it is loaded from the resolved
+ * package location. Returns `undefined` when it cannot be loaded (older
+ * `@angular/build` versions, platforms without lmdb prebuilds), in which
+ * case the transformer runs uncached.
+ */
+function createJavascriptTransformerCache(persistentCachePath) {
+    try {
+        const requireFn = (0, node_module_1.createRequire)(__filename);
+        const angularBuildDir = (0, node_path_1.dirname)(requireFn.resolve('@angular/build/package.json'));
+        const { LmdbCacheStore } = requireFn((0, node_path_1.join)(angularBuildDir, 'src/tools/esbuild/lmdb-cache-store.js'));
+        const store = new LmdbCacheStore((0, node_path_1.join)(persistentCachePath, 'angular-compiler.db'));
+        return {
+            cache: store.createCache('jstransformer'),
+            close: () => store.close(),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/utils/regex-filters.d.ts

@@ -1,4 +1,6 @@
 export declare const TS_ALL_EXT_REGEX: RegExp;
+export declare const TS_EXT_REGEX: RegExp;
+export declare const TSX_EXT_REGEX: RegExp;
 export declare const JS_ALL_EXT_REGEX: RegExp;
 export declare const JS_EXT_REGEX: RegExp;
 export declare function isStandardJsFile(filename: string): boolean;

package/dist/utils/regex-filters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regex-filters.d.ts","sourceRoot":"","sources":["../../src/utils/regex-filters.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,QAAsB,CAAC;AACpD,eAAO,MAAM,gBAAgB,QAAsB,CAAC;AACpD,eAAO,MAAM,YAAY,QAAe,CAAC;AAEzC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,WAEhD"}
+{"version":3,"file":"regex-filters.d.ts","sourceRoot":"","sources":["../../src/utils/regex-filters.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,QAAsB,CAAC;AACpD,eAAO,MAAM,YAAY,QAAoB,CAAC;AAC9C,eAAO,MAAM,aAAa,QAAgB,CAAC;AAC3C,eAAO,MAAM,gBAAgB,QAAsB,CAAC;AACpD,eAAO,MAAM,YAAY,QAAe,CAAC;AAEzC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,WAEhD"}

package/dist/utils/regex-filters.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JS_EXT_REGEX = exports.JS_ALL_EXT_REGEX = exports.TS_ALL_EXT_REGEX = void 0;
+exports.JS_EXT_REGEX = exports.JS_ALL_EXT_REGEX = exports.TSX_EXT_REGEX = exports.TS_EXT_REGEX = exports.TS_ALL_EXT_REGEX = void 0;
 exports.isStandardJsFile = isStandardJsFile;
 exports.TS_ALL_EXT_REGEX = /\.[cm]?tsx?(\?|$)/;
+exports.TS_EXT_REGEX = /\.[cm]?ts(\?|$)/;
+exports.TSX_EXT_REGEX = /\.tsx(\?|$)/;
 exports.JS_ALL_EXT_REGEX = /\.[cm]?jsx?(\?|$)/;
 exports.JS_EXT_REGEX = /\.[cm]?js$/;
 function isStandardJsFile(filename) {

package/dist/utils/source-file-cache.d.ts

@@ -6,13 +6,54 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import type ts from 'typescript';
+/**
+ * Angular compilation output after the JavaScript transformer has run, with
+ * any inline sourcemap already split off the code.
+ */
+export interface TransformedSource {
+    code: string;
+    map: string | undefined;
+}
+/**
+ * A {@link TransformedSource} produced under a specific loader-chained input
+ * sourcemap. The JavaScript transformer reads and merges a file's external
+ * sourcemap itself, so the entry is only valid while that map is unchanged;
+ * `chainedMap` holds the serialized map the entry was produced with.
+ */
+export interface BabelFileCacheEntry extends TransformedSource {
+    chainedMap: string | undefined;
+}
+/**
+ * Key used by `typeScriptFileCache`: the normalized path with any Windows
+ * drive letter stripped, so emitted filenames and loader resource paths match.
+ */
+export declare function toTypeScriptFileCacheKey(file: string): string;
 export declare class SourceFileCache extends Map<string, ts.SourceFile> {
     readonly persistentCachePath?: string;
     readonly modifiedFiles: Set<string>;
-    readonly babelFileCache: Map<string, Uint8Array<ArrayBufferLike>>;
-    readonly typeScriptFileCache: Map<string, string | Uint8Array<ArrayBufferLike>>;
+    /**
+     * Emitted build output keyed by {@link toTypeScriptFileCacheKey}. A `string`
+     * entry is the raw, untransformed emit; the loaders replace it in place with
+     * a {@link TransformedSource} once the JavaScript transformer has run.
+     * Overwriting an entry with a fresh raw emit evicts the stale transform.
+     */
+    readonly typeScriptFileCache: Map<string, string | TransformedSource>;
+    /**
+     * JavaScript transformer output for files outside the Angular compilation
+     * (e.g. package code), split into code and forwarded sourcemap, keyed by
+     * {@link toTypeScriptFileCacheKey}. These are never re-emitted, so
+     * modifying a file must evict its entry; a changed chained input map
+     * invalidates an entry at the consumer instead (see
+     * {@link BabelFileCacheEntry}).
+     */
+    readonly babelFileCache: Map<string, BabelFileCacheEntry>;
     referencedFiles?: readonly string[];
     constructor(persistentCachePath?: string);
     invalidate(files: Iterable<string>): void;
+    /**
+     * Drops output cached for files deleted from disk. Modified files don't
+     * need this for emitted output: their next emit overwrites the entry.
+     */
+    prune(removedFiles: Iterable<string>): void;
 }
 //# sourceMappingURL=source-file-cache.d.ts.map

package/dist/utils/source-file-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-file-cache.d.ts","sourceRoot":"","sources":["../../src/utils/source-file-cache.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAKjC,qBAAa,eAAgB,SAAQ,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC;IAOjD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM;IANjD,QAAQ,CAAC,aAAa,cAAqB;IAC3C,QAAQ,CAAC,cAAc,2CAAiC;IACxD,QAAQ,CAAC,mBAAmB,oDAA0C;IAEtE,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAEpC,YAAqB,mBAAmB,CAAC,EAAE,MAAM,EAEhD;IAED,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAgBxC;CACF"}
+{"version":3,"file":"source-file-cache.d.ts","sourceRoot":"","sources":["../../src/utils/source-file-cache.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAKjC;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,qBAAa,eAAgB,SAAQ,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC;IAuBjD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM;IAtBjD,QAAQ,CAAC,aAAa,cAAqB;IAE3C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,0CAAiD;IAE7E;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,mCAA0C;IAEjE,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAEpC,YAAqB,mBAAmB,CAAC,EAAE,MAAM,EAEhD;IAED,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAiBxC;IAED;;;OAGG;IACH,KAAK,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAM1C;CACF"}

package/dist/utils/source-file-cache.js

@@ -8,26 +8,47 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SourceFileCache = void 0;
+exports.toTypeScriptFileCacheKey = toTypeScriptFileCacheKey;
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("node:path"));
-const node_url_1 = require("node:url");
 const utils_1 = require("./utils");
 const WINDOWS_SEP_REGEXP = new RegExp(`\\${path.win32.sep}`, 'g');
+/**
+ * Key used by `typeScriptFileCache`: the normalized path with any Windows
+ * drive letter stripped, so emitted filenames and loader resource paths match.
+ */
+function toTypeScriptFileCacheKey(file) {
+    return path.normalize(file.replace(/^[A-Z]:/, ''));
+}
 class SourceFileCache extends Map {
     constructor(persistentCachePath) {
         super();
         this.persistentCachePath = persistentCachePath;
         this.modifiedFiles = new Set();
-        this.babelFileCache = new Map();
+        /**
+         * Emitted build output keyed by {@link toTypeScriptFileCacheKey}. A `string`
+         * entry is the raw, untransformed emit; the loaders replace it in place with
+         * a {@link TransformedSource} once the JavaScript transformer has run.
+         * Overwriting an entry with a fresh raw emit evicts the stale transform.
+         */
         this.typeScriptFileCache = new Map();
+        /**
+         * JavaScript transformer output for files outside the Angular compilation
+         * (e.g. package code), split into code and forwarded sourcemap, keyed by
+         * {@link toTypeScriptFileCacheKey}. These are never re-emitted, so
+         * modifying a file must evict its entry; a changed chained input map
+         * invalidates an entry at the consumer instead (see
+         * {@link BabelFileCacheEntry}).
+         */
+        this.babelFileCache = new Map();
     }
     invalidate(files) {
         if (files !== this.modifiedFiles) {
             this.modifiedFiles.clear();
         }
         for (let file of files) {
-            this.babelFileCache.delete(file);
-            this.typeScriptFileCache.delete((0, node_url_1.pathToFileURL)(file).href);
+            this.babelFileCache.delete(toTypeScriptFileCacheKey(file));
+            file = path.normalize(file);
             // Normalize separators to allow matching TypeScript Host paths
             if ((0, utils_1.isUsingWindows)()) {
                 file = file.replace(WINDOWS_SEP_REGEXP, path.posix.sep);
@@ -36,5 +57,16 @@ class SourceFileCache extends Map {
             this.modifiedFiles.add(file);
         }
     }
+    /**
+     * Drops output cached for files deleted from disk. Modified files don't
+     * need this for emitted output: their next emit overwrites the entry.
+     */
+    prune(removedFiles) {
+        for (const file of removedFiles) {
+            const key = toTypeScriptFileCacheKey(file);
+            this.typeScriptFileCache.delete(key);
+            this.babelFileCache.delete(key);
+        }
+    }
 }
 exports.SourceFileCache = SourceFileCache;

package/dist/utils/typescript-compiler-options.d.ts

@@ -0,0 +1,41 @@
+import * as ts from 'typescript';
+/**
+ * Raises `target` to ES2022, the syntax the bundling pipeline emits
+ * regardless of the configured target, defaulting `useDefineForClassFields`
+ * to `false` in that case to keep the assignment semantics a lower target
+ * implied. Returns whether the options were adjusted so callers can surface
+ * a setup warning.
+ */
+export declare function applyEs2022TargetDefaults(compilerOptions: ts.CompilerOptions): boolean;
+/**
+ * The `jsc.transform` options for the swc rule that transpiles TypeScript
+ * emitted by the Angular compilation (and raw sources), derived from the
+ * project's tsconfig so the output keeps the semantics the type program
+ * assumed.
+ */
+export interface SwcTranspilationTransform {
+    legacyDecorator: boolean;
+    /**
+     * The revision applied for standard (TC39) decorators
+     * (`legacyDecorator: false`); swc's default revision predates the
+     * semantics TypeScript implements.
+     */
+    decoratorVersion?: '2022-03' | '2023-11';
+    decoratorMetadata: boolean;
+    useDefineForClassFields: boolean;
+    verbatimModuleSyntax: boolean;
+    /**
+     * JSX lowering for `.tsx` sources, read from the tsconfig the way esbuild
+     * does: the automatic runtime for 'react-jsx'/'react-jsxdev', the classic
+     * transform otherwise ('preserve' included; esbuild lowers it too).
+     */
+    react: {
+        runtime: 'automatic' | 'classic';
+        development: boolean;
+        pragma?: string;
+        pragmaFrag?: string;
+        importSource?: string;
+    };
+}
+export declare function resolveSwcTranspilationTransform(tsconfigPath: string, standardDecoratorVersion: '2022-03' | '2023-11'): SwcTranspilationTransform;
+//# sourceMappingURL=typescript-compiler-options.d.ts.map

package/dist/utils/typescript-compiler-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-compiler-options.d.ts","sourceRoot":"","sources":["../../src/utils/typescript-compiler-options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,eAAe,EAAE,EAAE,CAAC,eAAe,GAClC,OAAO,CAUT;AAED;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,eAAe,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IACzC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,uBAAuB,EAAE,OAAO,CAAC;IACjC,oBAAoB,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,KAAK,EAAE;QACL,OAAO,EAAE,WAAW,GAAG,SAAS,CAAC;QACjC,WAAW,EAAE,OAAO,CAAC;QACrB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,wBAAgB,gCAAgC,CAC9C,YAAY,EAAE,MAAM,EACpB,wBAAwB,EAAE,SAAS,GAAG,SAAS,GAC9C,yBAAyB,CAiC3B"}

package/dist/utils/typescript-compiler-options.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyEs2022TargetDefaults = applyEs2022TargetDefaults;
+exports.resolveSwcTranspilationTransform = resolveSwcTranspilationTransform;
+const tslib_1 = require("tslib");
+const node_path_1 = require("node:path");
+const ts = tslib_1.__importStar(require("typescript"));
+/**
+ * Raises `target` to ES2022, the syntax the bundling pipeline emits
+ * regardless of the configured target, defaulting `useDefineForClassFields`
+ * to `false` in that case to keep the assignment semantics a lower target
+ * implied. Returns whether the options were adjusted so callers can surface
+ * a setup warning.
+ */
+function applyEs2022TargetDefaults(compilerOptions) {
+    if (compilerOptions.target === undefined ||
+        compilerOptions.target < ts.ScriptTarget.ES2022) {
+        compilerOptions.target = ts.ScriptTarget.ES2022;
+        compilerOptions.useDefineForClassFields ?? (compilerOptions.useDefineForClassFields = false);
+        return true;
+    }
+    return false;
+}
+function resolveSwcTranspilationTransform(tsconfigPath, standardDecoratorVersion) {
+    // Read errors are reported in-band and deliberately ignored: a missing or
+    // malformed tsconfig recovers to the forced defaults here, and the build
+    // still fails through rspack's own resolution of the same tsconfig path.
+    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    const compilerOptions = {
+        ...ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, node_path_1.dirname)(tsconfigPath)).options,
+    };
+    applyEs2022TargetDefaults(compilerOptions);
+    const legacyDecorator = !!compilerOptions.experimentalDecorators;
+    return {
+        legacyDecorator,
+        ...(legacyDecorator ? {} : { decoratorVersion: standardDecoratorVersion }),
+        // Design-type metadata comes from the type checker; swc emits what the
+        // annotations alone provide, which is as much as a per-file transpiler
+        // can honor.
+        decoratorMetadata: legacyDecorator && !!compilerOptions.emitDecoratorMetadata,
+        // With the target raised to ES2022 the forced default is false; an
+        // ES2022+ tsconfig without the option gets TypeScript's default. For a
+        // target-less tsconfig esbuild instead uses its own default of true,
+        // contradicting the program options it forces; we follow the program.
+        useDefineForClassFields: compilerOptions.useDefineForClassFields ?? true,
+        verbatimModuleSyntax: !!compilerOptions.verbatimModuleSyntax,
+        react: resolveJsxTransform(compilerOptions),
+    };
+}
+// swc's factory defaults (React.createElement, React.Fragment, 'react')
+// match esbuild's, so the options are only set when the tsconfig sets them.
+function resolveJsxTransform(compilerOptions) {
+    const { jsx, jsxFactory, jsxFragmentFactory, jsxImportSource } = compilerOptions;
+    return {
+        runtime: jsx === ts.JsxEmit.ReactJSX || jsx === ts.JsxEmit.ReactJSXDev
+            ? 'automatic'
+            : 'classic',
+        development: jsx === ts.JsxEmit.ReactJSXDev,
+        ...(jsxFactory ? { pragma: jsxFactory } : {}),
+        ...(jsxFragmentFactory ? { pragmaFrag: jsxFragmentFactory } : {}),
+        ...(jsxImportSource ? { importSource: jsxImportSource } : {}),
+    };
+}

package/dist/utils/utils.d.ts

@@ -1,8 +1,4 @@
-import { PropertyAssignment } from 'ts-morph';
 export declare const isUsingWindows: () => boolean;
-export declare function getTextByProperty(name: string, properties: PropertyAssignment[]): string[];
-export declare function getAllTextByProperty(name: string, properties: PropertyAssignment[]): string[];
-export declare function normalizeQuotes(str?: string): string;
 export declare function isPresent(variable: string | undefined): variable is string;
 export declare function parseMaxWorkers(value: string | undefined): number | null;
 export declare const maxWorkers: () => number;

package/dist/utils/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAA0B,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGtE,eAAO,MAAM,cAAc,eAA+B,CAAC;AAE3D,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,kBAAkB,EAAE,YAMjC;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,kBAAkB,EAAE,YAQjC;AAED,wBAAgB,eAAe,CAAC,GAAG,CAAC,EAAE,MAAM,UAE3C;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,IAAI,MAAM,CAE1E;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAIxE;AAED,eAAO,MAAM,UAAU,cAKtB,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,eAA+B,CAAC;AAE3D,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,IAAI,MAAM,CAE1E;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAIxE;AAED,eAAO,MAAM,UAAU,cAKtB,CAAC"}

package/dist/utils/utils.js

@@ -1,30 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.maxWorkers = exports.isUsingWindows = void 0;
-exports.getTextByProperty = getTextByProperty;
-exports.getAllTextByProperty = getAllTextByProperty;
-exports.normalizeQuotes = normalizeQuotes;
 exports.isPresent = isPresent;
 exports.parseMaxWorkers = parseMaxWorkers;
 const node_os_1 = require("node:os");
 const constants_1 = require("./constants");
 const isUsingWindows = () => (0, node_os_1.platform)() === 'win32';
 exports.isUsingWindows = isUsingWindows;
-function getTextByProperty(name, properties) {
-    return properties
-        .filter((property) => property.getName() === name)
-        .map((property) => normalizeQuotes(property.getInitializer()?.getText()))
-        .filter((url) => url !== undefined);
-}
-function getAllTextByProperty(name, properties) {
-    return properties
-        .filter((property) => property.getName() === name)
-        .map((property) => property.getInitializer())
-        .flatMap((array) => array.getElements().map((el) => normalizeQuotes(el.getText())));
-}
-function normalizeQuotes(str) {
-    return str ? str.replace(/['"`]/g, '') : str;
-}
 function isPresent(variable) {
     return typeof variable === 'string' && variable.trim() !== '';
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/angular-rspack-compiler",
   "private": false,
-  "version": "23.2.0-beta.1",
+  "version": "23.2.0-beta.11",
   "publishConfig": {
     "access": "public"
   },
@@ -42,10 +42,9 @@
   "dependencies": {
     "sass-embedded": "^1.97.2",
     "semver": "^7.6.3",
-    "ts-morph": "^28.0.0",
     "tslib": "^2.3.0",
     "typescript": "~6.0.3",
-    "@nx/devkit": "23.2.0-beta.1"
+    "@nx/devkit": "23.2.0-beta.11"
   },
   "devDependencies": {
     "jsonc-eslint-parser": "^2.4.0",

package/patch/patch-angular-build.js

@@ -3,9 +3,8 @@ const { gte, coerce } = require('semver');
 const { dirname, join } = require('path');
 
 function main() {
-  const angularBuildPackageJson = require.resolve(
-    '@angular/build/package.json'
-  );
+  const angularBuildPackageJson =
+    require.resolve('@angular/build/package.json');
   const fileContentsJson = JSON.parse(
     readFileSync(angularBuildPackageJson, 'utf8')
   );