@nx/angular-rspack 23.1.0 → 23.1.1

package/dist/lib/plugins/extract-licenses-plugin.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractLicensesPlugin = void 0;
+exports.extractLicenses = extractLicenses;
+const tslib_1 = require("tslib");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const models_1 = require("../models");
+/**
+ * The path segment used to signify that a file is part of a package.
+ */
+const NODE_MODULE_SEGMENT = 'node_modules';
+/**
+ * String constant for the NPM recommended custom license wording.
+ *
+ * See: https://docs.npmjs.com/cli/v9/configuring-npm/package-json#license
+ *
+ * Example:
+ * ```
+ * {
+ *   "license" : "SEE LICENSE IN <filename>"
+ * }
+ * ```
+ */
+const CUSTOM_LICENSE_TEXT = 'SEE LICENSE IN ';
+/**
+ * A list of commonly named license files found within packages.
+ */
+const LICENSE_FILES = ['LICENSE', 'LICENSE.txt', 'LICENSE.md'];
+/**
+ * Header text that will be added to the top of the output license extraction file.
+ */
+const EXTRACTION_FILE_HEADER = '';
+/**
+ * The package entry separator to use within the output license extraction file.
+ */
+const EXTRACTION_FILE_SEPARATOR = '-'.repeat(80) + '\n';
+/**
+ * Extracts license information for each node module package included in the output
+ * files of the built code. This includes JavaScript and CSS output files. The esbuild
+ * metafile generated during the bundling steps is used as the source of information
+ * regarding what input files where included and where they are located. A path segment
+ * of `node_modules` is used to indicate that a file belongs to a package and its license
+ * should be include in the output licenses file.
+ *
+ * The package name and license field are extracted from the `package.json` file for the
+ * package. If a license file (e.g., `LICENSE`) is present in the root of the package, it
+ * will also be included in the output licenses file.
+ *
+ * Vendored from `@angular/build` (`src/tools/esbuild/license-extractor.ts`, identical
+ * across the supported Angular majors) since it is not exposed in the package's public
+ * or private API. Only the esbuild `Metafile` type import is replaced with the local
+ * `LicenseMetafile` interface.
+ *
+ * @param metafile An esbuild metafile object.
+ * @param rootDirectory The root directory of the workspace.
+ * @returns A string containing the content of the output licenses file.
+ */
+async function extractLicenses(metafile, rootDirectory) {
+    let extractedLicenseContent = `${EXTRACTION_FILE_HEADER}\n${EXTRACTION_FILE_SEPARATOR}`;
+    const seenPaths = new Set();
+    const seenPackages = new Set();
+    for (const entry of Object.values(metafile.outputs)) {
+        for (const [inputPath, { bytesInOutput }] of Object.entries(entry.inputs)) {
+            // Skip if not included in output
+            if (bytesInOutput <= 0) {
+                continue;
+            }
+            // Skip already processed paths
+            if (seenPaths.has(inputPath)) {
+                continue;
+            }
+            seenPaths.add(inputPath);
+            // Skip non-package paths
+            if (!inputPath.includes(NODE_MODULE_SEGMENT)) {
+                continue;
+            }
+            // Extract the package name from the path
+            let baseDirectory = node_path_1.default.join(rootDirectory, inputPath);
+            let nameOrScope, nameOrFile;
+            let found = false;
+            while (baseDirectory !== node_path_1.default.dirname(baseDirectory)) {
+                const segment = node_path_1.default.basename(baseDirectory);
+                if (segment === NODE_MODULE_SEGMENT) {
+                    found = true;
+                    break;
+                }
+                nameOrFile = nameOrScope;
+                nameOrScope = segment;
+                baseDirectory = node_path_1.default.dirname(baseDirectory);
+            }
+            // Skip non-package path edge cases that are not caught in the includes check above
+            if (!found || !nameOrScope) {
+                continue;
+            }
+            const packageName = nameOrScope.startsWith('@')
+                ? `${nameOrScope}/${nameOrFile}`
+                : nameOrScope;
+            const packageDirectory = node_path_1.default.join(baseDirectory, packageName);
+            // Load the package's metadata to find the package's name, version, and license type
+            const packageJsonPath = node_path_1.default.join(packageDirectory, 'package.json');
+            let packageJson;
+            try {
+                packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonPath, 'utf-8'));
+            }
+            catch {
+                // Invalid package
+                continue;
+            }
+            // Skip already processed packages
+            const packageId = `${packageName}@${packageJson.version}`;
+            if (seenPackages.has(packageId)) {
+                continue;
+            }
+            seenPackages.add(packageId);
+            // Attempt to find license text inside package
+            let licenseText = '';
+            if (typeof packageJson.license === 'string' &&
+                packageJson.license.toLowerCase().startsWith(CUSTOM_LICENSE_TEXT)) {
+                // Attempt to load the package's custom license
+                let customLicensePath;
+                const customLicenseFile = node_path_1.default.normalize(packageJson.license.slice(CUSTOM_LICENSE_TEXT.length + 1).trim());
+                if (customLicenseFile.startsWith('..') ||
+                    node_path_1.default.isAbsolute(customLicenseFile)) {
+                    // Path is attempting to access files outside of the package
+                    // TODO: Issue warning?
+                }
+                else {
+                    customLicensePath = node_path_1.default.join(packageDirectory, customLicenseFile);
+                    try {
+                        licenseText = await (0, promises_1.readFile)(customLicensePath, 'utf-8');
+                        break;
+                    }
+                    catch { }
+                }
+            }
+            else {
+                // Search for a license file within the root of the package
+                for (const potentialLicense of LICENSE_FILES) {
+                    const packageLicensePath = node_path_1.default.join(packageDirectory, potentialLicense);
+                    try {
+                        licenseText = await (0, promises_1.readFile)(packageLicensePath, 'utf-8');
+                        break;
+                    }
+                    catch { }
+                }
+            }
+            // Generate the package's license entry in the output content
+            extractedLicenseContent += `Package: ${packageJson.name}\n`;
+            extractedLicenseContent += `License: ${JSON.stringify(packageJson.license, null, 2)}\n`;
+            extractedLicenseContent += `\n${licenseText}\n`;
+            extractedLicenseContent += EXTRACTION_FILE_SEPARATOR;
+        }
+    }
+    return extractedLicenseContent;
+}
+const PLUGIN_NAME = 'angular-extract-licenses-plugin';
+/**
+ * Emits a licenses file for the node module packages included in the output,
+ * mirroring the `@angular/build` application builder's `extractLicenses`
+ * behavior and output. Feeds the chunk graph's module paths to the vendored
+ * extractor in place of an esbuild metafile.
+ */
+class ExtractLicensesPlugin {
+    constructor(options) {
+        this.options = options;
+        this.sharedInputs = options.sharedInputs ?? new Map();
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: compiler.rspack.Compilation.PROCESS_ASSETS_STAGE_REPORT,
+            }, async () => {
+                const { outputFilename, rootDirectory } = this.options;
+                const inputs = {};
+                for (const chunk of compilation.chunks) {
+                    for (const module of compilation.chunkGraph.getChunkModulesIterable(chunk)) {
+                        // Concatenated modules (production) wrap the actual source
+                        // modules, whose paths carry the package information.
+                        const innerModules = module
+                            .modules;
+                        for (const m of innerModules ?? [module]) {
+                            const resourcePath = m.nameForCondition?.();
+                            if (!resourcePath) {
+                                continue;
+                            }
+                            inputs[node_path_1.default.relative(rootDirectory, resourcePath)] = {
+                                bytesInOutput: 1,
+                            };
+                        }
+                    }
+                }
+                // Packages bundled into component stylesheets never appear in the
+                // chunk graph; their inputs are tracked by the Angular plugin.
+                const stylesheetInputs = compilation[models_1.NG_RSPACK_SYMBOL_NAME]?.().stylesheetMetafileInputs;
+                Object.assign(inputs, stylesheetInputs);
+                this.sharedInputs.set(this, inputs);
+                const outputs = {};
+                let outputIndex = 0;
+                for (const compilerInputs of this.sharedInputs.values()) {
+                    outputs[outputIndex++] = { inputs: compilerInputs };
+                }
+                const licenses = await extractLicenses({ outputs }, rootDirectory);
+                compilation.emitAsset(outputFilename, new compiler.rspack.sources.RawSource(licenses));
+            });
+        });
+    }
+}
+exports.ExtractLicensesPlugin = ExtractLicensesPlugin;

