@ngtools/webpack 14.0.1 → 14.1.0-next.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngtools/webpack",
-  "version": "14.0.1",
+  "version": "14.1.0-next.1",
   "description": "Webpack plugin that AoT compiles your Angular components and modules.",
   "main": "./src/index.js",
   "typings": "src/index.d.ts",
@@ -26,7 +26,7 @@
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {},
   "peerDependencies": {
-    "@angular/compiler-cli": "^14.0.0",
+    "@angular/compiler-cli": "^14.0.0 || ^14.0.0-next || ^14.1.0-next",
     "typescript": ">=4.6.2 <4.8",
     "webpack": "^5.54.0"
   },

package/src/paths-plugin.d.ts

@@ -6,10 +6,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { CompilerOptions } from 'typescript';
-import type { Configuration } from 'webpack';
+import type { Resolver } from 'webpack';
 export interface TypeScriptPathsPluginOptions extends Pick<CompilerOptions, 'paths' | 'baseUrl'> {
 }
-declare type Resolver = Exclude<Exclude<Configuration['resolve'], undefined>['resolver'], undefined>;
+declare type ResolverRequest = NonNullable<Parameters<Parameters<Resolver['resolve']>[4]>[2]>;
+interface PathPluginResolverRequest extends ResolverRequest {
+    context?: {
+        issuer?: string;
+    };
+    typescriptPathMapped?: boolean;
+}
 export declare class TypeScriptPathsPlugin {
     private baseUrl?;
     private patterns?;
@@ -23,5 +29,7 @@ export declare class TypeScriptPathsPlugin {
      */
     update(options: TypeScriptPathsPluginOptions): void;
     apply(resolver: Resolver): void;
+    findReplacements(originalRequest: string): IterableIterator<string>;
+    createReplacementRequests(request: PathPluginResolverRequest, originalRequest: string): IterableIterator<PathPluginResolverRequest>;
 }
 export {};

package/src/paths-plugin.js

@@ -102,10 +102,10 @@ class TypeScriptPathsPlugin {
         const target = resolver.ensureHook('resolve');
         // To support synchronous resolvers this hook cannot be promise based.
         // Webpack supports synchronous resolution with `tap` and `tapAsync` hooks.
-        resolver.getHook('described-resolve').tapAsync('TypeScriptPathsPlugin', 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (request, resolveContext, callback) => {
-            var _a;
+        resolver
+            .getHook('described-resolve')
+            .tapAsync('TypeScriptPathsPlugin', (request, resolveContext, callback) => {
+            var _a, _b;
             // Preprocessing of the options will ensure that `patterns` is either undefined or has elements to check
             if (!this.patterns) {
                 callback();
@@ -121,7 +121,7 @@ class TypeScriptPathsPlugin {
                 return;
             }
             // Only work on Javascript/TypeScript issuers.
-            if (!request.context.issuer || !request.context.issuer.match(/\.[cm]?[jt]sx?$/)) {
+            if (!((_b = (_a = request === null || request === void 0 ? void 0 : request.context) === null || _a === void 0 ? void 0 : _a.issuer) === null || _b === void 0 ? void 0 : _b.match(/\.[cm]?[jt]sx?$/))) {
                 callback();
                 return;
             }
@@ -139,108 +139,103 @@ class TypeScriptPathsPlugin {
                     }
                     break;
             }
-            // A generator is used to limit the amount of replacements that need to be created.
+            // A generator is used to limit the amount of replacements requests that need to be created.
             // For example, if the first one resolves, any others are not needed and do not need
             // to be created.
-            const replacements = findReplacements(originalRequest, this.patterns);
-            const basePath = (_a = this.baseUrl) !== null && _a !== void 0 ? _a : '';
-            const attemptResolveRequest = (request) => {
-                return new Promise((resolve, reject) => {
-                    resolver.doResolve(target, request, '', resolveContext, (error, result) => {
-                        if (error) {
-                            reject(error);
-                        }
-                        else if (result) {
-                            resolve(result);
-                        }
-                        else {
-                            resolve(null);
-                        }
-                    });
-                });
-            };
-            const tryNextReplacement = () => {
-                const next = replacements.next();
+            const requests = this.createReplacementRequests(request, originalRequest);
+            const tryResolve = () => {
+                const next = requests.next();
                 if (next.done) {
                     callback();
                     return;
                 }
-                const targetPath = path.resolve(basePath, next.value);
-                // If there is no extension. i.e. the target does not refer to an explicit
-                // file, then this is a candidate for module/package resolution.
-                const canBeModule = path.extname(targetPath) === '';
-                // Resolution in the target location, preserving the original request.
-                // This will work with the `resolve-in-package` resolution hook, supporting
-                // package exports for e.g. locally-built APF libraries.
-                const potentialRequestAsPackage = {
-                    ...request,
-                    path: targetPath,
-                    typescriptPathMapped: true,
-                };
-                // Resolution in the original callee location, but with the updated request
-                // to point to the mapped target location.
-                const potentialRequestAsFile = {
-                    ...request,
-                    request: targetPath,
-                    typescriptPathMapped: true,
-                };
-                let resultPromise = attemptResolveRequest(potentialRequestAsFile);
-                // If the request can be a module, we configure the resolution to try package/module
-                // resolution if the file resolution did not have a result.
-                if (canBeModule) {
-                    resultPromise = resultPromise.then((result) => result !== null && result !== void 0 ? result : attemptResolveRequest(potentialRequestAsPackage));
-                }
-                // If we have a result, complete. If not, and no error, try the next replacement.
-                resultPromise
-                    .then((res) => (res === null ? tryNextReplacement() : callback(undefined, res)))
-                    .catch((error) => callback(error));
+                resolver.doResolve(target, next.value, '', resolveContext, (error, result) => {
+                    if (error) {
+                        callback(error);
+                    }
+                    else if (result) {
+                        callback(undefined, result);
+                    }
+                    else {
+                        tryResolve();
+                    }
+                });
             };
-            tryNextReplacement();
+            tryResolve();
         });
     }
-}
-exports.TypeScriptPathsPlugin = TypeScriptPathsPlugin;
-function* findReplacements(originalRequest, patterns) {
-    // check if any path mapping rules are relevant
-    for (const { starIndex, prefix, suffix, potentials } of patterns) {
-        let partial;
-        if (starIndex === -1) {
-            // No star means an exact match is required
-            if (prefix === originalRequest) {
-                partial = '';
-            }
+    *findReplacements(originalRequest) {
+        if (!this.patterns) {
+            return;
         }
-        else if (starIndex === 0 && !suffix) {
-            // Everything matches a single wildcard pattern ("*")
-            partial = originalRequest;
-        }
-        else if (!suffix) {
-            // No suffix means the star is at the end of the pattern
-            if (originalRequest.startsWith(prefix)) {
-                partial = originalRequest.slice(prefix.length);
+        // check if any path mapping rules are relevant
+        for (const { starIndex, prefix, suffix, potentials } of this.patterns) {
+            let partial;
+            if (starIndex === -1) {
+                // No star means an exact match is required
+                if (prefix === originalRequest) {
+                    partial = '';
+                }
             }
-        }
-        else {
-            // Star was in the middle of the pattern
-            if (originalRequest.startsWith(prefix) && originalRequest.endsWith(suffix)) {
-                partial = originalRequest.substring(prefix.length, originalRequest.length - suffix.length);
+            else if (starIndex === 0 && !suffix) {
+                // Everything matches a single wildcard pattern ("*")
+                partial = originalRequest;
             }
-        }
-        // If request was not matched, move on to the next pattern
-        if (partial === undefined) {
-            continue;
-        }
-        // Create the full replacement values based on the original request and the potentials
-        // for the successfully matched pattern.
-        for (const { hasStar, prefix, suffix } of potentials) {
-            let replacement = prefix;
-            if (hasStar) {
-                replacement += partial;
-                if (suffix) {
-                    replacement += suffix;
+            else if (!suffix) {
+                // No suffix means the star is at the end of the pattern
+                if (originalRequest.startsWith(prefix)) {
+                    partial = originalRequest.slice(prefix.length);
+                }
+            }
+            else {
+                // Star was in the middle of the pattern
+                if (originalRequest.startsWith(prefix) && originalRequest.endsWith(suffix)) {
+                    partial = originalRequest.substring(prefix.length, originalRequest.length - suffix.length);
+                }
+            }
+            // If request was not matched, move on to the next pattern
+            if (partial === undefined) {
+                continue;
+            }
+            // Create the full replacement values based on the original request and the potentials
+            // for the successfully matched pattern.
+            for (const { hasStar, prefix, suffix } of potentials) {
+                let replacement = prefix;
+                if (hasStar) {
+                    replacement += partial;
+                    if (suffix) {
+                        replacement += suffix;
+                    }
                 }
+                yield replacement;
+            }
+        }
+    }
+    *createReplacementRequests(request, originalRequest) {
+        var _a;
+        for (const replacement of this.findReplacements(originalRequest)) {
+            const targetPath = path.resolve((_a = this.baseUrl) !== null && _a !== void 0 ? _a : '', replacement);
+            // Resolution in the original callee location, but with the updated request
+            // to point to the mapped target location.
+            yield {
+                ...request,
+                request: targetPath,
+                typescriptPathMapped: true,
+            };
+            // If there is no extension. i.e. the target does not refer to an explicit
+            // file, then this is a candidate for module/package resolution.
+            const canBeModule = path.extname(targetPath) === '';
+            if (canBeModule) {
+                // Resolution in the target location, preserving the original request.
+                // This will work with the `resolve-in-package` resolution hook, supporting
+                // package exports for e.g. locally-built APF libraries.
+                yield {
+                    ...request,
+                    path: targetPath,
+                    typescriptPathMapped: true,
+                };
             }
-            yield replacement;
         }
     }
 }
+exports.TypeScriptPathsPlugin = TypeScriptPathsPlugin;

package/src/resource_loader.js

@@ -29,8 +29,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebpackResourceLoader = void 0;
+const assert_1 = __importDefault(require("assert"));
 const path = __importStar(require("path"));
 const vm = __importStar(require("vm"));
 const paths_1 = require("./ivy/paths");
@@ -99,7 +103,7 @@ class WebpackResourceLoader {
             throw new Error('WebpackResourceLoader cannot be used without parentCompilation');
         }
         const { context, webpack } = this._parentCompilation.compiler;
-        const { EntryPlugin, NormalModule, library, node, sources, util: { createHash }, } = webpack;
+        const { EntryPlugin, NormalModule, WebpackError, library, node, sources, util: { createHash }, } = webpack;
         const getEntry = () => {
             if (filePath) {
                 return `${filePath}?${replace_resources_1.NG_COMPONENT_RESOURCE_QUERY}`;
@@ -167,8 +171,9 @@ class WebpackResourceLoader {
                     }
                 }
                 catch (error) {
+                    (0, assert_1.default)(error instanceof Error, 'catch clause variable is not an Error instance');
                     // Use compilation errors, as otherwise webpack will choke
-                    compilation.errors.push(error);
+                    compilation.errors.push(new WebpackError(error.message));
                 }
             });
         });