@nx/angular-rspack 19.0.0-alpha.30

package/dist/lib/models/normalize-options.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INDEX_HTML_CSR = void 0;
+exports.resolveFileReplacements = resolveFileReplacements;
+exports.getHasServer = getHasServer;
+exports.validateSsr = validateSsr;
+exports.validateOptimization = validateOptimization;
+exports.normalizeOptions = normalizeOptions;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
+exports.INDEX_HTML_CSR = 'index.csr.html';
+/**
+ * Resolves file replacement paths to absolute paths based on the provided root directory.
+ *
+ * @param fileReplacements - Array of file replacements with relative paths.
+ * @param root - The root directory to resolve the paths against.
+ * @returns Array of file replacements resolved against the root.
+ */
+function resolveFileReplacements(fileReplacements, root) {
+    return fileReplacements.map((fileReplacement) => ({
+        replace: (0, node_path_1.resolve)(root, fileReplacement.replace),
+        with: (0, node_path_1.resolve)(root, fileReplacement.with),
+    }));
+}
+function getHasServer(root, server, ssr) {
+    return !!(server &&
+        ssr &&
+        ssr.entry &&
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(root, server)) &&
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(root, ssr.entry)));
+}
+function validateSsr(ssr) {
+    if (!ssr) {
+        return;
+    }
+    if (ssr === true) {
+        throw new Error('The "ssr" option should be an object or false. Please check the documentation.');
+    }
+    if (typeof ssr === 'object')
+        if (!ssr.entry) {
+            throw new Error('The "ssr" option should have an "entry" property. Please check the documentation.');
+        }
+        else if (ssr.experimentalPlatform === 'neutral') {
+            console.warn('The "ssr.experimentalPlatform" option is not currently supported. Node will be used as the platform.');
+        }
+}
+function validateOptimization(optimization) {
+    if (typeof optimization === 'boolean' || optimization === undefined) {
+        return;
+    }
+    if (typeof optimization === 'object')
+        console.warn('The "optimization" option currently only supports a boolean value. Please check the documentation.');
+}
+function normalizeOptions(options) {
+    const { fileReplacements = [], server, ssr, optimization } = options;
+    validateSsr(ssr);
+    const normalizedSsr = !ssr
+        ? false
+        : typeof ssr === 'object'
+            ? {
+                entry: ssr.entry,
+                experimentalPlatform: 'node', // @TODO: Add support for neutral platform
+            }
+            : ssr;
+    validateOptimization(optimization);
+    const normalizedOptimization = optimization !== false; // @TODO: Add support for optimization options
+    const root = options.root ?? process.cwd();
+    const tsConfig = options.tsConfig
+        ? (0, node_path_1.resolve)(root, options.tsConfig)
+        : (0, node_path_1.join)(root, 'tsconfig.app.json');
+    const aot = options.aot ?? true;
+    // @TODO: use this once we support granular optimization options
+    // const advancedOptimizations = aot && normalizedOptimization.scripts;
+    const advancedOptimizations = aot && normalizedOptimization;
+    const project = getProject(root);
+    const assets = project && options.assets?.length
+        ? normalizeAssetPatterns(options.assets, root, project.data.root, project.data.sourceRoot)
+        : [];
+    const globalStyles = normalizeGlobalEntries(options.styles, 'styles');
+    const globalScripts = normalizeGlobalEntries(options.scripts, 'scripts');
+    if (options.index === false) {
+        console.warn('Disabling the "index" option is not yet supported. Defaulting to "src/index.html".');
+        options.index = (0, node_path_1.join)(root, 'src/index.html');
+    }
+    let index;
+    // index can never have a value of `true` but in the schema it's of type `boolean`.
+    if (typeof options.index !== 'boolean') {
+        let indexOutput;
+        // The output file will be created within the configured output path
+        if (typeof options.index === 'string') {
+            indexOutput = options.index;
+        }
+        else {
+            if (options.index.preloadInitial) {
+                console.warn(`The "index.preloadInitial" option is not yet supported.`);
+            }
+            if (options.index.output) {
+                console.warn(`The "index.output" option is not yet supported.`);
+            }
+            indexOutput = options.index.output || 'index.html';
+        }
+        /**
+         * If SSR is activated, create a distinct entry file for the `index.html`.
+         * This is necessary because numerous server/cloud providers automatically serve the `index.html` as a static file
+         * if it exists (handling SSG).
+         *
+         * For instance, accessing `foo.com/` would lead to `foo.com/index.html` being served instead of hitting the server.
+         *
+         * This approach can also be applied to service workers, where the `index.csr.html` is served instead of the prerendered `index.html`.
+         */
+        const indexBaseName = (0, node_path_1.basename)(indexOutput);
+        indexOutput =
+            // @TODO: use this once we support prerenderOptions
+            // (normalizedSsr || prerenderOptions) && indexBaseName === 'index.html'
+            normalizedSsr && indexBaseName === 'index.html'
+                ? exports.INDEX_HTML_CSR
+                : indexBaseName;
+        index = {
+            input: (0, node_path_1.resolve)(root, typeof options.index === 'string' ? options.index : options.index.input),
+            output: indexOutput,
+            insertionOrder: [
+                ['polyfills', true],
+                ...globalStyles.filter((s) => s.initial).map((s) => [s.name, false]),
+                ...globalScripts.filter((s) => s.initial).map((s) => [s.name, false]),
+                ['main', true],
+                // [name, esm]
+            ],
+            // @TODO: Add support for transformer
+            transformer: undefined,
+            // Preload initial defaults to true
+            preloadInitial: typeof options.index !== 'object' ||
+                (options.index.preloadInitial ?? true),
+        };
+    }
+    return {
+        index,
+        browser: options.browser ?? './src/main.ts',
+        ...(server ? { server } : {}),
+        ...(ssr ? { ssr: normalizedSsr } : {}),
+        optimization: normalizedOptimization,
+        advancedOptimizations,
+        polyfills: options.polyfills ?? [],
+        assets,
+        globalStyles,
+        globalScripts,
+        outputPath: normalizeOutputPath(root, options.outputPath),
+        fileReplacements: resolveFileReplacements(fileReplacements, root),
+        aot,
+        outputHashing: options.outputHashing ?? 'all',
+        inlineStyleLanguage: options.inlineStyleLanguage ?? 'css',
+        tsConfig,
+        sourceMap: normalizeSourceMap(options.sourceMap),
+        hasServer: getHasServer(root, server, normalizedSsr),
+        skipTypeChecking: options.skipTypeChecking ?? false,
+        useTsProjectReferences: options.useTsProjectReferences ?? false,
+        namedChunks: options.namedChunks ?? false,
+        vendorChunk: options.vendorChunk ?? false,
+        commonChunk: options.commonChunk ?? true,
+        devServer: normalizeDevServer(options.devServer),
+        extractLicenses: options.extractLicenses ?? true,
+        root,
+    };
+}
+function normalizeSourceMap(sourceMap) {
+    if (sourceMap === undefined || sourceMap === true) {
+        return {
+            scripts: true,
+            styles: true,
+            hidden: false,
+            vendor: false,
+        };
+    }
+    if (sourceMap === false) {
+        return {
+            scripts: false,
+            styles: false,
+            hidden: false,
+            vendor: false,
+        };
+    }
+    return {
+        scripts: sourceMap.scripts ?? true,
+        styles: sourceMap.styles ?? true,
+        hidden: sourceMap.hidden ?? false,
+        vendor: sourceMap.vendor ?? false,
+    };
+}
+function normalizeDevServer(devServer) {
+    const defaultPort = 4200;
+    if (!devServer) {
+        return { port: defaultPort };
+    }
+    return {
+        ...devServer,
+        port: devServer.port ?? defaultPort,
+    };
+}
+function normalizeOutputPath(root, outputPath) {
+    const defaultBase = (0, node_path_1.join)(root, 'dist');
+    const defaultBrowser = (0, node_path_1.join)(defaultBase, 'browser');
+    if (!outputPath) {
+        return {
+            base: defaultBase,
+            browser: defaultBrowser,
+            server: (0, node_path_1.join)(defaultBase, 'server'),
+            media: (0, node_path_1.join)(defaultBrowser, 'media'),
+        };
+    }
+    if (typeof outputPath === 'string') {
+        if (!outputPath.startsWith(root)) {
+            outputPath = (0, node_path_1.join)(root, outputPath);
+        }
+        return {
+            base: outputPath,
+            browser: (0, node_path_1.join)(outputPath, 'browser'),
+            server: (0, node_path_1.join)(outputPath, 'server'),
+            media: (0, node_path_1.join)(outputPath, 'browser', 'media'),
+        };
+    }
+    if (outputPath.base && !outputPath.base.startsWith(root)) {
+        outputPath.base = (0, node_path_1.join)(root, outputPath.base);
+    }
+    if (outputPath.browser && !outputPath.browser.startsWith(root)) {
+        outputPath.browser = (0, node_path_1.join)(root, outputPath.browser);
+    }
+    if (outputPath.server && !outputPath.server.startsWith(root)) {
+        outputPath.server = (0, node_path_1.join)(root, outputPath.server);
+    }
+    if (outputPath.browser &&
+        !outputPath.browser.startsWith(outputPath.browser)) {
+        outputPath.browser = (0, node_path_1.join)(outputPath.browser, outputPath.browser);
+    }
+    const providedBase = outputPath.base ?? defaultBase;
+    const providedBrowser = outputPath.browser ?? (0, node_path_1.join)(providedBase, 'browser');
+    return {
+        base: providedBase,
+        browser: providedBrowser,
+        server: outputPath.server ?? (0, node_path_1.join)(outputPath.base ?? defaultBase, 'server'),
+        media: outputPath.media ?? (0, node_path_1.join)(providedBrowser, 'media'),
+    };
+}
+function normalizeAssetPatterns(assets, root, projectRoot, projectSourceRoot) {
+    if (assets.length === 0) {
+        return [];
+    }
+    // When sourceRoot is not available, we default to ${projectRoot}/src.
+    const sourceRoot = projectSourceRoot || (0, node_path_1.join)(projectRoot, 'src');
+    const resolvedSourceRoot = (0, node_path_1.resolve)(root, sourceRoot);
+    return assets.map((assetPattern) => {
+        // Normalize string asset patterns to objects.
+        if (typeof assetPattern === 'string') {
+            const assetPath = (0, node_path_1.normalize)(assetPattern);
+            const resolvedAssetPath = (0, node_path_1.resolve)(root, assetPath);
+            // Check if the string asset is within sourceRoot.
+            if (!resolvedAssetPath.startsWith(resolvedSourceRoot)) {
+                throw new Error(`The ${assetPattern} asset path must start with the project source root.`);
+            }
+            let glob, input;
+            let isDirectory = false;
+            try {
+                isDirectory = (0, node_fs_1.statSync)(resolvedAssetPath).isDirectory();
+            }
+            catch {
+                isDirectory = true;
+            }
+            if (isDirectory) {
+                // Folders get a recursive star glob.
+                glob = '**/*';
+                // Input directory is their original path.
+                input = assetPath;
+            }
+            else {
+                // Files are their own glob.
+                glob = (0, node_path_1.basename)(assetPath);
+                // Input directory is their original dirname.
+                input = (0, node_path_1.dirname)(assetPath);
+            }
+            // Output directory for both is the relative path from source root to input.
+            const output = (0, node_path_1.relative)(resolvedSourceRoot, (0, node_path_1.resolve)(root, input));
+            assetPattern = { glob, input, output };
+        }
+        else {
+            assetPattern.output = (0, node_path_1.join)('.', assetPattern.output ?? '');
+        }
+        (0, node_assert_1.default)(assetPattern.output !== undefined);
+        if (assetPattern.output.startsWith('..')) {
+            throw new Error('An asset cannot be written to a location outside of the output path.');
+        }
+        return assetPattern;
+    });
+}
+function normalizeGlobalEntries(rawEntries, _defaultName) {
+    if (!rawEntries?.length) {
+        return [];
+    }
+    const bundles = new Map();
+    let warnForInject = false;
+    let warnForBundleName = false;
+    for (const rawEntry of rawEntries) {
+        let entry;
+        if (typeof rawEntry === 'string') {
+            // string entries use default bundle name and inject values
+            entry = { input: rawEntry };
+        }
+        else {
+            entry = rawEntry;
+        }
+        const { bundleName, input, inject = true } = entry;
+        // @TODO: remove this once we support inject
+        if (inject === false) {
+            warnForInject = true;
+        }
+        // @TODO: remove this once we support bundleName
+        if (bundleName) {
+            warnForBundleName = true;
+        }
+        // @TODO: use this once we support inject and bundleName
+        // Non-injected entries default to the file name
+        // const name =
+        //   bundleName || (inject ? defaultName : basename(input, extname(input)));
+        const name = (0, node_path_1.basename)(input, (0, node_path_1.extname)(input));
+        const existing = bundles.get(name);
+        if (!existing) {
+            // @TODO: use this once we support inject
+            // bundles.set(name, { name, files: [input], initial: inject });
+            bundles.set(name, { name, files: [input], initial: true });
+            continue;
+        }
+        // @TODO: uncomment this once we support inject
+        // if (existing.initial !== inject) {
+        //   throw new Error(
+        //     `The "${name}" bundle is mixing injected and non-injected entries. ` +
+        //       'Verify that the project options are correct.'
+        //   );
+        // }
+        existing.files.push(input);
+    }
+    if (warnForInject) {
+        console.warn(`The "inject" option for scripts/styles is not yet supported.`);
+    }
+    if (warnForBundleName) {
+        console.warn(`The "bundleName" option for scripts/styles is not yet supported.`);
+    }
+    return [...bundles.values()];
+}
+function getProject(root) {
+    if (global.NX_GRAPH_CREATION) {
+        return undefined;
+    }
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    let projectName = process.env.NX_TASK_TARGET_PROJECT;
+    if (!projectName) {
+        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(projectGraph.nodes);
+        projectName = (0, find_project_for_path_1.findProjectForPath)(root, projectRootMappings) ?? undefined;
+    }
+    (0, node_assert_1.default)(projectName, 'Cannot find the project. Please make sure to run this task with the Nx CLI and set "root" to a directory contained in a project.');
+    return projectGraph.nodes[projectName];
+}

