@angular-devkit/build-angular 16.2.1 → 17.0.0-next.3

package/src/builders/prerender/schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "Prerender Target",
+  "type": "object",
+  "properties": {
+    "browserTarget": {
+      "type": "string",
+      "description": "Target to build.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
+    },
+    "serverTarget": {
+      "type": "string",
+      "description": "Server target to use for prerendering the app.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
+    },
+    "routesFile": {
+      "type": "string",
+      "description": "The path to a file containing routes separated by newlines."
+    },
+    "routes": {
+      "type": "array",
+      "description": "The routes to render.",
+      "items": {
+        "minItems": 1,
+        "type": "string",
+        "uniqueItems": true
+      },
+      "default": []
+    },
+    "guessRoutes": {
+      "type": "boolean",
+      "description": "Whether or not the builder should extract routes and guess which paths to render.",
+      "default": true
+    }
+  },
+  "required": ["browserTarget", "serverTarget"],
+  "anyOf": [{ "required": ["routes"] }, { "required": ["routesFile"] }],
+  "additionalProperties": false
+}

package/src/builders/prerender/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @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.io/license
+ */
+import { BuilderContext } from '@angular-devkit/architect';
+import { BrowserBuilderOptions } from '@angular-devkit/build-angular';
+import { json } from '@angular-devkit/core';
+import { Schema } from './schema';
+type PrerenderBuilderOptions = Schema & json.JsonObject;
+/**
+ * Returns the union of routes, the contents of routesFile if given,
+ * and the static routes extracted if guessRoutes is set to true.
+ */
+export declare function getRoutes(options: PrerenderBuilderOptions, tsConfigPath: string | undefined, context: BuilderContext): Promise<string[]>;
+/**
+ * Returns the name of the index file outputted by the browser builder.
+ */
+export declare function getIndexOutputFile(options: BrowserBuilderOptions): string;
+export {};

package/src/builders/prerender/utils.js

@@ -0,0 +1,79 @@
+"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.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIndexOutputFile = exports.getRoutes = void 0;
+const fs = __importStar(require("fs"));
+const guess_parser_1 = require("guess-parser");
+const path = __importStar(require("path"));
+const error_1 = require("../../utils/error");
+/**
+ * Returns the union of routes, the contents of routesFile if given,
+ * and the static routes extracted if guessRoutes is set to true.
+ */
+async function getRoutes(options, tsConfigPath, context) {
+    let routes = options.routes || [];
+    const { logger, workspaceRoot } = context;
+    if (options.routesFile) {
+        const routesFilePath = path.join(workspaceRoot, options.routesFile);
+        routes = routes.concat(fs
+            .readFileSync(routesFilePath, 'utf8')
+            .split(/\r?\n/)
+            .filter((v) => !!v));
+    }
+    if (options.guessRoutes && tsConfigPath) {
+        try {
+            routes = routes.concat((0, guess_parser_1.parseAngularRoutes)(path.join(workspaceRoot, tsConfigPath))
+                .map((routeObj) => routeObj.path)
+                .filter((route) => !route.includes('*') && !route.includes(':')));
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            logger.error('Unable to extract routes from application.', { ...e });
+        }
+    }
+    routes = routes.map((r) => (r === '' ? '/' : r));
+    return [...new Set(routes)];
+}
+exports.getRoutes = getRoutes;
+/**
+ * Returns the name of the index file outputted by the browser builder.
+ */
+function getIndexOutputFile(options) {
+    if (typeof options.index === 'string') {
+        return path.basename(options.index);
+    }
+    else {
+        return options.index.output || 'index.html';
+    }
+}
+exports.getIndexOutputFile = getIndexOutputFile;
+//# sourceMappingURL=data:application/json;base64,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

package/src/builders/ssr-dev-server/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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.io/license
+ */
+import { BuilderContext, BuilderOutput } from '@angular-devkit/architect';
+import { json, logging } from '@angular-devkit/core';
+import { Observable } from 'rxjs';
+import { Schema } from './schema';
+type SSRDevServerBuilderOptions = Schema & json.JsonObject;
+export type SSRDevServerBuilderOutput = BuilderOutput & {
+    baseUrl?: string;
+    port?: string;
+};
+export declare function execute(options: SSRDevServerBuilderOptions, context: BuilderContext): Observable<SSRDevServerBuilderOutput>;
+export declare function log({ stderr, stdout }: {
+    stderr: string | undefined;
+    stdout: string | undefined;
+}, logger: logging.LoggerApi): void;
+declare const _default: import("../../../../architect/src/internal").Builder<Schema & json.JsonObject>;
+export default _default;