package/dist/lib/plugins/loaders/angular-partial-transform.loader.d.ts

@@ -1,3 +1,3 @@
-import { LoaderContext } from '@rspack/core';
-export default function loader(this: LoaderContext<unknown>, content: string): void;
+import { LoaderContext, RawSourceMap } from '@rspack/core';
+export default function loader(this: LoaderContext<unknown>, content: string, inputMap?: string | RawSourceMap): void;
 //# sourceMappingURL=angular-partial-transform.loader.d.ts.map

package/dist/lib/plugins/loaders/angular-partial-transform.loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"angular-partial-transform.loader.d.ts","sourceRoot":"","sources":["../../../../src/lib/plugins/loaders/angular-partial-transform.loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM,QAyD3E"}
+{"version":3,"file":"angular-partial-transform.loader.d.ts","sourceRoot":"","sources":["../../../../src/lib/plugins/loaders/angular-partial-transform.loader.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAQ3D,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,QAuIjC"}

package/dist/lib/plugins/loaders/angular-partial-transform.loader.js

@@ -1,43 +1,105 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = loader;
+const promises_1 = require("node:fs/promises");
+const angular_rspack_compiler_1 = require("@nx/angular-rspack-compiler");
 const models_1 = require("../../models");
-function loader(content) {
+const inline_source_map_1 = require("./inline-source-map");
+function loader(content, inputMap) {
     const callback = this.async();
     if (this._compilation[models_1.NG_RSPACK_SYMBOL_NAME] ===
         undefined) {
-        callback(null, content);
+        callback(null, content, inputMap);
     }
     else {
-        const { javascriptTransformer, typescriptFileCache, angularCompilationFailed, } = this._compilation[models_1.NG_RSPACK_SYMBOL_NAME]();
+        const { javascriptTransformer, typescriptFileCache, babelFileCache, angularCompilationFailed, } = this._compilation[models_1.NG_RSPACK_SYMBOL_NAME]();
+        // The sourcemap chained by earlier loaders: source-map-loader runs first
+        // and consumes the file's own sourceMappingURL comment (inline or an
+        // external .map file) subject to the vendor sourcemap policy. Rspack
+        // fails the module build on maps it cannot deserialize, so drop anything
+        // unusable instead of forwarding it.
+        const chainMap = (0, inline_source_map_1.isForwardableSourceMap)(inputMap) ? inputMap : undefined;
         if (angularCompilationFailed) {
             // The build is already failing with the Angular compilation error,
             // so skip transforming and pass the original content through.
-            callback(null, content);
+            callback(null, content, chainMap);
             return;
         }
         const request = this.resourcePath;
         if (request.startsWith('data:text/javascript') &&
             request.includes('__module_federation_bundler_runtime__')) {
-            callback(null, content);
+            callback(null, content, chainMap);
+            return;
+        }
+        const normalizedRequest = (0, angular_rspack_compiler_1.toTypeScriptFileCacheKey)(request);
+        const cached = typescriptFileCache.get(normalizedRequest);
+        if (cached !== undefined) {
+            if (typeof cached !== 'string') {
+                callback(null, cached.code, cached.map);
+                return;
+            }
+            // A string entry is raw JavaScript emitted by the Angular compilation
+            // (allowJs); it always needs the JavaScript transformations applied.
+            javascriptTransformer
+                .transformData(normalizedRequest, cached, true, false)
+                .then((transformed) => {
+                const text = Buffer.from(transformed).toString('utf8');
+                const { code, map } = (0, inline_source_map_1.extractInlineSourceMap)(text);
+                // A newer emit may have replaced the entry while transforming;
+                // only store the result for the emit it was produced from.
+                if (typescriptFileCache.get(normalizedRequest) === cached) {
+                    typescriptFileCache.set(normalizedRequest, { code, map });
+                }
+                callback(null, code, map);
+            }, (error) => {
+                // Fail the module instead of leaving the loader callback pending,
+                // which would hang the build.
+                callback(error instanceof Error ? error : new Error(String(error)));
+            });
             return;
         }
         if (!content.includes('@angular')) {
-            callback(null, content);
+            callback(null, content, chainMap);
             return;
         }
-        const existingTransform = typescriptFileCache.get(request);
-        if (existingTransform) {
-            const existingContents = typeof existingTransform === 'string'
-                ? existingTransform
-                : Buffer.from(existingTransform).toString('utf8');
-            callback(null, existingContents);
+        // The chained map takes part in cache validity: the transformer reads
+        // the file's external map file itself and merges it into its output, so
+        // a cached transform is stale once that map changes, even though the
+        // file itself did not.
+        const serializedChainMap = chainMap ? JSON.stringify(chainMap) : undefined;
+        const cachedTransform = babelFileCache.get(normalizedRequest);
+        if (cachedTransform !== undefined &&
+            cachedTransform.chainedMap === serializedChainMap) {
+            callback(null, cachedTransform.code, cachedTransform.map);
             return;
         }
-        javascriptTransformer.transformFile(request, false, false).then((contents) => {
-            const transformedCode = Buffer.from(contents).toString('utf8');
-            typescriptFileCache.set(request, transformedCode);
-            callback(null, transformedCode);
+        // A mismatched entry means the chained map changed since the entry was
+        // produced. The transformer's persistent cache is keyed on the file
+        // bytes only, so `transformFile` would return the same stale output;
+        // hand it the current file data instead, which always runs the worker
+        // and re-reads the changed map file. A cold process has no entry to
+        // compare against, so a stale persistent entry can still be served
+        // there, matching the esbuild application builder's behavior.
+        const transformed = cachedTransform !== undefined
+            ? (0, promises_1.readFile)(request, 'utf8').then((data) => javascriptTransformer.transformData(request, data, false, false))
+            : javascriptTransformer.transformFile(request, false, false);
+        transformed.then((contents) => {
+            const text = Buffer.from(contents).toString('utf8');
+            const { code, map: extractedMap, strippedComment, } = (0, inline_source_map_1.extractInlineSourceMap)(text);
+            // The transformer's output carries a trailing sourcemap comment only
+            // when sourcemaps apply to this file: its own inline map for
+            // transformed output, the file's original comment when passed
+            // through untouched. A stripped comment without a usable inline map
+            // references an external map file, which source-map-loader has
+            // already read, so chain its map. No comment at all means sourcemaps
+            // are off for this file and nothing must be forwarded.
+            const map = extractedMap ?? (strippedComment ? serializedChainMap : undefined);
+            babelFileCache.set(normalizedRequest, {
+                code,
+                map,
+                chainedMap: serializedChainMap,
+            });
+            callback(null, code, map);
         }, (error) => {
             // Fail the module instead of leaving the loader callback pending,
             // which would hang the build.

package/dist/lib/plugins/loaders/angular-transform.loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"angular-transform.loader.d.ts","sourceRoot":"","sources":["../../../../src/lib/plugins/loaders/angular-transform.loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,6BAA6B,CAAC;AAKrC,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE;IACJ,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,oBAAoB,EAAE,oBAAoB,CAAC;CAC5C,QAkDF"}
+{"version":3,"file":"angular-transform.loader.d.ts","sourceRoot":"","sources":["../../../../src/lib/plugins/loaders/angular-transform.loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EAErB,MAAM,6BAA6B,CAAC;AAMrC,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE;IACJ,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,oBAAoB,EAAE,oBAAoB,CAAC;CAC5C,QAuFF"}

package/dist/lib/plugins/loaders/angular-transform.loader.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = loader;
-const path_1 = require("path");
 const models_1 = require("../../models");
 const angular_rspack_compiler_1 = require("@nx/angular-rspack-compiler");
+const inline_source_map_1 = require("./inline-source-map");
 const _styleUrlsResolver = new angular_rspack_compiler_1.StyleUrlsResolver();
 const _templateUrlsResolver = new angular_rspack_compiler_1.TemplateUrlsResolver();
 function loader(content, opt) {
@@ -14,7 +14,7 @@ function loader(content, opt) {
         callback(null, content);
     }
     else {
-        const { typescriptFileCache, angularCompilationFailed } = this._compilation[models_1.NG_RSPACK_SYMBOL_NAME]();
+        const { typescriptFileCache, javascriptTransformer, useTypeScriptTranspilation, angularCompilationFailed, resourceDependencies, } = this._compilation[models_1.NG_RSPACK_SYMBOL_NAME]();
         if (angularCompilationFailed) {
             // The Angular compilation failure is already reported as a compilation
             // error. Emit empty modules instead of raw TS sources that would only
@@ -22,26 +22,55 @@ function loader(content, opt) {
             callback(null, '');
             return;
         }
-        const request = this.resourcePath.replace(/^[A-Z]:/, '');
-        const normalizedRequest = (0, path_1.normalize)(request);
-        const templateUrls = templateUrlsResolver.resolve(content, normalizedRequest);
-        const styleUrls = styleUrlsResolver.resolve(content, normalizedRequest);
-        for (const urlSet of [...templateUrls, ...styleUrls]) {
-            // `urlSet` is a string where a relative path is joined with an
-            // absolute path using the `|` symbol.
-            // For example: `./app.component.html|/home/projects/analog/src/app/app.component.html`.
-            const [, absoluteFileUrl] = urlSet.split('|');
-            this.addDependency(absoluteFileUrl);
-        }
-        const contents = typescriptFileCache.get(normalizedRequest);
-        if (contents === undefined) {
-            callback(null, content);
-        }
-        else if (typeof contents === 'string') {
-            callback(null, contents);
+        const normalizedRequest = (0, angular_rspack_compiler_1.toTypeScriptFileCacheKey)(this.resourcePath);
+        const resourceDeps = resourceDependencies?.get(normalizedRequest);
+        if (resourceDeps !== undefined) {
+            // The compiler tracked this file's template and stylesheet
+            // dependencies; registering them keeps the module rebuilding when a
+            // resource changes, at no parsing cost.
+            for (const dependency of resourceDeps) {
+                this.addDependency(dependency);
+            }
         }
         else {
-            callback(null, Buffer.from(contents));
+            const templateUrls = templateUrlsResolver.resolve(content, normalizedRequest);
+            const styleUrls = styleUrlsResolver.resolve(content, normalizedRequest);
+            for (const urlSet of [...templateUrls, ...styleUrls]) {
+                // `urlSet` is a string where a relative path is joined with an
+                // absolute path using the `|` symbol.
+                // For example: `./app.component.html|/home/projects/analog/src/app/app.component.html`.
+                const [, absoluteFileUrl] = urlSet.split('|');
+                this.addDependency(absoluteFileUrl);
+            }
         }
+        const cached = typescriptFileCache.get(normalizedRequest);
+        if (cached !== undefined) {
+            if (typeof cached !== 'string') {
+                callback(null, cached.code, cached.map);
+                return;
+            }
+            // A string entry is a raw emit from the Angular compilation. Without
+            // TypeScript transpilation it is Angular-transformed TypeScript that
+            // the bundler transpiles as-is, matching `@angular/build`.
+            if (!useTypeScriptTranspilation) {
+                callback(null, cached);
+                return;
+            }
+            javascriptTransformer
+                .transformData(normalizedRequest, cached, true, false)
+                .then((transformed) => {
+                const text = Buffer.from(transformed).toString();
+                const { code, map } = (0, inline_source_map_1.extractInlineSourceMap)(text);
+                // A newer emit may have replaced the entry while transforming;
+                // only store the result for the emit it was produced from.
+                if (typescriptFileCache.get(normalizedRequest) === cached) {
+                    typescriptFileCache.set(normalizedRequest, { code, map });
+                }
+                callback(null, code, map);
+            })
+                .catch((err) => callback(err));
+            return;
+        }
+        callback(null, content);
     }
 }

package/dist/lib/plugins/loaders/inline-source-map.d.ts

@@ -0,0 +1,34 @@
+import type { RawSourceMap } from '@rspack/core';
+export interface ExtractedSourceMap {
+    code: string;
+    /** The decoded sourcemap as a JSON string, when inline and usable. */
+    map: string | undefined;
+    /**
+     * Whether a trailing sourceMappingURL comment was stripped from the code,
+     * even when it yielded no usable map (an external file reference or a
+     * payload rspack would reject).
+     */
+    strippedComment: boolean;
+}
+/**
+ * Splits a trailing sourcemap comment off the given code so the map can be
+ * passed to the loader callback and chained into the final sourcemaps,
+ * mirroring how the esbuild pipeline consumes the inline sourcemaps of the
+ * Angular compilation and the JavaScript transformer. Comments that carry no
+ * usable inline map are still stripped: esbuild never emits input
+ * sourceMappingURL comments into the bundle.
+ */
+export declare function extractInlineSourceMap(code: string): ExtractedSourceMap;
+/**
+ * Whether rspack's sourcemap deserializer accepts this value as a
+ * loader-provided map. Rspack fails the module build on any map it cannot
+ * deserialize, even when sourcemaps are disabled, so externally authored maps
+ * (a package's own sourcemap) must pass this check before being handed to
+ * the loader callback. Mirrors rspack's deserialization rules: `mappings`
+ * must be a string; every other field is optional and may be null, but a
+ * present value must have the expected type, including array elements
+ * (`sources`, `names` and `sourcesContent` entries may be null; `ignoreList`
+ * entries are deserialized as unsigned 32-bit integers).
+ */
+export declare function isForwardableSourceMap(value: unknown): value is RawSourceMap;
+//# sourceMappingURL=inline-source-map.d.ts.map

package/dist/lib/plugins/loaders/inline-source-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-source-map.d.ts","sourceRoot":"","sources":["../../../../src/lib/plugins/loaders/inline-source-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAiBjD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAqBvE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CA8B5E"}

package/dist/lib/plugins/loaders/inline-source-map.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInlineSourceMap = extractInlineSourceMap;
+exports.isForwardableSourceMap = isForwardableSourceMap;
+// A `sourceMappingURL` value: an inline base64 data URI (captured) or any
+// other reference, e.g. an external `.js.map` file.
+const SOURCE_MAP_URL_SOURCE = 'sourceMappingURL=(?:data:application\\/json[^,]*;base64,([A-Za-z0-9+/=]+)|[^\\r\\n]*?)';
+// Matches a trailing sourcemap comment in the forms source-map-loader
+// consumes: `//#`, the legacy `//@`, and their single-line block variants
+// `/*# ... */` and `/*@ ... */`. The leading `\r?\n` consumes the newline
+// preceding the comment so no stray `\r` is left on the stripped code. The
+// inline base64 payload lands in group 1 (line comment) or group 2 (block
+// comment).
+const TRAILING_SOURCE_MAP_COMMENT_REGEX = new RegExp(`(?:\\r?\\n)?(?:\\/\\/[#@][ \\t]+${SOURCE_MAP_URL_SOURCE}|\\/\\*[#@][ \\t]+${SOURCE_MAP_URL_SOURCE}[ \\t]*\\*\\/)\\s*$`);
+/**
+ * Splits a trailing sourcemap comment off the given code so the map can be
+ * passed to the loader callback and chained into the final sourcemaps,
+ * mirroring how the esbuild pipeline consumes the inline sourcemaps of the
+ * Angular compilation and the JavaScript transformer. Comments that carry no
+ * usable inline map are still stripped: esbuild never emits input
+ * sourceMappingURL comments into the bundle.
+ */
+function extractInlineSourceMap(code) {
+    const match = code.match(TRAILING_SOURCE_MAP_COMMENT_REGEX);
+    if (match?.index === undefined) {
+        return { code, map: undefined, strippedComment: false };
+    }
+    const stripped = code.slice(0, match.index);
+    const inlinePayload = match[1] ?? match[2];
+    if (inlinePayload === undefined) {
+        // A reference to an external map file; there is nothing to decode.
+        return { code: stripped, map: undefined, strippedComment: true };
+    }
+    const map = Buffer.from(inlinePayload, 'base64').toString('utf8');
+    try {
+        if (!isForwardableSourceMap(JSON.parse(map))) {
+            return { code: stripped, map: undefined, strippedComment: true };
+        }
+    }
+    catch {
+        // A malformed map is unusable; still strip its comment from the code.
+        return { code: stripped, map: undefined, strippedComment: true };
+    }
+    return { code: stripped, map, strippedComment: true };
+}
+/**
+ * Whether rspack's sourcemap deserializer accepts this value as a
+ * loader-provided map. Rspack fails the module build on any map it cannot
+ * deserialize, even when sourcemaps are disabled, so externally authored maps
+ * (a package's own sourcemap) must pass this check before being handed to
+ * the loader callback. Mirrors rspack's deserialization rules: `mappings`
+ * must be a string; every other field is optional and may be null, but a
+ * present value must have the expected type, including array elements
+ * (`sources`, `names` and `sourcesContent` entries may be null; `ignoreList`
+ * entries are deserialized as unsigned 32-bit integers).
+ */
+function isForwardableSourceMap(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const map = value;
+    const isNullableString = (v) => v === null || typeof v === 'string';
+    const isOptional = (v, check) => v === undefined || v === null || check(v);
+    const isArrayOf = (v, check) => Array.isArray(v) && v.every(check);
+    return (typeof map.mappings === 'string' &&
+        isOptional(map.sources, (v) => isArrayOf(v, isNullableString)) &&
+        isOptional(map.names, (v) => isArrayOf(v, isNullableString)) &&
+        isOptional(map.sourcesContent, (v) => isArrayOf(v, isNullableString)) &&
+        isOptional(map.file, (v) => typeof v === 'string') &&
+        isOptional(map.sourceRoot, (v) => typeof v === 'string') &&
+        isOptional(map.debugId, (v) => typeof v === 'string') &&
+        isOptional(map.ignoreList, (v) => isArrayOf(v, (el) => typeof el === 'number' &&
+            Number.isInteger(el) &&
+            el >= 0 &&
+            el <= 0xffffffff)));
+}

package/dist/lib/plugins/ng-rspack.d.ts

@@ -1,12 +1,30 @@
 import { Compiler, RspackPluginInstance } from '@rspack/core';
 import type { I18nOptions, NormalizedAngularRspackPluginOptions } from '../models';
+import { AngularRspackPlugin } from './angular-rspack-plugin';
+import { type SharedLicenseInputs } from './extract-licenses-plugin';
 export declare class NgRspackPlugin implements RspackPluginInstance {
     readonly pluginOptions: NormalizedAngularRspackPluginOptions;
     readonly isPlatformServer: boolean;
     readonly i18n: I18nOptions;
+    private readonly sharedLicenseInputs;
+    private readonly sharedAngularPlugin;
     constructor(pluginOptions: NormalizedAngularRspackPluginOptions, extraOptions: {
         platform: 'browser' | 'server';
         i18nOptions: I18nOptions;
+        /**
+         * License extraction inputs shared across the compilers of an SSR
+         * build, so the browser and server compilers emit the union instead of
+         * overwriting each other's licenses file.
+         */
+        sharedLicenseInputs?: SharedLicenseInputs;
+        /**
+         * Angular compilation shared across the compilers of an SSR build: the
+         * browser compiler owns it (its program includes the server entry
+         * points) and the server compiler consumes its output instead of
+         * running a second compilation. When absent, each compiler runs its
+         * own compilation.
+         */
+        sharedAngularPlugin?: AngularRspackPlugin;
     });
     apply(compiler: Compiler): void;
 }

package/dist/lib/plugins/ng-rspack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ng-rspack.d.ts","sourceRoot":"","sources":["../../../src/lib/plugins/ng-rspack.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAGR,oBAAoB,EACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EACV,WAAW,EACX,oCAAoC,EACrC,MAAM,WAAW,CAAC;AAUnB,qBAAa,cAAe,YAAW,oBAAoB;IACzD,QAAQ,CAAC,aAAa,EAAE,oCAAoC,CAAC;IAC7D,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAE3B,YACE,aAAa,EAAE,oCAAoC,EACnD,YAAY,EAAE;QACZ,QAAQ,EAAE,SAAS,GAAG,QAAQ,CAAC;QAC/B,WAAW,EAAE,WAAW,CAAC;KAC1B,EAKF;IAED,KAAK,CAAC,QAAQ,EAAE,QAAQ,QA2JvB;CACF"}
+{"version":3,"file":"ng-rspack.d.ts","sourceRoot":"","sources":["../../../src/lib/plugins/ng-rspack.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAGR,oBAAoB,EACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EACV,WAAW,EACX,oCAAoC,EACrC,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAC;AAMnC,qBAAa,cAAe,YAAW,oBAAoB;IACzD,QAAQ,CAAC,aAAa,EAAE,oCAAoC,CAAC;IAC7D,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkC;IACtE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkC;IAEtE,YACE,aAAa,EAAE,oCAAoC,EACnD,YAAY,EAAE;QACZ,QAAQ,EAAE,SAAS,GAAG,QAAQ,CAAC;QAC/B,WAAW,EAAE,WAAW,CAAC;QACzB;;;;WAIG;QACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;QAC1C;;;;;;WAMG;QACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;KAC3C,EAOF;IAED,KAAK,CAAC,QAAQ,EAAE,QAAQ,QA2MvB;CACF"}