package/dist/lib/plugins/angular-rspack-plugin.d.ts

@@ -0,0 +1,9 @@
+import { Compiler, RspackPluginInstance } from '@rspack/core';
+import { type NormalizedAngularRspackPluginOptions } from '../models';
+export declare class AngularRspackPlugin implements RspackPluginInstance {
+    #private;
+    constructor(options: NormalizedAngularRspackPluginOptions);
+    apply(compiler: Compiler): void;
+    private setupCompilation;
+}
+//# sourceMappingURL=angular-rspack-plugin.d.ts.map

package/dist/lib/plugins/angular-rspack-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-rspack-plugin.d.ts","sourceRoot":"","sources":["../../../src/lib/plugins/angular-rspack-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,oBAAoB,EACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EAGL,KAAK,oCAAoC,EAC1C,MAAM,WAAW,CAAC;AAiBnB,qBAAa,mBAAoB,YAAW,oBAAoB;;gBAWlD,OAAO,EAAE,oCAAoC;IAqBzD,KAAK,CAAC,QAAQ,EAAE,QAAQ;YAgJV,gBAAgB;CA0B/B"}

package/dist/lib/plugins/angular-rspack-plugin.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularRspackPlugin = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@rspack/core");
+const models_1 = require("../models");
+const angular_rspack_compiler_1 = require("@nx/angular-rspack-compiler");
+const path_1 = require("path");
+const fs_2 = tslib_1.__importDefault(require("fs"));
+const PLUGIN_NAME = 'AngularRspackPlugin';
+class AngularRspackPlugin {
+    #_options;
+    #typescriptFileCache;
+    #javascriptTransformer;
+    // This will be defined in the apply method correctly
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    #angularCompilation;
+    constructor(options) {
+        this.#_options = options;
+        this.#typescriptFileCache = new Map();
+        this.#javascriptTransformer = new angular_rspack_compiler_1.JavaScriptTransformer({
+            /**
+             * Matches https://github.com/angular/angular-cli/blob/33ed6e875e509ebbaa0cbdb57be9e932f9915dff/packages/angular/build/src/tools/esbuild/angular/compiler-plugin.ts#L89
+             * where pluginOptions.sourcemap is set https://github.com/angular/angular-cli/blob/61d98fde122468978de9b17bd79761befdbf2fac/packages/angular/build/src/tools/esbuild/compiler-plugin-options.ts#L34
+             */
+            sourcemap: !!(this.#_options.sourceMap.scripts &&
+                (this.#_options.sourceMap.hidden ? 'external' : true)),
+            thirdPartySourcemaps: this.#_options.sourceMap.vendor,
+            advancedOptimizations: this.#_options.advancedOptimizations,
+            jit: !this.#_options.aot,
+        }, (0, angular_rspack_compiler_1.maxWorkers)());
+    }
+    apply(compiler) {
+        const root = this.#_options.root;
+        // Both of these are exclusive to each other - only one of them can be used at a time
+        // But they will happen before the compiler is created - so we can use them to set up the parallel compilation once
+        compiler.hooks.beforeRun.tapAsync(PLUGIN_NAME, async (compiler, callback) => {
+            await this.setupCompilation(root, compiler.options.resolve.tsConfig);
+            compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, async (params, callback) => {
+                await (0, angular_rspack_compiler_1.buildAndAnalyzeWithParallelCompilation)(this.#angularCompilation, this.#typescriptFileCache, this.#javascriptTransformer);
+                callback();
+            });
+            compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
+                if (stats.hasErrors() || stats.hasWarnings()) {
+                    setTimeout(() => {
+                        process.exit(stats.hasErrors() ? 1 : 0);
+                    }, 1000);
+                }
+            });
+            callback();
+        });
+        compiler.hooks.watchRun.tapAsync(PLUGIN_NAME, async (compiler, callback) => {
+            if (!compiler.hooks.beforeCompile.taps.some((tap) => tap.name === PLUGIN_NAME)) {
+                compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, async (params, callback) => {
+                    const watchingModifiedFiles = compiler.watching?.compiler
+                        ?.modifiedFiles
+                        ? new Set(compiler.watching.compiler.modifiedFiles)
+                        : new Set();
+                    await this.setupCompilation(root, compiler.options.resolve.tsConfig);
+                    await this.#angularCompilation.update(watchingModifiedFiles);
+                    await (0, angular_rspack_compiler_1.buildAndAnalyzeWithParallelCompilation)(this.#angularCompilation, this.#typescriptFileCache, this.#javascriptTransformer);
+                    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+                        watchingModifiedFiles.forEach((file) => {
+                            compilation.fileDependencies.add(file);
+                        });
+                    });
+                    callback();
+                });
+            }
+            callback();
+        });
+        compiler.hooks.emit.tapAsync(PLUGIN_NAME, async (compilation, callback) => {
+            if (!this.#_options.skipTypeChecking) {
+                const { errors, warnings } = await this.#angularCompilation.diagnoseFiles(angular_rspack_compiler_1.DiagnosticModes.All);
+                for (const error of errors ?? []) {
+                    compilation.errors.push({
+                        name: PLUGIN_NAME,
+                        message: error.text || '',
+                        file: error.location?.file,
+                        loc: `${error.location?.line}:${error.location?.column}`,
+                        moduleIdentifier: error.location?.file,
+                        stack: error.text,
+                    });
+                }
+                for (const warning of warnings ?? []) {
+                    compilation.warnings.push({
+                        name: PLUGIN_NAME,
+                        message: warning.text || '',
+                        file: warning.location?.file,
+                        loc: `${warning.location?.line}:${warning.location?.column}`,
+                        stack: warning.text,
+                        moduleIdentifier: warning.location?.file,
+                    });
+                }
+            }
+            await this.#angularCompilation.close();
+            await this.#javascriptTransformer.close();
+            callback();
+        });
+        compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (normalModuleFactory) => {
+            normalModuleFactory.hooks.beforeResolve.tap(PLUGIN_NAME, (data) => {
+                if (data.request.startsWith('angular:jit:')) {
+                    const path = data.request.split(';')[1];
+                    data.request = `${(0, path_1.normalize)((0, path_1.resolve)((0, path_1.dirname)(data.contextInfo.issuer), path))}?raw`;
+                }
+            });
+        });
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation[models_1.NG_RSPACK_SYMBOL_NAME] = () => ({
+                javascriptTransformer: this
+                    .#javascriptTransformer,
+                typescriptFileCache: this.#typescriptFileCache,
+            });
+        });
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            const htmlRspackPluginHooks = core_1.HtmlRspackPlugin.getCompilationHooks(compilation);
+            htmlRspackPluginHooks.beforeEmit.tap(PLUGIN_NAME, (data) => {
+                const ngJsDispatchEvent = `<script type="text/javascript" id="ng-event-dispatch-contract">
+                ${fs_2.default.readFileSync(require.resolve('@angular/core/event-dispatch-contract.min.js'), 'utf-8')}
+                </script>`;
+                data.html = data.html.replace('</body>', `${ngJsDispatchEvent}</body>`);
+                return data;
+            });
+        });
+    }
+    async setupCompilation(root, tsConfig) {
+        const tsconfigPath = tsConfig
+            ? typeof tsConfig === 'string'
+                ? tsConfig
+                : tsConfig.configFile
+            : this.#_options.tsConfig;
+        this.#angularCompilation = await (0, angular_rspack_compiler_1.setupCompilationWithParallelCompilation)({
+            source: {
+                tsconfigPath: tsconfigPath,
+            },
+        }, {
+            root,
+            aot: this.#_options.aot,
+            tsConfig: tsconfigPath,
+            inlineStyleLanguage: this.#_options.inlineStyleLanguage,
+            fileReplacements: this.#_options.fileReplacements,
+            useTsProjectReferences: this.#_options.useTsProjectReferences,
+            hasServer: this.#_options.hasServer,
+        });
+    }
+}
+exports.AngularRspackPlugin = AngularRspackPlugin;

