@angular-devkit/build-angular 15.0.1 → 15.1.0-next.0

package/src/builders/server/index.js

@@ -37,9 +37,13 @@ const path = __importStar(require("path"));
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const utils_1 = require("../../utils");
+const color_1 = require("../../utils/color");
+const copy_assets_1 = require("../../utils/copy-assets");
+const error_1 = require("../../utils/error");
 const i18n_inlining_1 = require("../../utils/i18n-inlining");
 const output_paths_1 = require("../../utils/output-paths");
 const purge_cache_1 = require("../../utils/purge-cache");
+const spinner_1 = require("../../utils/spinner");
 const version_1 = require("../../utils/version");
 const webpack_browser_config_1 = require("../../utils/webpack-browser-config");
 const configs_1 = require("../../webpack/configs");
@@ -54,7 +58,7 @@ function execute(options, context, transforms = {}) {
     (0, version_1.assertCompatibleAngularVersion)(root);
     const baseOutputPath = path.resolve(root, options.outputPath);
     let outputPaths;
-    return (0, rxjs_1.from)(initialize(options, context, transforms.webpackConfiguration)).pipe((0, operators_1.concatMap)(({ config, i18n }) => {
+    return (0, rxjs_1.from)(initialize(options, context, transforms.webpackConfiguration)).pipe((0, operators_1.concatMap)(({ config, i18n, projectRoot, projectSourceRoot }) => {
         return (0, build_webpack_1.runWebpack)(config, context, {
             webpackFactory: require('webpack'),
             logging: (stats, config) => {
@@ -63,19 +67,47 @@ function execute(options, context, transforms = {}) {
                 }
             },
         }).pipe((0, operators_1.concatMap)(async (output) => {
+            var _a;
             const { emittedFiles = [], outputPath, webpackStats } = output;
             if (!webpackStats) {
                 throw new Error('Webpack stats build result is required.');
             }
-            let success = output.success;
-            if (success && i18n.shouldInline) {
-                outputPaths = (0, output_paths_1.ensureOutputPaths)(baseOutputPath, i18n);
-                success = await (0, i18n_inlining_1.i18nInlineEmittedFiles)(context, emittedFiles, i18n, baseOutputPath, Array.from(outputPaths.values()), [], outputPath, options.i18nMissingTranslation);
+            if (!output.success) {
+                return output;
+            }
+            const spinner = new spinner_1.Spinner();
+            spinner.enabled = options.progress !== false;
+            outputPaths = (0, output_paths_1.ensureOutputPaths)(baseOutputPath, i18n);
+            // Copy assets
+            if (!options.watch && ((_a = options.assets) === null || _a === void 0 ? void 0 : _a.length)) {
+                spinner.start('Copying assets...');
+                try {
+                    await (0, copy_assets_1.copyAssets)((0, utils_1.normalizeAssetPatterns)(options.assets, context.workspaceRoot, projectRoot, projectSourceRoot), Array.from(outputPaths.values()), context.workspaceRoot);
+                    spinner.succeed('Copying assets complete.');
+                }
+                catch (err) {
+                    spinner.fail(color_1.colors.redBright('Copying of assets failed.'));
+                    (0, error_1.assertIsError)(err);
+                    return {
+                        ...output,
+                        success: false,
+                        error: 'Unable to copy assets: ' + err.message,
+                    };
+                }
+            }
+            if (i18n.shouldInline) {
+                const success = await (0, i18n_inlining_1.i18nInlineEmittedFiles)(context, emittedFiles, i18n, baseOutputPath, Array.from(outputPaths.values()), [], outputPath, options.i18nMissingTranslation);
+                if (!success) {
+                    return {
+                        ...output,
+                        success: false,
+                    };
+                }
             }
             (0, stats_1.webpackStatsLogger)(context.logger, webpackStats, config);
-            return { ...output, success };
+            return output;
         }));
-    }), (0, operators_1.map)((output) => {
+    }), (0, operators_1.concatMap)(async (output) => {
         if (!output.success) {
             return output;
         }
@@ -102,8 +134,10 @@ async function initialize(options, context, webpackConfigurationTransform) {
     await (0, purge_cache_1.purgeStaleBuildCache)(context);
     const browserslist = (await Promise.resolve().then(() => __importStar(require('browserslist')))).default;
     const originalOutputPath = options.outputPath;
-    const { config, i18n } = await (0, webpack_browser_config_1.generateI18nBrowserWebpackConfigFromContext)({
-        ...options,
+    // Assets are processed directly by the builder except when watching
+    const adjustedOptions = options.watch ? options : { ...options, assets: [] };
+    const { config, projectRoot, projectSourceRoot, i18n } = await (0, webpack_browser_config_1.generateI18nBrowserWebpackConfigFromContext)({
+        ...adjustedOptions,
         buildOptimizer: false,
         aot: true,
         platform: 'server',
@@ -119,7 +153,7 @@ async function initialize(options, context, webpackConfigurationTransform) {
         (0, utils_1.deleteOutputDir)(context.workspaceRoot, originalOutputPath);
     }
     const transformedConfig = (_a = (await (webpackConfigurationTransform === null || webpackConfigurationTransform === void 0 ? void 0 : webpackConfigurationTransform(config)))) !== null && _a !== void 0 ? _a : config;
-    return { config: transformedConfig, i18n };
+    return { config: transformedConfig, i18n, projectRoot, projectSourceRoot };
 }
 /**
  * Add `@angular/platform-server` exports.

package/src/builders/server/schema.d.ts

@@ -1,4 +1,8 @@
 export interface Schema {
+    /**
+     * List of static application assets.
+     */
+    assets?: AssetPattern[];
     /**
      * Delete the output path before building.
      */
@@ -110,6 +114,30 @@ export interface Schema {
      */
     watch?: boolean;
 }
+export declare type AssetPattern = AssetPatternClass | string;
+export interface AssetPatternClass {
+    /**
+     * Allow glob patterns to follow symlink directories. This allows subdirectories of the
+     * symlink to be searched.
+     */
+    followSymlinks?: boolean;
+    /**
+     * The pattern to match.
+     */
+    glob: string;
+    /**
+     * An array of globs to ignore.
+     */
+    ignore?: string[];
+    /**
+     * The input directory path in which to apply 'glob'. Defaults to the project root.
+     */
+    input: string;
+    /**
+     * Absolute path within the output.
+     */
+    output: string;
+}
 export interface FileReplacement {
     replace?: string;
     replaceWith?: string;

package/src/builders/server/schema.json

@@ -4,6 +4,14 @@
   "title": "Universal Target",
   "type": "object",
   "properties": {
+    "assets": {
+      "type": "array",
+      "description": "List of static application assets.",
+      "default": [],
+      "items": {
+        "$ref": "#/definitions/assetPattern"
+      }
+    },
     "main": {
       "type": "string",
       "description": "The name of the main entry-point file."
@@ -212,6 +220,44 @@
   "additionalProperties": false,
   "required": ["outputPath", "main", "tsConfig"],
   "definitions": {
+    "assetPattern": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "followSymlinks": {
+              "type": "boolean",
+              "default": false,
+              "description": "Allow glob patterns to follow symlink directories. This allows subdirectories of the symlink to be searched."
+            },
+            "glob": {
+              "type": "string",
+              "description": "The pattern to match."
+            },
+            "input": {
+              "type": "string",
+              "description": "The input directory path in which to apply 'glob'. Defaults to the project root."
+            },
+            "ignore": {
+              "description": "An array of globs to ignore.",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "output": {
+              "type": "string",
+              "description": "Absolute path within the output."
+            }
+          },
+          "additionalProperties": false,
+          "required": ["glob", "input", "output"]
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
     "fileReplacement": {
       "oneOf": [
         {

package/src/sass/rebasing-importer.d.ts

@@ -6,10 +6,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <reference types="node" />
-/// <reference types="node" />
 import { RawSourceMap } from '@ampproject/remapping';
-import { Dirent } from 'node:fs';
 import type { FileImporter, Importer, ImporterResult } from 'sass';
+/**
+ * A preprocessed cache entry for the files and directories within a previously searched
+ * directory when performing Sass import resolution.
+ */
+export interface DirectoryEntry {
+    files: Set<string>;
+    directories: Set<string>;
+}
 /**
  * A Sass Importer base class that provides the load logic to rebase all `url()` functions
  * within a stylesheet. The rebasing will ensure that the URLs in the output of the Sass compiler
@@ -42,7 +48,7 @@ declare abstract class UrlRebasingImporter implements Importer<'sync'> {
  */
 export declare class RelativeUrlRebasingImporter extends UrlRebasingImporter {
     private directoryCache;
-    constructor(entryDirectory: string, directoryCache?: Map<string, Dirent[]>, rebaseSourceMaps?: Map<string, RawSourceMap>);
+    constructor(entryDirectory: string, directoryCache?: Map<string, DirectoryEntry>, rebaseSourceMaps?: Map<string, RawSourceMap>);
     canonicalize(url: string, options: {
         fromImport: boolean;
     }): URL | null;
@@ -59,7 +65,7 @@ export declare class RelativeUrlRebasingImporter extends UrlRebasingImporter {
      * Checks an array of potential stylesheet files to determine if there is a valid
      * stylesheet file. More than one discovered file may indicate an error.
      * @param found An array of discovered stylesheet files.
-     * @returns A fully resolved URL for a stylesheet file or `null` if not found.
+     * @returns A fully resolved path for a stylesheet file or `null` if not found.
      * @throws If there are ambiguous files discovered.
      */
     private checkFound;
@@ -71,7 +77,7 @@ export declare class RelativeUrlRebasingImporter extends UrlRebasingImporter {
  */
 export declare class ModuleUrlRebasingImporter extends RelativeUrlRebasingImporter {
     private finder;
-    constructor(entryDirectory: string, directoryCache: Map<string, Dirent[]>, rebaseSourceMaps: Map<string, RawSourceMap> | undefined, finder: FileImporter<'sync'>['findFileUrl']);
+    constructor(entryDirectory: string, directoryCache: Map<string, DirectoryEntry>, rebaseSourceMaps: Map<string, RawSourceMap> | undefined, finder: FileImporter<'sync'>['findFileUrl']);
     canonicalize(url: string, options: {
         fromImport: boolean;
     }): URL | null;
@@ -83,7 +89,7 @@ export declare class ModuleUrlRebasingImporter extends RelativeUrlRebasingImport
  */
 export declare class LoadPathsUrlRebasingImporter extends RelativeUrlRebasingImporter {
     private loadPaths;
-    constructor(entryDirectory: string, directoryCache: Map<string, Dirent[]>, rebaseSourceMaps: Map<string, RawSourceMap> | undefined, loadPaths: Iterable<string>);
+    constructor(entryDirectory: string, directoryCache: Map<string, DirectoryEntry>, rebaseSourceMaps: Map<string, RawSourceMap> | undefined, loadPaths: Iterable<string>);
     canonicalize(url: string, options: {
         fromImport: boolean;
     }): URL | null;

package/src/sass/rebasing-importer.js

@@ -275,17 +275,6 @@ class RelativeUrlRebasingImporter extends UrlRebasingImporter {
         const hasStyleExtension = extension === '.scss' || extension === '.sass' || extension === '.css';
         // Remove the style extension if present to allow adding the `.import` suffix
         const filename = (0, node_path_1.basename)(stylesheetPath, hasStyleExtension ? extension : undefined);
-        let entries;
-        try {
-            entries = this.directoryCache.get(directory);
-            if (!entries) {
-                entries = (0, node_fs_1.readdirSync)(directory, { withFileTypes: true });
-                this.directoryCache.set(directory, entries);
-            }
-        }
-        catch {
-            return null;
-        }
         const importPotentials = new Set();
         const defaultPotentials = new Set();
         if (hasStyleExtension) {
@@ -312,37 +301,69 @@ class RelativeUrlRebasingImporter extends UrlRebasingImporter {
             defaultPotentials.add('_' + filename + '.sass');
             defaultPotentials.add('_' + filename + '.css');
         }
-        const foundDefaults = [];
-        const foundImports = [];
+        let foundDefaults;
+        let foundImports;
         let hasPotentialIndex = false;
-        for (const entry of entries) {
-            // Record if the name should be checked as a directory with an index file
-            if (checkDirectory && !hasStyleExtension && entry.name === filename && entry.isDirectory()) {
-                hasPotentialIndex = true;
-            }
-            if (!entry.isFile()) {
-                continue;
+        let cachedEntries = this.directoryCache.get(directory);
+        if (cachedEntries) {
+            // If there is a preprocessed cache of the directory, perform an intersection of the potentials
+            // and the directory files.
+            const { files, directories } = cachedEntries;
+            foundDefaults = [...defaultPotentials].filter((potential) => files.has(potential));
+            foundImports = [...importPotentials].filter((potential) => files.has(potential));
+            hasPotentialIndex = checkDirectory && !hasStyleExtension && directories.has(filename);
+        }
+        else {
+            // If no preprocessed cache exists, get the entries from the file system and, while searching,
+            // generate the cache for later requests.
+            let entries;
+            try {
+                entries = (0, node_fs_1.readdirSync)(directory, { withFileTypes: true });
             }
-            if (importPotentials.has(entry.name)) {
-                foundImports.push((0, node_path_1.join)(directory, entry.name));
+            catch {
+                return null;
             }
-            if (defaultPotentials.has(entry.name)) {
-                foundDefaults.push((0, node_path_1.join)(directory, entry.name));
+            foundDefaults = [];
+            foundImports = [];
+            cachedEntries = { files: new Set(), directories: new Set() };
+            for (const entry of entries) {
+                const isDirectory = entry.isDirectory();
+                if (isDirectory) {
+                    cachedEntries.directories.add(entry.name);
+                }
+                // Record if the name should be checked as a directory with an index file
+                if (checkDirectory && !hasStyleExtension && entry.name === filename && isDirectory) {
+                    hasPotentialIndex = true;
+                }
+                if (!entry.isFile()) {
+                    continue;
+                }
+                cachedEntries.files.add(entry.name);
+                if (importPotentials.has(entry.name)) {
+                    foundImports.push(entry.name);
+                }
+                if (defaultPotentials.has(entry.name)) {
+                    foundDefaults.push(entry.name);
+                }
             }
+            this.directoryCache.set(directory, cachedEntries);
         }
         // `foundImports` will only contain elements if `options.fromImport` is true
         const result = (_a = this.checkFound(foundImports)) !== null && _a !== void 0 ? _a : this.checkFound(foundDefaults);
-        if (result === null && hasPotentialIndex) {
+        if (result !== null) {
+            return (0, node_url_1.pathToFileURL)((0, node_path_1.join)(directory, result));
+        }
+        if (hasPotentialIndex) {
             // Check for index files using filename as a directory
             return this.resolveImport(url + '/index', fromImport, false);
         }
-        return result;
+        return null;
     }
     /**
      * Checks an array of potential stylesheet files to determine if there is a valid
      * stylesheet file. More than one discovered file may indicate an error.
      * @param found An array of discovered stylesheet files.
-     * @returns A fully resolved URL for a stylesheet file or `null` if not found.
+     * @returns A fully resolved path for a stylesheet file or `null` if not found.
      * @throws If there are ambiguous files discovered.
      */
     checkFound(found) {
@@ -361,9 +382,9 @@ class RelativeUrlRebasingImporter extends UrlRebasingImporter {
             }
             // Return the non-CSS file (sass/scss files have priority)
             // https://github.com/sass/dart-sass/blob/44d6bb6ac72fe6b93f5bfec371a1fffb18e6b76d/lib/src/importer/utils.dart#L44-L47
-            return (0, node_url_1.pathToFileURL)(foundWithoutCss[0]);
+            return foundWithoutCss[0];
         }
-        return (0, node_url_1.pathToFileURL)(found[0]);
+        return found[0];
     }
 }
 exports.RelativeUrlRebasingImporter = RelativeUrlRebasingImporter;

package/src/utils/normalize-asset-patterns.js

@@ -78,13 +78,12 @@ function normalizeAssetPatterns(assetPatterns, workspaceRoot, projectRoot, proje
             }
             // Output directory for both is the relative path from source root to input.
             const output = path.relative(resolvedSourceRoot, path.resolve(workspaceRoot, input));
-            // Return the asset pattern in object format.
-            return { glob, input, output };
+            assetPattern = { glob, input, output };
         }
-        else {
-            // It's already an AssetPatternObject, no need to convert.
-            return assetPattern;
+        if (assetPattern.output.startsWith('..')) {
+            throw new Error('An asset cannot be written to a location outside of the output path.');
         }
+        return assetPattern;
     });
 }
 exports.normalizeAssetPatterns = normalizeAssetPatterns;