package/src/builders/ssr-dev-server/index.js

@@ -0,0 +1,309 @@
+"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.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.execute = void 0;
+const architect_1 = require("@angular-devkit/architect");
+const core_1 = require("@angular-devkit/core");
+const path_1 = require("path");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const url = __importStar(require("url"));
+const error_1 = require("../../utils/error");
+const utils_1 = require("./utils");
+/** Log messages to ignore and not rely to the logger */
+const IGNORED_STDOUT_MESSAGES = [
+    'server listening on',
+    'Angular is running in development mode. Call enableProdMode() to enable production mode.',
+];
+function execute(options, context) {
+    const browserTarget = (0, architect_1.targetFromTargetString)(options.browserTarget);
+    const serverTarget = (0, architect_1.targetFromTargetString)(options.serverTarget);
+    const getBaseUrl = (bs) => `${bs.getOption('scheme')}://${bs.getOption('host')}:${bs.getOption('port')}`;
+    const browserTargetRun = context.scheduleTarget(browserTarget, {
+        watch: options.watch,
+        progress: options.progress,
+        verbose: options.verbose,
+        // Disable bundle budgets are these are not meant to be used with a dev-server as this will add extra JavaScript for live-reloading.
+        budgets: [],
+    });
+    const serverTargetRun = context.scheduleTarget(serverTarget, {
+        watch: options.watch,
+        progress: options.progress,
+        verbose: options.verbose,
+    });
+    const bsInstance = require('browser-sync').create();
+    context.logger.error(core_1.tags.stripIndents `
+  ****************************************************************************************
+  This is a simple server for use in testing or debugging Angular applications locally.
+  It hasn't been reviewed for security issues.
+
+  DON'T USE IT FOR PRODUCTION!
+  ****************************************************************************************
+ `);
+    return (0, rxjs_1.zip)(browserTargetRun, serverTargetRun, (0, utils_1.getAvailablePort)()).pipe((0, operators_1.switchMap)(([br, sr, nodeServerPort]) => {
+        return (0, rxjs_1.combineLatest)([br.output, sr.output]).pipe(
+        // This is needed so that if both server and browser emit close to each other
+        // we only emit once. This typically happens on the first build.
+        (0, operators_1.debounceTime)(120), (0, operators_1.switchMap)(([b, s]) => {
+            if (!s.success || !b.success) {
+                return (0, rxjs_1.of)([b, s]);
+            }
+            return startNodeServer(s, nodeServerPort, context.logger, !!options.inspect).pipe((0, operators_1.mapTo)([b, s]), (0, operators_1.catchError)((err) => {
+                context.logger.error(`A server error has occurred.\n${mapErrorToMessage(err)}`);
+                return rxjs_1.EMPTY;
+            }));
+        }), (0, operators_1.map)(([b, s]) => [
+            {
+                success: b.success && s.success,
+                error: b.error || s.error,
+            },
+            nodeServerPort,
+        ]), (0, operators_1.tap)(([builderOutput]) => {
+            if (builderOutput.success) {
+                context.logger.info('\nCompiled successfully.');
+            }
+        }), (0, operators_1.debounce)(([builderOutput]) => builderOutput.success && !options.inspect
+            ? (0, utils_1.waitUntilServerIsListening)(nodeServerPort)
+            : rxjs_1.EMPTY), (0, operators_1.finalize)(() => {
+            void br.stop();
+            void sr.stop();
+        }));
+    }), (0, operators_1.concatMap)(([builderOutput, nodeServerPort]) => {
+        if (!builderOutput.success) {
+            return (0, rxjs_1.of)(builderOutput);
+        }
+        if (bsInstance.active) {
+            bsInstance.reload();
+            return (0, rxjs_1.of)(builderOutput);
+        }
+        else {
+            return (0, rxjs_1.from)(initBrowserSync(bsInstance, nodeServerPort, options, context)).pipe((0, operators_1.tap)((bs) => {
+                const baseUrl = getBaseUrl(bs);
+                context.logger.info(core_1.tags.oneLine `
+                **
+                Angular Universal Live Development Server is listening on ${baseUrl},
+                open your browser on ${baseUrl}
+                **
+              `);
+            }), (0, operators_1.mapTo)(builderOutput));
+        }
+    }), (0, operators_1.map)((builderOutput) => ({
+        success: builderOutput.success,
+        error: builderOutput.error,
+        baseUrl: getBaseUrl(bsInstance),
+        port: bsInstance.getOption('port'),
+    })), (0, operators_1.finalize)(() => {
+        if (bsInstance) {
+            bsInstance.exit();
+            bsInstance.cleanup();
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)({
+        success: false,
+        error: mapErrorToMessage(error),
+    })));
+}
+exports.execute = execute;
+// Logs output to the terminal.
+// Removes any trailing new lines from the output.
+function log({ stderr, stdout }, logger) {
+    if (stderr) {
+        // Strip the webpack scheme (webpack://) from error log.
+        logger.error(stderr.replace(/\n?$/, '').replace(/webpack:\/\//g, '.'));
+    }
+    if (stdout && !IGNORED_STDOUT_MESSAGES.some((x) => stdout.includes(x))) {
+        logger.info(stdout.replace(/\n?$/, ''));
+    }
+}
+exports.log = log;
+function startNodeServer(serverOutput, port, logger, inspectMode = false) {
+    const outputPath = serverOutput.outputPath;
+    const path = (0, path_1.join)(outputPath, 'main.js');
+    const env = { ...process.env, PORT: '' + port };
+    const args = ['--enable-source-maps', `"${path}"`];
+    if (inspectMode) {
+        args.unshift('--inspect-brk');
+    }
+    return (0, rxjs_1.of)(null).pipe((0, operators_1.delay)(0), // Avoid EADDRINUSE error since it will cause the kill event to be finish.
+    (0, operators_1.switchMap)(() => (0, utils_1.spawnAsObservable)('node', args, { env, shell: true })), (0, operators_1.tap)((res) => log({ stderr: res.stderr, stdout: res.stdout }, logger)), (0, operators_1.ignoreElements)(), 
+    // Emit a signal after the process has been started
+    (0, operators_1.startWith)(undefined));
+}
+async function initBrowserSync(browserSyncInstance, nodeServerPort, options, context) {
+    if (browserSyncInstance.active) {
+        return browserSyncInstance;
+    }
+    const { port: browserSyncPort, open, host, publicHost, proxyConfig } = options;
+    const bsPort = browserSyncPort || (await (0, utils_1.getAvailablePort)());
+    const bsOptions = {
+        proxy: {
+            target: `localhost:${nodeServerPort}`,
+            proxyOptions: {
+                xfwd: true,
+            },
+            proxyRes: [
+                (proxyRes) => {
+                    if ('headers' in proxyRes) {
+                        proxyRes.headers['cache-control'] = undefined;
+                    }
+                },
+            ],
+            // proxyOptions is not in the typings
+        },
+        host,
+        port: bsPort,
+        ui: false,
+        server: false,
+        notify: false,
+        ghostMode: false,
+        logLevel: options.verbose ? 'debug' : 'silent',
+        open,
+        https: getSslConfig(context.workspaceRoot, options),
+    };
+    const publicHostNormalized = publicHost && publicHost.endsWith('/')
+        ? publicHost.substring(0, publicHost.length - 1)
+        : publicHost;
+    if (publicHostNormalized) {
+        const { protocol, hostname, port, pathname } = url.parse(publicHostNormalized);
+        const defaultSocketIoPath = '/browser-sync/socket.io';
+        const defaultNamespace = '/browser-sync';
+        const hasPathname = !!(pathname && pathname !== '/');
+        const namespace = hasPathname ? pathname + defaultNamespace : defaultNamespace;
+        const path = hasPathname ? pathname + defaultSocketIoPath : defaultSocketIoPath;
+        bsOptions.socket = {
+            namespace,
+            path,
+            domain: url.format({
+                protocol,
+                hostname,
+                port,
+            }),
+        };
+        // When having a pathname we also need to create a reverse proxy because socket.io
+        // will be listening on: 'http://localhost:4200/ssr/browser-sync/socket.io'
+        // However users will typically have a reverse proxy that will redirect all matching requests
+        // ex: http://testinghost.com/ssr -> http://localhost:4200 which will result in a 404.
+        if (hasPathname) {
+            const { createProxyMiddleware } = await Promise.resolve().then(() => __importStar(require('http-proxy-middleware')));
+            // Remove leading slash
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            (bsOptions.scriptPath = (p) => p.substring(1)),
+                (bsOptions.middleware = [
+                    createProxyMiddleware(defaultSocketIoPath, {
+                        target: url.format({
+                            protocol: 'http',
+                            hostname: host,
+                            port: bsPort,
+                            pathname: path,
+                        }),
+                        ws: true,
+                        logLevel: 'silent',
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    }),
+                ]);
+        }
+    }
+    if (proxyConfig) {
+        if (!bsOptions.middleware) {
+            bsOptions.middleware = [];
+        }
+        else if (!Array.isArray(bsOptions.middleware)) {
+            bsOptions.middleware = [bsOptions.middleware];
+        }
+        bsOptions.middleware = [
+            ...bsOptions.middleware,
+            ...(await getProxyConfig(context.workspaceRoot, proxyConfig)),
+        ];
+    }
+    return new Promise((resolve, reject) => {
+        browserSyncInstance.init(bsOptions, (error, bs) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(bs);
+            }
+        });
+    });
+}
+function mapErrorToMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    return '';
+}
+function getSslConfig(root, options) {
+    const { ssl, sslCert, sslKey } = options;
+    if (ssl && sslCert && sslKey) {
+        return {
+            key: (0, path_1.resolve)(root, sslKey),
+            cert: (0, path_1.resolve)(root, sslCert),
+        };
+    }
+    return ssl;
+}
+async function getProxyConfig(root, proxyConfig) {
+    const proxyPath = (0, path_1.resolve)(root, proxyConfig);
+    let proxySettings;
+    try {
+        proxySettings = require(proxyPath);
+    }
+    catch (error) {
+        (0, error_1.assertIsError)(error);
+        if (error.code === 'MODULE_NOT_FOUND') {
+            throw new Error(`Proxy config file ${proxyPath} does not exist.`);
+        }
+        throw error;
+    }
+    const proxies = Array.isArray(proxySettings) ? proxySettings : [proxySettings];
+    const createdProxies = [];
+    const { createProxyMiddleware } = await Promise.resolve().then(() => __importStar(require('http-proxy-middleware')));
+    for (const proxy of proxies) {
+        for (const [key, context] of Object.entries(proxy)) {
+            if (typeof key === 'string') {
+                createdProxies.push(createProxyMiddleware(key.replace(/^\*$/, '**').replace(/\/\*$/, ''), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                context));
+            }
+            else {
+                createdProxies.push(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createProxyMiddleware(key, context));
+            }
+        }
+    }
+    return createdProxies;
+}
+exports.default = (0, architect_1.createBuilder)(execute);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/ssr-dev-server/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  BuilderContext,\n  BuilderOutput,\n  createBuilder,\n  targetFromTargetString,\n} from '@angular-devkit/architect';\nimport { json, logging, tags } from '@angular-devkit/core';\nimport type {\n  BrowserSyncInstance,\n  Options as BrowserSyncOptions,\n  HttpsOptions,\n  MiddlewareHandler,\n  ProxyOptions,\n} from 'browser-sync';\nimport { join, resolve as pathResolve } from 'path';\nimport { EMPTY, Observable, combineLatest, from, of, zip } from 'rxjs';\nimport {\n  catchError,\n  concatMap,\n  debounce,\n  debounceTime,\n  delay,\n  finalize,\n  ignoreElements,\n  map,\n  mapTo,\n  startWith,\n  switchMap,\n  tap,\n} from 'rxjs/operators';\nimport * as url from 'url';\nimport { assertIsError } from '../../utils/error';\nimport { Schema } from './schema';\n\nimport { getAvailablePort, spawnAsObservable, waitUntilServerIsListening } from './utils';\n\n/** Log messages to ignore and not rely to the logger */\nconst IGNORED_STDOUT_MESSAGES = [\n  'server listening on',\n  'Angular is running in development mode. Call enableProdMode() to enable production mode.',\n];\n\ntype SSRDevServerBuilderOptions = Schema & json.JsonObject;\nexport type SSRDevServerBuilderOutput = BuilderOutput & {\n  baseUrl?: string;\n  port?: string;\n};\n\nexport function execute(\n  options: SSRDevServerBuilderOptions,\n  context: BuilderContext,\n): Observable<SSRDevServerBuilderOutput> {\n  const browserTarget = targetFromTargetString(options.browserTarget);\n  const serverTarget = targetFromTargetString(options.serverTarget);\n  const getBaseUrl = (bs: BrowserSyncInstance) =>\n    `${bs.getOption('scheme')}://${bs.getOption('host')}:${bs.getOption('port')}`;\n  const browserTargetRun = context.scheduleTarget(browserTarget, {\n    watch: options.watch,\n    progress: options.progress,\n    verbose: options.verbose,\n    // Disable bundle budgets are these are not meant to be used with a dev-server as this will add extra JavaScript for live-reloading.\n    budgets: [],\n  } as json.JsonObject);\n\n  const serverTargetRun = context.scheduleTarget(serverTarget, {\n    watch: options.watch,\n    progress: options.progress,\n    verbose: options.verbose,\n  } as json.JsonObject);\n\n  const bsInstance = require('browser-sync').create();\n\n  context.logger.error(tags.stripIndents`\n  ****************************************************************************************\n  This is a simple server for use in testing or debugging Angular applications locally.\n  It hasn't been reviewed for security issues.\n\n  DON'T USE IT FOR PRODUCTION!\n  ****************************************************************************************\n `);\n\n  return zip(browserTargetRun, serverTargetRun, getAvailablePort()).pipe(\n    switchMap(([br, sr, nodeServerPort]) => {\n      return combineLatest([br.output, sr.output]).pipe(\n        // This is needed so that if both server and browser emit close to each other\n        // we only emit once. This typically happens on the first build.\n        debounceTime(120),\n        switchMap(([b, s]) => {\n          if (!s.success || !b.success) {\n            return of([b, s]);\n          }\n\n          return startNodeServer(s, nodeServerPort, context.logger, !!options.inspect).pipe(\n            mapTo([b, s]),\n            catchError((err) => {\n              context.logger.error(`A server error has occurred.\\n${mapErrorToMessage(err)}`);\n\n              return EMPTY;\n            }),\n          );\n        }),\n        map(\n          ([b, s]) =>\n            [\n              {\n                success: b.success && s.success,\n                error: b.error || s.error,\n              },\n              nodeServerPort,\n            ] as [SSRDevServerBuilderOutput, number],\n        ),\n        tap(([builderOutput]) => {\n          if (builderOutput.success) {\n            context.logger.info('\\nCompiled successfully.');\n          }\n        }),\n        debounce(([builderOutput]) =>\n          builderOutput.success && !options.inspect\n            ? waitUntilServerIsListening(nodeServerPort)\n            : EMPTY,\n        ),\n        finalize(() => {\n          void br.stop();\n          void sr.stop();\n        }),\n      );\n    }),\n    concatMap(([builderOutput, nodeServerPort]) => {\n      if (!builderOutput.success) {\n        return of(builderOutput);\n      }\n\n      if (bsInstance.active) {\n        bsInstance.reload();\n\n        return of(builderOutput);\n      } else {\n        return from(initBrowserSync(bsInstance, nodeServerPort, options, context)).pipe(\n          tap((bs) => {\n            const baseUrl = getBaseUrl(bs);\n            context.logger.info(tags.oneLine`\n                **\n                Angular Universal Live Development Server is listening on ${baseUrl},\n                open your browser on ${baseUrl}\n                **\n              `);\n          }),\n          mapTo(builderOutput),\n        );\n      }\n    }),\n    map(\n      (builderOutput) =>\n        ({\n          success: builderOutput.success,\n          error: builderOutput.error,\n          baseUrl: getBaseUrl(bsInstance),\n          port: bsInstance.getOption('port'),\n        }) as SSRDevServerBuilderOutput,\n    ),\n    finalize(() => {\n      if (bsInstance) {\n        bsInstance.exit();\n        bsInstance.cleanup();\n      }\n    }),\n    catchError((error) =>\n      of({\n        success: false,\n        error: mapErrorToMessage(error),\n      }),\n    ),\n  );\n}\n\n// Logs output to the terminal.\n// Removes any trailing new lines from the output.\nexport function log(\n  { stderr, stdout }: { stderr: string | undefined; stdout: string | undefined },\n  logger: logging.LoggerApi,\n) {\n  if (stderr) {\n    // Strip the webpack scheme (webpack://) from error log.\n    logger.error(stderr.replace(/\\n?$/, '').replace(/webpack:\\/\\//g, '.'));\n  }\n\n  if (stdout && !IGNORED_STDOUT_MESSAGES.some((x) => stdout.includes(x))) {\n    logger.info(stdout.replace(/\\n?$/, ''));\n  }\n}\n\nfunction startNodeServer(\n  serverOutput: BuilderOutput,\n  port: number,\n  logger: logging.LoggerApi,\n  inspectMode = false,\n): Observable<void> {\n  const outputPath = serverOutput.outputPath as string;\n  const path = join(outputPath, 'main.js');\n  const env = { ...process.env, PORT: '' + port };\n\n  const args = ['--enable-source-maps', `\"${path}\"`];\n  if (inspectMode) {\n    args.unshift('--inspect-brk');\n  }\n\n  return of(null).pipe(\n    delay(0), // Avoid EADDRINUSE error since it will cause the kill event to be finish.\n    switchMap(() => spawnAsObservable('node', args, { env, shell: true })),\n    tap((res) => log({ stderr: res.stderr, stdout: res.stdout }, logger)),\n    ignoreElements(),\n    // Emit a signal after the process has been started\n    startWith(undefined),\n  );\n}\n\nasync function initBrowserSync(\n  browserSyncInstance: BrowserSyncInstance,\n  nodeServerPort: number,\n  options: SSRDevServerBuilderOptions,\n  context: BuilderContext,\n): Promise<BrowserSyncInstance> {\n  if (browserSyncInstance.active) {\n    return browserSyncInstance;\n  }\n\n  const { port: browserSyncPort, open, host, publicHost, proxyConfig } = options;\n  const bsPort = browserSyncPort || (await getAvailablePort());\n  const bsOptions: BrowserSyncOptions = {\n    proxy: {\n      target: `localhost:${nodeServerPort}`,\n      proxyOptions: {\n        xfwd: true,\n      },\n      proxyRes: [\n        (proxyRes) => {\n          if ('headers' in proxyRes) {\n            proxyRes.headers['cache-control'] = undefined;\n          }\n        },\n      ],\n      // proxyOptions is not in the typings\n    } as ProxyOptions & { proxyOptions: { xfwd: boolean } },\n    host,\n    port: bsPort,\n    ui: false,\n    server: false,\n    notify: false,\n    ghostMode: false,\n    logLevel: options.verbose ? 'debug' : 'silent',\n    open,\n    https: getSslConfig(context.workspaceRoot, options),\n  };\n\n  const publicHostNormalized =\n    publicHost && publicHost.endsWith('/')\n      ? publicHost.substring(0, publicHost.length - 1)\n      : publicHost;\n\n  if (publicHostNormalized) {\n    const { protocol, hostname, port, pathname } = url.parse(publicHostNormalized);\n    const defaultSocketIoPath = '/browser-sync/socket.io';\n    const defaultNamespace = '/browser-sync';\n    const hasPathname = !!(pathname && pathname !== '/');\n    const namespace = hasPathname ? pathname + defaultNamespace : defaultNamespace;\n    const path = hasPathname ? pathname + defaultSocketIoPath : defaultSocketIoPath;\n\n    bsOptions.socket = {\n      namespace,\n      path,\n      domain: url.format({\n        protocol,\n        hostname,\n        port,\n      }),\n    };\n\n    // When having a pathname we also need to create a reverse proxy because socket.io\n    // will be listening on: 'http://localhost:4200/ssr/browser-sync/socket.io'\n    // However users will typically have a reverse proxy that will redirect all matching requests\n    // ex: http://testinghost.com/ssr -> http://localhost:4200 which will result in a 404.\n    if (hasPathname) {\n      const { createProxyMiddleware } = await import('http-proxy-middleware');\n\n      // Remove leading slash\n      // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n      (bsOptions.scriptPath = (p) => p.substring(1)),\n        (bsOptions.middleware = [\n          createProxyMiddleware(defaultSocketIoPath, {\n            target: url.format({\n              protocol: 'http',\n              hostname: host,\n              port: bsPort,\n              pathname: path,\n            }),\n            ws: true,\n            logLevel: 'silent',\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          }) as any,\n        ]);\n    }\n  }\n\n  if (proxyConfig) {\n    if (!bsOptions.middleware) {\n      bsOptions.middleware = [];\n    } else if (!Array.isArray(bsOptions.middleware)) {\n      bsOptions.middleware = [bsOptions.middleware];\n    }\n\n    bsOptions.middleware = [\n      ...bsOptions.middleware,\n      ...(await getProxyConfig(context.workspaceRoot, proxyConfig)),\n    ];\n  }\n\n  return new Promise((resolve, reject) => {\n    browserSyncInstance.init(bsOptions, (error, bs) => {\n      if (error) {\n        reject(error);\n      } else {\n        resolve(bs);\n      }\n    });\n  });\n}\n\nfunction mapErrorToMessage(error: unknown): string {\n  if (error instanceof Error) {\n    return error.message;\n  }\n\n  if (typeof error === 'string') {\n    return error;\n  }\n\n  return '';\n}\n\nfunction getSslConfig(\n  root: string,\n  options: SSRDevServerBuilderOptions,\n): HttpsOptions | undefined | boolean {\n  const { ssl, sslCert, sslKey } = options;\n  if (ssl && sslCert && sslKey) {\n    return {\n      key: pathResolve(root, sslKey),\n      cert: pathResolve(root, sslCert),\n    };\n  }\n\n  return ssl;\n}\n\nasync function getProxyConfig(root: string, proxyConfig: string): Promise<MiddlewareHandler[]> {\n  const proxyPath = pathResolve(root, proxyConfig);\n  let proxySettings: unknown;\n  try {\n    proxySettings = require(proxyPath);\n  } catch (error) {\n    assertIsError(error);\n\n    if (error.code === 'MODULE_NOT_FOUND') {\n      throw new Error(`Proxy config file ${proxyPath} does not exist.`);\n    }\n\n    throw error;\n  }\n\n  const proxies = Array.isArray(proxySettings) ? proxySettings : [proxySettings];\n  const createdProxies = [];\n  const { createProxyMiddleware } = await import('http-proxy-middleware');\n  for (const proxy of proxies) {\n    for (const [key, context] of Object.entries(proxy)) {\n      if (typeof key === 'string') {\n        createdProxies.push(\n          createProxyMiddleware(\n            key.replace(/^\\*$/, '**').replace(/\\/\\*$/, ''),\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            context as any,\n          ) as MiddlewareHandler,\n        );\n      } else {\n        createdProxies.push(\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          createProxyMiddleware(key, context as any) as MiddlewareHandler,\n        );\n      }\n    }\n  }\n\n  return createdProxies;\n}\n\nexport default createBuilder<SSRDevServerBuilderOptions, BuilderOutput>(execute);\n"]}

package/src/builders/ssr-dev-server/schema.d.ts

@@ -0,0 +1,64 @@
+/**
+ * SSR Dev Server target options for Build Facade.
+ */
+export interface Schema {
+    /**
+     * Browser target to build.
+     */
+    browserTarget: string;
+    /**
+     * Host to listen on.
+     */
+    host?: string;
+    /**
+     * Launch the development server in inspector mode and listen on address and port
+     * '127.0.0.1:9229'.
+     */
+    inspect?: boolean;
+    /**
+     * Opens the url in default browser.
+     */
+    open?: boolean;
+    /**
+     * Port to start the development server at. Default is 4200. Pass 0 to get a dynamically
+     * assigned port.
+     */
+    port?: number;
+    /**
+     * Log progress to the console while building.
+     */
+    progress?: boolean;
+    /**
+     * Proxy configuration file.
+     */
+    proxyConfig?: string;
+    /**
+     * The URL that the browser client should use to connect to the development server. Use for
+     * a complex dev server setup, such as one with reverse proxies.
+     */
+    publicHost?: string;
+    /**
+     * Server target to build.
+     */
+    serverTarget: string;
+    /**
+     * Serve using HTTPS.
+     */
+    ssl?: boolean;
+    /**
+     * SSL certificate to use for serving HTTPS.
+     */
+    sslCert?: string;
+    /**
+     * SSL key to use for serving HTTPS.
+     */
+    sslKey?: string;
+    /**
+     * Adds more details to output logging.
+     */
+    verbose?: boolean;
+    /**
+     * Rebuild on change.
+     */
+    watch?: boolean;
+}

package/src/builders/ssr-dev-server/schema.js

@@ -0,0 +1,5 @@
+"use strict";
+// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE
+// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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