package/dist/lib/plugins/angular-ssr-dev-server.d.ts

@@ -0,0 +1,8 @@
+import { Compiler, RspackPluginInstance } from '@rspack/core';
+import { OutputPath } from '../models';
+export declare class AngularSsrDevServer implements RspackPluginInstance {
+    #private;
+    constructor(outputPath: OutputPath);
+    apply(compiler: Compiler): void;
+}
+//# sourceMappingURL=angular-ssr-dev-server.d.ts.map

package/dist/lib/plugins/angular-ssr-dev-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-ssr-dev-server.d.ts","sourceRoot":"","sources":["../../../src/lib/plugins/angular-ssr-dev-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAG9D,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAKvC,qBAAa,mBAAoB,YAAW,oBAAoB;;gBAKlD,UAAU,EAAE,UAAU;IAKlC,KAAK,CAAC,QAAQ,EAAE,QAAQ;CAkCzB"}

package/dist/lib/plugins/angular-ssr-dev-server.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularSsrDevServer = void 0;
+const child_process_1 = require("child_process");
+const ssr_reload_server_1 = require("./server/ssr-reload-server");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const PLUGIN_NAME = 'AngularSsrDevServer';
+class AngularSsrDevServer {
+    #devServerProcess;
+    #wsServer;
+    #outputPath;
+    constructor(outputPath) {
+        this.#outputPath = outputPath;
+        this.#wsServer = new ssr_reload_server_1.SsrReloadServer();
+    }
+    apply(compiler) {
+        compiler.hooks.entryOption.tap(PLUGIN_NAME, (context, entry) => {
+            const keys = Object.keys(entry);
+            for (const key of keys) {
+                const entryValue = entry[key];
+                entryValue.import = [
+                    ...entryValue.import,
+                    require.resolve(`${__dirname}/client/ssr-reload-client.js`),
+                ];
+            }
+        });
+        compiler.hooks.watchRun.tapAsync(PLUGIN_NAME, async (compiler, callback) => {
+            compiler.hooks.afterEmit.tapAsync(PLUGIN_NAME, async (_, callback) => {
+                const serverPath = (0, node_path_1.join)(this.#outputPath.server, 'server.js');
+                if (this.#devServerProcess) {
+                    this.#devServerProcess.kill();
+                    this.#devServerProcess = undefined;
+                    await new Promise((res) => setTimeout(res, 50));
+                }
+                if (!(0, node_fs_1.existsSync)(serverPath)) {
+                    await new Promise((res) => setTimeout(res, 50));
+                }
+                this.#devServerProcess = (0, child_process_1.fork)(serverPath);
+                this.#devServerProcess.on('spawn', () => {
+                    this.#wsServer.sendReload();
+                });
+                callback();
+            });
+            callback();
+        });
+    }
+}
+exports.AngularSsrDevServer = AngularSsrDevServer;

package/dist/lib/plugins/client/ssr-reload-client.d.ts

@@ -0,0 +1,2 @@
+declare const socket: any;
+//# sourceMappingURL=ssr-reload-client.d.ts.map

package/dist/lib/plugins/client/ssr-reload-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-reload-client.d.ts","sourceRoot":"","sources":["../../../../src/lib/plugins/client/ssr-reload-client.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,MAAM,KAAwC,CAAC"}

package/dist/lib/plugins/client/ssr-reload-client.js

@@ -0,0 +1,16 @@
+"use strict";
+// @ts-expect-error: This is a client-side file
+const socket = new WebSocket(`ws://localhost:60000`);
+socket.addEventListener('message', (event) => {
+    if (event.data === 'ssr-reload') {
+        console.log('[AngularSSRDevServer] Reloading the page...');
+        // @ts-expect-error: This is a client-side file
+        window.location.reload();
+    }
+});
+socket.addEventListener('open', () => {
+    console.log('[AngularSSRDevServer] WebSocket connection established.');
+});
+socket.addEventListener('close', () => {
+    console.warn('[AngularSSRDevServer] WebSocket connection closed.');
+});

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

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

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

@@ -0,0 +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,QAuC3E"}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loader;
+const models_1 = require("../../models");
+function loader(content) {
+    const callback = this.async();
+    if (this._compilation[models_1.NG_RSPACK_SYMBOL_NAME] ===
+        undefined) {
+        callback(null, content);
+    }
+    else {
+        const { javascriptTransformer, typescriptFileCache } = this._compilation[models_1.NG_RSPACK_SYMBOL_NAME]();
+        const request = this.resourcePath;
+        if (request.startsWith('data:text/javascript') &&
+            request.includes('__module_federation_bundler_runtime__')) {
+            callback(null, content);
+            return;
+        }
+        if (!content.includes('@angular')) {
+            callback(null, content);
+            return;
+        }
+        const existingTransform = typescriptFileCache.get(request);
+        if (existingTransform) {
+            callback(null, existingTransform);
+            return;
+        }
+        javascriptTransformer
+            .transformFile(request, false, false)
+            .then((contents) => {
+            const transformedCode = Buffer.from(contents).toString('utf8');
+            typescriptFileCache.set(request, transformedCode);
+            callback(null, transformedCode);
+        });
+    }
+}

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

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

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

@@ -0,0 +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;AAWlD,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM,QAqC3E"}